MEDIA_GROUP_BOOKMARK,
MEDIA_GROUP_TAG_BY_MEDIA_ID,
MEDIA_GROUP_BOOKMARK_BY_MEDIA_ID,
+ MEDIA_GROUP_STORAGE,
} group_list_e;
typedef enum {
typedef struct _filter_s
{
+ char *storage_id;
char *condition;
char *order_keyword;
media_content_order_e order_type;
char *path;
char *name;
time_t modified_time;
- media_content_storage_e storage_type;
+ int storage_type;
+ char *storage_uuid;
+ int folder_order;
}media_folder_s;
typedef struct
int played_count;
time_t played_time;
int played_position;
+ char *storage_uuid;
int sync_status;
image_meta_s *image_meta;
video_meta_s *video_meta;
#define DB_FIELD_FOLDER_MODIFIED_TIME "modified_time"
#define DB_FIELD_FOLDER_STORAGE_TYPE "storage_type"
#define DB_FIELD_FOLDER_NAME_PINYIN "name_pinyin"
+#define DB_FIELD_FOLDER_ORDER "folder_order"
/* DB field for playlist */
#define DB_FIELD_PLAYLIST_ID "playlist_id"
#define QUERY_KEYWORD_LIMIT "limit"
#define QUERY_KEYWORD_DESC "DESC"
#define QUERY_KEYWORD_SPACE " "
+#define QUERY_KEYWORD_OPEN_BRACKET "("
#define QUERY_KEYWORD_BRACKET ")"
-#define UPDATE_SQL "UPDATE %s SET %s WHERE %s"
/* DB TABLE JOIN */
-#define SELECT_EMPTY_PLAYLIST "SELECT playlist_id, name FROM "DB_TABLE_PLAYLIST" WHERE playlist_id NOT IN (select playlist_id from "DB_TABLE_PLAYLIST_MAP")"
-#define SELECT_EMPTY_TAG "SELECT tag_id, name FROM "DB_TABLE_TAG" WHERE tag_id NOT IN (SELECT tag_id FROM "DB_TABLE_TAG_MAP")"
-#define FOLDER_MEDIA_JOIN "("DB_TABLE_FOLDER" AS f INNER JOIN "DB_TABLE_MEDIA" AS m ON f.folder_uuid=m.folder_uuid) WHERE m.validity=1"
-#define PLAYLISTMAP_MEDIA_JOIN "("DB_TABLE_PLAYLIST_MAP" AS pm INNER JOIN "DB_TABLE_MEDIA" AS m \
- ON (pm.media_uuid = m.media_uuid)) WHERE m.validity=1"
-#define SELECT_PLAYLIST_FROM_PLAYLIST_PLAYLISTMAP_MEDIA_JOIN "SELECT DISTINCT p.playlist_id, p.name FROM "DB_TABLE_PLAYLIST" AS p INNER JOIN "DB_TABLE_PLAYLIST_MAP" AS pm INNER JOIN "DB_TABLE_MEDIA" AS m \
- ON (p.playlist_id=pm.playlist_id AND pm.media_uuid = m.media_uuid) WHERE m.validity=1"
-#define SELECT_TAG_FROM_TAG_TAGMAP_MEDIA_JOIN "SELECT DISTINCT t.tag_id, t.name FROM "DB_TABLE_TAG" AS t INNER JOIN "DB_TABLE_MEDIA" AS m INNER JOIN "DB_TABLE_TAG_MAP" AS tm \
- ON (tm.media_uuid = m.media_uuid and tm.tag_id=t.tag_id) WHERE m.validity=1"
-#define BOOKMARK_MEDIA_JOIN "("DB_TABLE_BOOKMARK" AS b INNER JOIN "DB_TABLE_MEDIA" AS m \
+#define FOLDER_MEDIA_JOIN "("DB_TABLE_FOLDER" AS f INNER JOIN '%s' AS m ON f.folder_uuid=m.folder_uuid) WHERE m.validity=1 "
+#define BOOKMARK_MEDIA_JOIN "("DB_TABLE_BOOKMARK" AS b INNER JOIN '%s' AS m \
ON (b.media_uuid = m.media_uuid)) WHERE m.validity=1"
-#define ALBUM_MEDIA_JOIN "("DB_TABLE_ALBUM" AS a INNER JOIN "DB_TABLE_MEDIA" AS m \
+#define ALBUM_MEDIA_JOIN "("DB_TABLE_ALBUM" AS a INNER JOIN '%s' AS m \
ON (a.album_id = m.album_id)) WHERE m.validity=1"
/* Get Group List */
#define SELECT_ALBUM_LIST "SELECT DISTINCT a.album_id, a.name, a.artist, a.album_art FROM "ALBUM_MEDIA_JOIN
-#define SELECT_ARTIST_LIST "SELECT DISTINCT artist FROM "DB_TABLE_MEDIA" WHERE validity=1"
-#define SELECT_GENRE_LIST "SELECT DISTINCT genre FROM "DB_TABLE_MEDIA" WHERE validity=1"
-#define SELECT_COMPOSER_LIST "SELECT DISTINCT composer FROM "DB_TABLE_MEDIA" WHERE validity=1 "
-#define SELECT_YEAR_LIST "SELECT DISTINCT year FROM "DB_TABLE_MEDIA" WHERE validity=1 "
-#define SELECT_MEDIA_GROUP_LIST "SELECT DISTINCT %s FROM "DB_TABLE_MEDIA" WHERE validity=1 "
-
-#define SELECT_FOLDER_LIST "SELECT DISTINCT f.folder_uuid, f.path, f.name, f.storage_type, f.modified_time FROM "FOLDER_MEDIA_JOIN
-//#define SELECT_TAG_LIST SELECT_EMPTY_TAG" UNION "SELECT_TAG_FROM_TAG_TAGMAP_MEDIA_JOIN
-//#define SELECT_PLAYLIST_LIST SELECT_EMPTY_PLAYLIST" UNION "SELECT_PLAYLIST_FROM_PLAYLIST_PLAYLISTMAP_MEDIA_JOIN
+#define SELECT_MEDIA_GROUP_LIST "SELECT DISTINCT %s FROM '%s' WHERE validity=1 "
+
+#define SELECT_FOLDER_LIST "SELECT DISTINCT f.folder_uuid, f.path, f.name, f.storage_type, f.modified_time, f.storage_uuid, f.folder_order FROM "FOLDER_MEDIA_JOIN
+#define SELECT_FOLDER_LIST_BY_STORAGE_ID SELECT_FOLDER_LIST"AND f.storage_uuid='%s' "
#define SELECT_TAG_LIST "SELECT DISTINCT tag_id, name FROM "DB_VIEW_TAG" WHERE 1 "
-#define SELECT_PLAYLIST_LIST "SELECT DISTINCT playlist_id, name, thumbnail_path FROM "DB_VIEW_PLAYLIST" WHERE 1 "
-#define SELECT_BOOKMARK_LIST "SELECT DISTINCT b.bookmark_id, b.media_uuid, b.marked_time, b.thumbnail_path FROM "BOOKMARK_MEDIA_JOIN
+#define SELECT_PLAYLIST_LIST "SELECT DISTINCT playlist_id, name, p_thumbnail_path FROM "DB_VIEW_PLAYLIST" WHERE 1 "
/* Get Group Count */
#define SELECT_ALBUM_COUNT "SELECT COUNT(DISTINCT a.album_id) FROM "ALBUM_MEDIA_JOIN
-#define SELECT_ARTIST_COUNT "SELECT COUNT(DISTINCT artist) FROM "DB_TABLE_MEDIA" WHERE validity=1"
-#define SELECT_GENRE_COUNT "SELECT COUNT(DISTINCT genre) FROM "DB_TABLE_MEDIA" WHERE validity=1"
-#define SELECT_COMPOSER_COUNT "SELECT COUNT(DISTINCT composer) FROM "DB_TABLE_MEDIA" WHERE validity=1"
-#define SELECT_YEAR_COUNT "SELECT COUNT(DISTINCT year) FROM "DB_TABLE_MEDIA" WHERE validity=1"
#define SELECT_FOLDER_COUNT "SELECT COUNT(DISTINCT f.folder_uuid) FROM "FOLDER_MEDIA_JOIN
-//#define SELECT_TAG_COUNT "SELECT COUNT(*) FROM ("SELECT_TAG_LIST
-//#define SELECT_PLAYLIST_COUNT "SELECT COUNT(*) FROM ("SELECT_PLAYLIST_LIST
+#define SELECT_FOLDER_COUNT_BY_STORAGE_ID SELECT_FOLDER_COUNT"AND f.storage_uuid='%s' "
#define SELECT_TAG_COUNT "SELECT COUNT(DISTINCT tag_id) FROM "DB_VIEW_TAG" WHERE 1 "
#define SELECT_PLAYLIST_COUNT "SELECT COUNT(DISTINCT playlist_id) FROM "DB_VIEW_PLAYLIST" WHERE 1 "
#define SELECT_BOOKMARK_COUNT "SELECT COUNT(DISTINCT b.bookmark_id) FROM "BOOKMARK_MEDIA_JOIN
/* Get Media Count of Group */
#define SELECT_MEDIA_COUNT_FROM_MEDIA "SELECT COUNT(*) FROM ("SELECT_MEDIA_ITEM //to apply limit condition. "SELECT COUNT(*) FROM "DB_TABLE_MEDIA" WHERE validity=1"
-#define SELECT_MEDIA_COUNT_FROM_MEDIA_SIMPLE "SELECT COUNT(*) FROM "DB_TABLE_MEDIA" WHERE validity=1 "
-#define SELECT_MEDIA_COUNT_FROM_ALBUM "SELECT COUNT(*) FROM "DB_TABLE_MEDIA" WHERE validity=1 AND album_id='%d'"
-#define SELECT_MEDIA_COUNT_FROM_ARTIST "SELECT COUNT(*) FROM "DB_TABLE_MEDIA" WHERE validity=1 AND artist='%q'"
-#define SELECT_MEDIA_COUNT_FROM_GENRE "SELECT COUNT(*) FROM "DB_TABLE_MEDIA" WHERE validity=1 AND genre='%q'"
-#define SELECT_MEDIA_COUNT_FROM_COMPOSER "SELECT COUNT(*) FROM "DB_TABLE_MEDIA" WHERE validity=1 AND composer='%q'"
-#define SELECT_MEDIA_COUNT_FROM_YEAR "SELECT COUNT(*) FROM "DB_TABLE_MEDIA" WHERE validity=1 AND year='%q'"
+#define SELECT_MEDIA_COUNT_FROM_MEDIA_SIMPLE "SELECT COUNT(*) FROM '%s' WHERE validity=1 "
+#define SELECT_MEDIA_COUNT_FROM_ALBUM "SELECT COUNT(*) FROM '%s' WHERE validity=1 AND album_id='%d'"
#define SELECT_MEDIA_COUNT_FROM_GROUP "SELECT COUNT(*) FROM ("SELECT_MEDIA_FROM_GROUP //to apply limit condition.
#define SELECT_MEDIA_COUNT_FROM_GROUP_NULL "SELECT COUNT(*) FROM ("SELECT_MEDIA_FROM_GROUP_NULL //to apply limit condition.
-#define SELECT_MEDIA_COUNT_FROM_FOLDER "SELECT COUNT(*) FROM "DB_TABLE_MEDIA" WHERE validity=1 AND folder_uuid='%q'"
-//#define SELECT_MEDIA_COUNT_FROM_TAG "SELECT COUNT(*) FROM "DB_TABLE_TAG_MAP" WHERE tag_id=%d AND media_uuid IN (SELECT media_uuid FROM "DB_TABLE_MEDIA" WHERE validity=1"
-//#define SELECT_MEDIA_COUNT_FROM_PLAYLIST "SELECT COUNT(*) FROM "DB_TABLE_PLAYLIST_MAP" WHERE playlist_id=%d AND media_uuid IN (SELECT media_uuid FROM "DB_TABLE_MEDIA" WHERE validity=1"
+#define SELECT_MEDIA_COUNT_FROM_FOLDER "SELECT COUNT(*) FROM '%s' WHERE validity=1 AND folder_uuid='%q'"
+#define SELECT_MEDIA_COUNT_FROM_STORAGE "SELECT COUNT(*) FROM '%s' WHERE validity=1 AND storage_uuid='%q'"
#define SELECT_MEDIA_COUNT_FROM_TAG "SELECT COUNT(*) FROM "DB_VIEW_TAG" WHERE (tag_id=%d AND media_count>0) "
-#define SELECT_MEDIA_COUNT_FROM_PLAYLIST "SELECT COUNT(*) FROM "DB_VIEW_PLAYLIST" WHERE (playlist_id=%d and media_count>0) "
+#define SELECT_MEDIA_COUNT_FROM_PLAYLIST "SELECT COUNT(*) FROM "DB_VIEW_PLAYLIST" WHERE (playlist_id=%d and media_count>0) "
/* Get Group Info by Group ID*/
#define SELECT_ALBUM_FROM_ALBUM "SELECT * FROM "DB_TABLE_ALBUM" WHERE album_id=%d"
#define INSERT_TAG_TO_TAG "INSERT INTO "DB_TABLE_TAG" (name) VALUES (%Q)"
#define REMOVE_TAG_ITEM_FROM_TAG_MAP "DELETE FROM "DB_TABLE_TAG_MAP" WHERE tag_id=%d AND media_uuid='%q'"
#define UPDATE_TAG_NAME_FROM_TAG "UPDATE "DB_TABLE_TAG" SET name='%q' WHERE tag_id=%d"
-//#define SELECT_TAG_COUNT_BY_MEDIA_ID "SELECT COUNT(*) FROM "DB_TABLE_TAG" WHERE tag_id IN (SELECT tag_id FROM "DB_TABLE_TAG_MAP" WHERE media_uuid = '%q')"
-//#define SELECT_TAG_LIST_BY_MEDIA_ID "SELECT * FROM "DB_TABLE_TAG" WHERE tag_id IN (SELECT tag_id FROM "DB_TABLE_TAG_MAP" WHERE media_uuid = '%s')"
-#define SELECT_TAG_COUNT_BY_MEDIA_ID "SELECT COUNT(*) FROM "DB_VIEW_TAG" WHERE media_uuid = '%q'"
+#define SELECT_TAG_COUNT_BY_MEDIA_ID "SELECT COUNT(*) FROM "DB_VIEW_TAG" WHERE media_uuid = '%s'"
#define SELECT_TAG_LIST_BY_MEDIA_ID "SELECT tag_id, name FROM "DB_VIEW_TAG" WHERE media_uuid = '%s'"
/* Get Media list of Group */
#define MEDIA_INFO_ITEM "media_uuid, path, file_name, media_type, mime_type, size, added_time, modified_time, thumbnail_path, description, \
- rating, favourite, author, provider, content_name, category, location_tag, age_rating, keyword, is_drm, storage_type, longitude, latitude, altitude, exposure_time, fnumber, iso, model, width, height, datetaken, orientation, title, album, artist, album_artist, genre, composer, year, recorded_date, copyright, track_num, bitrate, bitpersample, duration, played_count, last_played_time, last_played_position, samplerate, channel, burst_id, timeline, weather, sync_status"
+ rating, favourite, author, provider, content_name, category, location_tag, age_rating, keyword, is_drm, storage_type, longitude, latitude, altitude, exposure_time, fnumber, iso, model, width, height, datetaken, orientation, title, album, artist, album_artist, genre, composer, year, recorded_date, copyright, track_num, bitrate, bitpersample, duration, played_count, last_played_time, last_played_position, samplerate, channel, burst_id, timeline, weather, sync_status, storage_uuid"
+
+/*Folder info*/
+#define UPDATE_FOLDER_ORDER "UPDATE "DB_TABLE_FOLDER" SET folder_order=%d WHERE folder_uuid=%Q"
/* Playlist Info */
#define INSERT_PLAYLIST_TO_PLAYLIST "INSERT INTO "DB_TABLE_PLAYLIST" (name) VALUES (%Q)"
#define UPDATE_PLAYLIST_NAME_FROM_PLAYLIST "UPDATE "DB_TABLE_PLAYLIST" SET name='%q' WHERE playlist_id=%d"
-#define UPDATE_PLAYLIST_THUMBNAIL_FROM_PLAYLIST "UPDATE "DB_TABLE_PLAYLIST" SET thumbnail_path='%q' WHERE playlist_id=%d"
+#define UPDATE_PLAYLIST_THUMBNAIL_FROM_PLAYLIST "UPDATE "DB_TABLE_PLAYLIST" SET thumbnail_path='%q' WHERE playlist_id=%d"
#define SELECT_PLAYLIST_ID_FROM_PLAYLIST "SELECT playlist_id FROM "DB_TABLE_PLAYLIST" WHERE name='%q'"
-//#define SELECT_PLAYLIST_ITEM_ID_FROM_PLAYLIST_MAP "SELECT pm._id, pm.media_uuid FROM "PLAYLISTMAP_MEDIA_JOIN" AND pm.playlist_id=%d"
-#define SELECT_PLAYLIST_ITEM_ID_FROM_PLAYLIST_VIEW "SELECT pm_id, media_uuid FROM "DB_VIEW_PLAYLIST" WHERE playlist_id=%d "
-
-//#define SELECT_PLAY_ORDER_FROM_PLAYLIST_MAP "SELECT play_order FROM "DB_TABLE_PLAYLIST_MAP" WHERE playlist_id=%d and _id=%d"
+#define SELECT_PLAYLIST_ITEM_ID_FROM_PLAYLIST_VIEW "SELECT pm_id, media_uuid FROM "DB_VIEW_PLAYLIST" WHERE (playlist_id=%d and media_count>0) "
+#define SELECT_PLAYLIST_ITEM_ALL_FROM_PLAYLIST_VIEW "SELECT "MEDIA_INFO_ITEM", pm_id FROM "DB_VIEW_PLAYLIST" WHERE (playlist_id=%d and media_count>0) "
#define SELECT_PLAY_ORDER_FROM_PLAYLIST_VIEW "SELECT play_order FROM "DB_VIEW_PLAYLIST" WHERE playlist_id=%d and pm_id=%d"
-//#define SELECT_MAX_PLAY_ORDER_FROM_PLAYLIST_MAP "SELECT MAX(play_order) FROM "DB_TABLE_PLAYLIST_MAP" WHERE playlist_id=%d"
#define SELECT_MAX_PLAY_ORDER_FROM_PLAYLIST_VIEW "SELECT MAX(play_order) FROM "DB_VIEW_PLAYLIST" WHERE playlist_id=%d"
#define REMOVE_PLAYLIST_ITEM_FROM_PLAYLIST_MAP "DELETE FROM "DB_TABLE_PLAYLIST_MAP" WHERE playlist_id=%d AND _id=%d"
#define UPDATE_PLAYLIST_ORDER_FROM_PLAYLIST_MAP "UPDATE "DB_TABLE_PLAYLIST_MAP" SET play_order=%d WHERE playlist_id=%d AND _id=%d"
/* Bookmark */
-#define INSERT_BOOKMARK_TO_BOOKMARK "INSERT INTO "DB_TABLE_BOOKMARK" (media_uuid, marked_time, thumbnail_path) VALUES ('%q', '%d', %Q)"
-#define SELECT_BOOKMARK_COUNT_BY_MEDIA_ID "SELECT COUNT(*) FROM "DB_TABLE_BOOKMARK" WHERE media_uuid='%q'"
-#define SELECT_BOOKMARK_LIST_BY_MEDIA_ID "SELECT * FROM "DB_TABLE_BOOKMARK" WHERE media_uuid='%q'"
-#define SELECT_BOOKMARK_LIST_BY_MEDIA_ID_USUAL "SELECT * FROM "DB_TABLE_BOOKMARK" WHERE media_uuid='%s'"
-
-/* Get Meta */
-#define MEDIA_AV_META "media_uuid, title, album, artist, genre, composer, year, recorded_date, copyright, track_num, bitrate, duration, played_count, last_played_time, last_played_position"
-#define MEDIA_IMAGE_META "media_uuid, width, height, datetaken, orientation"
-#define SELECT_IMAGE_FROM_MEDIA "SELECT "MEDIA_IMAGE_META" FROM "DB_TABLE_MEDIA" WHERE media_uuid='%s'"
-#define SELECT_AUDIO_FROM_MEDIA "SELECT "MEDIA_AV_META", samplerate, channel FROM "DB_TABLE_MEDIA" WHERE media_uuid='%s'"
-#define SELECT_VIDEO_FROM_MEDIA "SELECT "MEDIA_AV_META", width, height FROM "DB_TABLE_MEDIA" WHERE media_uuid='%s'"
+#define INSERT_BOOKMARK_TO_BOOKMARK "INSERT INTO "DB_TABLE_BOOKMARK" (media_uuid, marked_time, thumbnail_path) VALUES ('%q', '%d', %Q)"
+#define SELECT_BOOKMARK_COUNT_BY_MEDIA_ID "SELECT COUNT(*) FROM "BOOKMARK_MEDIA_JOIN" AND b.media_uuid='%s'"
+#define SELECT_BOOKMARK_LIST_BY_MEDIA_ID "SELECT b.bookmark_id, b.media_uuid, b.marked_time, b.thumbnail_path FROM "BOOKMARK_MEDIA_JOIN" AND b.media_uuid='%s'"
/* Update Meta*/
-#define UPDATE_AV_META_FROM_MEDIA "UPDATE "DB_TABLE_MEDIA" SET played_count=%d, last_played_time=%d, last_played_position=%d WHERE media_uuid='%q'"
-#define UPDATE_IMAGE_META_FROM_MEDIA "UPDATE "DB_TABLE_MEDIA" SET orientation=%d, weather=%Q WHERE media_uuid='%q'"
-
-#define SELECT_MEDIA_ITEM "SELECT "MEDIA_INFO_ITEM" FROM "DB_TABLE_MEDIA" WHERE validity=1"
-#define SELECT_MEDIA_FROM_MEDIA "SELECT "MEDIA_INFO_ITEM" FROM "DB_TABLE_MEDIA" WHERE validity=1 AND media_uuid='%s'"
-#define SELECT_MEDIA_BY_PATH "SELECT "MEDIA_INFO_ITEM" FROM "DB_TABLE_MEDIA" WHERE validity=1 AND path='%q'"
-#define SELECT_MEDIA_FROM_ALBUM "SELECT "MEDIA_INFO_ITEM" FROM "DB_TABLE_MEDIA" WHERE validity=1 AND album_id=%d"
-#define SELECT_MEDIA_FROM_GROUP "SELECT "MEDIA_INFO_ITEM" FROM "DB_TABLE_MEDIA" WHERE validity=1 AND %s='%q'"
-#define SELECT_MEDIA_FROM_GROUP_NULL "SELECT "MEDIA_INFO_ITEM" FROM "DB_TABLE_MEDIA" WHERE validity=1 AND %s IS NULL"
-#define SELECT_MEDIA_FROM_FOLDER "SELECT "MEDIA_INFO_ITEM" FROM "DB_TABLE_MEDIA" WHERE validity=1 AND folder_uuid='%q'"
-#define SELECT_MEDIA_FROM_TAG "SELECT "MEDIA_INFO_ITEM" FROM "DB_TABLE_MEDIA" WHERE media_uuid IN (SELECT media_uuid FROM "DB_TABLE_TAG_MAP" WHERE tag_id=%d) AND validity=1"
-#define SELECT_MEDIA_FROM_PLAYLIST "SELECT "MEDIA_INFO_ITEM" FROM "DB_TABLE_MEDIA" WHERE media_uuid IN (SELECT media_uuid FROM "DB_TABLE_PLAYLIST_MAP" WHERE playlist_id=%d) AND validity=1"
-#define SELECT_MEDIA_PATH_BY_ID "SELECT path FROM "DB_TABLE_MEDIA" WHERE media_uuid='%q'"
+#define UPDATE_AV_META_FROM_MEDIA "UPDATE '%s' SET played_count=%d, last_played_time=%d, last_played_position=%d WHERE media_uuid='%q'"
+#define UPDATE_IMAGE_META_FROM_MEDIA "UPDATE '%s' SET orientation=%d, weather=%Q WHERE media_uuid='%q'"
+
+#define SELECT_MEDIA_ITEM "SELECT "MEDIA_INFO_ITEM" FROM '%s' WHERE validity=1"
+#define SELECT_MEDIA_FROM_MEDIA "SELECT "MEDIA_INFO_ITEM" FROM '%s' WHERE validity=1 AND media_uuid='%s'"
+#define SELECT_MEDIA_BY_PATH "SELECT "MEDIA_INFO_ITEM" FROM '%s' WHERE validity=1 AND path='%q'"
+#define SELECT_MEDIA_FROM_ALBUM "SELECT "MEDIA_INFO_ITEM" FROM '%s' WHERE validity=1 AND album_id=%d"
+#define SELECT_MEDIA_FROM_GROUP "SELECT "MEDIA_INFO_ITEM" FROM '%s' WHERE validity=1 AND %s='%q'"
+#define SELECT_MEDIA_FROM_GROUP_NULL "SELECT "MEDIA_INFO_ITEM" FROM '%s' WHERE validity=1 AND %s IS NULL"
+#define SELECT_MEDIA_FROM_FOLDER "SELECT "MEDIA_INFO_ITEM" FROM '%s' WHERE validity=1 AND folder_uuid='%s'"
+#define SELECT_MEDIA_FROM_STORAGE "SELECT "MEDIA_INFO_ITEM" FROM '%s' WHERE validity=1 AND storage_uuid='%s'"
+#define SELECT_MEDIA_FROM_TAG "SELECT "MEDIA_INFO_ITEM" FROM '%s' WHERE media_uuid IN (SELECT media_uuid FROM "DB_TABLE_TAG_MAP" WHERE tag_id=%d) AND validity=1"
+#define SELECT_MEDIA_FROM_PLAYLIST "SELECT "MEDIA_INFO_ITEM" FROM '%s' WHERE media_uuid IN (SELECT media_uuid FROM "DB_TABLE_PLAYLIST_MAP" WHERE playlist_id=%d) AND validity=1"
+#define SELECT_MEDIA_PATH_BY_ID "SELECT path FROM "DB_TABLE_MEDIA_VIEW" WHERE media_uuid='%q'"
+#define SELECT_MEDIA_STORAGE_ID_BY_ID "SELECT storage_uuid FROM "DB_TABLE_MEDIA_VIEW" WHERE media_uuid='%q'"
/* Delete */
-#define DELETE_MEDIA_FROM_MEDIA "DELETE FROM "DB_TABLE_MEDIA" WHERE media_uuid='%q'"
-#define DELETE_MEDIA_FROM_MEDIA_BATCH "DELETE FROM "DB_TABLE_MEDIA" WHERE %s"
-#define DELETE_FOLDER_FROM_FOLDER "DELETE FROM "DB_TABLE_FOLDER" WHERE folder_uuid='%q'"
-#define DELETE_PLAYLIST_FROM_PLAYLIST "DELETE FROM "DB_TABLE_PLAYLIST" WHERE playlist_id=%d"
-#define DELETE_TAG_FROM_TAG "DELETE FROM "DB_TABLE_TAG" WHERE tag_id=%d"
-#define DELETE_BOOKMARK_FROM_BOOKMARK "DELETE FROM "DB_TABLE_BOOKMARK" WHERE bookmark_id=%d"
+#define DELETE_MEDIA_FROM_MEDIA_BATCH "DELETE FROM '%s' WHERE %s"
+#define DELETE_PLAYLIST_FROM_PLAYLIST "DELETE FROM "DB_TABLE_PLAYLIST" WHERE playlist_id=%d"
+#define DELETE_TAG_FROM_TAG "DELETE FROM "DB_TABLE_TAG" WHERE tag_id=%d"
+#define DELETE_BOOKMARK_FROM_BOOKMARK "DELETE FROM "DB_TABLE_BOOKMARK" WHERE bookmark_id=%d"
+
+/* Storage*/
+#define SELECT_STORAGE_COUNT "SELECT COUNT(*) FROM "DB_TABLE_STORAGE" WHERE validity=1"
+#define SELECT_STORAGE_LIST "SELECT * FROM "DB_TABLE_STORAGE" WHERE validity=1"
+#define SELECT_STORAGE_INFO_FROM_STORAGE "SELECT * FROM "DB_TABLE_STORAGE" WHERE validity=1 AND storage_uuid='%s'"
+#define DEFAULT_MEDIA_STORAGE_ID "media"
int _content_query_prepare(sqlite3_stmt **stmt, char *select_query, char *condition_query, char *option_query);
int _content_error_capi(int type, int cotent_error);
MediaSvcHandle* _content_get_db_handle(void);
attribute_h _content_get_attirbute_handle(void);
attribute_h _content_get_alias_attirbute_handle(void);
+int _media_info_get_media_info_from_db(const char *path, const char *storage_id, media_info_h media);
void _media_info_item_get_detail(sqlite3_stmt *stmt, media_info_h media);
int _media_db_get_group_count(filter_h filter, group_list_e group_type, int *group_count);
int _media_db_get_media_group_count(media_group_e group, filter_h filter, int *group_count);
int _media_db_get_group_item_count(const char *group_name, filter_h filter, group_list_e group_type, int *item_count);
int _media_db_get_group_item_by_id(int group_id, filter_h filter, media_info_cb callback, void *user_data, group_list_e group_type);
int _media_db_get_group_item(const char *group_name, filter_h filter, media_info_cb callback, void *user_data, group_list_e group_type);
-int _media_db_get_media_group_item_count(const char *group_name, media_group_e group, filter_h filter, int *item_count);
-int _media_db_get_media_group_item(const char *group_name, media_group_e group, filter_h filter, media_info_cb callback, void *user_data);
+int _media_db_get_media_group_item_count(const char *group_name, filter_h filter, media_group_e group, int *item_count);
+int _media_db_get_media_group_item(const char *group_name, filter_h filter, media_group_e group, media_info_cb callback, void *user_data);
+int _media_db_get_storage(filter_h filter, media_storage_cb callback, void *user_data);
+int _media_db_get_storage_id_by_media_id(const char *media_id, char *storage_id);
/**
* @internal
*/
int _media_util_check_file(const char *path);
+
int _media_util_check_ignore_dir(const char *dir_path, bool *ignore);
-int _media_util_get_store_type_by_path(const char *path, int *storage_type);
#ifdef __cplusplus
Name: capi-content-media-content
Summary: A Media content library in SLP C API
-Version: 0.2.62
+Version: 0.2.63
Release: 0
Group: Multimedia/API
License: Apache-2.0
%postun -p /sbin/ldconfig
+
%files
%manifest %{name}.manifest
%license LICENSE.APLv2.0
if(_audio != NULL && STRING_VALID(_audio->media_id))
{
- sql = sqlite3_mprintf(UPDATE_AV_META_FROM_MEDIA, _audio->played_count, _audio->played_time, _audio->played_position, _audio->media_id);
+ char storage_id[MEDIA_CONTENT_UUID_SIZE+1] = {0,};
+ memset(storage_id, 0x00, sizeof(storage_id));
+
+ ret = _media_db_get_storage_id_by_media_id(_audio->media_id, storage_id);
+ media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
+
+ sql = sqlite3_mprintf(UPDATE_AV_META_FROM_MEDIA, storage_id, _audio->played_count, _audio->played_time, _audio->played_position, _audio->media_id);
ret = _content_query_sql(sql);
sqlite3_free(sql);
}
{
int ret = MEDIA_CONTENT_ERROR_NONE;
- media_content_debug_func();
-
if (bookmark_count == NULL)
{
media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
*/
+#include <media_content.h>
#include <media_info_private.h>
-#include <media-util.h>
+#include <media_util_private.h>
+
+#include <unicode/uscript.h>
+#include <unicode/uloc.h>
+#include <unicode/ucol.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <dirent.h>
+#include <fcntl.h>
static attribute_h g_attr_handle = NULL;
static attribute_h g_alias_attr_handle = NULL;
static MediaSvcHandle *db_handle = NULL;
static int ref_count = 0;
-static GMutex *db_mutex = NULL;
+static GMutex db_mutex;
static __thread media_noti_cb_s *g_noti_info = NULL;
ret = _media_filter_attribute_add(g_alias_attr_handle, FOLDER_NAME_PINYIN, DB_TABLE_ALIAS_FOLDER"."DB_FIELD_FOLDER_NAME_PINYIN);
media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
+ ret = _media_filter_attribute_add(g_alias_attr_handle, FOLDER_ORDER, DB_TABLE_ALIAS_FOLDER"."DB_FIELD_FOLDER_ORDER);
+ media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
+
/* Playlist*/
ret = _media_filter_attribute_add(g_alias_attr_handle, PLAYLIST_NAME, DB_TABLE_ALIAS_PLAYLIST"."DB_FIELD_PLAYLIST_NAME);
media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
ret = __media_content_create_alias_attr_handle();
+ if(ret != MEDIA_CONTENT_ERROR_NONE)
+ _media_filter_attribute_destory(g_attr_handle);
return ret;
}
//query = sqlite3_mprintf("%s %s %s", select_query, condition_query, option_query);
len = snprintf(query, sizeof(query), "%s %s %s", select_query, condition_query, option_query);
- if (len > 0) {
+ if (len > 0 && len < MAX_QUERY_SIZE) {
query[len] = '\0';
+ } else if (len >= MAX_QUERY_SIZE) {
+ query[MAX_QUERY_SIZE -1] = '\0';
} else {
media_content_error("snprintf failed");
return MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
}
- media_content_info("Query : [%s]", query);
+ media_content_sec_debug("Query : [%s]", query);
err = sqlite3_prepare_v2((sqlite3*)db_handle, query, strlen(query), stmt, NULL);
if(err != SQLITE_OK)
{
media_content_error("DB_FAILED(0x%08x) fail to sqlite3_prepare(), %s", MEDIA_CONTENT_ERROR_DB_FAILED, sqlite3_errmsg((sqlite3*)db_handle));
- if (err == SQLITE_BUSY)
+ if (err == SQLITE_BUSY) {
+ media_content_error(" BUSY ERROR");
return MEDIA_CONTENT_ERROR_DB_BUSY;
- else
+ } else if (err == SQLITE_PERM) {
+ media_content_error("PERMISSION EROR");
+ return MEDIA_CONTENT_ERROR_PERMISSION_DENIED;
+ } else {
+ media_content_error("OTHER ERROR");
return MEDIA_CONTENT_ERROR_DB_FAILED;
+ }
}
}
else
{
int ret = MEDIA_CONTENT_ERROR_NONE;
- if (!db_mutex)
- db_mutex = g_mutex_new();
-
- if (db_mutex != NULL) {
- g_mutex_lock(db_mutex);
-
- media_content_debug("ref count : %d", ref_count);
+ if (g_mutex_trylock(&db_mutex)) {
+ media_content_info("ref count : %d", ref_count);
if(ref_count == 0)
{
if(db_handle == NULL)
{
- ret = media_svc_connect(&db_handle,tzplatform_getuid(TZ_USER_NAME));
- }
-
- ret = _content_error_capi(MEDIA_CONTENT_TYPE, ret);
-
- if(ret == MEDIA_CONTENT_ERROR_NONE) {
ret = __media_content_create_attribute_handle();
+ if(ret == MEDIA_CONTENT_ERROR_NONE) {
+ ret = media_svc_connect(&db_handle,tzplatform_getuid(TZ_USER_NAME));
+ ret = _content_error_capi(MEDIA_CONTENT_TYPE, ret);
+ if(ret == MEDIA_CONTENT_ERROR_NONE) {
+ ref_count++;
+ //__media_content_create_collate();
+ } else {
+ __media_content_destroy_attribute_handle();
+ }
+ } else {
+ media_content_error("Internal DB Connection Error");
+ }
+ } else {
+ media_content_error("Wrong DB Connection status");
+ ret = MEDIA_CONTENT_ERROR_DB_FAILED;
+ }
+ } else {
+ if(db_handle != NULL) {
+ ref_count++;
+ } else {
+ media_content_error("Wrong DB Handle status");
+ ret = MEDIA_CONTENT_ERROR_DB_FAILED;
}
}
- ref_count++;
- g_mutex_unlock(db_mutex);
+ media_content_info("ref count changed to: %d", ref_count);
+ g_mutex_unlock(&db_mutex);
} else {
media_content_error("mutex is NULL");
+ ret = MEDIA_CONTENT_ERROR_DB_FAILED;
}
return ret;
{
int ret = MEDIA_CONTENT_ERROR_NONE;
- if (db_mutex != NULL) {
- g_mutex_lock(db_mutex);
-
+ if (g_mutex_trylock(&db_mutex)) {
media_content_debug("ref count : %d", ref_count);
if(ref_count > 0)
{
- ref_count--;
+ if(db_handle != NULL) {
+ ref_count--;
+ } else {
+ media_content_error("Wrong DB Handle status");
+ ret = MEDIA_CONTENT_ERROR_DB_FAILED;
+ }
}
else
{
media_content_error("DB_FAILED(0x%08x) database is not connected", MEDIA_CONTENT_ERROR_DB_FAILED);
- g_mutex_unlock(db_mutex);
+ g_mutex_unlock(&db_mutex);
return MEDIA_CONTENT_ERROR_DB_FAILED;
}
if(ret == MEDIA_CONTENT_ERROR_NONE) {
ret = __media_content_destroy_attribute_handle();
db_handle = NULL;
+ } else {
+ media_content_error("database disconnect fail");
+ ref_count++;
}
+ } else {
+ media_content_error("Wrong DB Handle status");
+ ret = MEDIA_CONTENT_ERROR_DB_FAILED;
}
- g_mutex_unlock(db_mutex);
- g_mutex_free(db_mutex);
- db_mutex = NULL;
+ g_mutex_unlock(&db_mutex);
+
+ media_content_info("ref count changed to: %d", ref_count);
return ret;
}
- g_mutex_unlock(db_mutex);
+ g_mutex_unlock(&db_mutex);
} else {
media_content_error("mutex is NULL");
+ ret = MEDIA_CONTENT_ERROR_INVALID_OPERATION;
}
+ media_content_info("ref count changed to: %d", ref_count);
+
return ret;
}
int media_content_scan_file(const char *path)
{
int ret = MEDIA_CONTENT_ERROR_NONE;
+ bool ignore_dir = FALSE;
+ char *folder_path = NULL;
+ int check_file = MEDIA_CONTENT_ERROR_NONE;
if (!STRING_VALID(path)) {
media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
return MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
}
- media_content_debug("Path : %s", path);
+ media_content_sec_debug("Path : %s", path);
+
+ check_file = _media_util_check_file(path);
+ if (check_file == MEDIA_CONTENT_ERROR_NONE) {
+ /* This means this path has to be inserted or refreshed */
+ folder_path = g_path_get_dirname(path);
+ ret = _media_util_check_ignore_dir(folder_path, &ignore_dir);
+ SAFE_FREE(folder_path);
+
+ if(ignore_dir) {
+ media_content_error("Invalid folder path");
+ return MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
+ }
- if (g_file_test(path, G_FILE_TEST_EXISTS)) {
- if (g_file_test(path, G_FILE_TEST_IS_REGULAR)) {
- /* This means this path has to be inserted or refreshed */
- media_content_debug("This path exists in file system.");
+ media_svc_storage_type_e storage_type;
- media_svc_storage_type_e storage_type;
+ ret = media_svc_get_storage_type(path, &storage_type);
+ if(ret != MS_MEDIA_ERR_NONE) {
+ media_content_sec_error("media_svc_get_storage_type failed : %d (%s)", ret, path);
+ return _content_error_capi(MEDIA_CONTENT_TYPE, ret);
+ }
- ret = media_svc_get_storage_type(path, &storage_type);
- if (ret < 0) {
- media_content_error("media_svc_get_storage_type failed : %d (%s)", ret, path);
+ ret = media_svc_check_item_exist_by_path(_content_get_db_handle(), path);
+ if (ret == MS_MEDIA_ERR_NONE) {
+ /* Refresh */
+ ret = media_svc_refresh_item(_content_get_db_handle(), storage_type, "media", path,tzplatform_getuid(TZ_USER_NAME));
+ if(ret != MS_MEDIA_ERR_NONE) {
+ media_content_error("media_svc_refresh_item failed : %d", ret);
return _content_error_capi(MEDIA_CONTENT_TYPE, ret);
}
- ret = media_svc_check_item_exist_by_path(_content_get_db_handle(), path);
- if (ret == MS_MEDIA_ERR_NONE) {
- /* Refresh */
- ret = media_svc_refresh_item(_content_get_db_handle(), storage_type, path, tzplatform_getuid(TZ_USER_NAME));
- if (ret < 0) {
- media_content_error("media_svc_refresh_item failed : %d", ret);
- return _content_error_capi(MEDIA_CONTENT_TYPE, ret);
+ } else if (ret == MS_MEDIA_ERR_DB_NO_RECORD) {
+ /* Insert */
+ ret = media_svc_insert_item_immediately(_content_get_db_handle(), storage_type, path,tzplatform_getuid(TZ_USER_NAME));
+ if(ret != MS_MEDIA_ERR_NONE) {
+ if (ret == MS_MEDIA_ERR_DB_CONSTRAINT_FAIL) {
+ media_content_sec_error("This item is already inserted. This may be normal operation because other process already did this (%s)", path);
+ ret = MEDIA_CONTENT_ERROR_NONE;
+ } else {
+ media_content_sec_error("media_svc_insert_item_immediately failed : %d (%s)", ret, path);
}
- } else if (ret == MS_MEDIA_ERR_DB_NO_RECORD) {
- /* Insert */
- ret = media_svc_insert_item_immediately(_content_get_db_handle(), storage_type, path, tzplatform_getuid(TZ_USER_NAME));
- if (ret < 0) {
- media_content_error("media_svc_insert_item_immediately failed : %d", ret);
- return _content_error_capi(MEDIA_CONTENT_TYPE, ret);
- }
- } else {
- media_content_error("media_svc_check_item_exist_by_path failed : %d", ret);
return _content_error_capi(MEDIA_CONTENT_TYPE, ret);
}
- } else if (g_file_test(path, G_FILE_TEST_IS_DIR)) {
- /* Dierectory is not accpted in this function */
- media_content_error("This path is directory");
- return MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
+ } else {
+ media_content_error("media_svc_check_item_exist_by_path failed : %d", ret);
+ return _content_error_capi(MEDIA_CONTENT_TYPE, ret);
}
+ } else if (check_file == MEDIA_CONTENT_ERROR_PERMISSION_DENIED) {
+ media_content_error("You have no permission for this file %d", ret);
+ return MEDIA_CONTENT_ERROR_PERMISSION_DENIED;
} else {
/* This means this path has to be deleted */
media_content_debug("This path doesn't exists in file system... So now start to delete it from DB");
- ret = media_svc_delete_item_by_path(_content_get_db_handle(), path, tzplatform_getuid(TZ_USER_NAME));
- if (ret < 0) {
+ ret = media_svc_delete_item_by_path(_content_get_db_handle(), "media", path, tzplatform_getuid(TZ_USER_NAME));
+ if(ret != MS_MEDIA_ERR_NONE) {
media_content_error("media_svc_delete_item_by_path failed : %d", ret);
return _content_error_capi(MEDIA_CONTENT_TYPE, ret);
}
dp = opendir(path);
if (dp == NULL) {
- media_content_error("error [%s, %s]", path, strerror(errno));
+ media_content_sec_error("path [%s]", path);
+ media_content_stderror("open dir fail");
if (errno == EACCES || errno == EPERM) {
return MEDIA_CONTENT_ERROR_PERMISSION_DENIED;
} else {
return MEDIA_CONTENT_ERROR_NONE;
}
+
int media_content_scan_folder(const char *path, bool is_recursive, media_scan_completed_cb callback, void *user_data)
{
int ret = MEDIA_CONTENT_ERROR_NONE;
if (ret == MEDIA_CONTENT_ERROR_PERMISSION_DENIED) {
return ret;
}
+
media_content_scan_cb_data *cb_data = NULL;
cb_data = (media_content_scan_cb_data *)malloc(sizeof(media_content_scan_cb_data));
if (cb_data == NULL) {
- media_content_error("malloc failed");
+ media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
}
cb_data->user_data = user_data;
ret = media_directory_scanning_async(path, is_recursive, _media_content_scan_cb, cb_data, tzplatform_getuid(TZ_USER_NAME));
- if (ret < 0) {
+ if(ret != MS_MEDIA_ERR_NONE) {
+ media_content_error("media_directory_scanning_async failed : %d", ret);
+ }
+
+ return _content_error_capi(MEDIA_REGISTER_TYPE, ret);
+}
+
+int media_content_cancel_scan_folder(const char *path)
+{
+ int ret = MEDIA_CONTENT_ERROR_NONE;
+
+ //ret = media_directory_scanning_cancel(path);
+ if(ret != MS_MEDIA_ERR_NONE) {
media_content_error("media_directory_scanning_async failed : %d", ret);
}
{
int ret = MEDIA_CONTENT_ERROR_NONE;
+ if (callback == NULL) {
+ media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
+ return MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
+ }
+
+ if (g_noti_info != NULL) {
+ media_content_error("Noti callback is alreay set");
+ return MEDIA_CONTENT_ERROR_INVALID_OPERATION;
+ }
+
g_noti_info = (media_noti_cb_s*)calloc(1, sizeof(media_noti_cb_s));
if (g_noti_info == NULL) {
media_content_error("Failed to create noti info");
return _content_error_capi(MEDIA_REGISTER_TYPE, ret);
}
-int media_content_unset_db_updated_cb()
+int media_content_unset_db_updated_cb(void)
{
int ret = MEDIA_CONTENT_ERROR_NONE;
return _content_error_capi(MEDIA_REGISTER_TYPE, ret);
}
-
#include <media_info_private.h>
static char * __media_db_get_group_name(media_group_e group);
+static int __media_db_make_query(filter_h filter, attribute_h attr, char *select_query, int select_query_size, char **condition_query, char **option_query);
static char * __media_db_get_group_name(media_group_e group)
{
return NULL;
}
+static int __media_db_make_query(filter_h filter, attribute_h attr, char *select_query, int select_query_size, char **condition_query, char **option_query)
+{
+ int ret = MEDIA_CONTENT_ERROR_NONE;
+ filter_s *_filter = NULL;
+
+ if(filter != NULL)
+ {
+ _filter = (filter_s*)filter;
+
+ if(STRING_VALID(_filter->condition))
+ {
+ /*bracket should be added to condition. If application use "OR" condition, F/W restriction condition like "validity=1" is disregared
+ ex) select path from media where validity=1 and media_type=3 or media_type=1;*/
+ char bracket_added_condition[MAX_QUERY_SIZE] = {0, };
+ memset(bracket_added_condition, 0x00, sizeof(bracket_added_condition));
+
+ SAFE_STRLCAT(bracket_added_condition, QUERY_KEYWORD_OPEN_BRACKET, MAX_QUERY_SIZE);
+ SAFE_STRLCAT(bracket_added_condition, _filter->condition, MAX_QUERY_SIZE);
+ SAFE_STRLCAT(bracket_added_condition, QUERY_KEYWORD_BRACKET, MAX_QUERY_SIZE);
+ {
+ ret = _media_filter_attribute_generate(attr, bracket_added_condition, _filter->condition_collate_type, condition_query);
+ media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
+ }
+ }
+
+ ret = _media_filter_attribute_option_generate(attr, filter, option_query);
+ if(ret != MEDIA_CONTENT_ERROR_NONE)
+ {
+ SAFE_FREE(*condition_query);
+ return ret;
+ }
+
+ if(STRING_VALID(*condition_query))
+ {
+ SAFE_STRLCAT(select_query, QUERY_KEYWORD_SPACE, select_query_size);
+ SAFE_STRLCAT(select_query, QUERY_KEYWORD_AND, select_query_size);
+ }
+ }
+
+ return ret;
+}
+
int _media_db_get_group_count(filter_h filter, group_list_e group_type, int *group_count)
{
int ret = MEDIA_CONTENT_ERROR_NONE;
- int ret_view = MEDIA_CONTENT_ERROR_NONE;
sqlite3_stmt *stmt = NULL;
- filter_s *_filter = NULL;
- char select_query[DEFAULT_QUERY_SIZE];
+ char select_query[MAX_QUERY_SIZE] = {0, };
char *condition_query = NULL;
char *option_query = NULL;
- attribute_h attr;
-
- media_content_debug_func();
-
- memset(select_query, 0x00, sizeof(select_query));
+ attribute_h attr = NULL;
+ filter_s *_filter = (filter_s*)filter;
attr = _content_get_attirbute_handle();
+ memset(select_query, 0x00, sizeof(select_query));
switch(group_type) {
case MEDIA_GROUP_NONE:
break;
case MEDIA_GROUP_ALBUM:
attr = _content_get_alias_attirbute_handle();
- //snprintf(select_query, sizeof(select_query), SELECT_ALBUM_COUNT);
- if(!SAFE_STRLCPY(select_query, SELECT_ALBUM_COUNT, sizeof(select_query)))
- {
- media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
- return MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
- }
+
+ if((_filter != NULL) && STRING_VALID(_filter->storage_id))
+ snprintf(select_query, sizeof(select_query), SELECT_ALBUM_COUNT, _filter->storage_id);
+ else
+ snprintf(select_query, sizeof(select_query), SELECT_ALBUM_COUNT, DB_TABLE_MEDIA_VIEW);
break;
case MEDIA_GROUP_FOLDER:
attr = _content_get_alias_attirbute_handle();
- //snprintf(select_query, sizeof(select_query), SELECT_FOLDER_COUNT);
if(!SAFE_STRLCPY(select_query, SELECT_FOLDER_COUNT, sizeof(select_query)))
{
media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
return MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
}
+
+ if((_filter != NULL) && STRING_VALID(_filter->storage_id))
+ snprintf(select_query, sizeof(select_query), SELECT_FOLDER_COUNT_BY_STORAGE_ID, _filter->storage_id, _filter->storage_id);
+ else
+ snprintf(select_query, sizeof(select_query), SELECT_FOLDER_COUNT, DB_TABLE_MEDIA_VIEW);
+
break;
case MEDIA_GROUP_PLAYLIST:
- //attr = _content_get_alias_attirbute_handle();
- //snprintf(select_query, sizeof(select_query), SELECT_PLAYLIST_COUNT);
if(!SAFE_STRLCPY(select_query, SELECT_PLAYLIST_COUNT, sizeof(select_query)))
{
media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
}
break;
case MEDIA_GROUP_TAG:
- //attr = _content_get_alias_attirbute_handle();
- //snprintf(select_query, sizeof(select_query), SELECT_TAG_COUNT);
if(!SAFE_STRLCPY(select_query, SELECT_TAG_COUNT, sizeof(select_query)))
{
media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
break;
case MEDIA_GROUP_BOOKMARK:
attr = _content_get_alias_attirbute_handle();
- //snprintf(select_query, sizeof(select_query), SELECT_BOOKMARK_COUNT);
- if(!SAFE_STRLCPY(select_query, SELECT_BOOKMARK_COUNT, sizeof(select_query)))
+
+ if((_filter != NULL) && STRING_VALID(_filter->storage_id))
+ snprintf(select_query, sizeof(select_query), SELECT_BOOKMARK_COUNT, _filter->storage_id);
+ else
+ snprintf(select_query, sizeof(select_query), SELECT_BOOKMARK_COUNT, DB_TABLE_MEDIA_VIEW);
+
+ break;
+ case MEDIA_GROUP_STORAGE:
+ if(!SAFE_STRLCPY(select_query, SELECT_STORAGE_COUNT, sizeof(select_query)))
{
media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
return MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
break;
}
- if(filter != NULL)
- {
- _filter = (filter_s*)filter;
-
- if(STRING_VALID(_filter->condition))
- {
- ret = _media_filter_attribute_generate(attr, _filter->condition, _filter->condition_collate_type, &condition_query);
- media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
- }
-
- ret = _media_filter_attribute_option_generate(attr, filter, &option_query);
- if(ret != MEDIA_CONTENT_ERROR_NONE)
- {
- SAFE_FREE(condition_query);
- return ret;
- }
-
- if(STRING_VALID(condition_query))
- {
- SAFE_STRLCAT(select_query, QUERY_KEYWORD_SPACE, sizeof(select_query));
- SAFE_STRLCAT(select_query, QUERY_KEYWORD_AND, sizeof(select_query));
- }
- }
+ ret = __media_db_make_query(filter, attr, select_query, sizeof(select_query), &condition_query, &option_query);
+ media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
ret = _content_query_prepare(&stmt, select_query, condition_query, option_query);
SAFE_FREE(condition_query);
while(sqlite3_step(stmt) == SQLITE_ROW)
{
*group_count = (int)sqlite3_column_int(stmt, 0);
- media_content_debug("group count : [%d]", *group_count);
}
SQLITE3_FINALIZE(stmt);
+
return ret;
}
int _media_db_get_media_group_count(media_group_e group, filter_h filter, int *group_count)
{
int ret = MEDIA_CONTENT_ERROR_NONE;
- int ret_view = MEDIA_CONTENT_ERROR_NONE;
sqlite3_stmt *stmt = NULL;
- filter_s *_filter = NULL;
- char select_query[DEFAULT_QUERY_SIZE];
+ char select_query[MAX_QUERY_SIZE] = {0, };
char *condition_query = NULL;
char *option_query = NULL;
+ attribute_h attr = NULL;
+ filter_s *_filter = (filter_s*)filter;
- media_content_debug_func();
-
+ attr = _content_get_attirbute_handle();
memset(select_query, 0x00, sizeof(select_query));
- snprintf(select_query, sizeof(select_query), SELECT_MEDIA_GROUP_COUNT, __media_db_get_group_name(group));
-
- if(filter != NULL)
- {
- _filter = (filter_s*)filter;
-
- if(STRING_VALID(_filter->condition))
- {
- ret = _media_filter_attribute_generate(_content_get_attirbute_handle(), _filter->condition, _filter->condition_collate_type, &condition_query);
- media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
- }
-
- ret = _media_filter_attribute_option_generate(_content_get_attirbute_handle(), filter, &option_query);
- if(ret != MEDIA_CONTENT_ERROR_NONE)
- {
- SAFE_FREE(condition_query);
- return ret;
- }
-
- if(STRING_VALID(condition_query))
- {
- SAFE_STRLCAT(select_query, QUERY_KEYWORD_SPACE, sizeof(select_query));
- SAFE_STRLCAT(select_query, QUERY_KEYWORD_AND, sizeof(select_query));
- }
-
- SAFE_STRLCAT(select_query, QUERY_KEYWORD_SPACE, sizeof(select_query));
- if(STRING_VALID(condition_query))
- SAFE_STRLCAT(select_query, condition_query, sizeof(select_query));
- if(STRING_VALID(option_query))
- SAFE_STRLCAT(select_query, option_query, sizeof(select_query));
+ if((_filter != NULL) && STRING_VALID(_filter->storage_id))
+ snprintf(select_query, sizeof(select_query), SELECT_MEDIA_GROUP_COUNT, __media_db_get_group_name(group), _filter->storage_id);
+ else
+ snprintf(select_query, sizeof(select_query), SELECT_MEDIA_GROUP_COUNT, __media_db_get_group_name(group), DB_TABLE_MEDIA_VIEW);
- SAFE_FREE(condition_query);
- SAFE_FREE(option_query);
- }
+ ret = __media_db_make_query(filter, attr, select_query, sizeof(select_query), &condition_query, &option_query);
+ media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
+ SAFE_STRLCAT(select_query, QUERY_KEYWORD_SPACE, sizeof(select_query));
+ if(STRING_VALID(condition_query))
+ SAFE_STRLCAT(select_query, condition_query, sizeof(select_query));
+ if(STRING_VALID(option_query))
+ SAFE_STRLCAT(select_query, option_query, sizeof(select_query));
SAFE_STRLCAT(select_query, QUERY_KEYWORD_BRACKET, sizeof(select_query));
+ SAFE_FREE(condition_query);
+ SAFE_FREE(option_query);
+
ret = _content_query_prepare(&stmt, select_query, condition_query, option_query);
SAFE_FREE(condition_query);
SAFE_FREE(option_query);
while(sqlite3_step(stmt) == SQLITE_ROW)
{
*group_count = (int)sqlite3_column_int(stmt, 0);
- media_content_debug("group count : [%d]", *group_count);
}
SQLITE3_FINALIZE(stmt);
+
return ret;
}
int _media_db_get_media_group(media_group_e group, filter_h filter, media_group_cb callback, void *user_data)
{
int ret = MEDIA_CONTENT_ERROR_NONE;
- int ret_view = MEDIA_CONTENT_ERROR_NONE;
- char select_query[DEFAULT_QUERY_SIZE];
+ char select_query[MAX_QUERY_SIZE] = {0, };
char *condition_query = NULL;
char *option_query = NULL;
char *name = NULL;
sqlite3_stmt *stmt = NULL;
- filter_s *_filter = NULL;
+ attribute_h attr = NULL;
+ filter_s *_filter = (filter_s*)filter;
+ attr = _content_get_attirbute_handle();
memset(select_query, 0x00, sizeof(select_query));
- snprintf(select_query, sizeof(select_query), SELECT_MEDIA_GROUP_LIST, __media_db_get_group_name(group));
-
- if(filter != NULL)
- {
- _filter = (filter_s*)filter;
-
- if(_filter->condition)
- {
- ret = _media_filter_attribute_generate(_content_get_attirbute_handle(), _filter->condition, _filter->condition_collate_type, &condition_query);
- media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
- }
-
- ret = _media_filter_attribute_option_generate(_content_get_attirbute_handle(), filter, &option_query);
- if(ret != MEDIA_CONTENT_ERROR_NONE)
- {
- SAFE_FREE(condition_query);
- return ret;
- }
+ if((_filter != NULL) && STRING_VALID(_filter->storage_id))
+ snprintf(select_query, sizeof(select_query), SELECT_MEDIA_GROUP_LIST, __media_db_get_group_name(group), _filter->storage_id);
+ else
+ snprintf(select_query, sizeof(select_query), SELECT_MEDIA_GROUP_LIST, __media_db_get_group_name(group), DB_TABLE_MEDIA_VIEW);
- if(STRING_VALID(condition_query))
- {
- SAFE_STRLCAT(select_query, QUERY_KEYWORD_SPACE, sizeof(select_query));
- SAFE_STRLCAT(select_query, QUERY_KEYWORD_AND, sizeof(select_query));
- }
- }
+ ret = __media_db_make_query(filter, attr, select_query, sizeof(select_query), &condition_query, &option_query);
+ media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
ret = _content_query_prepare(&stmt, select_query, condition_query, option_query);
SAFE_FREE(condition_query);
if(STRING_VALID((const char *)sqlite3_column_text(stmt, 0)))
{
name = strdup((const char *)sqlite3_column_text(stmt, 0));
- media_content_debug("group name : [%s]", name);
}
if(callback(name, user_data) == false)
}
SQLITE3_FINALIZE(stmt);
+
return ret;
}
int _media_db_get_album(filter_h filter, media_album_cb callback, void *user_data)
{
int ret = MEDIA_CONTENT_ERROR_NONE;
- int ret_view = MEDIA_CONTENT_ERROR_NONE;
- char select_query[DEFAULT_QUERY_SIZE];
+ char select_query[MAX_QUERY_SIZE] = {0, };
char *condition_query = NULL;
char *option_query = NULL;
sqlite3_stmt *stmt = NULL;
- filter_s *_filter = NULL;
+ attribute_h attr = NULL;
+ filter_s *_filter = (filter_s*)filter;
+ attr = _content_get_alias_attirbute_handle();
memset(select_query, 0x00, sizeof(select_query));
- //snprintf(select_query, sizeof(select_query), SELECT_ALBUM_LIST);
- if(!SAFE_STRLCPY(select_query, SELECT_ALBUM_LIST, sizeof(select_query)))
- {
- media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
- return MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
- }
-
- if(filter != NULL)
- {
- _filter = (filter_s*)filter;
-
- if(_filter->condition)
- {
- ret = _media_filter_attribute_generate(_content_get_alias_attirbute_handle(), _filter->condition, _filter->condition_collate_type, &condition_query);
- media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
- }
-
- ret = _media_filter_attribute_option_generate(_content_get_alias_attirbute_handle(), filter, &option_query);
- if(ret != MEDIA_CONTENT_ERROR_NONE)
- {
- SAFE_FREE(condition_query);
- return ret;
- }
+ if((_filter != NULL) && STRING_VALID(_filter->storage_id))
+ snprintf(select_query, sizeof(select_query), SELECT_ALBUM_LIST, _filter->storage_id);
+ else
+ snprintf(select_query, sizeof(select_query), SELECT_ALBUM_LIST, DB_TABLE_MEDIA_VIEW);
- if(STRING_VALID(condition_query))
- {
- SAFE_STRLCAT(select_query, QUERY_KEYWORD_SPACE, sizeof(select_query));
- SAFE_STRLCAT(select_query, QUERY_KEYWORD_AND, sizeof(select_query));
- }
- }
+ ret = __media_db_make_query(filter, attr, select_query, sizeof(select_query), &condition_query, &option_query);
+ media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
ret = _content_query_prepare(&stmt, select_query, condition_query, option_query);
SAFE_FREE(condition_query);
}
SQLITE3_FINALIZE(stmt);
+
return ret;
}
int _media_db_get_folder(filter_h filter, media_folder_cb callback, void *user_data)
{
int ret = MEDIA_CONTENT_ERROR_NONE;
- int ret_view = MEDIA_CONTENT_ERROR_NONE;
- char select_query[DEFAULT_QUERY_SIZE];
+ char select_query[MAX_QUERY_SIZE] = {0, };
char *condition_query = NULL;
char *option_query = NULL;
sqlite3_stmt *stmt = NULL;
- filter_s *_filter = NULL;
-
+ attribute_h attr = NULL;
+ filter_s *_filter = (filter_s*)filter;
+ attr = _content_get_alias_attirbute_handle();
memset(select_query, 0x00, sizeof(select_query));
- //snprintf(select_query, sizeof(select_query), SELECT_FOLDER_LIST);
- if(!SAFE_STRLCPY(select_query, SELECT_FOLDER_LIST, sizeof(select_query)))
- {
- media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
- return MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
- }
-
- if(filter != NULL)
- {
- _filter = (filter_s*)filter;
-
- if(_filter->condition)
- {
- ret = _media_filter_attribute_generate(_content_get_alias_attirbute_handle(), _filter->condition, _filter->condition_collate_type, &condition_query);
- media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
- }
-
- ret = _media_filter_attribute_option_generate(_content_get_alias_attirbute_handle(), filter, &option_query);
- if(ret != MEDIA_CONTENT_ERROR_NONE)
- {
- SAFE_FREE(condition_query);
- return ret;
- }
+ if((_filter != NULL) && STRING_VALID(_filter->storage_id))
+ snprintf(select_query, sizeof(select_query), SELECT_FOLDER_LIST_BY_STORAGE_ID, _filter->storage_id, _filter->storage_id);
+ else
+ snprintf(select_query, sizeof(select_query), SELECT_FOLDER_LIST, DB_TABLE_MEDIA_VIEW);
- if(STRING_VALID(condition_query))
- {
- SAFE_STRLCAT(select_query, QUERY_KEYWORD_SPACE, sizeof(select_query));
- SAFE_STRLCAT(select_query, QUERY_KEYWORD_AND, sizeof(select_query));
- }
- }
+ ret = __media_db_make_query(filter, attr, select_query, sizeof(select_query), &condition_query, &option_query);
+ media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
ret = _content_query_prepare(&stmt, select_query, condition_query, option_query);
+
SAFE_FREE(condition_query);
SAFE_FREE(option_query);
media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
if(STRING_VALID((const char *)sqlite3_column_text(stmt, 2)))
_folder->name = strdup((const char *)sqlite3_column_text(stmt, 2));
- _folder->storage_type = (int)sqlite3_column_int(stmt,3);
+ _folder->storage_type = (int)sqlite3_column_int(stmt, 3);
- _folder->modified_time = (int)sqlite3_column_int(stmt,4);
+ _folder->modified_time = (int)sqlite3_column_int(stmt, 4);
+
+ if(STRING_VALID((const char *)sqlite3_column_text(stmt, 5)))
+ _folder->storage_uuid = strdup((const char *)sqlite3_column_text(stmt, 5));
+
+ _folder->folder_order = (int)sqlite3_column_int(stmt, 6);
if(callback((media_folder_h)_folder, user_data) == false)
{
}
SQLITE3_FINALIZE(stmt);
+
return ret;
}
int _media_db_get_playlist(filter_h filter, media_playlist_cb callback, void *user_data)
{
int ret = MEDIA_CONTENT_ERROR_NONE;
- int ret_view = MEDIA_CONTENT_ERROR_NONE;
- char select_query[DEFAULT_QUERY_SIZE];
+ char select_query[MAX_QUERY_SIZE] = {0, };
char *condition_query = NULL;
char *option_query = NULL;
sqlite3_stmt *stmt = NULL;
- filter_s *_filter = NULL;
+ attribute_h attr = NULL;
+ attr = _content_get_attirbute_handle();
memset(select_query, 0x00, sizeof(select_query));
- //snprintf(select_query, sizeof(select_query), SELECT_PLAYLIST_LIST);
if(!SAFE_STRLCPY(select_query, SELECT_PLAYLIST_LIST, sizeof(select_query)))
{
media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
return MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
}
-
- if(filter != NULL)
- {
- _filter = (filter_s*)filter;
-
- if(_filter->condition)
- {
- //ret = _media_filter_attribute_generate(_content_get_alias_attirbute_handle(), _filter->condition, _filter->condition_collate_type, &condition_query);
- ret = _media_filter_attribute_generate(_content_get_attirbute_handle(), _filter->condition, _filter->condition_collate_type, &condition_query);
- media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
- }
-
- //ret = _media_filter_attribute_option_generate(_content_get_alias_attirbute_handle(), filter, &option_query);
- ret = _media_filter_attribute_option_generate(_content_get_attirbute_handle(), filter, &option_query);
- if(ret != MEDIA_CONTENT_ERROR_NONE)
- {
- SAFE_FREE(condition_query);
- return ret;
- }
-
- if(STRING_VALID(condition_query))
- {
- SAFE_STRLCAT(select_query, QUERY_KEYWORD_SPACE, sizeof(select_query));
- SAFE_STRLCAT(select_query, QUERY_KEYWORD_AND, sizeof(select_query));
- }
- }
+ ret = __media_db_make_query(filter, attr, select_query, sizeof(select_query), &condition_query, &option_query);
+ media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
ret = _content_query_prepare(&stmt, select_query, condition_query, option_query);
SAFE_FREE(condition_query);
}
SQLITE3_FINALIZE(stmt);
+
return ret;
}
int _media_db_get_playlist_item(int playlist_id, filter_h filter, playlist_member_cb callback, void *user_data)
{
int ret = MEDIA_CONTENT_ERROR_NONE;
- int ret_view = MEDIA_CONTENT_ERROR_NONE;
- char select_query[DEFAULT_QUERY_SIZE];
+ char select_query[MAX_QUERY_SIZE] = {0, };
char *condition_query = NULL;
char *option_query = NULL;
sqlite3_stmt *stmt = NULL;
- filter_s *_filter = NULL;
+ attribute_h attr = NULL;
+ attr = _content_get_attirbute_handle();
memset(select_query, 0x00, sizeof(select_query));
- snprintf(select_query, sizeof(select_query), SELECT_PLAYLIST_ITEM_ID_FROM_PLAYLIST_VIEW, playlist_id);
-
- if(filter != NULL)
- {
- _filter = (filter_s*)filter;
-
- if(_filter->condition)
- {
- //ret = _media_filter_attribute_generate(_content_get_alias_attirbute_handle(), _filter->condition, _filter->condition_collate_type, &condition_query);
- ret = _media_filter_attribute_generate(_content_get_attirbute_handle(), _filter->condition, _filter->condition_collate_type, &condition_query);
- media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
- }
-
- //ret = _media_filter_attribute_option_generate(_content_get_alias_attirbute_handle(), filter, &option_query);
- ret = _media_filter_attribute_option_generate(_content_get_attirbute_handle(), filter, &option_query);
- if(ret != MEDIA_CONTENT_ERROR_NONE)
- {
- SAFE_FREE(condition_query);
- return ret;
- }
+ //snprintf(select_query, sizeof(select_query), SELECT_PLAYLIST_ITEM_ID_FROM_PLAYLIST_VIEW, playlist_id);
+ snprintf(select_query, sizeof(select_query), SELECT_PLAYLIST_ITEM_ALL_FROM_PLAYLIST_VIEW, playlist_id);
- if(STRING_VALID(condition_query))
- {
- SAFE_STRLCAT(select_query, QUERY_KEYWORD_SPACE, sizeof(select_query));
- SAFE_STRLCAT(select_query, QUERY_KEYWORD_AND, sizeof(select_query));
- }
- }
+ ret = __media_db_make_query(filter, attr, select_query, sizeof(select_query), &condition_query, &option_query);
+ media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
ret = _content_query_prepare(&stmt, select_query, condition_query, option_query);
SAFE_FREE(condition_query);
while(sqlite3_step(stmt) == SQLITE_ROW)
{
int playlist_member_id = 0;
- char media_uuid[MEDIA_CONTENT_UUID_SIZE+1];
- media_info_h media = NULL;
- memset(media_uuid, 0x00, sizeof(media_uuid));
+ playlist_member_id = (int)sqlite3_column_int(stmt, MEDIA_INFO_ITEM_MAX); //MEDIA_INFO_ITEM_MAX is pm_id
- playlist_member_id = (int)sqlite3_column_int(stmt, 0);
+ media_info_s *_media = (media_info_s*)calloc(1, sizeof(media_info_s));
- if(STRING_VALID((const char *)sqlite3_column_text(stmt, 1)))
- strncpy(media_uuid, (const char *)sqlite3_column_text(stmt, 1), MEDIA_CONTENT_UUID_SIZE);
+ if(_media == NULL)
+ {
+ media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
+ SQLITE3_FINALIZE(stmt);
+ return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
+ }
- ret = media_info_get_media_from_db(media_uuid, &media);
+ _media_info_item_get_detail(stmt, (media_info_h)_media);
- if(callback(playlist_member_id, media, user_data) == false)
+ if(callback(playlist_member_id, (media_info_h)_media, user_data) == false)
{
- media_info_destroy(media);
+ media_info_destroy((media_info_h)_media);
break;
}
- media_info_destroy(media);
+ media_info_destroy((media_info_h)_media);
+
}
SQLITE3_FINALIZE(stmt);
+
return ret;
}
-//same as _media_db_get_playlist
int _media_db_get_tag(const char *media_id, filter_h filter, media_tag_cb callback, void *user_data)
{
int ret = MEDIA_CONTENT_ERROR_NONE;
- int ret_view = MEDIA_CONTENT_ERROR_NONE;
- char select_query[DEFAULT_QUERY_SIZE];
+ char select_query[MAX_QUERY_SIZE] = {0, };
char *condition_query = NULL;
char *option_query = NULL;
sqlite3_stmt *stmt = NULL;
- filter_s *_filter = NULL;
- attribute_h attr;
+ attribute_h attr = NULL;
+ attr = _content_get_attirbute_handle();
memset(select_query, 0x00, sizeof(select_query));
if(!STRING_VALID(media_id))
{
- //attr = _content_get_alias_attirbute_handle();
- attr = _content_get_attirbute_handle();
- //snprintf(select_query, sizeof(select_query), SELECT_TAG_LIST);
if(!SAFE_STRLCPY(select_query, SELECT_TAG_LIST, sizeof(select_query)))
{
media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
}
else
{
- attr = _content_get_attirbute_handle();
snprintf(select_query, sizeof(select_query), SELECT_TAG_LIST_BY_MEDIA_ID, media_id);
}
- if(filter != NULL)
- {
- _filter = (filter_s*)filter;
+ ret = __media_db_make_query(filter, attr, select_query, sizeof(select_query), &condition_query, &option_query);
+ media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
- if(_filter->condition)
- {
- ret = _media_filter_attribute_generate(attr, _filter->condition, _filter->condition_collate_type, &condition_query);
- media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
- }
-
- ret = _media_filter_attribute_option_generate(attr, filter, &option_query);
- if(ret != MEDIA_CONTENT_ERROR_NONE)
- {
- SAFE_FREE(condition_query);
- return ret;
- }
-
- if(STRING_VALID(condition_query))
- {
- SAFE_STRLCAT(select_query, QUERY_KEYWORD_SPACE, sizeof(select_query));
- SAFE_STRLCAT(select_query, QUERY_KEYWORD_AND, sizeof(select_query));
- }
- }
-
- SAFE_STRLCAT(select_query, QUERY_KEYWORD_SPACE, sizeof(select_query));
+ SAFE_STRLCAT(select_query, QUERY_KEYWORD_SPACE, sizeof(select_query));
ret = _content_query_prepare(&stmt, select_query, condition_query, option_query);
SAFE_FREE(condition_query);
}
SQLITE3_FINALIZE(stmt);
+
return ret;
}
int _media_db_get_bookmark(const char *media_id, filter_h filter, media_bookmark_cb callback, void *user_data)
{
int ret = MEDIA_CONTENT_ERROR_NONE;
- int ret_view = MEDIA_CONTENT_ERROR_NONE;
- char select_query[DEFAULT_QUERY_SIZE];
+ char select_query[MAX_QUERY_SIZE] = {0, };
char *condition_query = NULL;
char *option_query = NULL;
sqlite3_stmt *stmt = NULL;
- filter_s *_filter = NULL;
- attribute_h attr;
+ attribute_h attr = NULL;
+ filter_s *_filter = (filter_s*)filter;
+
+ attr = _content_get_attirbute_handle();
memset(select_query, 0x00, sizeof(select_query));
- if(!STRING_VALID(media_id))
- {
- attr = _content_get_alias_attirbute_handle();
- //snprintf(select_query, sizeof(select_query), SELECT_BOOKMARK_LIST);
- if(!SAFE_STRLCPY(select_query, SELECT_BOOKMARK_LIST, sizeof(select_query)))
- {
- media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
- return MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
- }
- }
+ if((_filter != NULL) && STRING_VALID(_filter->storage_id))
+ snprintf(select_query, sizeof(select_query), SELECT_BOOKMARK_LIST_BY_MEDIA_ID, _filter->storage_id, media_id);
else
- {
- attr = _content_get_attirbute_handle();
- snprintf(select_query, sizeof(select_query), SELECT_BOOKMARK_LIST_BY_MEDIA_ID_USUAL, media_id);
- }
-
- if(filter != NULL)
- {
- _filter = (filter_s*)filter;
-
- if(_filter->condition)
- {
- ret = _media_filter_attribute_generate(attr, _filter->condition, _filter->condition_collate_type, &condition_query);
- media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
- }
-
- ret = _media_filter_attribute_option_generate(attr, filter, &option_query);
- if(ret != MEDIA_CONTENT_ERROR_NONE)
- {
- SAFE_FREE(condition_query);
- return ret;
- }
+ snprintf(select_query, sizeof(select_query), SELECT_BOOKMARK_LIST_BY_MEDIA_ID, DB_TABLE_MEDIA_VIEW, media_id);
- if(STRING_VALID(condition_query))
- {
- SAFE_STRLCAT(select_query, QUERY_KEYWORD_SPACE, sizeof(select_query));
- SAFE_STRLCAT(select_query, QUERY_KEYWORD_AND, sizeof(select_query));
- }
- }
+ ret = __media_db_make_query(filter, attr, select_query, sizeof(select_query), &condition_query, &option_query);
+ media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
ret = _content_query_prepare(&stmt, select_query, condition_query, option_query);
SAFE_FREE(condition_query);
}
SQLITE3_FINALIZE(stmt);
+
return ret;
}
int _media_db_get_group_item_count_by_id(int group_id, filter_h filter, group_list_e group_type, int *item_count)
{
int ret = MEDIA_CONTENT_ERROR_NONE;
- int ret_view = MEDIA_CONTENT_ERROR_NONE;
sqlite3_stmt *stmt = NULL;
- filter_s *_filter = NULL;
- char select_query[DEFAULT_QUERY_SIZE];
+ char select_query[MAX_QUERY_SIZE] = {0, };
char *condition_query = NULL;
char *option_query = NULL;
attribute_h attr = NULL;
+ filter_s *_filter = (filter_s*)filter;
- media_content_debug_func();
-
+ attr = _content_get_attirbute_handle();
memset(select_query, 0x00, sizeof(select_query));
if(group_type == MEDIA_GROUP_ALBUM)
{
- attr = _content_get_attirbute_handle();
- snprintf(select_query, sizeof(select_query), SELECT_MEDIA_COUNT_FROM_ALBUM, group_id);
+ if((_filter != NULL) && STRING_VALID(_filter->storage_id))
+ snprintf(select_query, sizeof(select_query), SELECT_MEDIA_COUNT_FROM_ALBUM, _filter->storage_id, group_id);
+ else
+ snprintf(select_query, sizeof(select_query), SELECT_MEDIA_COUNT_FROM_ALBUM, DB_TABLE_MEDIA_VIEW, group_id);
}
else if(group_type == MEDIA_GROUP_PLAYLIST)
{
- //attr = _content_get_alias_attirbute_handle();
- attr = _content_get_attirbute_handle();
snprintf(select_query, sizeof(select_query), SELECT_MEDIA_COUNT_FROM_PLAYLIST, group_id);
}
else if(group_type == MEDIA_GROUP_TAG)
{
- attr = _content_get_attirbute_handle();
snprintf(select_query, sizeof(select_query), SELECT_MEDIA_COUNT_FROM_TAG, group_id);
}
else
return MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
}
- if(filter != NULL)
- {
- _filter = (filter_s*)filter;
-
- if(_filter->condition)
- {
- ret = _media_filter_attribute_generate(attr, _filter->condition, _filter->condition_collate_type, &condition_query);
- media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
- }
-
- ret = _media_filter_attribute_option_generate(attr, filter, &option_query);
- if(ret != MEDIA_CONTENT_ERROR_NONE)
- {
- SAFE_FREE(condition_query);
- return ret;
- }
-
- if(STRING_VALID(condition_query))
- {
- SAFE_STRLCAT(select_query, QUERY_KEYWORD_SPACE, sizeof(select_query));
- SAFE_STRLCAT(select_query, QUERY_KEYWORD_AND, sizeof(select_query));
- }
- }
-/*
- if((group_type == MEDIA_GROUP_PLAYLIST) || (group_type == MEDIA_GROUP_TAG))
- {
- strncat(select_query, QUERY_KEYWORD_SPACE, strlen(QUERY_KEYWORD_SPACE));
-
- if(STRING_VALID(condition_query))
- strncat(select_query, condition_query, strlen(condition_query));
- if(STRING_VALID(option_query))
- strncat(select_query, option_query, strlen(option_query));
-
- strncat(select_query, QUERY_KEYWORD_BRACKET, strlen(QUERY_KEYWORD_BRACKET));
-
- SAFE_FREE(condition_query);
- SAFE_FREE(option_query);
- }
-*/
+ ret = __media_db_make_query(filter, attr, select_query, sizeof(select_query), &condition_query, &option_query);
+ media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
ret = _content_query_prepare(&stmt, select_query, condition_query, option_query);
SAFE_FREE(condition_query);
while(sqlite3_step(stmt) == SQLITE_ROW)
{
*item_count = (int)sqlite3_column_int(stmt, 0);
- media_content_debug("group item count : [%d]", *item_count);
}
SQLITE3_FINALIZE(stmt);
+
return ret;
}
int _media_db_get_group_item_count(const char *group_name, filter_h filter, group_list_e group_type, int *item_count)
{
int ret = MEDIA_CONTENT_ERROR_NONE;
- int ret_view = MEDIA_CONTENT_ERROR_NONE;
sqlite3_stmt *stmt = NULL;
- filter_s *_filter = NULL;
- char complete_select_query[DEFAULT_QUERY_SIZE];
- char *select_query = NULL;
+ char select_query[MAX_QUERY_SIZE] = {0, };
+ char *tmp_query = NULL;
char *condition_query = NULL;
char *option_query = NULL;
bool is_simple = FALSE;
+ attribute_h attr = NULL;
+ filter_s *_filter = (filter_s*)filter;
- media_content_debug_func();
+ attr = _content_get_attirbute_handle();
+ memset(select_query, 0x00, sizeof(select_query));
if(group_type == MEDIA_GROUP_NONE)
{
- /* There are 2 ways to get count for media table for performance
+ /* There are 2 ways to get count for media table for performance
If user wants to set offset and count, use SQL SELECT_MEDIA_COUNT_FROM_MEDIA.
If user wants to get count without setting count, SELECT_MEDIA_COUNT_FROM_MEDIA_SIMPLE */
- _filter = (filter_s *)filter;
- if (_filter) {
- if ((_filter->offset < 0) && (_filter->count < 0)) {
- select_query = sqlite3_mprintf(SELECT_MEDIA_COUNT_FROM_MEDIA_SIMPLE);
+ if (_filter && ((_filter->offset < 0) && (_filter->count < 0))) {
+ if(STRING_VALID(_filter->storage_id))
+ snprintf(select_query, sizeof(select_query), SELECT_MEDIA_COUNT_FROM_MEDIA_SIMPLE, _filter->storage_id);
+ else
+ snprintf(select_query, sizeof(select_query), SELECT_MEDIA_COUNT_FROM_MEDIA_SIMPLE, DB_TABLE_MEDIA_VIEW);
is_simple = TRUE;
- } else {
- select_query = sqlite3_mprintf(SELECT_MEDIA_COUNT_FROM_MEDIA);
- }
} else {
- select_query = sqlite3_mprintf(SELECT_MEDIA_COUNT_FROM_MEDIA);
+ snprintf(select_query, sizeof(select_query), SELECT_MEDIA_COUNT_FROM_MEDIA, DB_TABLE_MEDIA_VIEW);
}
}
else if(group_type == MEDIA_GROUP_FOLDER)
{
- select_query = sqlite3_mprintf(SELECT_MEDIA_COUNT_FROM_FOLDER, group_name);
+ if((_filter != NULL) && STRING_VALID(_filter->storage_id))
+ tmp_query = sqlite3_mprintf(SELECT_MEDIA_COUNT_FROM_FOLDER, _filter->storage_id, group_name);
+ else
+ tmp_query = sqlite3_mprintf(SELECT_MEDIA_COUNT_FROM_FOLDER, DB_TABLE_MEDIA_VIEW, group_name);
+
+ SAFE_STRLCAT(select_query, tmp_query, sizeof(select_query));
}
else if(group_type == MEDIA_GROUP_TAG_BY_MEDIA_ID)
{
- select_query = sqlite3_mprintf(SELECT_TAG_COUNT_BY_MEDIA_ID, group_name);
+ snprintf(select_query, sizeof(select_query), SELECT_TAG_COUNT_BY_MEDIA_ID, group_name);
}
else if(group_type == MEDIA_GROUP_BOOKMARK_BY_MEDIA_ID)
{
- select_query = sqlite3_mprintf(SELECT_BOOKMARK_COUNT_BY_MEDIA_ID, group_name);
+ if((_filter != NULL) && STRING_VALID(_filter->storage_id))
+ tmp_query = sqlite3_mprintf(SELECT_BOOKMARK_COUNT_BY_MEDIA_ID, _filter->storage_id, group_name);
+ else
+ tmp_query = sqlite3_mprintf(SELECT_BOOKMARK_COUNT_BY_MEDIA_ID, DB_TABLE_MEDIA_VIEW, group_name);
+
+ SAFE_STRLCAT(select_query, tmp_query, sizeof(select_query));
+ }
+ else if(group_type == MEDIA_GROUP_STORAGE)
+ {
+ tmp_query = sqlite3_mprintf(SELECT_MEDIA_COUNT_FROM_STORAGE, group_name, group_name);
+
+ SAFE_STRLCAT(select_query, tmp_query, sizeof(select_query));
}
else
{
return MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
}
- if(filter != NULL)
+ ret = __media_db_make_query(filter, attr, select_query, sizeof(select_query), &condition_query, &option_query);
+ if(ret != MEDIA_CONTENT_ERROR_NONE)
{
- _filter = (filter_s*)filter;
-
- if(_filter->condition)
- {
- ret = _media_filter_attribute_generate(_content_get_attirbute_handle(), _filter->condition, _filter->condition_collate_type, &condition_query);
- if(ret != MEDIA_CONTENT_ERROR_NONE)
- {
- sqlite3_free(select_query);
- return ret;
- }
- }
-
- ret = _media_filter_attribute_option_generate(_content_get_attirbute_handle(), filter, &option_query);
- if(ret != MEDIA_CONTENT_ERROR_NONE)
- {
- sqlite3_free(select_query);
- SAFE_FREE(condition_query);
- return ret;
- }
-
- if(STRING_VALID(condition_query))
- {
- snprintf(complete_select_query, sizeof(complete_select_query), "%s %s", select_query, QUERY_KEYWORD_AND);
- }
- else
- {
- snprintf(complete_select_query, sizeof(complete_select_query), "%s", select_query);
- }
- } else {
- snprintf(complete_select_query, sizeof(complete_select_query), "%s", select_query);
+ if(tmp_query != NULL)
+ sqlite3_free(tmp_query);
+ return ret;
}
if(group_type == MEDIA_GROUP_NONE)
{
- SAFE_STRLCAT(complete_select_query, QUERY_KEYWORD_SPACE, sizeof(complete_select_query));
+ SAFE_STRLCAT(select_query, QUERY_KEYWORD_SPACE, sizeof(select_query));
if(STRING_VALID(condition_query))
- SAFE_STRLCAT(complete_select_query, condition_query, sizeof(complete_select_query));
+ SAFE_STRLCAT(select_query, condition_query, sizeof(select_query));
if(STRING_VALID(option_query))
- SAFE_STRLCAT(complete_select_query, option_query, sizeof(complete_select_query));
+ SAFE_STRLCAT(select_query, option_query, sizeof(select_query));
if (!is_simple)
- SAFE_STRLCAT(complete_select_query, QUERY_KEYWORD_BRACKET, sizeof(complete_select_query));
+ SAFE_STRLCAT(select_query, QUERY_KEYWORD_BRACKET, sizeof(select_query));
SAFE_FREE(condition_query);
SAFE_FREE(option_query);
}
- ret = _content_query_prepare(&stmt, complete_select_query, condition_query, option_query);
- sqlite3_free(select_query);
+ ret = _content_query_prepare(&stmt, select_query, condition_query, option_query);
+ if(tmp_query != NULL)
+ sqlite3_free(tmp_query);
SAFE_FREE(condition_query);
SAFE_FREE(option_query);
media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
while(sqlite3_step(stmt) == SQLITE_ROW)
{
*item_count = (int)sqlite3_column_int(stmt, 0);
- media_content_debug("group item count : [%d]", *item_count);
}
SQLITE3_FINALIZE(stmt);
+
return ret;
}
int _media_db_get_group_item_by_id(int group_id, filter_h filter, media_info_cb callback, void *user_data, group_list_e group_type)
{
int ret = MEDIA_CONTENT_ERROR_NONE;
- int ret_view = MEDIA_CONTENT_ERROR_NONE;
- char select_query[DEFAULT_QUERY_SIZE];
+ char select_query[MAX_QUERY_SIZE] = {0, };
char *condition_query = NULL;
char *option_query = NULL;
sqlite3_stmt *stmt = NULL;
- filter_s *_filter = NULL;
+ attribute_h attr = NULL;
+ filter_s *_filter = (filter_s*)filter;
+ attr = _content_get_attirbute_handle();
memset(select_query, 0x00, sizeof(select_query));
if(group_type == MEDIA_GROUP_ALBUM)
{
- snprintf(select_query, sizeof(select_query), SELECT_MEDIA_FROM_ALBUM, group_id);
+ if((_filter != NULL) && STRING_VALID(_filter->storage_id))
+ snprintf(select_query, sizeof(select_query), SELECT_MEDIA_FROM_ALBUM, _filter->storage_id, group_id);
+ else
+ snprintf(select_query, sizeof(select_query), SELECT_MEDIA_FROM_ALBUM, DB_TABLE_MEDIA_VIEW, group_id);
}
else if(group_type == MEDIA_GROUP_PLAYLIST)
{
- snprintf(select_query, sizeof(select_query), SELECT_MEDIA_FROM_PLAYLIST, group_id);
+ if((_filter != NULL) && STRING_VALID(_filter->storage_id))
+ snprintf(select_query, sizeof(select_query), SELECT_MEDIA_FROM_PLAYLIST, _filter->storage_id, group_id);
+ else
+ snprintf(select_query, sizeof(select_query), SELECT_MEDIA_FROM_PLAYLIST, DB_TABLE_MEDIA_VIEW, group_id);
}
else if(group_type == MEDIA_GROUP_TAG)
{
- snprintf(select_query, sizeof(select_query), SELECT_MEDIA_FROM_TAG, group_id);
+ if((_filter != NULL) && STRING_VALID(_filter->storage_id))
+ snprintf(select_query, sizeof(select_query), SELECT_MEDIA_FROM_TAG, _filter->storage_id, group_id);
+ else
+ snprintf(select_query, sizeof(select_query), SELECT_MEDIA_FROM_TAG, DB_TABLE_MEDIA_VIEW, group_id);
}
else
{
return MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
}
- if(filter != NULL)
- {
- _filter = (filter_s*)filter;
-
- if(_filter->condition)
- {
- ret = _media_filter_attribute_generate(_content_get_attirbute_handle(), _filter->condition, _filter->condition_collate_type, &condition_query);
- media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
- }
-
- ret = _media_filter_attribute_option_generate(_content_get_attirbute_handle(), filter, &option_query);
- if(ret != MEDIA_CONTENT_ERROR_NONE)
- {
- SAFE_FREE(condition_query);
- return ret;
- }
-
- if(STRING_VALID(condition_query))
- {
- SAFE_STRLCAT(select_query, QUERY_KEYWORD_SPACE, sizeof(select_query));
- SAFE_STRLCAT(select_query, QUERY_KEYWORD_AND, sizeof(select_query));
- }
- }
+ ret = __media_db_make_query(filter, attr, select_query, sizeof(select_query), &condition_query, &option_query);
+ media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
ret = _content_query_prepare(&stmt, select_query, condition_query, option_query);
SAFE_FREE(condition_query);
}
SQLITE3_FINALIZE(stmt);
+
return ret;
}
int _media_db_get_group_item(const char *group_name, filter_h filter, media_info_cb callback, void *user_data, group_list_e group_type)
{
int ret = MEDIA_CONTENT_ERROR_NONE;
- int ret_view = MEDIA_CONTENT_ERROR_NONE;
- char complete_select_query[DEFAULT_QUERY_SIZE];
- char *select_query = NULL;
+ char select_query[MAX_QUERY_SIZE] = {0, };
char *condition_query = NULL;
char *option_query = NULL;
sqlite3_stmt *stmt = NULL;
- filter_s *_filter = NULL;
+ attribute_h attr = NULL;
+ filter_s *_filter = (filter_s*)filter;
+
+ attr = _content_get_attirbute_handle();
+ memset(select_query, 0x00, sizeof(select_query));
if(group_type == MEDIA_GROUP_NONE)
{
- select_query = sqlite3_mprintf(SELECT_MEDIA_ITEM);
+ if((_filter != NULL) && STRING_VALID(_filter->storage_id))
+ snprintf(select_query, sizeof(select_query), SELECT_MEDIA_ITEM, _filter->storage_id);
+ else
+ snprintf(select_query, sizeof(select_query), SELECT_MEDIA_ITEM, DB_TABLE_MEDIA_VIEW);
}
else if(group_type == MEDIA_GROUP_FOLDER)
{
- select_query = sqlite3_mprintf(SELECT_MEDIA_FROM_FOLDER, group_name);
+ if((_filter != NULL) && STRING_VALID(_filter->storage_id))
+ snprintf(select_query, sizeof(select_query), SELECT_MEDIA_FROM_FOLDER, _filter->storage_id, group_name);
+ else
+ snprintf(select_query, sizeof(select_query), SELECT_MEDIA_FROM_FOLDER, DB_TABLE_MEDIA_VIEW, group_name);
}
- else if(group_type == MEDIA_GROUP_BOOKMARK_BY_MEDIA_ID)
+ else if(group_type == MEDIA_GROUP_STORAGE)
{
- select_query = sqlite3_mprintf(SELECT_BOOKMARK_LIST_BY_MEDIA_ID, group_name);
+ snprintf(select_query, sizeof(select_query), SELECT_MEDIA_FROM_STORAGE, group_name, group_name);
}
else
{
return MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
}
- if(filter != NULL)
- {
- _filter = (filter_s*)filter;
-
- if(_filter->condition)
- {
- ret = _media_filter_attribute_generate(_content_get_attirbute_handle(), _filter->condition, _filter->condition_collate_type, &condition_query);
- if(ret != MEDIA_CONTENT_ERROR_NONE)
- {
- sqlite3_free(select_query);
- return ret;
- }
- }
-
- ret = _media_filter_attribute_option_generate(_content_get_attirbute_handle(), filter, &option_query);
- if(ret != MEDIA_CONTENT_ERROR_NONE)
- {
- sqlite3_free(select_query);
- SAFE_FREE(condition_query);
- return ret;
- }
-
- if(STRING_VALID(condition_query))
- {
- snprintf(complete_select_query, sizeof(complete_select_query), "%s %s", select_query, QUERY_KEYWORD_AND);
- }
- else
- {
- snprintf(complete_select_query, sizeof(complete_select_query), "%s", select_query);
- }
- } else {
- snprintf(complete_select_query, sizeof(complete_select_query), "%s", select_query);
- }
+ ret = __media_db_make_query(filter, attr, select_query, sizeof(select_query), &condition_query, &option_query);
+ media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
- ret = _content_query_prepare(&stmt, complete_select_query, condition_query, option_query);
- sqlite3_free(select_query);
+ ret = _content_query_prepare(&stmt, select_query, condition_query, option_query);
SAFE_FREE(condition_query);
SAFE_FREE(option_query);
media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
}
SQLITE3_FINALIZE(stmt);
+
return ret;
}
-int _media_db_get_media_group_item_count(const char *group_name, media_group_e group, filter_h filter, int *item_count)
+int _media_db_get_media_group_item_count(const char *group_name, filter_h filter, media_group_e group, int *item_count)
{
int ret = MEDIA_CONTENT_ERROR_NONE;
- int ret_view = MEDIA_CONTENT_ERROR_NONE;
sqlite3_stmt *stmt = NULL;
- filter_s *_filter = NULL;
- char complete_select_query[DEFAULT_QUERY_SIZE];
- char *select_query = NULL;
+ char select_query[MAX_QUERY_SIZE] = {0, };
+ char *tmp_query = NULL;
char *condition_query = NULL;
char *option_query = NULL;
+ attribute_h attr = NULL;
+ filter_s *_filter = (filter_s*)filter;
- media_content_debug_func();
+ attr = _content_get_attirbute_handle();
+ memset(select_query, 0x00, sizeof(select_query));
if(group_name != NULL)
- select_query = sqlite3_mprintf(SELECT_MEDIA_COUNT_FROM_GROUP, __media_db_get_group_name(group), group_name);
- else
- select_query = sqlite3_mprintf(SELECT_MEDIA_COUNT_FROM_GROUP_NULL, __media_db_get_group_name(group));
-
- if(filter != NULL)
{
- _filter = (filter_s*)filter;
-
- if(_filter->condition)
- {
- ret = _media_filter_attribute_generate(_content_get_attirbute_handle(), _filter->condition, _filter->condition_collate_type, &condition_query);
- if(ret != MEDIA_CONTENT_ERROR_NONE)
- {
- sqlite3_free(select_query);
- return ret;
- }
- }
-
- ret = _media_filter_attribute_option_generate(_content_get_attirbute_handle(), filter, &option_query);
- if(ret != MEDIA_CONTENT_ERROR_NONE)
- {
- sqlite3_free(select_query);
- SAFE_FREE(condition_query);
- return ret;
- }
-
- if(STRING_VALID(condition_query))
+ if((_filter != NULL) && STRING_VALID(_filter->storage_id))
{
- snprintf(complete_select_query, sizeof(complete_select_query), "%s %s", select_query, QUERY_KEYWORD_AND);
+ tmp_query = sqlite3_mprintf(SELECT_MEDIA_COUNT_FROM_GROUP, _filter->storage_id, __media_db_get_group_name(group), group_name);
+ SAFE_STRLCAT(select_query, tmp_query, sizeof(select_query));
}
else
{
- snprintf(complete_select_query, sizeof(complete_select_query), "%s", select_query);
+ tmp_query = sqlite3_mprintf(SELECT_MEDIA_COUNT_FROM_GROUP, DB_TABLE_MEDIA_VIEW, __media_db_get_group_name(group), group_name);
+ SAFE_STRLCAT(select_query, tmp_query, sizeof(select_query));
}
- } else {
- snprintf(complete_select_query, sizeof(complete_select_query), "%s", select_query);
+ }
+ else
+ {
+ if((_filter != NULL) && STRING_VALID(_filter->storage_id))
+ snprintf(select_query, sizeof(select_query), SELECT_MEDIA_COUNT_FROM_GROUP_NULL, _filter->storage_id, __media_db_get_group_name(group));
+ else
+ snprintf(select_query, sizeof(select_query), SELECT_MEDIA_COUNT_FROM_GROUP_NULL, DB_TABLE_MEDIA_VIEW, __media_db_get_group_name(group));
}
- SAFE_STRLCAT(complete_select_query, QUERY_KEYWORD_SPACE, sizeof(complete_select_query));
+ ret = __media_db_make_query(filter, attr, select_query, sizeof(select_query), &condition_query, &option_query);
+ if(ret != MEDIA_CONTENT_ERROR_NONE)
+ {
+ if(tmp_query != NULL)
+ sqlite3_free(tmp_query);
+ return ret;
+ }
+
+ SAFE_STRLCAT(select_query, QUERY_KEYWORD_SPACE, sizeof(select_query));
if(STRING_VALID(condition_query))
- SAFE_STRLCAT(complete_select_query, condition_query, sizeof(complete_select_query));
+ SAFE_STRLCAT(select_query, condition_query, sizeof(select_query));
if(STRING_VALID(option_query))
- SAFE_STRLCAT(complete_select_query, option_query, sizeof(complete_select_query));
-
- SAFE_STRLCAT(complete_select_query, QUERY_KEYWORD_BRACKET, sizeof(complete_select_query));
+ SAFE_STRLCAT(select_query, option_query, sizeof(select_query));
+ SAFE_STRLCAT(select_query, QUERY_KEYWORD_BRACKET, sizeof(select_query));
SAFE_FREE(condition_query);
SAFE_FREE(option_query);
- ret = _content_query_prepare(&stmt, complete_select_query, condition_query, option_query);
- sqlite3_free(select_query);
+ ret = _content_query_prepare(&stmt, select_query, condition_query, option_query);
+ if(tmp_query != NULL)
+ sqlite3_free(tmp_query);
SAFE_FREE(condition_query);
SAFE_FREE(option_query);
media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
while(sqlite3_step(stmt) == SQLITE_ROW)
{
*item_count = (int)sqlite3_column_int(stmt, 0);
- media_content_debug("group item count : [%d]", *item_count);
}
SQLITE3_FINALIZE(stmt);
+
return ret;
}
-int _media_db_get_media_group_item(const char *group_name, media_group_e group, filter_h filter, media_info_cb callback, void *user_data)
+int _media_db_get_media_group_item(const char *group_name, filter_h filter, media_group_e group, media_info_cb callback, void *user_data)
{
int ret = MEDIA_CONTENT_ERROR_NONE;
- int ret_view = MEDIA_CONTENT_ERROR_NONE;
- char complete_select_query[DEFAULT_QUERY_SIZE];
- char *select_query = NULL;
+ char select_query[MAX_QUERY_SIZE] = {0, };
+ char *tmp_query = NULL;
char *condition_query = NULL;
char *option_query = NULL;
sqlite3_stmt *stmt = NULL;
- filter_s *_filter = NULL;
+ attribute_h attr = NULL;
+ filter_s *_filter = (filter_s*)filter;
- media_content_debug_func();
+ attr = _content_get_attirbute_handle();
+ memset(select_query, 0x00, sizeof(select_query));
if(group_name != NULL)
- select_query = sqlite3_mprintf(SELECT_MEDIA_FROM_GROUP, __media_db_get_group_name(group), group_name);
+ {
+ if((_filter != NULL) && STRING_VALID(_filter->storage_id))
+ tmp_query = sqlite3_mprintf(SELECT_MEDIA_FROM_GROUP, _filter->storage_id, __media_db_get_group_name(group), group_name);
+ else
+ tmp_query = sqlite3_mprintf(SELECT_MEDIA_FROM_GROUP, DB_TABLE_MEDIA_VIEW, __media_db_get_group_name(group), group_name);
+
+ SAFE_STRLCAT(select_query, tmp_query, sizeof(select_query));
+ }
else
- select_query = sqlite3_mprintf(SELECT_MEDIA_FROM_GROUP_NULL, __media_db_get_group_name(group));
+ {
+ if((_filter != NULL) && STRING_VALID(_filter->storage_id))
+ snprintf(select_query, sizeof(select_query), SELECT_MEDIA_FROM_GROUP_NULL, _filter->storage_id, __media_db_get_group_name(group));
+ else
+ snprintf(select_query, sizeof(select_query), SELECT_MEDIA_FROM_GROUP_NULL, DB_TABLE_MEDIA_VIEW, __media_db_get_group_name(group));
+ }
- if(filter != NULL)
+ ret = __media_db_make_query(filter, attr, select_query, sizeof(select_query), &condition_query, &option_query);
+ if(ret != MEDIA_CONTENT_ERROR_NONE)
{
- _filter = (filter_s*)filter;
+ if(tmp_query != NULL)
+ sqlite3_free(tmp_query);
+ return ret;
+ }
- if(_filter->condition)
- {
- ret = _media_filter_attribute_generate(_content_get_attirbute_handle(), _filter->condition, _filter->condition_collate_type, &condition_query);
- if(ret != MEDIA_CONTENT_ERROR_NONE)
- {
- sqlite3_free(select_query);
- return ret;
- }
- }
+ ret = _content_query_prepare(&stmt, select_query, condition_query, option_query);
+ if(tmp_query != NULL)
+ sqlite3_free(tmp_query);
+ SAFE_FREE(condition_query);
+ SAFE_FREE(option_query);
+ media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
- ret = _media_filter_attribute_option_generate(_content_get_attirbute_handle(), filter, &option_query);
- if(ret != MEDIA_CONTENT_ERROR_NONE)
+ while(sqlite3_step(stmt) == SQLITE_ROW)
+ {
+ media_info_s *item = (media_info_s*)calloc(1, sizeof(media_info_s));
+ if(item == NULL)
{
- sqlite3_free(select_query);
- SAFE_FREE(condition_query);
- return ret;
+ media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
+ SQLITE3_FINALIZE(stmt);
+ return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
}
- if(STRING_VALID(condition_query))
- {
- snprintf(complete_select_query, sizeof(complete_select_query), "%s %s", select_query, QUERY_KEYWORD_AND);
- }
- else
+ _media_info_item_get_detail(stmt, (media_info_h)item);
+
+ if(callback((media_info_h)item, user_data) == false)
{
- snprintf(complete_select_query, sizeof(complete_select_query), "%s", select_query);
+ media_info_destroy((media_info_h)item);
+ break;
}
- } else {
- snprintf(complete_select_query, sizeof(complete_select_query), "%s", select_query);
+
+ media_info_destroy((media_info_h)item);
}
- ret = _content_query_prepare(&stmt, complete_select_query, condition_query, option_query);
- sqlite3_free(select_query);
+ SQLITE3_FINALIZE(stmt);
+
+ return ret;
+}
+
+int _media_db_get_storage(filter_h filter, media_storage_cb callback, void *user_data)
+{
+ int ret = MEDIA_CONTENT_ERROR_NONE;
+ char select_query[DEFAULT_QUERY_SIZE];
+ char *condition_query = NULL;
+ char *option_query = NULL;
+ sqlite3_stmt *stmt = NULL;
+ attribute_h attr = NULL;
+
+ attr = _content_get_attirbute_handle();
+ memset(select_query, 0x00, sizeof(select_query));
+
+ if(!SAFE_STRLCPY(select_query, SELECT_STORAGE_LIST, sizeof(select_query)))
+ {
+ media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
+ return MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
+ }
+
+ ret = __media_db_make_query(filter, attr, select_query, sizeof(select_query), &condition_query, &option_query);
+ media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
+
+ ret = _content_query_prepare(&stmt, select_query, condition_query, option_query);
SAFE_FREE(condition_query);
SAFE_FREE(option_query);
media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
while(sqlite3_step(stmt) == SQLITE_ROW)
{
- media_info_s *item = (media_info_s*)calloc(1, sizeof(media_info_s));
- if(item == NULL)
+ media_storage_s *_storage = (media_storage_s*)calloc(1, sizeof(media_storage_s));
+
+ if(_storage == NULL)
{
media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
SQLITE3_FINALIZE(stmt);
return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
}
- _media_info_item_get_detail(stmt, (media_info_h)item);
+ if(STRING_VALID((const char *)sqlite3_column_text(stmt, 0)))
+ _storage->storage_id = strdup((const char *)sqlite3_column_text(stmt, 0));
- if(callback((media_info_h)item, user_data) == false)
+ if(STRING_VALID((const char *)sqlite3_column_text(stmt, 1)))
+ _storage->storage_name = strdup((const char *)sqlite3_column_text(stmt, 1));
+
+ if(STRING_VALID((const char *)sqlite3_column_text(stmt, 2)))
+ _storage->storage_path = strdup((const char *)sqlite3_column_text(stmt, 2));
+
+ if(STRING_VALID((const char *)sqlite3_column_text(stmt, 3)))
+ _storage->storage_account = strdup((const char *)sqlite3_column_text(stmt, 3));
+
+ _storage->storage_type = (int)sqlite3_column_int(stmt, 4);
+
+ if(callback((media_storage_h)_storage, user_data) == false)
{
- media_info_destroy((media_info_h)item);
+ media_storage_destroy((media_storage_h) _storage);
break;
}
- media_info_destroy((media_info_h)item);
+ media_storage_destroy((media_storage_h) _storage);
}
SQLITE3_FINALIZE(stmt);
+
+ return ret;
+}
+
+int _media_db_get_storage_id_by_media_id(const char *media_id, char *storage_id)
+{
+ int ret = MEDIA_CONTENT_ERROR_NONE;
+ sqlite3_stmt *stmt = NULL;
+ char *select_query = NULL;
+
+ select_query = sqlite3_mprintf(SELECT_MEDIA_STORAGE_ID_BY_ID, media_id);
+
+ ret = _content_query_prepare(&stmt, select_query, NULL, NULL);
+ sqlite3_free(select_query);
+ media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
+
+ if(sqlite3_step(stmt) == SQLITE_ROW)
+ {
+ if(STRING_VALID((const char *)sqlite3_column_text(stmt, 0)))
+ strncpy(storage_id, (const char *)sqlite3_column_text(stmt, 0), MEDIA_CONTENT_UUID_SIZE);
+ } else {
+ media_content_error("There's no media!!");
+ ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
+ }
+
+ SQLITE3_FINALIZE(stmt);
+
return ret;
}
*/
-#include <media_content.h>
#include <media_info_private.h>
-#include <media-svc.h>
static char *media_token[] =
{
static int __tokenize_operator(token_t *token, const char *str, int op_type);
static int __tokenize(GList **token_list, const char *str);
+static bool __is_pinyin_needed(void)
+{
+ char *lang = NULL;
+ char *china = "zh_CN";
+ char *hongkong = "zh_HK";
+ int ret = FALSE;
+#if 0
+ /*Check CSC first*/
+ bool pinyin_support = FALSE;
+ media_svc_check_pinyin_support(&pinyin_support);
+ if(pinyin_support)
+ {
+ /*Check Language Setting*/
+ lang = vconf_get_str(VCONFKEY_LANGSET);
+ if (lang == NULL)
+ {
+ media_content_error("Fail to get string of language set");
+ return ret;
+ }
+ if((strncmp(china, lang, strlen(china)) == 0) ||
+ (strncmp(hongkong, lang, strlen(hongkong)) == 0))
+ {
+ ret = TRUE;
+ }
+
+ SAFE_FREE(lang);
+ }
+#endif
+ return ret;
+}
+
static char *__get_order_str(media_content_order_e order_enum)
{
switch(order_enum) {
return "NOCASE";
case MEDIA_CONTENT_COLLATE_RTRIM:
return "RTRIM";
+ case MEDIA_CONTENT_COLLATE_LOCALIZED:
+ if(__is_pinyin_needed())
+ return "NOCASE";
+ else
+ return "localized";
default: return " ";
}
}
token->str = (char*)calloc(token_size+1, sizeof(char));
if(token->str == NULL)
{
- media_content_error("OUT_OF_MEMORY");
+ media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
return -1;
}
token->str = (char*)calloc(size+1, sizeof(char));
if(token->str == NULL)
{
- media_content_error("OUT_OF_MEMORY");
+ media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
return -1;
}
token->type = UNKNOWN_TYPE;
continue;
}
token_t *token = (token_t*)calloc(1, sizeof(token_t));
+ if(token == NULL)
+ {
+ media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
+ return -1;
+ }
token->type = UNKNOWN_TYPE;
token->str = (char*)calloc(idx+1, sizeof(char));
+ if(token->str == NULL)
+ {
+ SAFE_FREE(token);
+ media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
+ return -1;
+ }
strncpy(token->str, tmp, idx);
- media_content_debug("type : [%d] str : [%s]", token->type, token->str);
+ //media_content_debug("type : [%d] str : [%s]", token->type, token->str);
*token_list = g_list_append(*token_list, token);
tmp = tmp +idx + strlen(media_token[0]);
idx = -1;
token_t *token = (token_t*)calloc(1, sizeof(token_t));
if(token == NULL)
{
- media_content_error("OUT_OF_MEMORY");
+ media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
return -1;
}
ret = __tokenize_string(token, tmp, idx);
if (ret < 0)
{
SAFE_FREE(token);
- media_content_error("tokenize error occued");
+ media_content_error("tokenize error occured");
return -1;
}
else
else
{
SAFE_FREE(token);
- media_content_error("tokenize error occued");
+ media_content_error("tokenize error occured");
return -1;
}
}
token_t *token = (token_t*)calloc(1, sizeof(token_t));
if(token == NULL)
{
- media_content_error("OUT_OF_MEMORY");
+ media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
return -1;
}
if (ret < 0)
{
SAFE_FREE(token);
- media_content_error("tokenize error occued");
+ media_content_error("tokenize error occured");
return -1;
}
else
{
SAFE_FREE(token);
- media_content_error("tokenize error occued");
+ media_content_error("tokenize error occured");
return -1;
}
}
}
token_t *token = (token_t*)calloc(1, sizeof(token_t));
+ if(token == NULL)
+ {
+ media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
+ return -1;
+ }
token->type = UNKNOWN_TYPE;
token->str = (char*)calloc(idx+1, sizeof(char));
+ if(token->str == NULL)
+ {
+ SAFE_FREE(token);
+ media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
+ return -1;
+ }
strncpy(token->str, tmp, idx);
//media_content_debug("type : [%d] str : [%s]", token->type, token->str);
*token_list = g_list_append(*token_list, token);
if(tmp[j] == media_token[1][0])
{
token_t *token = (token_t*)calloc(1, sizeof(token_t));
+ if(token == NULL)
+ {
+ media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
+ return -1;
+ }
token->str = (char*) calloc(j+1+1, sizeof(char));
+ if(token->str == NULL)
+ {
+ SAFE_FREE(token);
+ media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
+ return -1;
+ }
token->type = STRING_TYPE;
strncpy(token->str, tmp, j+1);
- media_content_debug("type : [%d] str : [%s], j : %d", token->type, token->str, j);
+ //media_content_debug("type : [%d] str : [%s], j : %d", token->type, token->str, j);
*token_list = g_list_append(*token_list, token);
tmp = tmp + strlen(token->str);
idx = -1;
if(!flag && *tmp != '\0' && tmp[j]=='\0')
{
token_t *token = (token_t*)calloc(1, sizeof(token_t));
+ if(token == NULL)
+ {
+ media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
+ return -1;
+ }
token->str = (char*) calloc(j+1,sizeof(char));
+ if(token->str == NULL)
+ {
+ SAFE_FREE(token);
+ media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
+ return -1;
+ }
token->type = UNKNOWN_TYPE;
strncpy(token->str, tmp,j);
- media_content_debug("type : [%d] str : [%s]", token->type, token->str);
+ //media_content_debug("type : [%d] str : [%s]", token->type, token->str);
*token_list = g_list_append(*token_list, token);
tmp = tmp +strlen(token->str);
idx = -1;
if(tmp[j] == media_token[2][0])
{
token_t *token = (token_t*)calloc(1, sizeof(token_t));
+ if(token == NULL)
+ {
+ media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
+ return -1;
+ }
token->str = (char*) calloc(j+1+1, sizeof(char));
+ if(token->str == NULL)
+ {
+ SAFE_FREE(token);
+ media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
+ return -1;
+ }
token->type = STRING_TYPE;
strncpy(token->str, tmp, j+1);
//media_content_debug("type : [%d] str : [%s]", token->type, token->str);
if(!flag && *tmp != '\0' && tmp[j]=='\0')
{
token_t *token = (token_t*)calloc(1, sizeof(token_t));
+ if(token == NULL)
+ {
+ media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
+ return -1;
+ }
token->str = (char*) calloc(j+1,sizeof(char));
+ if(token->str == NULL)
+ {
+ SAFE_FREE(token);
+ media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
+ return -1;
+ }
token->type = UNKNOWN_TYPE;
strncpy(token->str, tmp,j);
- media_content_debug("type : [%d] str : [%s]", token->type, token->str);
+ //media_content_debug("type : [%d] str : [%s]", token->type, token->str);
*token_list = g_list_append(*token_list, token);
tmp = tmp + strlen(token->str);
idx = -1;
token_t *token = (token_t*)calloc(1, sizeof(token_t));
if(token == NULL)
{
- media_content_error("OUT_OF_MEMORY");
+ media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
return -1;
}
ret = __tokenize_string(token, tmp, idx);
if (ret < 0)
{
SAFE_FREE(token);
- media_content_error("tokenize error occued");
+ media_content_error("tokenize error occured");
return -1;
}
else
else
{
SAFE_FREE(token);
- media_content_error("tokenize error occued");
+ media_content_error("tokenize error occured");
return -1;
}
token_t *token = (token_t*)calloc(1, sizeof(token_t));
if(token == NULL)
{
- media_content_error("OUT_OF_MEMORY");
+ media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
return -1;
}
if (ret < 0)
{
SAFE_FREE(token);
- media_content_error("tokenize error occued");
+ media_content_error("tokenize error occured");
return -1;
}
else
else
{
SAFE_FREE(token);
- media_content_error("tokenize error occued");
+ media_content_error("tokenize error occured");
return -1;
}
token_t *token = (token_t*)calloc(1, sizeof(token_t));
if(token == NULL)
{
- media_content_error("OUT_OF_MEMORY");
+ media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
return -1;
}
if (ret < 0)
{
SAFE_FREE(token);
- media_content_error("tokenize error occued");
+ media_content_error("tokenize error occured");
return -1;
}
else
else
{
SAFE_FREE(token);
- media_content_error("tokenize error occued");
+ media_content_error("tokenize error occured");
return -1;
}
token_t *token = (token_t*)calloc(1, sizeof(token_t));
if(token == NULL)
{
- media_content_error("OUT_OF_MEMORY");
+ media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
return -1;
}
if (ret < 0)
{
SAFE_FREE(token);
- media_content_error("tokenize error occued");
+ media_content_error("tokenize error occured");
return -1;
}
else
else
{
SAFE_FREE(token);
- media_content_error("tokenize error occued");
+ media_content_error("tokenize error occured");
return -1;
}
token_t *token = (token_t*)calloc(1, sizeof(token_t));
if(token == NULL)
{
- media_content_error("OUT_OF_MEMORY");
+ media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
return -1;
}
if (ret < 0)
{
SAFE_FREE(token);
- media_content_error("tokenize error occued");
+ media_content_error("tokenize error occured");
return -1;
}
else
else
{
SAFE_FREE(token);
- media_content_error("tokenize error occued");
+ media_content_error("tokenize error occured");
return -1;
}
token_t *token = (token_t*)calloc(1, sizeof(token_t));
if(token == NULL)
{
- media_content_error("OUT_OF_MEMORY");
+ media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
return -1;
}
if (ret < 0)
{
SAFE_FREE(token);
- media_content_error("tokenize error occued");
+ media_content_error("tokenize error occured");
return -1;
}
else
else
{
SAFE_FREE(token);
- media_content_error("tokenize error occued");
+ media_content_error("tokenize error occured");
return -1;
}
token_t *token = (token_t*)calloc(1, sizeof(token_t));
if(token == NULL)
{
- media_content_error("OUT_OF_MEMORY");
+ media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
return -1;
}
if (ret < 0)
{
SAFE_FREE(token);
- media_content_error("tokenize error occued");
+ media_content_error("tokenize error occured");
return -1;
}
else
else
{
SAFE_FREE(token);
- media_content_error("tokenize error occued");
+ media_content_error("tokenize error occured");
return -1;
}
token_t *token = (token_t*)calloc(1, sizeof(token_t));
if(token == NULL)
{
- media_content_error("OUT_OF_MEMORY");
+ media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
return -1;
}
if (ret < 0)
{
SAFE_FREE(token);
- media_content_error("tokenize error occued");
+ media_content_error("tokenize error occured");
return -1;
}
else
{
SAFE_FREE(token);
- media_content_error("tokenize error occued");
+ media_content_error("tokenize error occured");
return -1;
}
}
}
}
- if(collate_type == MEDIA_CONTENT_COLLATE_NOCASE || collate_type == MEDIA_CONTENT_COLLATE_RTRIM) {
+ if(collate_type == MEDIA_CONTENT_COLLATE_NOCASE || collate_type == MEDIA_CONTENT_COLLATE_RTRIM ||collate_type == MEDIA_CONTENT_COLLATE_LOCALIZED) {
SAFE_STRLCAT(*generated_condition, "COLLATE ", size);
SAFE_STRLCAT(*generated_condition, __get_collate_str(collate_type), size);
SAFE_STRLCAT(*generated_condition, SPACE, size);
}
- media_content_debug("statement : %s(%d) (total:%d)", *generated_condition, strlen(*generated_condition), total_str_size);
- media_content_debug("Condition : %s", *generated_condition);
+ //media_content_debug("statement : %s(%d) (total:%d)", *generated_condition, strlen(*generated_condition), total_str_size);
+ media_content_sec_debug("Condition : %s", *generated_condition);
//if(*generated_condition != NULL)
// res = 1;
int size = 0;
//bool order_by = true;
- media_content_debug_func();
-
if(filter == NULL)
{
media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
token_t *token;
char *attr_str;
- media_content_debug("Tokenize for [%s]", _filter->order_keyword);
if(__tokenize_attribute(&token_list, _filter->order_keyword) < 0)
{
media_content_error("INVALID_PARAMETER(0x%08x):Invalid the condition", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
if(STRING_VALID(replace_str))
{
attr_str = (char*)calloc(strlen(replace_str) + COLLATE_STR_SIZE + 1, sizeof(char));
+ if(attr_str == NULL)
+ {
+ media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
+ SAFE_FREE(replace_str);
+ continue;
+ }
- if(_filter->order_collate_type == MEDIA_CONTENT_COLLATE_NOCASE || _filter->order_collate_type == MEDIA_CONTENT_COLLATE_RTRIM) {
+ if(_filter->order_collate_type == MEDIA_CONTENT_COLLATE_NOCASE || _filter->order_collate_type == MEDIA_CONTENT_COLLATE_RTRIM ||_filter->order_collate_type == MEDIA_CONTENT_COLLATE_LOCALIZED) {
snprintf(attr_str, strlen(replace_str) + COLLATE_STR_SIZE + 1, "%s COLLATE %s %s", replace_str, __get_collate_str(_filter->order_collate_type), __get_order_str(_filter->order_type));
} else {
snprintf(attr_str, strlen(replace_str) + COLLATE_STR_SIZE + 1, "%s %s", replace_str, __get_order_str(_filter->order_type));
}
total_str_size += strlen(token->str) + 1;
- media_content_debug("[%d][type:%d]:%s", idx, token->type, token->str);
+ //media_content_debug("[%d][type:%d]:%s", idx, token->type, token->str);
}
//make the statment
if((token != NULL) && STRING_VALID(token->str))
{
- media_content_debug("[%d] %s", idx, token->str);
+ //media_content_debug("[%d] %s", idx, token->str);
SAFE_STRLCAT(generated_condition, token->str, size);
SAFE_STRLCAT(generated_condition, SPACE, size);
}
else
{
+ _filter->storage_id = NULL;
_filter->condition = NULL;
_filter->order_keyword = NULL;
_filter->order_type = -1;
if(_filter)
{
+ SAFE_FREE(_filter->storage_id);
SAFE_FREE(_filter->condition);
SAFE_FREE(_filter->order_keyword);
SAFE_FREE(_filter);
filter_s *_filter = (filter_s*)filter;
if((_filter != NULL) && STRING_VALID(condition)
- && ((collate_type >= MEDIA_CONTENT_COLLATE_DEFAULT) && (collate_type <= MEDIA_CONTENT_COLLATE_RTRIM)))
+ && ((collate_type >= MEDIA_CONTENT_COLLATE_DEFAULT) && (collate_type <= MEDIA_CONTENT_COLLATE_LOCALIZED)))
{
if(STRING_VALID(_filter->condition))
{
return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
}
- media_content_debug("Condition string : %s", _filter->condition);
+ media_content_sec_debug("Condition string : %s", _filter->condition);
_filter->condition_collate_type = collate_type;
}
if((_filter != NULL) && STRING_VALID(order_keyword)
&& ((order_type == MEDIA_CONTENT_ORDER_ASC) ||(order_type == MEDIA_CONTENT_ORDER_DESC))
- && ((collate_type >= MEDIA_CONTENT_COLLATE_DEFAULT) && (collate_type <= MEDIA_CONTENT_COLLATE_RTRIM)))
+ && ((collate_type >= MEDIA_CONTENT_COLLATE_DEFAULT) && (collate_type <= MEDIA_CONTENT_COLLATE_LOCALIZED)))
{
SAFE_FREE(_filter->order_keyword);
return ret;
}
+int media_filter_set_storage(filter_h filter, const char *storage_id)
+{
+ int ret = MEDIA_CONTENT_ERROR_NONE;
+ filter_s *_filter = (filter_s*)filter;
+
+ if((_filter != NULL) && STRING_VALID(storage_id))
+ {
+ if(STRING_VALID(_filter->storage_id))
+ {
+ SAFE_FREE(_filter->storage_id);
+ }
+
+ _filter->storage_id = strdup(storage_id);
+ if(_filter->storage_id == NULL)
+ {
+ media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
+ return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
+ }
+
+ media_content_sec_debug("storage_id : %s", _filter->storage_id);
+ }
+ else
+ {
+ media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
+ ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
+ }
+
+ return ret;
+}
+
int media_filter_get_offset(filter_h filter, int *offset, int *count)
{
int ret = MEDIA_CONTENT_ERROR_NONE;
return ret;
}
+
+int media_filter_get_storage(filter_h filter, char **storage_id)
+{
+ int ret = MEDIA_CONTENT_ERROR_NONE;
+ filter_s *_filter = (filter_s*)filter;
+
+ if(_filter)
+ {
+ if(STRING_VALID(_filter->storage_id))
+ {
+ *storage_id = strdup(_filter->storage_id);
+ if(*storage_id == NULL)
+ {
+ media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
+ return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
+ }
+ }
+ else
+ {
+ *storage_id = NULL;
+ }
+ }
+ else
+ {
+ media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
+ ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
+ }
+
+ return ret;
+}
*/
-#include <media_content.h>
#include <media_info_private.h>
#include <media_util_private.h>
{
int ret = MEDIA_CONTENT_ERROR_NONE;
- media_content_debug_func();
-
if(!folder_count)
{
media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
{
int ret = MEDIA_CONTENT_ERROR_NONE;
- media_content_debug_func();
-
if(callback == NULL)
{
media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
{
int ret = MEDIA_CONTENT_ERROR_NONE;
- media_content_debug_func();
-
if(STRING_VALID(folder_id) && media_count)
{
ret = _media_db_get_group_item_count(folder_id, filter, MEDIA_GROUP_FOLDER, media_count);
{
int ret = MEDIA_CONTENT_ERROR_NONE;
- media_content_debug_func();
-
if((callback != NULL) && STRING_VALID(folder_id))
{
ret = _media_db_get_group_item(folder_id, filter, callback, user_data, MEDIA_GROUP_FOLDER);
SAFE_FREE(_folder->path);
SAFE_FREE(_folder->name);
SAFE_FREE(_folder->folder_id);
+ SAFE_FREE(_folder->storage_uuid);
SAFE_FREE(_folder);
ret = MEDIA_CONTENT_ERROR_NONE;
}
}
}
+ if(STRING_VALID(_src->storage_uuid))
+ {
+ _dst->storage_uuid = strdup(_src->storage_uuid);
+ if(_dst->storage_uuid == NULL)
+ {
+ media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
+ media_folder_destroy((media_folder_h)_dst);
+ return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
+ }
+ }
+
*dst = (media_folder_h)_dst;
ret = MEDIA_CONTENT_ERROR_NONE;
return ret;
}
+int media_folder_get_storage_id(media_folder_h folder, char **storage_id)
+{
+ int ret = MEDIA_CONTENT_ERROR_NONE;
+ media_folder_s *_folder = (media_folder_s*)folder;
+ if(_folder)
+ {
+ if(STRING_VALID(_folder->storage_uuid))
+ {
+ *storage_id = strdup(_folder->storage_uuid);
+ if(*storage_id == NULL)
+ {
+ media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
+ return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
+ }
+ }
+ else
+ {
+ *storage_id = NULL;
+ }
+ ret = MEDIA_CONTENT_ERROR_NONE;
+
+ }
+ else
+ {
+ media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
+ ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
+ }
+
+ return ret;
+}
+
+int media_folder_get_order(media_folder_h folder, int *order)
+{
+ int ret = MEDIA_CONTENT_ERROR_NONE;
+ media_folder_s *_folder = (media_folder_s*)folder;
+ if(_folder)
+ {
+ *order = _folder->folder_order;
+ ret = MEDIA_CONTENT_ERROR_NONE;
+ }
+ else
+ {
+ media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
+ ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
+ }
+
+ return ret;
+}
+
+
int media_folder_get_folder_from_db(const char *folder_id, media_folder_h *folder)
{
int ret = MEDIA_CONTENT_ERROR_NONE;
- int ret_view = MEDIA_CONTENT_ERROR_NONE;
sqlite3_stmt *stmt = NULL;
char select_query[DEFAULT_QUERY_SIZE];
return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
}
+ media_content_error("folder handle %x", _folder);
+
if(STRING_VALID((const char *)sqlite3_column_text(stmt, 0)))
_folder->folder_id = strdup((const char *)sqlite3_column_text(stmt, 0));
}
SQLITE3_FINALIZE(stmt);
+
return ret;
}
int media_folder_update_to_db(media_folder_h folder)
{
int ret = MEDIA_CONTENT_ERROR_NONE;
- int len = 0;
media_folder_s *_folder = (media_folder_s*)folder;
-
- char sql[MAX_QUERY_SIZE];
- memset(sql, '\0', sizeof(sql));
char *set_sql = NULL;
- char *where_sql = NULL;
+ char *sql = NULL;
- if((_folder != NULL) && STRING_VALID(_folder->folder_id) && g_src_path)
+ if((_folder == NULL) || (_folder->folder_id == NULL))
+ {
+ media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
+ return MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
+ }
+
+ /* Update folder order */
+ sql = sqlite3_mprintf(UPDATE_FOLDER_ORDER, _folder->folder_order, _folder->folder_id);
+
+ ret = _content_query_sql(sql);
+ sqlite3_free(sql);
+
+ if(STRING_VALID(_folder->folder_id) && g_src_path)
{
/* Set modified time */
time_t date;
set_sql = __media_folder_get_update_folder_sql((media_folder_h)_folder);
if(set_sql == NULL)
{
+ SAFE_FREE(g_src_path);
media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
}
- where_sql = sqlite3_mprintf("folder_uuid='%q'", _folder->folder_id);
-
- len = snprintf(sql, sizeof(sql), UPDATE_SQL, DB_TABLE_FOLDER, set_sql, where_sql);
- if (len > 0) {
- sql[len] = '\0';
- } else {
- media_content_error("snprintf failed");
- return MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
- }
+ sql = sqlite3_mprintf("UPDATE %Q SET %s WHERE folder_uuid=%Q", DB_TABLE_FOLDER, set_sql, _folder->folder_id);
ret = _content_query_sql(sql);
sqlite3_free(set_sql);
- sqlite3_free(where_sql);
+ sqlite3_free(sql);
+ if (ret != MEDIA_CONTENT_ERROR_NONE)
+ {
+ SAFE_FREE(g_src_path);
+ return ret;
+ }
+
+ ret = media_svc_rename_folder(_content_get_db_handle(), _folder->storage_uuid, g_src_path, _folder->path, tzplatform_getuid(TZ_USER_NAME));
+ SAFE_FREE(g_src_path);
- /* Do folder rename operation using libmedia-service */
- ret = media_svc_rename_folder(_content_get_db_handle(), g_src_path, _folder->path, tzplatform_getuid(TZ_USER_NAME));
return _content_error_capi(MEDIA_CONTENT_TYPE, ret);
}
- else
- {
- media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
- ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
- }
return ret;
}
char new_folder_path[MAX_QUERY_SIZE] = {0,};
folder_path = g_path_get_dirname(_folder->path);
- media_content_debug("Existed Folder Path : %s", _folder->path);
+ media_content_sec_debug("Existed Folder Path : %s", _folder->path);
snprintf(new_folder_path, sizeof(new_folder_path), "%s/%s", folder_path, name);
- media_content_debug("New Path : %s", new_folder_path);
+ media_content_sec_debug("New Path : %s", new_folder_path);
SAFE_FREE(g_src_path);
g_src_path = strdup(_folder->path);
return ret;
}
+
+int media_folder_set_order(media_folder_h folder, int order)
+{
+ int ret = MEDIA_CONTENT_ERROR_NONE;
+ media_folder_s *_folder = (media_folder_s*)folder;
+
+ if(_folder != NULL && order >= 0)
+ {
+ _folder->folder_order = order;
+ }
+ else
+ {
+ media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
+ ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
+ }
+
+ return ret;
+}
{
int ret = MEDIA_CONTENT_ERROR_NONE;
- media_content_debug_func();
-
if(album_count != NULL)
{
ret = _media_db_get_group_count(filter, MEDIA_GROUP_ALBUM, album_count);
{
int ret = MEDIA_CONTENT_ERROR_NONE;
- media_content_debug_func();
-
if(callback == NULL)
{
media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
{
int ret = MEDIA_CONTENT_ERROR_NONE;
- media_content_debug_func();
-
if((album_id > 0) && (media_count != NULL))
{
ret = _media_db_get_group_item_count_by_id(album_id, filter, MEDIA_GROUP_ALBUM, media_count);
{
int ret = MEDIA_CONTENT_ERROR_NONE;
- media_content_debug_func();
-
if((album_id > 0) && (callback != NULL))
{
ret = _media_db_get_group_item_by_id(album_id, filter, callback, user_data, MEDIA_GROUP_ALBUM);
sqlite3_stmt *stmt = NULL;
char select_query[DEFAULT_QUERY_SIZE];
- media_content_debug_func();
-
if(album_id < 0)
{
media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
while(sqlite3_step(stmt) == SQLITE_ROW)
{
media_album_s *_album = (media_album_s*)calloc(1, sizeof(media_album_s));
+ if(_album == NULL)
+ {
+ media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
+ SQLITE3_FINALIZE(stmt);
+ return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
+ }
_album->album_id = (int)sqlite3_column_int(stmt, 0);
*album = (media_album_h)_album;
}
- if(stmt != NULL)
- {
- sqlite3_finalize(stmt);
- }
+ SQLITE3_FINALIZE(stmt);
return ret;
}
{
int ret = MEDIA_CONTENT_ERROR_NONE;
- media_content_debug_func();
-
- if((group < MEDIA_CONTENT_GROUP_DISPLAY_NAME) || (group > MEDIA_CONTENT_GROUP_KEYWORD) || (group_count == NULL))
+ if((group < MEDIA_CONTENT_GROUP_DISPLAY_NAME) || (group >= MEDIA_CONTENT_GROUP_MAX) || (group_count == NULL))
{
media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
{
int ret = MEDIA_CONTENT_ERROR_NONE;
- media_content_debug_func();
-
- if((callback == NULL) || (group < MEDIA_CONTENT_GROUP_DISPLAY_NAME) || (group > MEDIA_CONTENT_GROUP_KEYWORD))
+ if((callback == NULL) || (group < MEDIA_CONTENT_GROUP_DISPLAY_NAME) || (group >= MEDIA_CONTENT_GROUP_MAX))
{
media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
{
int ret = MEDIA_CONTENT_ERROR_NONE;
- media_content_debug_func();
-
- if((media_count == NULL) || (group < MEDIA_CONTENT_GROUP_DISPLAY_NAME) || (group > MEDIA_CONTENT_GROUP_KEYWORD))
+ if((media_count == NULL) || (group < MEDIA_CONTENT_GROUP_DISPLAY_NAME) || (group >= MEDIA_CONTENT_GROUP_MAX))
{
media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
}
else
{
- ret = _media_db_get_media_group_item_count(group_name, group, filter, media_count);
+ ret = _media_db_get_media_group_item_count(group_name, filter, group, media_count);
}
return ret;
{
int ret = MEDIA_CONTENT_ERROR_NONE;
- media_content_debug_func();
-
- if((callback == NULL) || (group < MEDIA_CONTENT_GROUP_DISPLAY_NAME) || (group > MEDIA_CONTENT_GROUP_KEYWORD))
+ if((callback == NULL) || (group < MEDIA_CONTENT_GROUP_DISPLAY_NAME) || (group >= MEDIA_CONTENT_GROUP_MAX))
{
media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
}
else
{
- ret = _media_db_get_media_group_item(group_name, group, filter, callback, user_data);
+ ret = _media_db_get_media_group_item(group_name, filter, group, callback, user_data);
}
return ret;
*/
-#include <media_image.h>
-#include <media_content.h>
#include <media_info_private.h>
-#include <media-svc.h>
int image_meta_destroy(image_meta_h image)
if(_image != NULL && STRING_VALID(_image->media_id))
{
- sql = sqlite3_mprintf(UPDATE_IMAGE_META_FROM_MEDIA, _image->orientation, _image->weather, _image->media_id);
+ char storage_id[MEDIA_CONTENT_UUID_SIZE+1] = {0,};
+ memset(storage_id, 0x00, sizeof(storage_id));
+
+ ret = _media_db_get_storage_id_by_media_id(_image->media_id, storage_id);
+ media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
+
+ sql = sqlite3_mprintf(UPDATE_IMAGE_META_FROM_MEDIA, storage_id, _image->orientation, _image->weather, _image->media_id);
ret = _content_query_sql(sql);
sqlite3_free(sql);
}
* limitations under the License.
*/
-#include <unistd.h>
#include <media_info.h>
-#include <media_content.h>
#include <media-thumbnail.h>
#include <media_info_private.h>
#include <media_util_private.h>
-#include <media-svc.h>
-#include <media-util.h>
-static int __media_info_get_media_info_from_db(char *path, media_info_h media);
static void __media_info_insert_completed_cb(media_request_result_s *result, void *user_data);
static void __media_info_thumbnail_completed_cb(int error, const char *path, void *user_data);
static bool __media_info_delete_batch_cb(media_info_h media, void *user_data);
static int __media_info_insert_batch(media_batch_insert_e insert_type, const char **path_array, unsigned int array_length, media_insert_completed_cb completed_cb, void *user_data);
-static int __media_info_get_media_info_from_db(char *path, media_info_h media)
-{
- int ret = MEDIA_CONTENT_ERROR_NONE;
- int ret_view = MEDIA_CONTENT_ERROR_NONE;
- sqlite3_stmt *stmt = NULL;
- char *select_query = NULL;
- media_info_s *_media = (media_info_s*)media;
-
- if(_media == NULL)
- {
- media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
- return MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
- }
-
- select_query = sqlite3_mprintf(SELECT_MEDIA_BY_PATH, path);
-
- ret = _content_query_prepare(&stmt, select_query, NULL, NULL);
- sqlite3_free(select_query);
- media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
-
- if(sqlite3_step(stmt) == SQLITE_ROW)
- {
- _media_info_item_get_detail(stmt, (media_info_h)_media);
- media_content_debug("New Media ID: %s", _media->media_id);
- } else {
- media_content_debug("There's no media!!");
- }
-/*
- while(sqlite3_step(stmt) == SQLITE_ROW)
- {
- _media_info_item_get_detail(stmt, (media_info_h)_media);
- media_content_debug("New Media ID: %s", _media->media_id);
- }
-*/
- SQLITE3_FINALIZE(stmt);
-
- return ret;
-}
-
static int __media_info_get_media_path_by_id_from_db(const char *media_id, char **path)
{
int ret = MEDIA_CONTENT_ERROR_NONE;
- int ret_view = MEDIA_CONTENT_ERROR_NONE;
sqlite3_stmt *stmt = NULL;
char *select_query = NULL;
if(STRING_VALID((const char *)sqlite3_column_text(stmt, 0)))
*path = strdup((const char *)sqlite3_column_text(stmt, 0));
} else {
- media_content_debug("There's no media with this ID : %s", media_id);
+ media_content_error("There's no media with this ID : %s", media_id);
*path = NULL;
- ret = MEDIA_CONTENT_ERROR_DB_FAILED;
+ ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
}
SQLITE3_FINALIZE(stmt);
+
return ret;
}
if (STRING_VALID(_cb_data->insert_list_path)) {
if (unlink(_cb_data->insert_list_path) < 0) {
- media_content_error("failed to delete : %s", strerror(errno));
+ media_content_stderror("failed to delete");
}
SAFE_FREE(_cb_data->insert_list_path);
}
static bool __media_info_delete_batch_cb(media_info_h media, void *user_data)
{
+ int err = MEDIA_CONTENT_ERROR_NONE;
char *thumb_path = NULL;
media_content_type_e media_type = 0;
+ GArray *thumb_list = (GArray *)user_data;
if(media == NULL)
{
- media_content_debug("NO Item \n");
+ media_content_debug("NO Item");
return true;
}
- media_info_get_media_type(media, &media_type);
- media_content_debug("media_type : [%d] \n", media_type);
+ err = media_info_get_media_type(media, &media_type);
+ if (err == MEDIA_CONTENT_ERROR_NONE) {
+ media_content_debug("media_type : [%d]", media_type);
- media_info_get_thumbnail_path(media, &thumb_path);
- if (STRING_VALID(thumb_path)) {
- if (strncmp(MEDIA_CONTENT_THUMB_DEFAULT_PATH, thumb_path, strlen(MEDIA_CONTENT_THUMB_DEFAULT_PATH)) != 0) {
- media_content_debug("Deleting thumbnail : [%s] \n", thumb_path);
- if (unlink(thumb_path) < 0) {
- media_content_error("failed to delete : %s", strerror(errno));
+ media_info_get_thumbnail_path(media, &thumb_path);
+ if (STRING_VALID(thumb_path)) {
+ if (strncmp(MEDIA_CONTENT_THUMB_DEFAULT_PATH, thumb_path, strlen(MEDIA_CONTENT_THUMB_DEFAULT_PATH)) != 0) {
+ g_array_append_val(thumb_list, thumb_path);
}
}
-
- SAFE_FREE(thumb_path);
+ } else {
+ media_content_error("media_info_get_media_type failed");
}
return true;
}
+static int __media_info_insert_batch(media_batch_insert_e insert_type, const char **path_array,
+ unsigned int array_length,
+ media_insert_completed_cb completed_cb,
+ void *user_data)
+{
+ int ret = MEDIA_CONTENT_ERROR_NONE;
+ FILE *fp = NULL;
+ char list_path[255] = {0,};
+ int idx = 0;
+ int nwrites = 0;
+
+ for (idx = 0; idx < BATCH_REQUEST_MAX; idx++) {
+ snprintf(list_path, sizeof(list_path), "%s/request-%ld-%d", MEDIA_CONTENT_INSERT_FILES_PATH, media_content_gettid(), idx);
+
+ if (g_file_test(list_path, G_FILE_TEST_EXISTS | G_FILE_TEST_IS_REGULAR)) {
+ memset(list_path, 0x00, sizeof(list_path));
+ continue;
+ } else {
+ media_content_debug("The request file list path : %s", list_path);
+ break;
+ }
+ }
+
+ if (idx == BATCH_REQUEST_MAX) {
+ media_content_error("Too many batch request for one thread");
+ return MEDIA_CONTENT_ERROR_DB_BUSY;
+ }
+
+ fp = fopen(list_path, "w");
+ if (fp == NULL) {
+ media_content_error("failed to open file : [%s]", list_path);
+ media_content_stderror("failed to open file");
+ return MEDIA_CONTENT_ERROR_INVALID_OPERATION;
+ }
+
+ for (idx = 0; idx < array_length; idx++) {
+ if (STRING_VALID(path_array[idx])) {
+ int size = strlen(path_array[idx]);
+
+ ret = _media_util_check_file(path_array[idx]);
+ if (ret != MEDIA_CONTENT_ERROR_NONE) {
+ fclose(fp);
+ if (unlink(list_path) < 0) {
+ media_content_stderror("failed to delete");
+ }
+ return ret;
+ }
+
+ nwrites = fwrite(path_array[idx], 1, size, fp);
+ if (nwrites != size) {
+ media_content_stderror("failed to write");
+ fclose(fp);
+ if (unlink(list_path) < 0) {
+ media_content_stderror("failed to delete");
+ }
+ return MEDIA_CONTENT_ERROR_INVALID_OPERATION;
+ }
+
+ nwrites = fwrite("\n", 1, 1, fp);
+ if (nwrites != 1) {
+ media_content_stderror("failed to write");
+ fclose(fp);
+ if (unlink(list_path) < 0) {
+ media_content_stderror("failed to delete");
+ }
+ return MEDIA_CONTENT_ERROR_INVALID_OPERATION;
+ }
+ } else {
+ media_content_error("path[%d] is invalid string", idx);
+ }
+ }
+
+ fclose(fp);
+
+ media_insert_cb_s *_cb_data = (media_insert_cb_s *)calloc(1, sizeof(media_insert_cb_s));
+ if(_cb_data == NULL)
+ {
+ media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
+ return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
+ }
+
+ _cb_data->insert_completed_cb = completed_cb;
+ _cb_data->user_data = user_data;
+ _cb_data->insert_list_path = strdup(list_path);
+
+ if(insert_type == MEDIA_BATCH_INSERT_NORMAL)
+ ret = media_files_register(list_path, __media_info_insert_completed_cb, _cb_data, tzplatform_getuid(TZ_USER_NAME));
+ else if(insert_type == MEDIA_BATCH_INSERT_BURSTSHOT)
+ ret = media_burstshot_register(list_path, __media_info_insert_completed_cb, _cb_data, tzplatform_getuid(TZ_USER_NAME));
+ else
+ ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
+
+ if (ret != MEDIA_CONTENT_ERROR_NONE) {
+ media_content_error("media_files_register failed : %d", ret);
+ if (unlink(list_path) < 0) {
+ media_content_stderror("failed to delete");
+ }
+ return _content_error_capi(MEDIA_CONTENT_TYPE, ret);
+ }
+
+ return ret;
+}
void _media_info_item_get_detail(sqlite3_stmt* stmt, media_info_h media)
{
-//#define MEDIA_INFO_ITEM "media_uuid, path, file_name, media_type, mime_type, size, added_time, modified_time, thumbnail_path, description,
-// rating, favourite, author, provider, content_name, category, location_tag, age_rating, keyword, is_drm, storage_type, longitude, latitude, altitude, width, height, datetaken, orientation, title, album, artist, genre, composer, year, recorded_date, copyright, track_num, bitrate, duration, played_count, last_played_time, last_played_position, samplerate, channel"
-
media_info_s *_media = (media_info_s*)media;
if(STRING_VALID((const char *)sqlite3_column_text(stmt, MEDIA_INFO_UUID)))
_media->sync_status = (int)sqlite3_column_int(stmt, MEDIA_INFO_SYNC_STATUS);
+ if(STRING_VALID((const char *)sqlite3_column_text(stmt, MEDIA_INFO_STORAGE_UUID)))
+ _media->storage_uuid = strdup((const char *)sqlite3_column_text(stmt, MEDIA_INFO_STORAGE_UUID));
if(_media->media_type == MEDIA_CONTENT_TYPE_IMAGE) {
_media->image_meta = (image_meta_s *)calloc(1, sizeof(image_meta_s));
_media->audio_meta->samplerate = sqlite3_column_int(stmt, MEDIA_INFO_SAMPLERATE);
_media->audio_meta->channel = sqlite3_column_int(stmt, MEDIA_INFO_CHANNEL);
}
+ }
+}
+
+int _media_info_get_media_info_from_db(const char *path, const char *storage_id, media_info_h media)
+{
+ int ret = MEDIA_CONTENT_ERROR_NONE;
+ sqlite3_stmt *stmt = NULL;
+ char *select_query = NULL;
+ media_info_s *_media = (media_info_s*)media;
+
+ if(_media == NULL)
+ {
+ media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
+ return MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
+ }
+
+ select_query = sqlite3_mprintf(SELECT_MEDIA_BY_PATH, storage_id, path);
+ ret = _content_query_prepare(&stmt, select_query, NULL, NULL);
+ sqlite3_free(select_query);
+ media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
+
+ if(sqlite3_step(stmt) == SQLITE_ROW)
+ {
+ _media_info_item_get_detail(stmt, (media_info_h)_media);
+ } else {
+ media_content_error("There's no media!!");
+ ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
}
+
+ SQLITE3_FINALIZE(stmt);
+
+ return ret;
}
-int media_info_insert_to_db (const char *path, media_info_h *info)
+int media_info_insert_to_db(const char *path, media_info_h *info)
{
+ bool ignore_dir = FALSE;
+ char *folder_path = NULL;
int ret = MEDIA_CONTENT_ERROR_NONE;
if(!STRING_VALID(path))
return MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
}
-#if 0
- media_content_debug("Register: %s", path);
- ret = media_file_register(path);
- if(ret != MS_MEDIA_ERR_NONE)
- {
- media_content_error("media_file_register failed");
- return _content_error_capi(MEDIA_REGISTER_TYPE, ret);
+ ret = _media_util_check_file(path);
+ if (ret != MEDIA_CONTENT_ERROR_NONE) {
+ return ret;
}
-#else
- char *_path = strdup(path);
- if (_path == NULL) {
- media_content_error("strdup failed : %s", path);
- return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
+ folder_path = g_path_get_dirname(path);
+ ret = _media_util_check_ignore_dir(folder_path, &ignore_dir);
+ SAFE_FREE(folder_path);
+
+ if(ignore_dir) {
+ media_content_error("Invalid folder path");
+ return MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
}
- ret = media_svc_check_item_exist_by_path(_content_get_db_handle(), _path);
+ ret = media_svc_check_item_exist_by_path(_content_get_db_handle(), path);
if (ret == MS_MEDIA_ERR_DB_NO_RECORD) {
- media_content_debug("media_svc_check_item_exist_by_path : no record : %s", _path);
+ media_content_sec_debug("media_svc_check_item_exist_by_path : no record : %s", path);
- media_svc_storage_type_e storage_type;
+ media_svc_storage_type_e storage_type = 0;
- ret = media_svc_get_storage_type(_path, &storage_type);
- if (ret < 0) {
- media_content_error("media_svc_get_storage_type failed : %d (%s)", ret, _path);
- SAFE_FREE(_path);
+ ret = media_svc_get_storage_type(path, &storage_type);
+ if(ret != MS_MEDIA_ERR_NONE) {
+ media_content_sec_error("media_svc_get_storage_type failed : %d", ret);
return _content_error_capi(MEDIA_CONTENT_TYPE, ret);
}
- media_content_debug("media_svc_insert_item_immediately: %s", _path);
- ret = media_svc_insert_item_immediately(_content_get_db_handle(), storage_type, _path, tzplatform_getuid(TZ_USER_NAME));
+ ret = media_svc_insert_item_immediately(_content_get_db_handle(), storage_type, path, tzplatform_getuid(TZ_USER_NAME));
+
+ if(ret != MS_MEDIA_ERR_NONE) {
+ if (ret == MS_MEDIA_ERR_DB_CONSTRAINT_FAIL) {
+ media_content_sec_error("This item is already inserted. This may be normal operation because other process already did this (%s)", path);
+ ret = MEDIA_CONTENT_ERROR_NONE;
+ } else {
+ media_content_sec_error("media_svc_insert_item_immediately failed : %d (%s)", ret, path);
+ }
- if (ret < 0) {
- media_content_error("media_svc_insert_item_immediately failed : %d (%s)", ret, _path);
- SAFE_FREE(_path);
return _content_error_capi(MEDIA_CONTENT_TYPE, ret);
}
} else if (ret != MS_MEDIA_ERR_NONE) {
- media_content_error("media_svc_check_item_exist_by_path failed : %d (%s)", ret, _path);
- SAFE_FREE(_path);
+ media_content_sec_error("media_svc_check_item_exist_by_path failed : %d (%s)", ret, path);
return _content_error_capi(MEDIA_CONTENT_TYPE, ret);
}
-#endif
media_info_s *_media = (media_info_s*)calloc(1, sizeof(media_info_s));
if(_media == NULL)
{
media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
- SAFE_FREE(_path);
- return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
- }
-
- _media->file_path = _path;
- if(_media->file_path == NULL)
- {
- media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
- SAFE_FREE(_media);
return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
}
- ret = __media_info_get_media_info_from_db(_media->file_path, (media_info_h)_media);
+ ret = _media_info_get_media_info_from_db(path, DEFAULT_MEDIA_STORAGE_ID, (media_info_h)_media);
*info = (media_info_h)_media;
return ret;
}
-static int __media_info_insert_batch(media_batch_insert_e insert_type, const char **path_array,
- unsigned int array_length,
- media_insert_completed_cb completed_cb,
- void *user_data)
-{
- int ret = MEDIA_CONTENT_ERROR_NONE;
- FILE *fp = NULL;
- char list_path[255] = {0,};
- int idx = 0;
- int nwrites = 0;
-
- for (idx = 0; idx < BATCH_REQUEST_MAX; idx++) {
- snprintf(list_path, sizeof(list_path), "%s/request-%ld-%d", MEDIA_CONTENT_INSERT_FILES_PATH, media_content_gettid(), idx);
-
- if (g_file_test(list_path, G_FILE_TEST_EXISTS | G_FILE_TEST_IS_REGULAR)) {
- memset(list_path, 0x00, sizeof(list_path));
- continue;
- } else {
- media_content_debug("The request file list path : %s", list_path);
- break;
- }
- }
-
- if (idx == BATCH_REQUEST_MAX) {
- media_content_error("Too many batch request for one thread");
- return MEDIA_CONTENT_ERROR_DB_BUSY;
- }
-
- fp = fopen(list_path, "w");
- if (fp == NULL) {
- media_content_error("failed to open file : %s [%s]", list_path, strerror(errno));
- return MEDIA_CONTENT_ERROR_INVALID_OPERATION;
- }
-
- for (idx = 0; idx < array_length; idx++) {
- if (STRING_VALID(path_array[idx])) {
- int size = strlen(path_array[idx]);
-
- nwrites = fwrite(path_array[idx], 1, size, fp);
- if (nwrites != size) {
- media_content_error("failed to write thumbnail : %s", strerror(errno));
- fclose(fp);
- if (unlink(list_path) < 0) {
- media_content_error("failed to delete : %s", strerror(errno));
- }
- return MEDIA_CONTENT_ERROR_INVALID_OPERATION;
- }
-
- nwrites = fwrite("\n", 1, 1, fp);
- if (nwrites != 1) {
- media_content_error("failed to write thumbnail : %s", strerror(errno));
- fclose(fp);
- if (unlink(list_path) < 0) {
- media_content_error("failed to delete : %s", strerror(errno));
- }
- return MEDIA_CONTENT_ERROR_INVALID_OPERATION;
- }
- } else {
- media_content_error("path[%d] is invalid string", idx);
- }
- }
-
- fclose(fp);
-
- media_insert_cb_s *_cb_data = (media_insert_cb_s *)calloc(1, sizeof(media_insert_cb_s));
- _cb_data->insert_completed_cb = completed_cb;
- _cb_data->user_data = user_data;
- _cb_data->insert_list_path = strdup(list_path);
-
- if(insert_type == MEDIA_BATCH_INSERT_NORMAL)
- ret = media_files_register(list_path, __media_info_insert_completed_cb, _cb_data, tzplatform_getuid(TZ_USER_NAME));
- else if(insert_type == MEDIA_BATCH_INSERT_BURSTSHOT)
- ret = media_burstshot_register(list_path, __media_info_insert_completed_cb, _cb_data, tzplatform_getuid(TZ_USER_NAME));
- else
- ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
-
- if (ret != MEDIA_CONTENT_ERROR_NONE) {
- media_content_error("media_files_register failed : %d", ret);
- if (unlink(list_path) < 0) {
- media_content_error("failed to delete : %s", strerror(errno));
- }
- return _content_error_capi(MEDIA_CONTENT_TYPE, ret);
- }
-
- return ret;
-}
-
int media_info_insert_batch_to_db(
const char **path_array,
unsigned int array_length,
int media_info_delete_from_db(const char *media_id)
{
int ret = MEDIA_CONTENT_ERROR_NONE;
+ char *path = NULL;
+ char storage_id[MEDIA_CONTENT_UUID_SIZE+1] = {0,};
if(!STRING_VALID(media_id))
{
return MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
}
-#if 0
- char *query_string = NULL;
- query_string = sqlite3_mprintf(DELETE_MEDIA_FROM_MEDIA, media_id);
-
- ret = _content_query_sql(query_string);
-
- sqlite3_free(query_string);
-
- return ret;
-#else
- char *path = NULL;
+ memset(storage_id, 0x00, sizeof(storage_id));
ret = __media_info_get_media_path_by_id_from_db(media_id, &path);
- if (ret < MEDIA_CONTENT_ERROR_NONE) {
+ if(ret != MEDIA_CONTENT_ERROR_NONE) {
media_content_error("__media_info_get_media_path_by_id_from_db failed : %d", ret);
SAFE_FREE(path);
return ret;
}
- ret = media_svc_delete_item_by_path(_content_get_db_handle(), path, tzplatform_getuid(TZ_USER_NAME));
+ ret = _media_db_get_storage_id_by_media_id(media_id, storage_id);
+ if(ret != MEDIA_CONTENT_ERROR_NONE) {
+ media_content_error("_media_db_get_storage_id_by_media_id failed : %d", ret);
+ SAFE_FREE(path);
+ return ret;
+ }
+
+ ret = media_svc_delete_item_by_path(_content_get_db_handle(), storage_id, path, tzplatform_getuid(TZ_USER_NAME));
SAFE_FREE(path);
- return _content_error_capi(ret,MEDIA_CONTENT_TYPE);
-#endif
+ return _content_error_capi(MEDIA_CONTENT_TYPE, ret);
+}
+
+static int __media_info_delete_thumb_from_list(GArray *thumb_list)
+{
+ int i = 0;
+ int list_len = 0;
+ char *thumb_path = NULL;
+
+ if (thumb_list != NULL) {
+
+ list_len = thumb_list->len;
+
+ for (i = 0; i < list_len; i ++) {
+ thumb_path = g_array_index(thumb_list, char*, i);
+ media_content_debug("thumb path [%s]", thumb_path);
+ if (unlink(thumb_path) < 0) {
+ media_content_stderror("failed to delete");
+ }
+ }
+ }
+ return MEDIA_CONTENT_ERROR_NONE;
+}
+
+static int __media_info_release_thumb_list(GArray *thumb_list)
+{
+ int i = 0;
+ int list_len = 0;
+ char *thumb_path = NULL;
+
+ if (thumb_list != NULL) {
+
+ list_len = thumb_list->len;
+
+ for (i = 0; i < list_len; i ++) {
+ thumb_path = g_array_index(thumb_list, char*, 0);
+ g_array_remove_index(thumb_list,0);
+ SAFE_FREE(thumb_path);
+ }
+
+ g_array_free(thumb_list, FALSE);
+ }
+
+ return MEDIA_CONTENT_ERROR_NONE;
}
int media_info_delete_batch_from_db(filter_h filter)
filter_s *_filter = NULL;
attribute_h attr;
char *condition_query = NULL;
+ GArray *thumb_list = NULL;
if(filter == NULL)
{
return MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
}
+ thumb_list = g_array_new(FALSE, FALSE, sizeof(char*));
+
/* Delete thumbnail of each item */
- ret = _media_db_get_group_item(NULL, filter, __media_info_delete_batch_cb, NULL, MEDIA_GROUP_NONE);
+ ret = _media_db_get_group_item(NULL, filter, __media_info_delete_batch_cb, thumb_list, MEDIA_GROUP_NONE);
_filter = (filter_s*)filter;
attr = _content_get_attirbute_handle();
if(_filter->condition)
{
ret = _media_filter_attribute_generate(attr, _filter->condition, _filter->condition_collate_type, &condition_query);
- media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
+ if (ret != MEDIA_CONTENT_ERROR_NONE) {
+ __media_info_release_thumb_list(thumb_list);
+ return ret;
+ }
}
if(STRING_VALID(condition_query))
{
- query_string = sqlite3_mprintf(DELETE_MEDIA_FROM_MEDIA_BATCH, condition_query);
+ if (_filter->storage_id == NULL) {
+ /*FIX ME*/
+ query_string = sqlite3_mprintf(DELETE_MEDIA_FROM_MEDIA_BATCH, "media", condition_query);
+ } else {
+ query_string = sqlite3_mprintf(DELETE_MEDIA_FROM_MEDIA_BATCH, _filter->storage_id, condition_query);
+ }
}
else
{
SAFE_FREE(condition_query);
+ __media_info_release_thumb_list(thumb_list);
+
return MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
}
In this case, send noti for internal storage and external storage
*/
media_content_debug("Batch deletion is successfull. Send notification for this");
- media_db_update_send(getpid(), MS_MEDIA_ITEM_DIRECTORY, MS_MEDIA_ITEM_UPDATE, MEDIA_CONTENT_PATH_PHONE, NULL, -1, NULL);
- media_db_update_send(getpid(), MS_MEDIA_ITEM_DIRECTORY, MS_MEDIA_ITEM_UPDATE, MEDIA_CONTENT_PATH_MMC, NULL, -1, NULL);
+ media_svc_publish_noti(_content_get_db_handle(), MS_MEDIA_ITEM_DIRECTORY, MS_MEDIA_ITEM_UPDATE, MEDIA_CONTENT_PATH_PHONE, -1, NULL, NULL);
+ media_svc_publish_noti(_content_get_db_handle(), MS_MEDIA_ITEM_DIRECTORY, MS_MEDIA_ITEM_UPDATE, MEDIA_CONTENT_PATH_MMC, -1, NULL, NULL);
+
+ __media_info_delete_thumb_from_list(thumb_list);
+ __media_info_release_thumb_list(thumb_list);
}
SAFE_FREE(condition_query);
SAFE_FREE(_media->keyword);
SAFE_FREE(_media->title);
SAFE_FREE(_media->weather);
+ SAFE_FREE(_media->storage_uuid);
if(_media->image_meta) {
SAFE_FREE(_media->image_meta->media_id);
SAFE_FREE(_media->image_meta->weather);
SAFE_FREE(_media->image_meta);
- } else if(_media->video_meta) {
+ }
+
+ if(_media->video_meta) {
SAFE_FREE(_media->video_meta->media_id);
SAFE_FREE(_media->video_meta->title);
SAFE_FREE(_media->video_meta->album);
SAFE_FREE(_media->video_meta->track_num);
SAFE_FREE(_media->video_meta);
- } else if(_media->audio_meta) {
+ }
+
+ if(_media->audio_meta) {
SAFE_FREE(_media->audio_meta->media_id);
SAFE_FREE(_media->audio_meta->title);
SAFE_FREE(_media->audio_meta->album);
}
}
+ if(STRING_VALID(_src->storage_uuid))
+ {
+ _dst->storage_uuid = strdup(_src->storage_uuid);
+ if(_dst->storage_uuid == NULL)
+ {
+ media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
+ media_info_destroy((media_info_h)_dst);
+ return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
+ }
+ }
+
_dst->media_type = _src->media_type;
_dst->size = _src->size;
_dst->added_time = _src->added_time;
return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
}
}
+ if(STRING_VALID(_src->video_meta->album_artist))
+ {
+ _dst->video_meta->album_artist = strdup(_src->video_meta->album_artist);
+ if(_dst->video_meta->album_artist == NULL)
+ {
+ media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
+ media_info_destroy((media_info_h)_dst);
+ return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
+ }
+ }
if(STRING_VALID(_src->video_meta->genre))
{
_dst->video_meta->genre = strdup(_src->video_meta->genre);
return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
}
}
+ if(STRING_VALID(_src->audio_meta->album_artist))
+ {
+ _dst->audio_meta->album_artist = strdup(_src->audio_meta->album_artist);
+ if(_dst->audio_meta->album_artist == NULL)
+ {
+ media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
+ media_info_destroy((media_info_h)_dst);
+ return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
+ }
+ }
if(STRING_VALID(_src->audio_meta->genre))
{
_dst->audio_meta->genre = strdup(_src->audio_meta->genre);
{
int ret = MEDIA_CONTENT_ERROR_NONE;
- media_content_debug_func();
-
if(media_count == NULL)
{
media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
{
int ret = MEDIA_CONTENT_ERROR_NONE;
- media_content_debug_func();
-
if(callback == NULL)
{
media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
{
int ret = MEDIA_CONTENT_ERROR_NONE;
- media_content_debug_func();
-
if(STRING_VALID(media_id) && tag_count)
{
ret = _media_db_get_group_item_count(media_id, filter, MEDIA_GROUP_TAG_BY_MEDIA_ID, tag_count);
{
int ret = MEDIA_CONTENT_ERROR_NONE;
- media_content_debug_func();
-
if((callback != NULL) && STRING_VALID(media_id))
{
ret = _media_db_get_tag(media_id, filter, callback, user_data);
{
int ret = MEDIA_CONTENT_ERROR_NONE;
- media_content_debug_func();
-
if(STRING_VALID(media_id) && bookmark_count)
{
ret = _media_db_get_group_item_count(media_id, filter, MEDIA_GROUP_BOOKMARK_BY_MEDIA_ID, bookmark_count);
{
int ret = MEDIA_CONTENT_ERROR_NONE;
- media_content_debug_func();
-
if((callback != NULL) && STRING_VALID(media_id))
{
ret = _media_db_get_bookmark(media_id, filter, callback, user_data);
if(STRING_VALID(_media->video_meta->artist)) {
_video->artist = strdup(_media->video_meta->artist);
}
+ if(STRING_VALID(_media->video_meta->album_artist)) {
+ _video->album_artist = strdup(_media->video_meta->album_artist);
+ }
if(STRING_VALID(_media->video_meta->genre)) {
_video->genre = strdup(_media->video_meta->genre);
}
if(STRING_VALID(_media->audio_meta->artist)) {
_audio->artist = strdup(_media->audio_meta->artist);
}
+ if(STRING_VALID(_media->audio_meta->album_artist)) {
+ _audio->album_artist = strdup(_media->audio_meta->album_artist);
+ }
if(STRING_VALID(_media->audio_meta->genre)) {
_audio->genre = strdup(_media->audio_meta->genre);
}
return ret;
}
+int media_info_get_storage_id(media_info_h media, char **storage_id)
+{
+ int ret = MEDIA_CONTENT_ERROR_NONE;
+ media_info_s *_media = (media_info_s*)media;
+
+ if(_media && storage_id)
+ {
+ if(STRING_VALID(_media->storage_uuid))
+ {
+ *storage_id = strdup(_media->storage_uuid);
+ if(*storage_id == NULL)
+ {
+ media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
+ return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
+ }
+ }
+ else
+ {
+ *storage_id = NULL;
+ }
+ ret = MEDIA_CONTENT_ERROR_NONE;
+ }
+ else
+ {
+ media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
+ ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
+ }
+
+ return ret;
+}
+
int media_info_is_drm(media_info_h media, bool *is_drm)
{
int ret = MEDIA_CONTENT_ERROR_NONE;
int media_info_get_media_from_db(const char *media_id, media_info_h *media)
{
int ret = MEDIA_CONTENT_ERROR_NONE;
- int ret_view = MEDIA_CONTENT_ERROR_NONE;
char select_query[DEFAULT_QUERY_SIZE];
+ char storage_id[MEDIA_CONTENT_UUID_SIZE+1] = {0,};
sqlite3_stmt *stmt = NULL;
if(!STRING_VALID(media_id) || (media == NULL))
}
memset(select_query, 0x00, sizeof(select_query));
+ memset(storage_id, 0x00, sizeof(storage_id));
+
+ ret = _media_db_get_storage_id_by_media_id(media_id, storage_id);
+ media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
+
+ snprintf(select_query, sizeof(select_query), SELECT_MEDIA_FROM_MEDIA, storage_id, media_id);
- snprintf(select_query, sizeof(select_query), SELECT_MEDIA_FROM_MEDIA, media_id);
ret = _content_query_prepare(&stmt, select_query, NULL, NULL);
media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
+ media_info_s *_media = NULL;
+
while(sqlite3_step(stmt) == SQLITE_ROW)
{
- media_info_s *_media = (media_info_s*)calloc(1, sizeof(media_info_s));
+ if(_media)
+ media_info_destroy((media_info_h)_media);
+
+ _media = (media_info_s*)calloc(1, sizeof(media_info_s));
if(_media == NULL)
{
}
SQLITE3_FINALIZE(stmt);
+
return ret;
}
int media_info_update_to_db(media_info_h media)
{
int ret = MEDIA_CONTENT_ERROR_NONE;
- int len = 0;
media_info_s *_media = (media_info_s*)media;
char *set_sql = NULL;
- char sql[MAX_QUERY_SIZE];
- memset(sql, '\0', sizeof(sql));
+ char *sql = NULL;
if(_media != NULL && STRING_VALID(_media->media_id))
{
set_sql = sqlite3_mprintf("file_name=%Q, added_time=%d, description=%Q, longitude=%f, latitude=%f, altitude=%f, \
played_count=%d, last_played_time=%d, last_played_position=%d, \
rating=%d, favourite=%d, author=%Q, provider=%Q, content_name=%Q, category=%Q, location_tag=%Q, age_rating=%Q, keyword=%Q, weather=%Q, sync_status=%d, \
- file_name_pinyin=%Q, description_pinyin=%Q, author_pinyin=%Q, provider_pinyin=%Q, content_name_pinyin=%Q, category_pinyin=%Q, location_tag_pinyin=%Q, age_rating_pinyin=%Q, keyword_pinyin=%Q",
+ file_name_pinyin=%Q, description_pinyin=%Q, author_pinyin=%Q, provider_pinyin=%Q, content_name_pinyin=%Q, category_pinyin=%Q, location_tag_pinyin=%Q, age_rating_pinyin=%Q, keyword_pinyin=%Q, title=%Q",
_media->display_name, _media->added_time, _media->description, _media->longitude, _media->latitude, _media->altitude, _media->played_count, _media->played_time, _media->played_position, _media->rating, _media->favourite,
_media->author, _media->provider, _media->content_name, _media->category, _media->location_tag, _media->age_rating, _media->keyword, _media->weather, _media->sync_status,
- file_name_pinyin, description_pinyin, author_pinyin, provider_pinyin, content_name_pinyin, category_pinyin, location_tag_pinyin, age_rating_pinyin, keyword_pinyin);
+ file_name_pinyin, description_pinyin, author_pinyin, provider_pinyin, content_name_pinyin, category_pinyin, location_tag_pinyin, age_rating_pinyin, keyword_pinyin, _media->title);
+
+ sql = sqlite3_mprintf("UPDATE %Q SET %s WHERE media_uuid=%Q", _media->storage_uuid, set_sql, _media->media_id);
- len = snprintf(sql, sizeof(sql), "UPDATE %s SET %s WHERE media_uuid='%s'", DB_TABLE_MEDIA, set_sql, _media->media_id);
+ ret = _content_query_sql(sql);
sqlite3_free(set_sql);
+ sqlite3_free(sql);
SAFE_FREE(description_pinyin);
SAFE_FREE(author_pinyin);
SAFE_FREE(age_rating_pinyin);
SAFE_FREE(keyword_pinyin);
- if (len > 0) {
- sql[len] = '\0';
- } else {
- media_content_error("snprintf failed");
- return MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
- }
+ if(_media->storage_type == MEDIA_CONTENT_STORAGE_CLOUD)
+ {
+ set_sql = NULL;
+ sql = NULL;
+
+ if(_media->media_type == MEDIA_CONTENT_TYPE_VIDEO)
+ {
+ set_sql = sqlite3_mprintf("title=%Q, album=%Q, artist=%Q, genre=%Q, duration=%d, width=%d, height=%d", \
+ _media->title, _media->video_meta->album, _media->video_meta->artist, _media->video_meta->genre, _media->video_meta->duration, _media->video_meta->width, _media->video_meta->height);
+ }
+ else if((_media->media_type == MEDIA_CONTENT_TYPE_MUSIC) || (_media->media_type == MEDIA_CONTENT_TYPE_SOUND))
+ {
+ set_sql = sqlite3_mprintf("title=%Q, album=%Q, artist=%Q, genre=%Q, duration=%d", \
+ _media->title, _media->audio_meta->album, _media->audio_meta->artist, _media->audio_meta->genre, _media->audio_meta->duration);
+ }
+ else if(_media->media_type == MEDIA_CONTENT_TYPE_IMAGE)
+ {
+ set_sql = sqlite3_mprintf("title=%Q, width=%d, height=%d", _media->title, _media->image_meta->width, _media->image_meta->height);
+ }
+ else
+ {
+ set_sql = sqlite3_mprintf("title=%Q", _media->title);
+ }
+ sql = sqlite3_mprintf("UPDATE %Q SET %s WHERE media_uuid=%Q", _media->storage_uuid, set_sql, _media->media_id);
+
+ ret = _content_query_sql(sql);
+
+ sqlite3_free(set_sql);
+ sqlite3_free(sql);
+ }
- ret = _content_query_sql(sql);
if (ret == MEDIA_CONTENT_ERROR_NONE) {
/* Send notification for this update */
media_content_debug("Update is successfull. Send notification for this");
if (_media->file_path && _media->mime_type) {
- media_db_update_send(getpid(), MS_MEDIA_ITEM_FILE, MS_MEDIA_ITEM_UPDATE, _media->file_path, _media->media_id, _media->media_type, _media->mime_type);
+ media_svc_publish_noti(_content_get_db_handle(), MS_MEDIA_ITEM_FILE, MS_MEDIA_ITEM_UPDATE, _media->file_path, _media->media_type, _media->media_id, _media->mime_type);
} else {
- media_content_error("Can't media_db_update_send : path or mime type is NULL");
+ media_content_error("Can't Send Noti : path or mime type is NULL");
}
}
}
return ret;
}
+ if(storage_type == MEDIA_CONTENT_STORAGE_CLOUD)
+ {
+ media_info_destroy(media);
+ media_content_error("Can't refresh cloud content!!");
+ return MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
+ }
+
ret = media_info_get_file_path(media, &file_path);
if(ret != MEDIA_CONTENT_ERROR_NONE)
{
return ret;
}
- ret = media_svc_refresh_item(_content_get_db_handle(), storage_type, file_path, tzplatform_getuid(TZ_USER_NAME));
+ ret = _media_util_check_file(file_path);
+ if (ret != MEDIA_CONTENT_ERROR_NONE) {
+ SAFE_FREE(file_path);
+ media_info_destroy(media);
+ return ret;
+ }
+
+ ret = media_svc_refresh_item(_content_get_db_handle(), storage_type, "media", file_path, tzplatform_getuid(TZ_USER_NAME));
+ if (ret != MS_MEDIA_ERR_NONE)
+ {
+ ret = _content_error_capi(MEDIA_CONTENT_TYPE, ret);
+ }
SAFE_FREE(file_path);
media_info_destroy(media);
{
int ret = MEDIA_CONTENT_ERROR_NONE;
- int src_storage_type = 0;
- int dst_storage_type = 0;
+ media_svc_storage_type_e src_storage_type = 0;
+ media_svc_storage_type_e dst_storage_type = 0;
if(media == NULL || !STRING_VALID(dst_path))
{
media_info_s *_media = (media_info_s*)media;
- ret = _media_util_get_store_type_by_path(_media->file_path, &src_storage_type);
- media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
- ret = _media_util_get_store_type_by_path(dst_path, &dst_storage_type);
- media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
+ ret = _media_util_check_file(dst_path);
+ if (ret != MEDIA_CONTENT_ERROR_NONE) {
+ return ret;
+ }
+
+ ret = media_svc_get_storage_type(_media->file_path, &src_storage_type);
+ if(ret != MS_MEDIA_ERR_NONE)
+ {
+ media_content_sec_error("media_svc_get_storage_type failed : %d", ret);
+ return _content_error_capi(MEDIA_CONTENT_TYPE, ret);
+ }
+
+ ret = media_svc_get_storage_type(dst_path, &dst_storage_type);
+ if(ret != MS_MEDIA_ERR_NONE)
+ {
+ media_content_sec_error("media_svc_get_storage_type failed : %d", ret);
+ return _content_error_capi(MEDIA_CONTENT_TYPE, ret);
+ }
ret = media_svc_move_item(_content_get_db_handle(), src_storage_type, _media->file_path, dst_storage_type, dst_path, tzplatform_getuid(TZ_USER_NAME));
return _content_error_capi(MEDIA_CONTENT_TYPE, ret);
if(_media != NULL && STRING_VALID(_media->media_id) && STRING_VALID(_media->file_path))
{
media_thumbnail_cb_s *_thumb_cb = (media_thumbnail_cb_s*)calloc(1, sizeof(media_thumbnail_cb_s));
+ if(_thumb_cb == NULL)
+ {
+ media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
+ return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
+ }
+
_thumb_cb->handle = _media;
_thumb_cb->user_data = user_data;
_thumb_cb->thumbnail_completed_cb = callback;
return ret;
}
+
+static int __media_info_map_data_usr_to_svc(media_info_s *media, media_svc_content_info_s **service_content, media_content_storage_e storage_type)
+{
+ if(media == NULL)
+ {
+ media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
+ return MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
+ }
+
+ media_svc_content_info_s *svc_content_info = calloc(1, sizeof(media_svc_content_info_s));
+ if(svc_content_info == NULL)
+ {
+ media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
+ return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
+ }
+
+ svc_content_info->path = g_strdup(media->file_path);
+ svc_content_info->media_type = media->media_type;
+ svc_content_info->mime_type = g_strdup(media->mime_type);
+ svc_content_info->size = media->size;
+ svc_content_info->storage_type = storage_type;
+ svc_content_info->storage_uuid = g_strdup(media->storage_uuid);
+
+ svc_content_info->added_time = media->added_time;
+ svc_content_info->modified_time = media->modified_time;
+ svc_content_info->thumbnail_path = g_strdup(media->thumbnail_path);
+ svc_content_info->is_drm = media->is_drm;
+
+ svc_content_info->media_meta.title = g_strdup(media->title);
+ svc_content_info->media_meta.rating = media->rating;
+ svc_content_info->media_meta.description = g_strdup(media->description);
+ svc_content_info->media_meta.longitude = media->longitude;
+ svc_content_info->media_meta.latitude = media->latitude;
+ svc_content_info->media_meta.altitude = media->altitude;
+ svc_content_info->media_meta.weather = g_strdup(media->weather);
+
+ switch(media->media_type)
+ {
+ case MEDIA_CONTENT_TYPE_IMAGE:
+ svc_content_info->media_meta.width = media->image_meta->width;
+ svc_content_info->media_meta.height = media->image_meta->height;
+ svc_content_info->media_meta.datetaken = g_strdup(media->image_meta->date_taken);
+ svc_content_info->media_meta.orientation = media->image_meta->orientation;
+ break;
+ case MEDIA_CONTENT_TYPE_VIDEO:
+ svc_content_info->media_meta.album = g_strdup(media->audio_meta->album);
+ svc_content_info->media_meta.artist = g_strdup(media->audio_meta->artist);
+ svc_content_info->media_meta.album_artist = g_strdup(media->audio_meta->album_artist);
+ svc_content_info->media_meta.genre = g_strdup(media->audio_meta->genre);
+ svc_content_info->media_meta.composer = g_strdup(media->audio_meta->composer);
+ svc_content_info->media_meta.year = g_strdup(media->audio_meta->year);
+ svc_content_info->media_meta.recorded_date = g_strdup(media->audio_meta->recorded_date);
+ svc_content_info->media_meta.copyright = g_strdup(media->audio_meta->copyright);
+ svc_content_info->media_meta.track_num = g_strdup(media->audio_meta->track_num);
+ svc_content_info->media_meta.bitrate = media->audio_meta->bitrate;
+ svc_content_info->media_meta.duration = media->audio_meta->duration;
+ svc_content_info->media_meta.width = media->image_meta->width;
+ svc_content_info->media_meta.height = media->image_meta->height;
+ break;
+ case MEDIA_CONTENT_TYPE_SOUND:
+ case MEDIA_CONTENT_TYPE_MUSIC:
+ svc_content_info->media_meta.album = g_strdup(media->audio_meta->album);
+ svc_content_info->media_meta.artist = g_strdup(media->audio_meta->artist);
+ svc_content_info->media_meta.album_artist = g_strdup(media->audio_meta->album_artist);
+ svc_content_info->media_meta.genre = g_strdup(media->audio_meta->genre);
+ svc_content_info->media_meta.composer = g_strdup(media->audio_meta->composer);
+ svc_content_info->media_meta.year = g_strdup(media->audio_meta->year);
+ svc_content_info->media_meta.recorded_date = g_strdup(media->audio_meta->recorded_date);
+ svc_content_info->media_meta.copyright = g_strdup(media->audio_meta->copyright);
+ svc_content_info->media_meta.track_num = g_strdup(media->audio_meta->track_num);
+ svc_content_info->media_meta.bitrate = media->audio_meta->bitrate;
+ svc_content_info->media_meta.duration = media->audio_meta->duration;
+ svc_content_info->media_meta.channel = media->audio_meta->channel;
+ svc_content_info->media_meta.samplerate = media->audio_meta->samplerate;
+ break;
+ case MEDIA_CONTENT_TYPE_OTHERS:
+ default:
+ break;
+ }
+
+ *service_content = svc_content_info;
+ return MEDIA_CONTENT_ERROR_NONE;
+}
+
+static int __media_info_set_str_data(media_info_h media, media_info_item_e data_type, const char *str_data)
+{
+ media_info_s *_media = (media_info_s*)media;
+
+ if(_media == NULL)
+ {
+ media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
+ return MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
+ }
+
+ switch(data_type)
+ {
+ case MEDIA_INFO_PATH:
+ SAFE_FREE(_media->file_path);
+ if(STRING_VALID(str_data))
+ {
+ _media->file_path = strdup(str_data);
+
+ if(_media->file_path == NULL)
+ {
+ media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
+ return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
+ }
+ }
+ else
+ {
+ _media->file_path = NULL;
+ }
+ break;
+ case MEDIA_INFO_MIME_TYPE:
+ SAFE_FREE(_media->mime_type);
+ if(STRING_VALID(str_data))
+ {
+ _media->mime_type = strdup(str_data);
+
+ if(_media->mime_type == NULL)
+ {
+ media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
+ return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
+ }
+ }
+ else
+ {
+ _media->mime_type = NULL;
+ }
+ break;
+ case MEDIA_INFO_THUMBNAIL_PATH:
+ SAFE_FREE(_media->thumbnail_path);
+ if(STRING_VALID(str_data))
+ {
+ _media->thumbnail_path = strdup(str_data);
+
+ if(_media->thumbnail_path == NULL)
+ {
+ media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
+ return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
+ }
+ }
+ else
+ {
+ _media->thumbnail_path = NULL;
+ }
+ break;
+ case MEDIA_INFO_TITLE:
+ SAFE_FREE(_media->title);
+ if(STRING_VALID(str_data))
+ {
+ _media->title = strdup(str_data);
+
+ if(_media->title == NULL)
+ {
+ media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
+ return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
+ }
+ }
+ else
+ {
+ _media->title = NULL;
+ }
+ break;
+ case MEDIA_INFO_STORAGE_UUID:
+ SAFE_FREE(_media->storage_uuid);
+ if(STRING_VALID(str_data))
+ {
+ _media->storage_uuid = strdup(str_data);
+
+ if(_media->storage_uuid == NULL)
+ {
+ media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
+ return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
+ }
+ }
+ else
+ {
+ _media->storage_uuid = NULL;
+ }
+ break;
+ case MEDIA_INFO_ALBUM:
+ if(_media->media_type == MEDIA_CONTENT_TYPE_VIDEO)
+ {
+ SAFE_FREE(_media->video_meta->album);
+ if(STRING_VALID(str_data))
+ {
+ _media->video_meta->album = strdup(str_data);
+
+ if(_media->video_meta->album == NULL)
+ {
+ media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
+ return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
+ }
+ }
+ else
+ {
+ _media->video_meta->album = NULL;
+ }
+ }
+ else if((_media->media_type == MEDIA_CONTENT_TYPE_MUSIC) || (_media->media_type == MEDIA_CONTENT_TYPE_SOUND))
+ {
+ SAFE_FREE(_media->audio_meta->album);
+ if(STRING_VALID(str_data))
+ {
+ _media->audio_meta->album = strdup(str_data);
+
+ if(_media->audio_meta->album == NULL)
+ {
+ media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
+ return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
+ }
+ }
+ else
+ {
+ _media->audio_meta->album = NULL;
+ }
+ }
+ else
+ {
+ media_content_error("Invalid media type");
+ return MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
+ }
+ break;
+ case MEDIA_INFO_ARTIST:
+ if(_media->media_type == MEDIA_CONTENT_TYPE_VIDEO)
+ {
+ SAFE_FREE(_media->video_meta->artist);
+ if(STRING_VALID(str_data))
+ {
+ _media->video_meta->artist = strdup(str_data);
+
+ if(_media->video_meta->artist == NULL)
+ {
+ media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
+ return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
+ }
+ }
+ else
+ {
+ _media->video_meta->artist = NULL;
+ }
+ }
+ else if((_media->media_type == MEDIA_CONTENT_TYPE_MUSIC) || (_media->media_type == MEDIA_CONTENT_TYPE_SOUND))
+ {
+ SAFE_FREE(_media->audio_meta->artist);
+ if(STRING_VALID(str_data))
+ {
+ _media->audio_meta->artist = strdup(str_data);
+
+ if(_media->audio_meta->artist == NULL)
+ {
+ media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
+ return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
+ }
+ }
+ else
+ {
+ _media->audio_meta->artist = NULL;
+ }
+ }
+ else
+ {
+ media_content_error("Invalid media type");
+ return MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
+ }
+ break;
+ case MEDIA_INFO_GENRE:
+ if(_media->media_type == MEDIA_CONTENT_TYPE_VIDEO)
+ {
+ SAFE_FREE(_media->video_meta->genre);
+ if(STRING_VALID(str_data))
+ {
+ _media->video_meta->genre = strdup(str_data);
+
+ if(_media->video_meta->genre == NULL)
+ {
+ media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
+ return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
+ }
+ }
+ else
+ {
+ _media->video_meta->genre = NULL;
+ }
+ }
+ else if((_media->media_type == MEDIA_CONTENT_TYPE_MUSIC) || (_media->media_type == MEDIA_CONTENT_TYPE_SOUND))
+ {
+ SAFE_FREE(_media->audio_meta->genre);
+ if(STRING_VALID(str_data))
+ {
+ _media->audio_meta->genre = strdup(str_data);
+
+ if(_media->audio_meta->genre == NULL)
+ {
+ media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
+ return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
+ }
+ }
+ else
+ {
+ _media->audio_meta->genre = NULL;
+ }
+ }
+ else
+ {
+ media_content_error("Invalid media type");
+ return MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
+ }
+ break;
+ case MEDIA_INFO_RECORDED_DATE:
+ if(_media->media_type == MEDIA_CONTENT_TYPE_VIDEO)
+ {
+ SAFE_FREE(_media->video_meta->recorded_date);
+ if(STRING_VALID(str_data))
+ {
+ _media->video_meta->recorded_date = strdup(str_data);
+
+ if(_media->video_meta->recorded_date == NULL)
+ {
+ media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
+ return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
+ }
+ }
+ else
+ {
+ _media->video_meta->recorded_date = NULL;
+ }
+ }
+ else if((_media->media_type == MEDIA_CONTENT_TYPE_MUSIC) || (_media->media_type == MEDIA_CONTENT_TYPE_SOUND))
+ {
+ SAFE_FREE(_media->audio_meta->recorded_date);
+ if(STRING_VALID(str_data))
+ {
+ _media->audio_meta->recorded_date = strdup(str_data);
+
+ if(_media->audio_meta->recorded_date == NULL)
+ {
+ media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
+ return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
+ }
+ }
+ else
+ {
+ _media->audio_meta->recorded_date = NULL;
+ }
+ }
+ else
+ {
+ media_content_error("Invalid media type");
+ return MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
+ }
+ break;
+ default:
+ media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
+ return MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
+ }
+
+ return MEDIA_CONTENT_ERROR_NONE;
+}
+
+int media_info_insert_to_db_with_data(media_info_h media, media_info_h *info)
+{
+ int ret = MEDIA_CONTENT_ERROR_NONE;
+
+ media_info_s *_media = (media_info_s*)media;
+
+ if(_media == NULL)
+ {
+ media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
+ return MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
+ }
+
+ if (!STRING_VALID(_media->file_path))
+ {
+ media_content_error("invalid media path");
+ return MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
+ }
+
+ if (!STRING_VALID(_media->mime_type))
+ {
+ media_content_error("invalid mime_type");
+ return MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
+ }
+
+ if (!STRING_VALID(_media->storage_uuid))
+ {
+ media_content_error("invalid storage_uuid");
+ return MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
+ }
+
+ if (!STRING_VALID(_media->title))
+ {
+ media_content_error("invalid title");
+ return MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
+ }
+
+ if(_media->storage_type < 0)
+ {
+ media_content_error("invalid storage_type");
+ return MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
+ }
+
+ if ((_media->media_type < MEDIA_CONTENT_TYPE_IMAGE) || (_media->media_type > MEDIA_CONTENT_TYPE_OTHERS))
+ {
+ media_content_error("invalid media type [%d]", _media->media_type);
+ return MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
+ }
+
+ if (_media->size <= 0)
+ {
+ media_content_error("invalid size [%d]", _media->size);
+ return MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
+ }
+
+ if (_media->modified_time <= 0)
+ {
+ media_content_error("invalid modified_time [%d]", _media->modified_time);
+ return MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
+ }
+
+ media_content_sec_debug("storage[%d], path[%s], media_type[%d]", _media->storage_type, _media->file_path, _media->media_type);
+
+ media_svc_content_info_s *svc_content_info = NULL;
+
+ ret = __media_info_map_data_usr_to_svc(_media, &svc_content_info, MEDIA_CONTENT_STORAGE_CLOUD);
+ if(ret != MEDIA_CONTENT_ERROR_NONE)
+ {
+ media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
+ return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
+ }
+
+ if(svc_content_info == NULL)
+ {
+ media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
+ return MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
+ }
+#if 0
+ ret = media_svc_insert_item_immediately_with_data(_content_get_db_handle(), svc_content_info);
+ if(ret != MS_MEDIA_ERR_NONE) {
+ media_content_sec_error("media_svc_insert_item_immediately failed : %d (%s)", ret, _media->file_path);
+ media_svc_destroy_content_info(svc_content_info);
+ SAFE_FREE(svc_content_info);
+ return _content_error_capi(MEDIA_CONTENT_TYPE, ret);
+ }
+ /*free the svc_content_info*/
+ media_svc_destroy_content_info(svc_content_info);
+ SAFE_FREE(svc_content_info);
+#endif
+ if(info != NULL)
+ {
+ media_info_s *_get_media = (media_info_s*)calloc(1, sizeof(media_info_s));
+ if(_get_media == NULL)
+ {
+ media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
+ return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
+ }
+
+ ret = _media_info_get_media_info_from_db(_media->file_path, _media->storage_uuid, (media_info_h)_get_media);
+
+ *info = (media_info_h)_get_media;
+ }
+
+ return ret;
+}
+
+int media_info_create_handle(media_info_h *media)
+{
+ int ret = MEDIA_CONTENT_ERROR_NONE;
+
+ if(media == NULL)
+ {
+ media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
+ return MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
+ }
+
+ media_info_s *_media = (media_info_s*)calloc(1,sizeof(media_info_s));
+ if(_media == NULL)
+ {
+ media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
+ return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
+ }
+
+ _media->audio_meta = (audio_meta_s *)calloc(1, sizeof(audio_meta_s));
+ if(_media->audio_meta == NULL)
+ {
+ SAFE_FREE(_media);
+ media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
+ return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
+ }
+
+ _media->video_meta = (video_meta_s *)calloc(1, sizeof(video_meta_s));
+ if(_media->video_meta == NULL)
+ {
+ SAFE_FREE(_media->audio_meta);
+ SAFE_FREE(_media);
+ media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
+ return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
+ }
+
+ _media->image_meta = (image_meta_s *)calloc(1, sizeof(image_meta_s));
+ if(_media->image_meta == NULL)
+ {
+ SAFE_FREE(_media->audio_meta);
+ SAFE_FREE(_media->video_meta);
+ SAFE_FREE(_media);
+ media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
+ return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
+ }
+
+ _media->storage_type = -1;
+ _media->media_type = -1;
+ _media->modified_time = -1;
+ _media->size = -1;
+
+ *media = (media_info_h)_media;
+
+ return ret;
+}
+
+int media_info_set_path(media_info_h media, const char *path)
+{
+ return __media_info_set_str_data(media, MEDIA_INFO_PATH, path);
+}
+
+int media_info_set_mime_type(media_info_h media, const char *mime_type)
+{
+ return __media_info_set_str_data(media, MEDIA_INFO_MIME_TYPE, mime_type);
+}
+
+int media_info_set_title(media_info_h media, const char *title)
+{
+ return __media_info_set_str_data(media, MEDIA_INFO_TITLE, title);
+}
+
+int media_info_set_album(media_info_h media, const char *album)
+{
+ return __media_info_set_str_data(media, MEDIA_INFO_ALBUM, album);
+}
+
+int media_info_set_artist(media_info_h media, const char *artist)
+{
+ return __media_info_set_str_data(media, MEDIA_INFO_ARTIST, artist);
+}
+
+int media_info_set_genre(media_info_h media, const char *genre)
+{
+ return __media_info_set_str_data(media, MEDIA_INFO_GENRE, genre);
+}
+
+int media_info_set_recorded_date(media_info_h media, const char *recorded_date)
+{
+ return __media_info_set_str_data(media, MEDIA_INFO_RECORDED_DATE, recorded_date);
+}
+
+int media_info_set_thumbnail_path(media_info_h media, const char *thumbnail_path)
+{
+ return __media_info_set_str_data(media, MEDIA_INFO_THUMBNAIL_PATH, thumbnail_path);
+}
+
+int media_info_set_storage_id(media_info_h media, const char *storage_id)
+{
+ return __media_info_set_str_data(media, MEDIA_INFO_STORAGE_UUID, storage_id);
+}
+
+int media_info_set_size(media_info_h media, unsigned long long size)
+{
+ media_info_s *_media = (media_info_s*)media;
+
+ if(_media == NULL)
+ {
+ media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
+ return MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
+ }
+
+ _media->size = size;
+
+ return MEDIA_CONTENT_ERROR_NONE;
+}
+
+int media_info_set_modified_time(media_info_h media, time_t modified_time)
+{
+ media_info_s *_media = (media_info_s*)media;
+
+ if(_media == NULL)
+ {
+ media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
+ return MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
+ }
+
+ _media->modified_time = modified_time;
+
+ return MEDIA_CONTENT_ERROR_NONE;
+}
+
+int media_info_set_media_type(media_info_h media, media_content_type_e type)
+{
+ media_info_s *_media = (media_info_s*)media;
+
+ if(_media == NULL)
+ {
+ media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
+ return MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
+ }
+
+ _media->media_type = type;
+
+ return MEDIA_CONTENT_ERROR_NONE;
+}
+
+int media_info_set_duration(media_info_h media, int duration)
+{
+ media_info_s *_media = (media_info_s*)media;
+
+ if(_media == NULL)
+ {
+ media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
+ return MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
+ }
+
+ if(_media->media_type == MEDIA_CONTENT_TYPE_VIDEO)
+ _media->video_meta->duration = duration;
+ else if((_media->media_type == MEDIA_CONTENT_TYPE_MUSIC) || (_media->media_type == MEDIA_CONTENT_TYPE_SOUND))
+ _media->audio_meta->duration = duration;
+ else
+ {
+ media_content_error("Invalid media type");
+ return MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
+ }
+
+ return MEDIA_CONTENT_ERROR_NONE;
+}
+
+int media_info_set_width(media_info_h media, int width)
+{
+ media_info_s *_media = (media_info_s*)media;
+
+ if(_media == NULL)
+ {
+ media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
+ return MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
+ }
+
+ if(_media->media_type == MEDIA_CONTENT_TYPE_VIDEO)
+ _media->video_meta->width = width;
+ else if(_media->media_type == MEDIA_CONTENT_TYPE_IMAGE)
+ _media->image_meta->width = width;
+ else
+ {
+ media_content_error("Invalid media type");
+ return MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
+ }
+
+ return MEDIA_CONTENT_ERROR_NONE;
+}
+
+int media_info_set_height(media_info_h media, int height)
+{
+ media_info_s *_media = (media_info_s*)media;
+
+ if(_media == NULL)
+ {
+ media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
+ return MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
+ }
+
+ if(_media->media_type == MEDIA_CONTENT_TYPE_VIDEO)
+ _media->video_meta->height = height;
+ else if(_media->media_type == MEDIA_CONTENT_TYPE_IMAGE)
+ _media->image_meta->height = height;
+ else
+ {
+ media_content_error("Invalid media type");
+ return MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
+ }
+
+ return MEDIA_CONTENT_ERROR_NONE;
+}
+
+int media_info_set_storage_type(media_info_h media, media_content_storage_e storage_type)
+{
+ media_info_s *_media = (media_info_s*)media;
+
+ if(_media == NULL)
+ {
+ media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
+ return MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
+ }
+
+ _media->storage_type = storage_type;
+
+ return MEDIA_CONTENT_ERROR_NONE;
+}
#include <media_info_private.h>
#include <media_playlist.h>
+#define PLAYLIST_ARRAY_SIZE 20
+#define PLAYLIST_ARRAY_EXPAND 10
+#define MAX_TMP_STR 2048
static __thread GList *g_playlist_item_list = NULL;
static int __media_playlist_update_playlist_name(int playlist_id, const char *playlist_name);
static int __media_playlist_update_thumbnail_path(int playlist_id, const char *path);
static int __media_playlist_update_play_order(int playlist_id, int playlist_member_id, int play_order);
+static int __media_playlist_reset_file(const char* playlist_path);
+static int __media_playlist_append_to_file(const char* playlist_path, const char* path);
+static int __media_playlist_import_item_from_file(const char* playlist_path, char*** const item_list, int* item_count);
+static int __media_playlist_destroy_import_item(char** item_list, int item_count);
+static void __media_playlist_destroy_export_item(gpointer data);
static void __media_playlist_item_add(media_playlist_item_s *item_s)
{
return ret;
}
+static bool __media_playlist_media_info_cb(media_info_h media, void *user_data)
+{
+ int ret = MEDIA_CONTENT_ERROR_NONE;
+ char **media_id = (char**)user_data;
+ ret = media_info_get_media_id(media, media_id);
+ if(ret != MEDIA_CONTENT_ERROR_NONE)
+ {
+ media_content_error("Fail to get file path");
+ return FALSE;
+ }
+ return TRUE;
+}
+
+static bool __media_playlist_member_cb(int playlist_member_id, media_info_h media, void *user_data)
+{
+ int ret = MEDIA_CONTENT_ERROR_NONE;
+ GList **list = (GList**)user_data;
+ char *path = NULL;
+
+ ret = media_info_get_file_path(media, &path);
+ if(ret != MEDIA_CONTENT_ERROR_NONE)
+ {
+ media_content_error("Fail to get file path");
+ return FALSE;
+ }
+
+ *list = g_list_append(*list, path);
+
+ return TRUE;
+}
+
+static int __media_playlist_reset_file(const char* playlist_path)
+{
+ FILE *fp = NULL;
+
+ fp = fopen(playlist_path, "wb");
+ if(fp == NULL)
+ {
+ media_content_stderror("fopen fail");
+ return MEDIA_CONTENT_ERROR_INVALID_OPERATION;
+ }
+
+ fputs("", fp); // remove previous playlist
+
+ fclose(fp);
+
+ return MEDIA_CONTENT_ERROR_NONE;
+}
+
+static int __media_playlist_append_to_file(const char* playlist_path, const char* path)
+{
+ FILE *fp = NULL;
+
+ fp = fopen(playlist_path, "a"); // append only
+ if(fp == NULL)
+ {
+ media_content_stderror("fopen fail");
+ return MEDIA_CONTENT_ERROR_INVALID_OPERATION;
+ }
+
+ fputs(path, fp);
+
+ fputs("\n", fp);
+
+ fclose(fp);
+
+ return MEDIA_CONTENT_ERROR_NONE;
+}
+
+static int __media_playlist_import_item_from_file(const char* playlist_path, char*** const item_list, int* item_count)
+{
+ int current_index = 0; // Current record number
+ int current_max_size = PLAYLIST_ARRAY_SIZE; // Current max number of records in array
+ int tmp_str_len = 0; // Length of the string
+ char *buf = NULL;
+ char *tmp_buf = NULL;
+ char *tmp_str = NULL; // Next line from buffer, this string is used for parsing
+
+ FILE *fp = NULL;
+ long int file_size = 0;
+
+ *item_list = NULL; *item_count = 0;
+
+ fp = fopen(playlist_path, "rb"); // Open as binary for precise estimation of file length
+ if(fp == NULL)
+ {
+ media_content_stderror("fopen fail");
+ return MEDIA_CONTENT_ERROR_INVALID_OPERATION;
+ }
+
+ fseek(fp, 0, SEEK_END); // Move to the end of file
+ file_size = ftell(fp); // Here we can find the size of file
+ fseek(fp, 0 , SEEK_SET); // Return to the beginning of file
+
+ if(file_size == 0) {
+ media_content_debug("file is empty.");
+ fclose(fp);
+ return MEDIA_CONTENT_ERROR_NONE;
+ }
+ // Allocate the memory and copy file content there
+ if(file_size > 0)
+ buf = malloc(file_size + 1);
+
+ if(buf == NULL)
+ {
+ media_content_error("Out of Memory");
+ fclose(fp);
+ return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
+ }
+
+ tmp_buf = buf;
+
+ if(fread(buf, file_size, 1, fp) != 1) {
+ fclose(fp);
+ SAFE_FREE(buf);
+ media_content_stderror("fread fail");
+ return MEDIA_CONTENT_ERROR_INVALID_OPERATION;
+ }
+ buf[file_size] = 0;
+ fclose(fp);
+
+ // Preliminary memory allocation
+ *item_list = calloc(current_max_size, sizeof(char*));
+ tmp_str = malloc(MAX_TMP_STR);
+ if (tmp_str == NULL || *item_list == NULL) {
+ SAFE_FREE(*item_list);
+ SAFE_FREE(buf);
+ SAFE_FREE(tmp_str);
+ media_content_error("Out of Memory");
+ return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
+ }
+ // Here we create format string for sscanf(...) that allows to get a line from buffer
+ char format[25];
+ snprintf(format, 25, "%%%d[^\n]", MAX_TMP_STR);
+
+ // This cycle gets lines one by one from buffer till the end of buffer. Empty line ("\n") must be treated specifically
+ while((sscanf(tmp_buf, format, tmp_str) == 1) || (*tmp_buf == '\n')) {
+ if(*tmp_buf == '\n') {// Check if there is an empty line, skip '\n' symbol
+ tmp_buf += 1;
+
+ if(tmp_buf < (buf + file_size))
+ continue; // We are still in buffer
+ else
+ break; // Empty line was in the end of buffer
+ }
+
+ tmp_str_len = strlen(tmp_str); // Save the length of line
+
+ if(tmp_str[0] != '#') { // Check that the line is not a comment
+ if(!(current_index < (current_max_size - 1))) { // Check if we have completely filled record array
+ // Expand array size and relocate the array (records will be copied into new one)
+ current_max_size += PLAYLIST_ARRAY_EXPAND;
+ char **tmp_ptr = calloc(current_max_size, sizeof(char*));
+ if (tmp_ptr == NULL) {
+ __media_playlist_destroy_import_item(*item_list, current_index);
+ SAFE_FREE(buf);
+ SAFE_FREE(tmp_str);
+ media_content_error("Out of Memory");
+ return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
+ }
+ memmove(tmp_ptr, *item_list, sizeof(char*) * current_index);
+ SAFE_FREE(*item_list);
+ *item_list = tmp_ptr;
+ }
+
+ // Save new file path (current string in tmp_str)
+ (*item_list)[current_index] = malloc(tmp_str_len + 1);
+ if ((*item_list)[current_index] == NULL) {
+ __media_playlist_destroy_import_item(*item_list, current_index);
+ SAFE_FREE(buf);
+ SAFE_FREE(tmp_str);
+ media_content_error("Out of Memory");
+ return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
+ }
+ memmove((*item_list)[current_index], tmp_str, tmp_str_len + 1);
+
+ // Increase the index of buffer
+ current_index += 1;
+ }
+
+ tmp_buf += (tmp_str_len + 1); // Move position in buffer after the string that was parsed
+ }
+
+ *item_count = current_index; // Now we need to save the number of records in array
+
+ SAFE_FREE(buf);
+ SAFE_FREE(tmp_str); // Free temporary variables
+
+ return MEDIA_CONTENT_ERROR_NONE;
+}
+
+static int __media_playlist_destroy_import_item(char** item_list, int item_count)
+{
+ int i;
+
+ for(i = 0; i < item_count; ++i) {
+ SAFE_FREE(item_list[i]);
+ item_list[i] = NULL;
+ }
+
+ if (item_list != NULL) {
+ SAFE_FREE(item_list);
+ item_list = NULL;
+ }
+
+ return MEDIA_CONTENT_ERROR_NONE;
+}
+
+static void __media_playlist_destroy_export_item(gpointer data)
+{
+ SAFE_FREE(data);
+ data = NULL;
+}
+
int media_playlist_insert_to_db(const char *name, media_playlist_h *playlist)
{
int ret = MEDIA_CONTENT_ERROR_NONE;
}
media_playlist_s *_playlist = (media_playlist_s*)calloc(1, sizeof(media_playlist_s));
-
if(_playlist == NULL)
{
media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
{
int ret = MEDIA_CONTENT_ERROR_NONE;
- media_content_debug_func();
-
if(playlist_count != NULL)
{
ret = _media_db_get_group_count(filter, MEDIA_GROUP_PLAYLIST, playlist_count);
{
int ret = MEDIA_CONTENT_ERROR_NONE;
- media_content_debug_func();
-
if(callback == NULL)
{
media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
{
int ret = MEDIA_CONTENT_ERROR_NONE;
- media_content_debug_func();
-
if((playlist_id > 0) && (media_count != NULL))
{
ret = _media_db_get_group_item_count_by_id(playlist_id, filter, MEDIA_GROUP_PLAYLIST, media_count);
{
int ret = MEDIA_CONTENT_ERROR_NONE;
- media_content_debug_func();
-
if((playlist_id > 0) && (callback != NULL))
{
- //ret = _media_db_get_group_item_by_id(playlist_id, filter, callback, user_data, MEDIA_GROUP_PLAYLIST);
ret = _media_db_get_playlist_item(playlist_id, filter, callback, user_data);
}
else
while(sqlite3_step(stmt) == SQLITE_ROW)
{
media_playlist_s *_playlist = (media_playlist_s*)calloc(1, sizeof(media_playlist_s));
+ if(_playlist == NULL)
+ {
+ media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
+ SQLITE3_FINALIZE(stmt);
+ return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
+ }
_playlist->playlist_id = (int)sqlite3_column_int(stmt, 0);
if(STRING_VALID((const char *)sqlite3_column_text(stmt, 1)))
_playlist->name = strdup((const char *)sqlite3_column_text(stmt, 1));
- if(STRING_VALID((const char *)sqlite3_column_text(stmt, 2)))
- _playlist->thumbnail_path = strdup((const char *)sqlite3_column_text(stmt, 2));
+ if(STRING_VALID((const char *)sqlite3_column_text(stmt, 3)))
+ _playlist->thumbnail_path = strdup((const char *)sqlite3_column_text(stmt, 3));
*playlist = (media_playlist_h)_playlist;
}
SAFE_FREE(_playlist->name);
media_playlist_item_s *item = (media_playlist_item_s*)calloc(1, sizeof(media_playlist_item_s));
+ if(item == NULL)
+ {
+ media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
+ return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
+ }
item->playlist_name = strdup(playlist_name);
item->function = MEDIA_PLAYLIST_UPDATE_PLAYLIST_NAME;
SAFE_FREE(_playlist->thumbnail_path);
media_playlist_item_s *item = (media_playlist_item_s*)calloc(1, sizeof(media_playlist_item_s));
+ if(item == NULL)
+ {
+ media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
+ return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
+ }
item->thumbnail_path = strdup(path);
item->function = MEDIA_PLAYLIST_UPDATE_THUMBNAIL_PATH;
if((_playlist != NULL) && (playlist_member_id > 0) && (play_order >= 0))
{
media_playlist_item_s *item = (media_playlist_item_s*)calloc(1, sizeof(media_playlist_item_s));
+ if(item == NULL)
+ {
+ media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
+ return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
+ }
item->playlist_member_id = playlist_member_id;
item->function = MEDIA_PLAYLIST_UPDATE_PLAY_ORDER;
if(_playlist != NULL && STRING_VALID(media_id))
{
media_playlist_item_s *item = (media_playlist_item_s*)calloc(1, sizeof(media_playlist_item_s));
+ if(item == NULL)
+ {
+ media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
+ return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
+ }
item->media_id = strdup(media_id);
item->function = MEDIA_PLAYLIST_ADD;
if((_playlist != NULL) && (playlist_member_id > 0))
{
media_playlist_item_s *item = (media_playlist_item_s*)calloc(1, sizeof(media_playlist_item_s));
+ if(item == NULL)
+ {
+ media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
+ return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
+ }
item->playlist_member_id = playlist_member_id;
item->function = MEDIA_PLAYLIST_REMOVE;
return ret;
}
+
+int media_playlist_import_from_file(const char *path, const char *playlist_name, media_playlist_h *playlist)
+{
+ int ret = MEDIA_CONTENT_ERROR_NONE;
+ char** import_item_list = NULL;
+ int import_item_count = 0;
+ int idx;
+
+ if(!STRING_VALID(path))
+ {
+ media_content_error("Invalid path");
+ return MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
+ }
+
+ if(!STRING_VALID(playlist_name))
+ {
+ media_content_error("Invalid playlist_name");
+ return MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
+ }
+
+ ret = media_playlist_insert_to_db(playlist_name, playlist);
+ if(ret != MEDIA_CONTENT_ERROR_NONE)
+ {
+ media_content_error("Fail to insert playlist to db");
+ return ret;
+ }
+
+ ret = __media_playlist_import_item_from_file(path, &import_item_list, &import_item_count);
+ if(ret != MEDIA_CONTENT_ERROR_NONE)
+ {
+ __media_playlist_destroy_import_item(import_item_list, import_item_count);
+ media_content_error("Fail to get playlist from file");
+ return ret;
+ }
+
+ if (import_item_count == 0)
+ {
+ media_content_debug("The playlist from file is empty");
+ }
+
+ for (idx=0; idx < import_item_count; idx++)
+ {
+ filter_h filter = NULL;
+ char *media_id = NULL;
+ char *condition = NULL;
+
+ ret = media_filter_create(&filter);
+ if(ret != MEDIA_CONTENT_ERROR_NONE)
+ {
+ __media_playlist_destroy_import_item(import_item_list, import_item_count);
+ media_filter_destroy(filter);
+ media_content_error("error media_filter_create");
+ return ret;
+ }
+ condition = sqlite3_mprintf("path = '%q'", import_item_list[idx]);
+ ret = media_filter_set_condition(filter, condition, MEDIA_CONTENT_COLLATE_DEFAULT);
+ if(ret != MEDIA_CONTENT_ERROR_NONE)
+ {
+ __media_playlist_destroy_import_item(import_item_list, import_item_count);
+ media_filter_destroy(filter);
+ sqlite3_free(condition);
+ media_content_error("error media_filter_set_condition");
+ return ret;
+ }
+ ret = _media_db_get_group_item(NULL, filter, __media_playlist_media_info_cb, &media_id, MEDIA_GROUP_NONE);
+ if(ret != MEDIA_CONTENT_ERROR_NONE)
+ {
+ __media_playlist_destroy_import_item(import_item_list, import_item_count);
+ media_filter_destroy(filter);
+ SAFE_FREE(media_id);
+ sqlite3_free(condition);
+ media_content_error("error media_info_foreach_media_from_db");
+ return ret;
+ }
+ ret = media_playlist_add_media((media_playlist_h)*playlist, media_id);
+ if(ret != MEDIA_CONTENT_ERROR_NONE)
+ {
+ __media_playlist_destroy_import_item(import_item_list, import_item_count);
+ media_filter_destroy(filter);
+ SAFE_FREE(media_id);
+ sqlite3_free(condition);
+ media_content_error("error media_playlist_add_media");
+ return ret;
+ }
+ media_filter_destroy(filter);
+ SAFE_FREE(media_id);
+ sqlite3_free(condition);
+ }
+
+ ret = media_playlist_update_to_db(*playlist);
+ if(ret != MEDIA_CONTENT_ERROR_NONE)
+ {
+ __media_playlist_destroy_import_item(import_item_list, import_item_count);
+ media_content_error("Fail to update playlist to db");
+ return ret;
+ }
+ __media_playlist_destroy_import_item(import_item_list, import_item_count);
+
+ return ret;
+}
+
+int media_playlist_export_to_file(media_playlist_h playlist, const char* path)
+{
+ int ret = MEDIA_CONTENT_ERROR_NONE;
+ media_playlist_s *_playlist = (media_playlist_s*)playlist;
+ GList *item_list = NULL;
+ int idx;
+
+ if(!STRING_VALID(path))
+ {
+ media_content_error("Invalid path");
+ return MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
+ }
+
+ if(_playlist == NULL)
+ {
+ media_content_error("Invalid playlist");
+ return MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
+ }
+
+ if(_playlist->playlist_id <= 0)
+ {
+ media_content_error("Invalid playlist id");
+ return MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
+ }
+
+ ret = _media_db_get_playlist_item(_playlist->playlist_id, NULL, __media_playlist_member_cb, &item_list);
+ if(ret != MEDIA_CONTENT_ERROR_NONE)
+ {
+ media_content_error("Fail to get playlist from db");
+ return ret;
+ }
+
+ ret = __media_playlist_reset_file(path);
+ if(ret != MEDIA_CONTENT_ERROR_NONE)
+ {
+ g_list_free_full(item_list, __media_playlist_destroy_export_item);
+ media_content_error("Fail to init playlist file");
+ return ret;
+ }
+
+ for (idx=0; idx < g_list_length(item_list); idx++)
+ {
+ char *item = g_list_nth_data(item_list, idx);
+ ret = __media_playlist_append_to_file(path, item);
+ if(ret != MEDIA_CONTENT_ERROR_NONE)
+ {
+ g_list_free_full(item_list, __media_playlist_destroy_export_item);
+ media_content_error("Fail to export paths into file");
+ return ret;
+ }
+ }
+
+ g_list_free_full(item_list, __media_playlist_destroy_export_item);
+
+ return ret;
+}
--- /dev/null
+ /*
+ * Copyright (c) 2011 Samsung Electronics Co., Ltd All Rights Reserved
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+#include <media_content.h>
+#include <media_info_private.h>
+
+static void __media_storage_get_detail(sqlite3_stmt* stmt, media_storage_h storage)
+{
+ media_storage_s *_storage = (media_storage_s*)storage;
+
+ if(STRING_VALID((const char *)sqlite3_column_text(stmt, 0)))
+ _storage->storage_id = strdup((const char *)sqlite3_column_text(stmt, 0));
+
+ if(STRING_VALID((const char *)sqlite3_column_text(stmt, 1)))
+ _storage->storage_name = strdup((const char *)sqlite3_column_text(stmt, 1));
+
+ if(STRING_VALID((const char *)sqlite3_column_text(stmt, 2)))
+ _storage->storage_path = strdup((const char *)sqlite3_column_text(stmt, 2));
+
+ if(STRING_VALID((const char *)sqlite3_column_text(stmt, 3)))
+ _storage->storage_account = strdup((const char *)sqlite3_column_text(stmt, 3));
+
+ _storage->storage_type = (int)sqlite3_column_int(stmt, 4);
+
+ return;
+}
+
+int media_storage_insert_to_db(const char *storage_name, const char *storage_path, const char *storage_account, media_content_storage_e storage_type, media_storage_h *storage)
+{
+ int ret = MEDIA_CONTENT_ERROR_NONE;
+ char *storage_uuid = NULL;
+ media_storage_s *_storage = NULL;
+
+ if(!STRING_VALID(storage_name))
+ {
+ media_content_error("Invalid Storage Name");
+ return MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
+ }
+
+ if(!STRING_VALID(storage_path))
+ {
+ media_content_error("Invalid path");
+ return MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
+ }
+
+ storage_uuid = media_info_generate_uuid();
+ if(storage_uuid == NULL)
+ {
+ media_content_error("Fail to get storage_id");
+ return MEDIA_CONTENT_ERROR_INVALID_OPERATION;
+ }
+
+ //ret = media_svc_insert_storage(_content_get_db_handle(), storage_uuid, storage_name, storage_path, storage_account, storage_type);
+ if (ret != MS_MEDIA_ERR_NONE)
+ {
+ ret = _content_error_capi(MEDIA_CONTENT_TYPE, ret);
+ return ret;
+ }
+
+ _storage = (media_storage_s*)calloc(1, sizeof(media_storage_s));
+ if(_storage == NULL)
+ {
+ media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
+ return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
+ }
+
+ _storage->storage_id = strdup(storage_uuid);
+ _storage->storage_path = strdup(storage_path);
+ _storage->storage_name = strdup(storage_name);
+ _storage->storage_type = storage_type;
+
+ *storage = (media_storage_h)_storage;
+
+ return ret;
+}
+
+int media_storage_delete_from_db(const char *storage_id)
+{
+ int ret = MEDIA_CONTENT_ERROR_NONE;
+
+ if(!STRING_VALID(storage_id))
+ {
+ media_content_error("Invalid Storage ID");
+ return MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
+ }
+
+ //ret = media_svc_delete_storage(_content_get_db_handle(), storage_id);
+
+ return _content_error_capi(MEDIA_CONTENT_TYPE, ret);
+}
+
+int media_storage_get_storage_info_from_db(const char *storage_id, media_storage_h *storage)
+{
+ int ret = MEDIA_CONTENT_ERROR_NONE;
+ char select_query[DEFAULT_QUERY_SIZE];
+ sqlite3_stmt *stmt = NULL;
+
+ if(!STRING_VALID(storage_id) || (storage == NULL))
+ {
+ media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
+ return MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
+ }
+
+ memset(select_query, 0x00, sizeof(select_query));
+ snprintf(select_query, sizeof(select_query), SELECT_STORAGE_INFO_FROM_STORAGE, storage_id);
+
+ ret = _content_query_prepare(&stmt, select_query, NULL, NULL);
+ media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
+
+ while(sqlite3_step(stmt) == SQLITE_ROW)
+ {
+ media_storage_s *_storage = (media_storage_s*)calloc(1, sizeof(media_storage_s));
+
+ if(_storage == NULL)
+ {
+ media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
+ SQLITE3_FINALIZE(stmt);
+ return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
+ }
+
+ __media_storage_get_detail(stmt, (media_storage_h)_storage);
+
+ *storage = (media_storage_h)_storage;
+ }
+
+ SQLITE3_FINALIZE(stmt);
+
+ return ret;
+}
+
+int media_storage_get_storage_count_from_db(filter_h filter, int *storage_count)
+{
+ int ret = MEDIA_CONTENT_ERROR_NONE;
+
+ if(storage_count)
+ {
+ ret = _media_db_get_group_count(filter, MEDIA_GROUP_STORAGE, storage_count);
+ }
+ else
+ {
+ media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
+ return MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
+ }
+
+ return ret;
+}
+
+int media_storage_foreach_storage_from_db(filter_h filter, media_storage_cb callback, void *user_data)
+{
+ int ret = MEDIA_CONTENT_ERROR_NONE;
+
+ if(callback != NULL)
+ {
+ ret = _media_db_get_storage(filter, callback, user_data);
+ }
+ else
+ {
+ media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
+ return MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
+ }
+
+ return ret;
+}
+
+int media_storage_get_media_count_from_db(const char *storage_id, filter_h filter, int *media_count)
+{
+ int ret = MEDIA_CONTENT_ERROR_NONE;
+
+ if(STRING_VALID(storage_id) && media_count)
+ {
+ ret = _media_db_get_group_item_count(storage_id, filter, MEDIA_GROUP_STORAGE, media_count);
+ }
+ else
+ {
+ media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
+ return MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
+ }
+
+ return ret;
+}
+
+int media_storage_foreach_media_from_db(const char *storage_id, filter_h filter, media_info_cb callback, void *user_data)
+{
+ int ret = MEDIA_CONTENT_ERROR_NONE;
+
+ if((callback != NULL) && STRING_VALID(storage_id))
+ {
+ ret = _media_db_get_group_item(storage_id, filter, callback, user_data, MEDIA_GROUP_STORAGE);
+ }
+ else
+ {
+ media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
+ return MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
+ }
+
+ return ret;
+}
+
+int media_storage_destroy(media_storage_h storage)
+{
+ int ret = MEDIA_CONTENT_ERROR_NONE;
+ media_storage_s *_storage = (media_storage_s*)storage;
+ if(_storage)
+ {
+ SAFE_FREE(_storage->storage_id);
+ SAFE_FREE(_storage->storage_path);
+ SAFE_FREE(_storage->storage_name);
+ SAFE_FREE(_storage->storage_account);
+ SAFE_FREE(_storage);
+
+ ret = MEDIA_CONTENT_ERROR_NONE;
+ }
+ else
+ {
+ media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
+ ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
+ }
+
+ return ret;
+}
+
+int media_storage_clone(media_storage_h *dst, media_storage_h src)
+{
+ int ret = MEDIA_CONTENT_ERROR_NONE;
+ media_storage_s *_src = (media_storage_s*)src;
+
+ if(_src != NULL)
+ {
+ media_storage_s *_dst = (media_storage_s*)calloc(1, sizeof(media_storage_s));
+ if(_dst == NULL)
+ {
+ media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
+ return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
+ }
+
+ if(STRING_VALID(_src->storage_id))
+ {
+ _dst->storage_id = strdup(_src->storage_id);
+ if(_dst->storage_id == NULL)
+ {
+ media_storage_destroy((media_storage_h)_dst);
+ media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
+ return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
+ }
+ }
+
+ if(STRING_VALID(_src->storage_name))
+ {
+ _dst->storage_name = strdup(_src->storage_name);
+ if(_dst->storage_name == NULL)
+ {
+ media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
+ media_storage_destroy((media_storage_h)_dst);
+ return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
+ }
+ }
+
+ if(STRING_VALID(_src->storage_path))
+ {
+ _dst->storage_path = strdup(_src->storage_path);
+ if(_dst->storage_path == NULL)
+ {
+ media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
+ media_storage_destroy((media_storage_h)_dst);
+ return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
+ }
+ }
+
+ if(STRING_VALID(_src->storage_account))
+ {
+ _dst->storage_account = strdup(_src->storage_account);
+ if(_dst->storage_account == NULL)
+ {
+ media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
+ media_storage_destroy((media_storage_h)_dst);
+ return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
+ }
+ }
+
+ _dst->storage_type = _src->storage_type;
+
+ *dst = (media_storage_h)_dst;
+
+ ret = MEDIA_CONTENT_ERROR_NONE;
+ }
+ else
+ {
+ media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
+ ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
+ }
+
+ return ret;
+}
+
+int media_storage_get_id(media_storage_h storage, char **storage_id)
+{
+ int ret = MEDIA_CONTENT_ERROR_NONE;
+ media_storage_s *_storage = (media_storage_s*)storage;
+
+ if(_storage && storage_id)
+ {
+ if(STRING_VALID(_storage->storage_id))
+ {
+ *storage_id = strdup(_storage->storage_id);
+ if(*storage_id == NULL)
+ {
+ media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
+ return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
+ }
+ }
+ else
+ {
+ *storage_id = NULL;
+ }
+
+ ret = MEDIA_CONTENT_ERROR_NONE;
+ }
+ else
+ {
+ media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
+ ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
+ }
+
+ return ret;
+}
+
+int media_storage_get_name(media_storage_h storage, char **storage_name)
+{
+ int ret = MEDIA_CONTENT_ERROR_NONE;
+ media_storage_s *_storage = (media_storage_s*)storage;
+
+ if(_storage && storage_name)
+ {
+ if(STRING_VALID(_storage->storage_name))
+ {
+ *storage_name = strdup(_storage->storage_name);
+ if(*storage_name == NULL)
+ {
+ media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
+ return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
+ }
+ }
+ else
+ {
+ *storage_name = NULL;
+ }
+
+ ret = MEDIA_CONTENT_ERROR_NONE;
+ }
+ else
+ {
+ media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
+ ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
+ }
+
+ return ret;
+}
+
+int media_storage_get_path(media_storage_h storage, char **storage_path)
+{
+ int ret = MEDIA_CONTENT_ERROR_NONE;
+ media_storage_s *_storage = (media_storage_s*)storage;
+
+ if(_storage && storage_path)
+ {
+ if(STRING_VALID(_storage->storage_path))
+ {
+ *storage_path = strdup(_storage->storage_path);
+ if(*storage_path == NULL)
+ {
+ media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
+ return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
+ }
+ }
+ else
+ {
+ *storage_path = NULL;
+ }
+
+ ret = MEDIA_CONTENT_ERROR_NONE;
+ }
+ else
+ {
+ media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
+ ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
+ }
+
+ return ret;
+}
+
+int media_storage_get_storage_account(media_storage_h storage, char **storage_account)
+{
+ int ret = MEDIA_CONTENT_ERROR_NONE;
+ media_storage_s *_storage = (media_storage_s*)storage;
+
+ if(_storage && storage_account)
+ {
+ if(STRING_VALID(_storage->storage_account))
+ {
+ *storage_account = strdup(_storage->storage_account);
+ if(*storage_account == NULL)
+ {
+ media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
+ return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
+ }
+ }
+ else
+ {
+ *storage_account = NULL;
+ }
+
+ ret = MEDIA_CONTENT_ERROR_NONE;
+ }
+ else
+ {
+ media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
+ ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
+ }
+
+ return ret;
+}
+
+int media_storage_get_type(media_storage_h storage, media_content_storage_e *storage_type)
+{
+ int ret = MEDIA_CONTENT_ERROR_NONE;
+ media_storage_s *_storage = (media_storage_s*)storage;
+
+ if(_storage && storage_type)
+ {
+ *storage_type = _storage->storage_type;
+ ret = MEDIA_CONTENT_ERROR_NONE;
+ }
+ else
+ {
+ media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
+ ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
+ }
+
+ return ret;
+}
*/
-#include <media_content.h>
#include <media_info_private.h>
{
int ret = MEDIA_CONTENT_ERROR_NONE;
- media_content_debug_func();
-
if(tag_count != NULL)
{
ret = _media_db_get_group_count(filter, MEDIA_GROUP_TAG, tag_count);
{
int ret = MEDIA_CONTENT_ERROR_NONE;
- media_content_debug_func();
-
if(callback == NULL)
{
media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
{
int ret = MEDIA_CONTENT_ERROR_NONE;
- media_content_debug_func();
-
if((tag_id > 0) && (media_count != NULL))
{
ret = _media_db_get_group_item_count_by_id(tag_id, filter, MEDIA_GROUP_TAG, media_count);
{
int ret = MEDIA_CONTENT_ERROR_NONE;
- media_content_debug_func();
-
if(callback == NULL)
{
media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
if((_tag != NULL) && STRING_VALID(media_id))
{
media_tag_item_s *_item = (media_tag_item_s*)calloc(1, sizeof(media_tag_item_s));
+ if(_item == NULL)
+ {
+ media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
+ return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
+ }
_item->media_id = strdup(media_id);
_item->function = MEDIA_TAG_ADD;
if(_tag != NULL && STRING_VALID(media_id))
{
media_tag_item_s *_item = (media_tag_item_s*)calloc(1, sizeof(media_tag_item_s));
+ if(_item == NULL)
+ {
+ media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
+ return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
+ }
_item->media_id = strdup(media_id);
_item->function = MEDIA_TAG_REMOVE;
SAFE_FREE(_tag->name);
media_tag_item_s *_item = (media_tag_item_s*)calloc(1, sizeof(media_tag_item_s));
+ if(_item == NULL)
+ {
+ media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
+ return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
+ }
_item->tag_name = strdup(tag_name);
_item->function = MEDIA_TAG_UPDATE_TAG_NAME;
* limitations under the License.
*/
-
+#include <dirent.h>
#include <string.h>
#include <sys/stat.h>
+#include <sys/types.h>
+#include <fcntl.h>
#include <media_util_private.h>
#include <media_info_private.h>
#include <media_content_type.h>
-
-int _media_util_get_store_type_by_path(const char *path, int *storage_type)
+int _media_util_check_file(const char *path)
{
- if(STRING_VALID(path))
- {
- if(strncmp(path, MEDIA_CONTENT_PATH_PHONE, strlen(MEDIA_CONTENT_PATH_PHONE)) == 0)
- {
- *storage_type = MEDIA_CONTENT_STORAGE_INTERNAL;
- }
- else if(strncmp (path, MEDIA_CONTENT_PATH_MMC, strlen(MEDIA_CONTENT_PATH_MMC)) == 0)
- {
- *storage_type = MEDIA_CONTENT_STORAGE_EXTERNAL;
+ int exist;
+
+ /* check the file exits actually */
+ exist = open(path, O_RDONLY);
+ if(exist < 0) {
+ media_content_sec_debug("path [%s]", path);
+ media_content_stderror("open file fail");
+ if (errno == EACCES || errno == EPERM) {
+ return MEDIA_CONTENT_ERROR_PERMISSION_DENIED;
+ } else {
+ return MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
}
}
- else
- {
- media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
- return MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
- }
+
+ close(exist);
return MEDIA_CONTENT_ERROR_NONE;
}
char *scan_ignore = ".scan_ignore";
bool find = false;
- media_content_info("dir_path : %s", dir_path);
+ media_content_sec_debug("dir_path : %s", dir_path);
if(!STRING_VALID(dir_path))
{
if(STRING_VALID(entry.d_name) && (strcmp(entry.d_name, scan_ignore) == 0))
{
media_content_info("Find Ignore path");
- media_content_info("Ignore path[%s]", search_path);
+ media_content_sec_debug("Ignore path[%s]", search_path);
find = TRUE;
break;
}
else
{
- //media_content_info("entry.d_name[%s]", entry.d_name);
+ //media_content_sec_debug("entry.d_name[%s]", entry.d_name);
continue;
}
}
{
int seek_len = leaf_path -search_path;
search_path[seek_len] = '\0';
- //media_content_info("go to other dir [%s]", search_path);
+ //media_content_sec_debug("go to other dir [%s]", search_path);
}
else
{
*/
-#include <media_content.h>
#include <media_info_private.h>
-#include <media-svc.h>
int video_meta_destroy(video_meta_h video)
if(_video != NULL && STRING_VALID(_video->media_id))
{
- sql = sqlite3_mprintf(UPDATE_AV_META_FROM_MEDIA, _video->played_count, _video->played_time, _video->played_position, _video->media_id);
+ char storage_id[MEDIA_CONTENT_UUID_SIZE+1] = {0,};
+ memset(storage_id, 0x00, sizeof(storage_id));
+
+ ret = _media_db_get_storage_id_by_media_id(_video->media_id, storage_id);
+ media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
+
+ sql = sqlite3_mprintf(UPDATE_AV_META_FROM_MEDIA, storage_id, _video->played_count, _video->played_time, _video->played_position, _video->media_id);
ret = _content_query_sql(sql);
sqlite3_free(sql);
}
SET(EXTRA_CFLAGS "${EXTRA_CFLAGS} ${flag}")
ENDFOREACH(flag)
-SET(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${EXTRA_CFLAGS} -Wall")
+SET(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${EXTRA_CFLAGS} -Wall -pie")
aux_source_directory(. sources)
FOREACH(src ${sources})
#include <stdlib.h>
#include <unistd.h>
#include <media_content.h>
+#include <media_content_internal.h>
#include <media_info_private.h>
#include <dlog.h>
#include <pthread.h>
{
char *c_value = NULL;
char *media_id = NULL;
- int i_value = 0;
- time_t t_value = 0;
- bool b_value = false;
media_content_type_e media_type = 0;
- unsigned long long size = 0;
int ret = MEDIA_CONTENT_ERROR_NONE;
if(media == NULL)
media_content_debug("file_path : [%s]", c_value);
SAFE_FREE(c_value);
-#if 1
+#if 0
+ int i_value = 0;
+ time_t t_value = 0;
+ bool b_value = false;
+ unsigned long long size = 0;
+
if(media_type == MEDIA_CONTENT_TYPE_MUSIC)
{
audio_meta_h audio;
if(ret != MEDIA_CONTENT_ERROR_NONE)
media_content_error("error when get info : [%d]", ret);
media_content_debug("is_drm : [%d]", b_value);
-
- // build error
- /*
+
ret = media_info_set_weather(media, "Sunny");
if(ret != MEDIA_CONTENT_ERROR_NONE) {
media_content_error("Fail to set weather");
media_content_error("error when get info : [%d]", ret);
media_content_debug("weather : [%s]", c_value);
SAFE_FREE(c_value);
- */
/* Media server can't update when another db handle holds DB connection by sqlite3_prepare */
//ret = media_info_set_location_tag(media, "Test location tag");
//media_info_update_to_db(media);
SAFE_FREE(media_id);
#endif
+ SAFE_FREE(media_id);
return true;
}
{
int item_count;
char *folder_id = NULL;
- char *folder_path = NULL;
- char *folder_name = NULL;
+ char *str_val = NULL;
+ int int_val = -1;
media_content_storage_e storage_type;
bool ret;
media_folder_h *_folder = (media_folder_h*)user_data;
}
media_content_debug("folder_id = [%s]", folder_id);
- if(media_folder_get_path(folder, &folder_path) != MEDIA_CONTENT_ERROR_NONE)
+ if(media_folder_get_path(folder, &str_val) != MEDIA_CONTENT_ERROR_NONE)
{
SAFE_FREE(folder_id);
media_content_error("[ERROR] media_folder_get_path is failed");
return false;
}
- media_content_debug("folder_path = [%s]", folder_path);
- SAFE_FREE(folder_path);
+ media_content_debug("folder_path = [%s]", str_val);
+ SAFE_FREE(str_val);
- if(media_folder_get_name(folder, &folder_name) != MEDIA_CONTENT_ERROR_NONE)
+ if(media_folder_get_name(folder, &str_val) != MEDIA_CONTENT_ERROR_NONE)
{
SAFE_FREE(folder_id);
- SAFE_FREE(folder_path);
media_content_error("[ERROR] media_folder_get_name is failed");
return false;
}
- media_content_debug("folder_name = [%s]", folder_name);
- SAFE_FREE(folder_name);
+ media_content_debug("folder_name = [%s]", str_val);
+ SAFE_FREE(str_val);
if(media_folder_get_storage_type(folder, &storage_type) != MEDIA_CONTENT_ERROR_NONE)
{
SAFE_FREE(folder_id);
- SAFE_FREE(folder_path);
- SAFE_FREE(folder_name);
media_content_error("[ERROR] media_folder_get_storage_type is failed");
return false;
}
media_content_debug("storage_type = [%d]", storage_type);
+ if(media_folder_get_storage_id(folder, &str_val) != MEDIA_CONTENT_ERROR_NONE)
+ {
+ SAFE_FREE(folder_id);
+ media_content_error("[ERROR] media_folder_get_name is failed");
+ return false;
+ }
+ media_content_debug("storage_id = [%s]", str_val);
+
+ if(media_folder_get_order(folder, &int_val) != MEDIA_CONTENT_ERROR_NONE)
+ {
+ media_content_error("[ERROR] media_folder_get_order is failed");
+ return false;
+ }
+ media_content_debug("folder_order = [%d]", int_val);
+
if(media_folder_get_media_count_from_db(folder_id, g_filter, &item_count) != MEDIA_CONTENT_ERROR_NONE)
{
SAFE_FREE(folder_id);
- SAFE_FREE(folder_path);
- SAFE_FREE(folder_name);
media_content_error("[ERROR] media_folder_get_media_count_from_db is failed");
return false;
}
if(media_folder_foreach_media_from_db(folder_id, g_filter, media_item_cb, NULL) != MEDIA_CONTENT_ERROR_NONE)
{
SAFE_FREE(folder_id);
- SAFE_FREE(folder_path);
- SAFE_FREE(folder_name);
media_content_error("[ERROR] media_folder_foreach_media_from_db is failed");
return false;
}
SAFE_FREE(folder_id);
- SAFE_FREE(folder_path);
- SAFE_FREE(folder_name);
-
ret = true;
}
else
if(media_album_get_artist(album_h, &artist) != MEDIA_CONTENT_ERROR_NONE)
{
media_album_destroy(album_h);
+ /* fix prevent: Resource Leak */
+ SAFE_FREE(album_name);
return false;
}
int ret = MEDIA_CONTENT_ERROR_NONE;
/* Filter for media */
- char *condition = "MEDIA_TYPE=1"; /*MEDIA_TYPE 0-image, 1-video, 2-sound, 3-music, 4-other*/
+ char *condition = "MEDIA_TYPE=3"; /*MEDIA_TYPE 0-image, 1-video, 2-sound, 3-music, 4-other*/
//char *condition = "MEDIA_TYPE IS NOT 0 AND MEDIA_DESCRIPTION IS NOT NULL"; /*MEDIA_TYPE 0-image, 1-video, 2-sound, 3-music, 4-other*/
ret = media_filter_create(&g_filter);
* Or,
* call media_filter_set_order(g_filter, MEDIA_CONTENT_ORDER_ASC, MEDIA_ARTIST, MEDIA_CONTENT_COLLATE_DEFAULT);
*/
- ret = media_filter_set_order(g_filter, MEDIA_CONTENT_ORDER_ASC, MEDIA_ARTIST, MEDIA_CONTENT_COLLATE_DEFAULT);
+ /* Able to set multi column to set order */
+ //ret = media_filter_set_order(g_filter, MEDIA_CONTENT_ORDER_ASC, "MEDIA_MODIFIED_TIME, MEDIA_DISPLAY_NAME", MEDIA_CONTENT_COLLATE_DEFAULT);
+ //ret = media_filter_set_order(g_filter, MEDIA_CONTENT_ORDER_ASC, MEDIA_ARTIST, MEDIA_CONTENT_COLLATE_DEFAULT);
+ //ret = media_filter_set_order(g_filter, MEDIA_CONTENT_ORDER_ASC, MEDIA_TRACK_NUM_INT, MEDIA_CONTENT_COLLATE_DEFAULT);
+ //ret = media_filter_set_storage(g_filter, "cfbf3d2c-71c5-4611-bccc-7cbac890146e");
/* Filter for group */
//char *g_condition = "TAG_NAME like \"\%my\%\"";
ret = media_filter_create(&g_filter_g);
//ret = media_filter_set_condition(g_filter_g, g_condition, MEDIA_CONTENT_COLLATE_DEFAULT);
- //ret = media_filter_set_order(g_filter_g, MEDIA_CONTENT_ORDER_DESC, TAG_NAME, MEDIA_CONTENT_COLLATE_DEFAULT);
+ ret = media_filter_set_order(g_filter_g, MEDIA_CONTENT_ORDER_DESC, TAG_NAME, MEDIA_CONTENT_COLLATE_DEFAULT);
return ret;
}
media_content_debug("folder_name [%d] : %s", i, folder_name);
media_content_debug("folder_path [%d] : %s", i, folder_path);
-
ret = media_folder_get_media_count_from_db(folder_id, filter, &count);
/* User should free these string */
SAFE_FREE(folder_id);
/* To check performance */
gettimeofday(&end, NULL);
long time = (end.tv_sec * 1000000 + end.tv_usec) - (start.tv_sec * 1000000 + start.tv_usec);
- printf("Time : %ld\n", time);
+ media_content_debug("Time : %ld\n", time);
/* Third, Get item list of a folder */
GList *item_list = NULL;
media_tag_get_tag_id(tag_handle, &tag_id);
media_tag_get_name(tag_handle, &tag_name);
- printf("[%d] %s", tag_id, tag_name);
+ media_content_debug("[%d] %s", tag_id, tag_name);
ret = media_tag_foreach_media_from_db(tag_id, filter, gallery_media_item_cb, &media_list_in_tag);
if(ret != MEDIA_CONTENT_ERROR_NONE) {
media_content_error("Fail to create filter");
return ret;
}
- ret = media_filter_set_condition(filter, condition, MEDIA_CONTENT_COLLATE_DEFAULT);
+ ret = media_filter_set_condition(filter, condition, MEDIA_CONTENT_COLLATE_LOCALIZED);
if(ret != MEDIA_CONTENT_ERROR_NONE) {
media_filter_destroy(filter);
media_content_error("Fail to set condition");
return ret;
}
- ret = media_filter_set_order(filter, MEDIA_CONTENT_ORDER_ASC, MEDIA_TITLE, MEDIA_CONTENT_COLLATE_NOCASE);
+ ret = media_filter_set_order(filter, MEDIA_CONTENT_ORDER_ASC, MEDIA_TITLE, MEDIA_CONTENT_COLLATE_LOCALIZED);
if(ret != MEDIA_CONTENT_ERROR_NONE) {
media_filter_destroy(filter);
media_content_error("Fail to set order");
int test_folder_operation(void)
{
int ret = MEDIA_CONTENT_ERROR_NONE;
- filter_h filter;
+ filter_h filter = NULL;
media_folder_h folder = NULL;
char *folder_id = NULL;
- int folder_count = 0;
+ int count = 0;
media_content_debug("\n============Folder Test============\n\n");
media_filter_set_condition(filter, "(MEDIA_TYPE = 0 or MEDIA_TYPE = 1) and MEDIA_STORAGE_TYPE=0", MEDIA_CONTENT_COLLATE_DEFAULT); /*MEDIA_TYPE 0-image, 1-video, 2-sound, 3-music, 4-other*/
media_filter_set_offset(filter, 0,5);
media_filter_set_order(filter,MEDIA_CONTENT_ORDER_DESC, MEDIA_PATH, MEDIA_CONTENT_COLLATE_NOCASE);
+ media_filter_set_storage(filter, "cfbf3d2c-71c5-4611-bccc-7cbac890146e");
- ret = media_folder_get_folder_count_from_db(filter, &folder_count);
- media_content_debug("Folder count : %d", folder_count);
+ ret = media_folder_get_folder_count_from_db(filter, &count);
+ media_content_debug("Folder count : [%d]", count);
ret = media_folder_foreach_folder_from_db(filter, folder_list_cb, &folder);
//test.3 get the media list in first folder
filter_h m_filter = NULL;
+
ret = media_filter_create(&m_filter);
if(ret != MEDIA_CONTENT_ERROR_NONE)
{
media_filter_set_offset(m_filter, 0,5);
media_filter_set_order(m_filter,MEDIA_CONTENT_ORDER_DESC, MEDIA_PATH, MEDIA_CONTENT_COLLATE_NOCASE);
- media_folder_get_folder_id(folder, &folder_id);
- media_content_debug("folder_id : %s", folder_id);
-
ret = media_folder_foreach_media_from_db(folder_id, m_filter, media_item_cb, NULL);
-
if(ret != MEDIA_CONTENT_ERROR_NONE)
- {
media_content_error("[ERROR] media_folder_foreach_media_from_db is failed, error code : %d", ret);
- }
media_filter_destroy(filter);
media_filter_destroy(m_filter);
char *folder_id = NULL;
char *folder_path = NULL;
char *folder_name = NULL;
+ int folder_order = -1;
bool ret = true;
if(folder != NULL)
media_content_debug("folder_name = [%s]", folder_name);
SAFE_FREE(folder_name);
+ ret = media_folder_get_order(folder, &folder_order);
+ media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
+ media_content_debug("folder_order = [%d]", folder_order);
+
ret = media_folder_clone(&g_folder, folder);
media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
ret = media_filter_create(&filter);
media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
- media_filter_set_condition(filter, "MEDIA_TYPE=0 and MEDIA_STORAGE_TYPE=0", MEDIA_CONTENT_COLLATE_DEFAULT); /*MEDIA_TYPE 0-image, 1-video, 2-sound, 3-music, 4-other*/
+ ret = media_filter_set_condition(filter, "MEDIA_TYPE=0 and MEDIA_STORAGE_TYPE=0", MEDIA_CONTENT_COLLATE_DEFAULT); /*MEDIA_TYPE 0-image, 1-video, 2-sound, 3-music, 4-other*/
+ ret = media_filter_set_order(filter, MEDIA_CONTENT_ORDER_DESC, FOLDER_ORDER, MEDIA_CONTENT_COLLATE_NOCASE);
ret = media_folder_get_folder_count_from_db(filter, &folder_count);
ret = media_folder_set_name(g_folder, "test_folder");
+ ret = media_folder_set_order(g_folder, 200);
+
ret = media_folder_update_to_db(g_folder);
ret = media_folder_destroy(g_folder);
media_playlist_h playlist_1 = NULL;
media_playlist_h playlist_2 = NULL;
media_playlist_h playlist_3 = NULL;
+ media_playlist_h playlist_4 = NULL;
int playlist_id_1 = 0;
int playlist_id_2 = 0;
int playlist_id_3 = 0;
media_content_debug("playlist_id_2 [%d]", playlist_id_2);
media_content_debug("playlist_id_3 [%d]", playlist_id_3);
+ /* Export and import playlist */
+ media_playlist_export_to_file(playlist_3, "/opt/usr/media/Music/playlist.m3u");
+ media_playlist_import_from_file( "/opt/usr/media/Music/playlist.m3u", "playlist_4", &playlist_4);
+
/* Filter for media*/
ret = media_filter_create(&m_filter);
media_playlist_destroy(playlist_2);
if(playlist_3 != NULL)
media_playlist_destroy(playlist_3);
+ if(playlist_4 != NULL)
+ media_playlist_destroy(playlist_4);
g_list_free(playlist_id_list);
g_list_free(playlist_member_id_list);
//insert bookmark to video
char *thumbnail_path1 = tzplatform_mkpath(TZ_USER_CONTENT, "Images and videos/My video clips/teat11.jpg");
-
ret = media_bookmark_insert_to_db(test_video_id, 400, thumbnail_path1);
if(ret != MEDIA_CONTENT_ERROR_NONE)
media_content_error("error media_bookmark_insert_to_db : [%d]", ret);
ret = test_filter_create();
if(ret != MEDIA_CONTENT_ERROR_NONE) {
- media_content_error("[%d]error(0x%08x)", __LINE__, ret);
+ media_content_error("[error(0x%08x)", ret);
return ret;
}
- for(idx = 0; idx <= MEDIA_CONTENT_GROUP_KEYWORD; idx++)
+ for(idx = 0; idx < MEDIA_CONTENT_GROUP_MAX; idx++)
{
ret = media_group_get_group_count_from_db(g_filter, idx, &group_count);
if(ret != MEDIA_CONTENT_ERROR_NONE) {
{
int ret = MEDIA_CONTENT_ERROR_NONE;
media_info_h media = NULL;
+ char *content_name = NULL;
+ bool favorite = FALSE;
//get the content of Over the horizon
- ret = media_info_get_media_from_db("0f999626-6218-450c-a4ad-181a3bab6ebf", &media);
+ ret = media_info_get_media_from_db("71b19196-5b38-4ab1-ab34-bfe05c369614", &media);
if(ret != MEDIA_CONTENT_ERROR_NONE)
media_content_error("media_info_get_media_from_db failed: %d", ret);
- test_disconnect_database();
-
ret = media_info_set_content_name(media, "TEST_content_name");
if(ret != MEDIA_CONTENT_ERROR_NONE)
media_content_error("media_info_set_content_name failed: %d", ret);
+ ret = media_info_set_favorite(media, TRUE);
+ if(ret != MEDIA_CONTENT_ERROR_NONE)
+ media_content_error("media_info_set_favorite failed: %d", ret);
+
ret = media_info_update_to_db(media);
if(ret == MEDIA_CONTENT_ERROR_NONE)
media_content_debug("media_info_update_to_db is success");
if(media != NULL)
media_info_destroy(media);
+ /*get the updated value*/
+ ret = media_info_get_media_from_db("71b19196-5b38-4ab1-ab34-bfe05c369614", &media);
+ if(ret != MEDIA_CONTENT_ERROR_NONE)
+ media_content_error("media_info_get_media_from_db failed: %d", ret);
+
+ ret = media_info_get_content_name(media, &content_name);
+ if(ret != MEDIA_CONTENT_ERROR_NONE)
+ media_content_error("media_info_get_content_name failed: %d", ret);
+ else
+ media_content_debug("content name [%s]", content_name);
+
+ SAFE_FREE(content_name);
+
+ ret = media_info_get_favorite(media, &favorite);
+ if(ret != MEDIA_CONTENT_ERROR_NONE)
+ media_content_error("media_info_get_favorite failed: %d", ret);
+ else
+ media_content_debug("favorite [%d]", favorite);
+
+ ret = media_info_destroy(media);
+
return ret;
}
}
else
{
- printf("invalid media_type");
+ media_content_debug("invalid media_type");
}
if(mime_type != NULL)
int DFT_test(void)
{
int ret = MEDIA_CONTENT_ERROR_NONE;
- printf("\n============DFT_test============\n\n");
+ media_content_debug("\n============DFT_test============\n\n");
filter_h filter = NULL;
int media_cnt = 0;
ret = media_filter_create(&filter);
/*Internal Memory*/
- printf("[Internal Memory]\n");
+ media_content_debug("[Internal Memory]\n");
/*1. Photo ============================================================*/
ret = media_filter_set_condition(filter, "MEDIA_STORAGE_TYPE=0 AND MEDIA_TYPE=0", MEDIA_CONTENT_COLLATE_DEFAULT);
/*Get Photo Count*/
ret = media_info_get_media_count_from_db(filter, &media_cnt);
- printf("Photo count = [%d]\n", media_cnt);
+ media_content_debug("Photo count = [%d]\n", media_cnt);
/*Get Photo Size*/
ret = media_info_foreach_media_from_db(filter, dft_cb, NULL);
- printf("Photo size = [%d]\n", g_total_photo_size);
+ media_content_debug("Photo size = [%d]\n", g_total_photo_size);
/*2. Video ============================================================*/
ret = media_filter_set_condition(filter, "MEDIA_STORAGE_TYPE=0 AND MEDIA_TYPE=1", MEDIA_CONTENT_COLLATE_DEFAULT);
/*Get Video Count*/
ret = media_info_get_media_count_from_db(filter, &media_cnt);
- printf("Video count = [%d]\n", media_cnt);
+ media_content_debug("Video count = [%d]\n", media_cnt);
/*Get Video Size*/
ret = media_info_foreach_media_from_db(filter, dft_cb, NULL);
- printf("Video size = [%d]\n", g_total_video_size);
+ media_content_debug("Video size = [%d]\n", g_total_video_size);
/*3. MP3 ============================================================*/
ret = media_filter_set_condition(filter, "MEDIA_STORAGE_TYPE=0 AND MEDIA_TYPE=3 AND MEDIA_MIME_TYPE=\"audio/mpeg\"", MEDIA_CONTENT_COLLATE_DEFAULT);
/*Get MP3 Count*/
ret = media_info_get_media_count_from_db(filter, &media_cnt);
- printf("MP3 count = [%d]\n", media_cnt);
+ media_content_debug("MP3 count = [%d]\n", media_cnt);
/*Get MP3 Size*/
ret = media_info_foreach_media_from_db(filter, dft_cb, NULL);
- printf("MP3 size = [%d]\n", g_total_mp3_size);
+ media_content_debug("MP3 size = [%d]\n", g_total_mp3_size);
/*4. Voice Memo ============================================================*/
ret = media_filter_set_condition(filter, "MEDIA_STORAGE_TYPE=0 AND (MEDIA_MIME_TYPE=\"audio/AMR\" OR MEDIA_MIME_TYPE=\"audio/mp4\")", MEDIA_CONTENT_COLLATE_DEFAULT);
/*Get Voice Memo Count*/
ret = media_info_get_media_count_from_db(filter, &media_cnt);
- printf("Voice Memo count = [%d]\n", media_cnt);
+ media_content_debug("Voice Memo count = [%d]\n", media_cnt);
/*Get Voice Memo Size*/
ret = media_info_foreach_media_from_db(filter, dft_cb, NULL);
- printf("Voice Memo size = [%d]\n", g_total_voice_memo_size);
+ media_content_debug("Voice Memo size = [%d]\n", g_total_voice_memo_size);
g_total_photo_size = 0;
g_total_video_size = 0;
g_total_voice_memo_size = 0;
/*External Memory*/
- printf("\n[External Memory]\n");
+ media_content_debug("\n[External Memory]\n");
/*1. Photo ============================================================*/
ret = media_filter_set_condition(filter, "MEDIA_STORAGE_TYPE=1 AND MEDIA_TYPE=0", MEDIA_CONTENT_COLLATE_DEFAULT);
/*Get Photo Count*/
ret = media_info_get_media_count_from_db(filter, &media_cnt);
- printf("Photo count = [%d]\n", media_cnt);
+ media_content_debug("Photo count = [%d]\n", media_cnt);
/*Get Photo Size*/
ret = media_info_foreach_media_from_db(filter, dft_cb, NULL);
- printf("Photo size = [%d]\n", g_total_photo_size);
+ media_content_debug("Photo size = [%d]\n", g_total_photo_size);
/*2. Video ============================================================*/
ret = media_filter_set_condition(filter, "MEDIA_STORAGE_TYPE=1 AND MEDIA_TYPE=1", MEDIA_CONTENT_COLLATE_DEFAULT);
/*Get Video Count*/
ret = media_info_get_media_count_from_db(filter, &media_cnt);
- printf("Video count = [%d]\n", media_cnt);
+ media_content_debug("Video count = [%d]\n", media_cnt);
/*Get Video Size*/
ret = media_info_foreach_media_from_db(filter, dft_cb, NULL);
- printf("Video size = [%d]\n", g_total_video_size);
+ media_content_debug("Video size = [%d]\n", g_total_video_size);
/*3. MP3 ============================================================*/
ret = media_filter_set_condition(filter, "MEDIA_STORAGE_TYPE=1 AND MEDIA_TYPE=3 AND MEDIA_MIME_TYPE=\"audio/mpeg\"", MEDIA_CONTENT_COLLATE_DEFAULT);
/*Get MP3 Count*/
ret = media_info_get_media_count_from_db(filter, &media_cnt);
- printf("MP3 count = [%d]\n", media_cnt);
+ media_content_debug("MP3 count = [%d]\n", media_cnt);
/*Get MP3 Size*/
ret = media_info_foreach_media_from_db(filter, dft_cb, NULL);
- printf("MP3 size = [%d]\n", g_total_mp3_size);
+ media_content_debug("MP3 size = [%d]\n", g_total_mp3_size);
/*4. Voice Memo ============================================================*/
ret = media_filter_set_condition(filter, "MEDIA_STORAGE_TYPE=1 AND (MEDIA_MIME_TYPE=\"audio/AMR\" OR MEDIA_MIME_TYPE=\"audio/mp4\")", MEDIA_CONTENT_COLLATE_DEFAULT);
/*Get Voice Memo Count*/
ret = media_info_get_media_count_from_db(filter, &media_cnt);
- printf("Voice Memo count = [%d]\n", media_cnt);
+ media_content_debug("Voice Memo count = [%d]\n", media_cnt);
/*Get Voice Memo Size*/
ret = media_info_foreach_media_from_db(filter, dft_cb, NULL);
- printf("Voice Memo size = [%d]\n", g_total_voice_memo_size);
+ media_content_debug("Voice Memo size = [%d]\n", g_total_voice_memo_size);
ret = media_filter_destroy(filter);
return ret;
void insert_batch_cb(media_content_error_e error, void * user_data)
{
- printf("media_info_insert_batch_to_db completed!\n");
+ media_content_debug("media_info_insert_batch_to_db completed!\n");
}
int test_batch_operations()
void insert_burst_shot_cb(media_content_error_e error, void * user_data)
{
- printf("media_info_insert_burst_shot_to_db completed![%d]\n", error);
+ media_content_debug("media_info_insert_burst_shot_to_db completed![%d]\n", error);
g_main_loop_quit(g_loop);
}
void _scan_cb(media_content_error_e err, void *user_data)
{
- printf("scan callback is called : %d\n", err);
+ media_content_debug("scan callback is called : %d\n", err);
g_main_loop_quit(g_loop);
return;
ret = media_content_scan_folder(dir_path, TRUE, _scan_cb, NULL);
if(ret != MEDIA_CONTENT_ERROR_NONE) {
- media_content_error("Fail to media_content_scan_file : %d", ret);
+ media_content_error("Fail to test_scan_dir_start : %d", ret);
return ret;
}
return 0;
}
-int test_scan_dir()
+gboolean cancel_scan_dir_start(gpointer data)
+{
+ int ret = MEDIA_CONTENT_ERROR_NONE;
+
+ const char *dir_path = "/opt/usr/media/Images";
+
+ ret = media_content_cancel_scan_folder(dir_path);
+
+ if(ret == MEDIA_CONTENT_ERROR_NONE)
+ media_content_debug("media_content_cancel_scan_folder is success");
+ else
+ media_content_error("media_content_cancel_scan_folder is failed");
+
+ return false;
+}
+
+int test_scan_dir(int cancel)
{
GSource *source = NULL;
GMainContext *context = NULL;
g_source_set_callback (source, test_scan_dir_start, NULL, NULL);
g_source_attach (source, context);
+ if (cancel) {
+ GSource *cancel_src = NULL;
+ cancel_src = g_idle_source_new();
+ g_source_set_callback (cancel_src, cancel_scan_dir_start, NULL, NULL);
+ g_source_attach (cancel_src, context);
+ }
+
g_main_loop_run(g_loop);
g_main_loop_unref(g_loop);
void *user_data)
{
if (error == 0) {
- printf("noti success! : %d\n", error);
+ media_content_debug("noti success! : %d\n", error);
} else {
- printf("error occured! : %d\n", error);
+ media_content_debug("error occured! : %d\n", error);
}
- printf("Noti from PID(%d)\n", pid);
+ media_content_debug("Noti from PID(%d)\n", pid);
if (update_item == MEDIA_ITEM_FILE) {
- printf("Noti item : MEDIA_ITEM_FILE\n");
+ media_content_debug("Noti item : MEDIA_ITEM_FILE\n");
} else if (update_item == MEDIA_ITEM_DIRECTORY) {
- printf("Noti item : MEDIA_ITEM_DIRECTORY\n");
+ media_content_debug("Noti item : MEDIA_ITEM_DIRECTORY\n");
}
if (update_type == MEDIA_CONTENT_INSERT) {
- printf("Noti type : MEDIA_CONTENT_INSERT\n");
+ media_content_debug("Noti type : MEDIA_CONTENT_INSERT\n");
} else if (update_type == MEDIA_CONTENT_DELETE) {
- printf("Noti type : MEDIA_CONTENT_DELETE\n");
+ media_content_debug("Noti type : MEDIA_CONTENT_DELETE\n");
} else if (update_type == MEDIA_CONTENT_UPDATE) {
- printf("Noti type : MEDIA_CONTENT_UPDATE\n");
+ media_content_debug("Noti type : MEDIA_CONTENT_UPDATE\n");
}
- printf("content type : %d\n", media_type);
+ media_content_debug("content type : %d\n", media_type);
if (path)
- printf("path : %s\n", path);
+ media_content_debug("path : %s\n", path);
else
- printf("path not\n");
+ media_content_debug("path not\n");
if (uuid)
- printf("uuid : %s\n", uuid);
+ media_content_debug("uuid : %s\n", uuid);
else
- printf("uuid not\n");
+ media_content_debug("uuid not\n");
if (mime_type)
- printf("mime_type : %s\n", mime_type);
+ media_content_debug("mime_type : %s\n", mime_type);
else
- printf("mime not\n");
+ media_content_debug("mime not\n");
- if (user_data) printf("String : %s\n", (char *)user_data);
+ if (user_data) media_content_debug("String : %s\n", (char *)user_data);
//g_main_loop_quit(g_loop);
return;
char *path = tzplatform_mkpath(TZ_USER_CONTENT, "test/image1.jpg");
ret = media_info_insert_to_db(path, &media_item);
- if (ret < MEDIA_CONTENT_ERROR_NONE) {
+ if (ret != MEDIA_CONTENT_ERROR_NONE) {
media_content_error("media_info_insert_to_db failed : %d", ret);
media_info_destroy(media_item);
return FALSE;
return ret;
}
+int test_create_handle()
+{
+ int ret = MEDIA_CONTENT_ERROR_NONE;
+ media_info_h media = NULL;
+ media_info_h info = NULL;
+ char *path = "/opt/usr/media/test_storage_path/cloud_other.txt";
+ char *str_value = NULL;
+ int int_value = -1;
+
+ ret = media_info_create_handle(&media);
+
+ ret = media_info_set_path(media, path);
+ ret = media_info_set_mime_type(media, "test_mime_type");
+ ret = media_info_set_title(media, "test_title");
+ ret = media_info_set_album(media, "test_album");
+ ret = media_info_set_artist(media, "test_artist");
+ ret = media_info_set_genre(media, "test_genre");
+ ret = media_info_set_width(media, 1920);
+ ret = media_info_set_height(media, 1080);
+ ret = media_info_set_recorded_date(media, "test_recorded_date");
+ ret = media_info_set_thumbnail_path(media, "/opt/usr/media/test_thumbnail_path");
+ ret = media_info_set_size(media, 5555);
+ ret = media_info_set_modified_time(media, 4444);
+ ret = media_info_set_media_type(media, MEDIA_CONTENT_TYPE_VIDEO);
+ ret = media_info_set_duration(media, 3333);
+ ret = media_info_set_width(media, 1111);
+ ret = media_info_set_height(media, 2222);
+ ret = media_info_set_storage_type(media, MEDIA_CONTENT_STORAGE_CLOUD);
+ ret = media_info_set_storage_id(media, "5e0ad455-9b84-4489-ad51-4dd93b795413");
+
+ ret = media_info_insert_to_db_with_data(media, &info);
+ if(ret != MEDIA_CONTENT_ERROR_NONE)
+ {
+ media_content_error("media_info_insert_to_db_with_data failed : %d\n", ret);
+ return ret;
+ }
+
+ ret = media_info_get_file_path(info, &str_value);
+ media_content_debug("file_path = [%s]", str_value);
+ SAFE_FREE(str_value);
+
+ ret = media_info_get_mime_type(info, &str_value);
+ media_content_debug("mime_type = [%s]", str_value);
+ SAFE_FREE(str_value);
+
+ ret = media_info_get_title(info, &str_value);
+ media_content_debug("title = [%s]", str_value);
+ SAFE_FREE(str_value);
+
+ ret = media_info_get_size(info,(unsigned long long*) &int_value);
+ media_content_debug("size = [%d]", int_value);
+
+ ret = media_info_get_modified_time(info, (time_t*)&int_value);
+ media_content_debug("time = [%d]", int_value);
+
+ ret = media_info_get_media_type(info, (media_content_type_e *)&int_value);
+ media_content_debug("media_type = [%d]", int_value);
+
+ ret = media_info_get_storage_type(info, (media_content_storage_e *)&int_value);
+ media_content_debug("storage_type = [%d]", int_value);
+
+ media_info_destroy(media);
+ media_info_destroy(info);
+
+ return ret;
+
+}
+
+int test_storage_item_insert()
+{
+ int ret = MEDIA_CONTENT_ERROR_NONE;
+
+ media_info_h media = NULL;
+
+ ret = media_info_create_handle(&media);
+ ret = media_info_set_path(media, "/opt/storage/cloud/c_storage/test_file.png");
+ ret = media_info_set_mime_type(media, "test_mime_type");
+ ret = media_info_set_title(media, "test_title");
+ ret = media_info_set_storage_type(media, MEDIA_CONTENT_STORAGE_CLOUD);
+ ret = media_info_set_storage_id(media, "2a4e8103-33e3-4846-afe9-5be4681b0dba");
+ ret = media_info_set_modified_time(media, 100);
+ ret = media_info_set_media_type(media, MEDIA_CONTENT_TYPE_IMAGE);
+ ret = media_info_insert_to_db_with_data(media, NULL);
+
+ if(ret != MEDIA_CONTENT_ERROR_NONE)
+ media_content_error("media_info_insert_to_db_with_data failed : %d\n", ret);
+
+ return ret;
+}
+
+int test_storage()
+{
+ int ret = MEDIA_CONTENT_ERROR_NONE;
+
+ media_storage_h storage = NULL;
+#if 1
+ char *storage_name = "test_storage_name";
+ char *storage_path = "/opt/storage/cloud/c_storage/test_storage_path";
+ char *storage_account = "test_storage_account";
+#endif
+ char *storage_id = NULL;
+ char *st_val = NULL;
+ media_content_storage_e storage_type_out = -1;
+ int storage_cnt = -1;
+
+#if 1
+ ret = media_storage_insert_to_db(storage_name, storage_path, storage_account, MEDIA_CONTENT_STORAGE_CLOUD, &storage);
+ if(ret != MEDIA_CONTENT_ERROR_NONE)
+ {
+ media_content_error("media_storage_insert_to_db failed : %d\n", ret);
+ goto ERROR;
+ }
+ ret = media_storage_get_id(storage, &storage_id);
+
+ ret = media_storage_destroy(storage);
+ storage = NULL;
+#endif
+ ret = media_storage_get_storage_count_from_db(NULL, &storage_cnt);
+ if(ret != MEDIA_CONTENT_ERROR_NONE)
+ {
+ media_content_error("media_storage_get_storage_count_from_db failed : %d\n", ret);
+ goto ERROR;
+ }
+ media_content_debug("storage_cnt = [%d]", storage_cnt);
+
+ //media_storage_foreach_storage_from_db(filter_h filter, media_storage_cb callback, void *user_data);
+
+ ret = media_storage_get_storage_info_from_db(storage_id, &storage);
+ if(ret != MEDIA_CONTENT_ERROR_NONE)
+ {
+ media_content_error("media_storage_get_storage_info_from_db failed : %d\n", ret);
+ goto ERROR;
+ }
+
+ ret = media_storage_get_id(storage, &st_val);
+ if(ret != MEDIA_CONTENT_ERROR_NONE)
+ {
+ media_content_error("media_storage_get_id failed : %d\n", ret);
+ goto ERROR;
+ }
+ media_content_debug("storage_id = [%s]", st_val);
+ SAFE_FREE(st_val);
+
+ ret = media_storage_get_name(storage, &st_val);
+ if(ret != MEDIA_CONTENT_ERROR_NONE)
+ {
+ media_content_error("media_storage_get_name failed : %d\n", ret);
+ goto ERROR;
+ }
+ media_content_debug("storage_name = [%s]", st_val);
+ SAFE_FREE(st_val);
+
+ ret = media_storage_get_path(storage, &st_val);
+ if(ret != MEDIA_CONTENT_ERROR_NONE)
+ {
+ media_content_error("media_storage_get_path failed : %d\n", ret);
+ goto ERROR;
+ }
+ media_content_debug("storage_path = [%s]", st_val);
+ SAFE_FREE(st_val);
+
+ ret = media_storage_get_storage_account(storage, &st_val);
+ if(ret != MEDIA_CONTENT_ERROR_NONE)
+ {
+ media_content_error("media_storage_get_path failed : %d\n", ret);
+ goto ERROR;
+ }
+ media_content_debug("storage_ccount = [%s]", st_val);
+ SAFE_FREE(st_val);
+
+ ret = media_storage_get_type(storage, &storage_type_out);
+ if(ret != MEDIA_CONTENT_ERROR_NONE)
+ {
+ media_content_error("media_storage_get_type failed : %d\n", ret);
+ goto ERROR;
+ }
+ media_content_debug("storage_type = [%d]", storage_type_out);
+
+ //ret = media_storage_clone(media_storage_h *dst, media_storage_h src);
+
+ //ret = media_storage_delete_from_db(storage_id);
+
+ERROR:
+ SAFE_FREE(storage_id);
+ SAFE_FREE(st_val);
+
+ ret = media_storage_destroy(storage);
+
+ return ret;
+}
+
int main(int argc, char *argv[])
{
int ret = MEDIA_CONTENT_ERROR_NONE;
if(ret != MEDIA_CONTENT_ERROR_NONE)
return MEDIA_CONTENT_ERROR_NONE;
- ret = test_media_info_operation();
- if(ret != MEDIA_CONTENT_ERROR_NONE)
- return ret;
-
#if 0
ret = test_move();
if(ret != MEDIA_CONTENT_ERROR_NONE)
if(ret != MEDIA_CONTENT_ERROR_NONE)
return MEDIA_CONTENT_ERROR_NONE;
- ret = test_scan_dir();
+ ret = test_scan_dir(true);
if(ret != MEDIA_CONTENT_ERROR_NONE)
return MEDIA_CONTENT_ERROR_NONE;
ret = test_noti();
if(ret != MEDIA_CONTENT_ERROR_NONE)
return MEDIA_CONTENT_ERROR_NONE;
+
+ ret = test_storage();
+ if(ret != MEDIA_CONTENT_ERROR_NONE)
+ return MEDIA_CONTENT_ERROR_NONE;
+
+ ret = test_storage_item_insert();
+ if(ret != MEDIA_CONTENT_ERROR_NONE)
+ return MEDIA_CONTENT_ERROR_NONE;
+
+ ret = test_create_handle();
+ if(ret != MEDIA_CONTENT_ERROR_NONE)
+ return MEDIA_CONTENT_ERROR_NONE;
#endif
ret = test_disconnect_database();
projects / platform / core / api / media-content.git / commitdiff