*/
int audio_meta_get_artist(audio_meta_h audio, char **artist_name);
+/**
+ * @brief Gets name of album_artist of given audio metadata.\n
+ * If the value is an empty string, the method returns "Unknown".
+ *
+ * @remarks @a album_artist_name must be released with free() by you.
+ *
+ * @param [in] audio The handle to audio metadata
+ * @param [out] album_artist_name The name of the album_artist
+ * @return 0 on success, otherwise a negative error value.
+ * @retval #MEDIA_CONTENT_ERROR_NONE Successful
+ * @retval #MEDIA_CONTENT_ERROR_INVALID_PARAMETER Invalid parameter
+ * @retval #MEDIA_CONTENT_ERROR_OUT_OF_MEMORY Out of memory
+ */
+int audio_meta_get_album_artist(audio_meta_h audio, char **album_artist_name);
/**
* @brief Gets the genre name of the given audio metadata.
*/
int audio_meta_get_bit_rate(audio_meta_h audio, int *bit_rate);
+/**
+ * @brief Gets bit per sample of the given audio metadata.
+ * @since_tizen 2.3
+ *
+ * @param [in] audio The handle to the audio metadata
+ * @param [out] bitpersample The audio bit per sample
+ *
+ * @return @c 0 on success,
+ * otherwise a negative error value
+ *
+ * @retval #MEDIA_CONTENT_ERROR_NONE Successful
+ * @retval #MEDIA_CONTENT_ERROR_INVALID_PARAMETER Invalid parameter
+ * @retval #MEDIA_CONTENT_ERROR_PERMISSION_DENIED Permission denied
+ */
+
+int audio_meta_get_bitpersample(audio_meta_h audio, int *bitpersample);
/**
* @brief Gets the sample rate of the given audio metadata.
MEDIA_CONTENT_COLLATE_DEFAULT = 0, /**< Default collation BINARY */
MEDIA_CONTENT_COLLATE_NOCASE = 1, /**< Collation NOCASE, not case sensitive */
MEDIA_CONTENT_COLLATE_RTRIM = 2, /**< Collation RTRIM, trailing space characters are ignored */
+ MEDIA_CONTENT_COLLATE_LOCALIZED = 3, /**< Collation LOCALIZATION, NOCASE also applied */
} media_content_collation_e;
#define MEDIA_CONTENT_ERROR_CLASS TIZEN_ERROR_MEDIA_CONTENT
#define MEDIA_SIZE "MEDIA_SIZE" /**< Media MIME size */
#define MEDIA_ADDED_TIME "MEDIA_ADDED_TIME" /**< Media added time */
#define MEDIA_MODIFIED_TIME "MEDIA_MODIFIED_TIME" /**< Media modified time */
+#define MEDIA_TIMELINE "MEDIA_TIMELINE" /**< Media modified time */
#define MEDIA_THUMBNAIL_PATH "MEDIA_THUMBNAIL_PATH" /**< Media thumbnail path */
#define MEDIA_TITLE "MEDIA_TITLE" /**< Media title get from tag or file name */
#define MEDIA_ALBUM "MEDIA_ALBUM" /**< Media album name*/
#define MEDIA_ARTIST "MEDIA_ARTIST" /**< Media artist*/
+#define MEDIA_ALBUM_ARTIST "MEDIA_ALBUM_ARTIST" /**< Media album_artist*/
#define MEDIA_GENRE "MEDIA_GENRE" /**< Media genre*/
#define MEDIA_COMPOSER "MEDIA_COMPOSER" /**< Media composer*/
#define MEDIA_YEAR "MEDIA_YEAR" /**< Media year*/
#define MEDIA_TRACK_NUM "MEDIA_TRACK_NUM" /**< Media track number*/
#define MEDIA_DESCRIPTION "MEDIA_DESCRIPTION" /**< Media description*/
#define MEDIA_BITRATE "MEDIA_BITRATE" /**< Media bitrate*/
+#define MEDIA_BITPERSAMPLE "MEDIA_BITPERSAMPLE" /**< Media bit per sample*/
#define MEDIA_SAMPLERATE "MEDIA_SAMPLERATE" /**< Media sample rate*/
#define MEDIA_CHANNEL "MEDIA_CHANNEL" /**< Media channel*/
#define MEDIA_DURATION "MEDIA_DURATION" /**< Media duration */
#define MEDIA_LOCATION_TAG "MEDIA_LOCATION_TAG" /**< Media location tag*/
#define MEDIA_AGE_RATING "MEDIA_AGE_RATING" /**< Media age rating*/
#define MEDIA_KEYWORD "MEDIA_KEYWORD" /**< Media keyword*/
+#define MEDIA_WEATHER "MEDIA_WEATHER" /**< Media weather*/
#define MEDIA_IS_DRM "MEDIA_IS_DRM" /**< Is DRM. 0-not drm, 1-drm*/
#define MEDIA_STORAGE_TYPE "MEDIA_STORAGE_TYPE" /**< Media storage. 0-internal storage, 1-external storage*/
+#define MEDIA_FILE_NAME_PINYIN "MEDIA_FILE_NAME_PINYIN" /**< media file name pinyin */
+#define MEDIA_TITLE_PINYIN "MEDIA_TITLE_PINYIN" /**< media title pinyin */
+#define MEDIA_ALBUM_PINYIN "MEDIA_ALBUM_PINYIN" /**< media album pinyin*/
+#define MEDIA_ARTIST_PINYIN "MEDIA_ARTIST_PINYIN" /**< media artist pinyin*/
+#define MEDIA_ALBUM_ARTIST_PINYIN "MEDIA_ALBUM_ARTIST_PINYIN" /**< media album_artist pinyin*/
+#define MEDIA_GENRE_PINYIN "MEDIA_GENRE_PINYIN" /**< media genre pinyin*/
+#define MEDIA_COMPOSER_PINYIN "MEDIA_COMPOSER_PINYIN" /**< media composer pinyin*/
+#define MEDIA_COPYRIGHT_PINYIN "MEDIA_COPYRIGHT_PINYIN" /**< media copyright pinyin*/
+#define MEDIA_DESCRIPTION_PINYIN "MEDIA_DESCRIPTION_PINYIN" /**< media description pinyin*/
+#define MEDIA_AUTHOR_PINYIN "MEDIA_AUTHOR_PINYIN" /**< media authore pinyin*/
+#define MEDIA_PROVIDER_PINYIN "MEDIA_PROVIDER_PINYIN" /**< media provider pinyin*/
+#define MEDIA_CONTENT_NAME_PINYIN "MEDIA_CONTENT_NAME_PINYIN" /**< media content name pinyin*/
+#define MEDIA_CATEGORY_PINYIN "MEDIA_CATEGORY_PINYIN" /**< media category pinyin*/
+#define MEDIA_LOCATION_TAG_PINYIN "MEDIA_LOCATION_TAG_PINYIN" /**< media location tag pinyin*/
+#define MEDIA_AGE_RATING_PINYIN "MEDIA_AGE_RATING_PINYIN" /**< media age rating pinyin*/
+#define MEDIA_KEYWORD_PINYIN "MEDIA_KEYWORD_PINYIN" /**< media keyword pinyin*/
/**
* @}
*/
#define FOLDER_NAME "FOLDER_NAME" /**< Folder base name */
#define FOLDER_MODIFIED_TIME "FOLDER_MODIFIED_TIME" /**< Folder modified time */
#define FOLDER_STORAGE_TYPE "FOLDER_STORAGE_TYPE" /**< Folder storage. 0-internal storage, 1-external storage*/
+#define FOLDER_NAME_PINYIN "FOLDER_NAME_PINYIN" /**< folder base name pinyin*/
/**
* @}
*/
int media_info_get_modified_time(media_info_h media, time_t *time);
+/**
+ * @brief Gets media info's timeline.
+ *
+ * @param[in] media The handle to media info
+ * @param[out] time The date of timeline.
+ * @return 0 on success, otherwise a negative error value.
+ * @retval #MEDIA_CONTENT_ERROR_NONE Successful
+ * @retval #MEDIA_CONTENT_ERROR_INVALID_PARAMETER Invalid parameter
+ *
+ */
+int media_info_get_timeline(media_info_h media, time_t* time);
/**
* @brief Gets the thumbnail of media info.
*/
int media_info_get_altitude(media_info_h media, double* altitude);
+/**
+ * @brief Gets media info's weather.
+ *
+ * @param[in] media The handle to media info
+ * @param[out] weater The weather of media info
+ * @return 0 on success, otherwise a negative error value.
+ * @retval #MEDIA_CONTENT_ERROR_NONE Successful
+ * @retval #MEDIA_CONTENT_ERROR_INVALID_PARAMETER Invalid parameter
+ *
+ */
+int media_info_get_weather(media_info_h media, char **weather);
/**
* @brief Gets the rating of media info.
*/
int media_info_set_altitude(media_info_h media, double altitude);
+/**
+ * @brief Sets weather to media info.
+ *
+ * @param[in] media The handle to media info
+ * @param[in] weather The weather of media info
+ * @return 0 on success, otherwise a negative error value.
+ * @retval #MEDIA_CONTENT_ERROR_NONE Successful
+ * @retval #MEDIA_CONTENT_ERROR_OUT_OF_MEMORY Out of memory
+ * @retval #MEDIA_CONTENT_ERROR_INVALID_PARAMETER Invalid parameter
+ * @post media_info_update_to_db()
+ *
+ */
+int media_info_set_weather(media_info_h media, const char *weather);
/**
* @brief Sets the rating of media info.
char *date_taken;
char *title;
char *burst_id;
+ char *weather;
media_content_orientation_e orientation;
}image_meta_s;
char *title;
char *album;
char *artist;
+ char *album_artist;
char *genre;
char *composer;
char *year;
char *title;
char *album;
char *artist;
+ char *album_artist;
char *genre;
char *composer;
char *year;
char *copyright;
char *track_num;
int bitrate;
+ int bitpersample;
int samplerate;
int channel;
int duration;
unsigned long long size;
time_t added_time;
time_t modified_time;
+ time_t timeline;
char *thumbnail_path;
char *description;
double longitude;
double latitude;
double altitude;
+ char *weather;
int rating;
int favourite;
char *title;
char *keyword;
int is_drm;
int storage_type;
+ int sync_status;
image_meta_s *image_meta;
video_meta_s *video_meta;
audio_meta_s *audio_meta;
#define DB_FIELD_MEDIA_SIZE "size"
#define DB_FIELD_MEDIA_ADDED_TIME "added_time"
#define DB_FIELD_MEDIA_MODIFIED_TIME "modified_time"
+#define DB_FIELD_MEDIA_TIMELINE "timeline"
#define DB_FIELD_MEDIA_THUMBNAIL_PATH "thumbnail_path"
#define DB_FIELD_MEDIA_TITLE "title"
#define DB_FIELD_MEDIA_ALBUM "album"
#define DB_FIELD_MEDIA_ARTIST "artist"
+#define DB_FIELD_MEDIA_ALBUM_ARTIST "album_artist"
#define DB_FIELD_MEDIA_GENRE "genre"
#define DB_FIELD_MEDIA_COMPOSER "composer"
#define DB_FIELD_MEDIA_YEAR "year"
#define DB_FIELD_MEDIA_TRACK_NUM "track_num"
#define DB_FIELD_MEDIA_DESCRIPTION "description"
#define DB_FIELD_MEDIA_BITRATE "bitrate"
+#define DB_FIELD_MEDIA_BITPERSAMPLE "bitpersample"
#define DB_FIELD_MEDIA_SAMPLERATE "samplerate"
#define DB_FIELD_MEDIA_CHANNEL "channel"
#define DB_FIELD_MEDIA_DURATION "duration"
#define DB_FIELD_MEDIA_LOCATION_TAG "location_tag"
#define DB_FIELD_MEDIA_AGE_RATING "age_rating"
#define DB_FIELD_MEDIA_KEYWORD "keyword"
+#define DB_FIELD_MEDIA_WEATHER "weather"
#define DB_FIELD_MEDIA_IS_DRM "is_drm"
#define DB_FIELD_MEDIA_STORAGE_TYPE "storage_type"
+#define DB_FIELD_MEDIA_FILE_NAME_PINYIN "file_name_pinyin"
+#define DB_FIELD_MEDIA_TITLE_PINYIN "title_pinyin"
+#define DB_FIELD_MEDIA_ALBUM_PINYIN "album_pinyin"
+#define DB_FIELD_MEDIA_ARTIST_PINYIN "artist_pinyin"
+#define DB_FIELD_MEDIA_ALBUM_ARTIST_PINYIN "album_artist_pinyin"
+#define DB_FIELD_MEDIA_GENRE_PINYIN "genre_pinyin"
+#define DB_FIELD_MEDIA_COMPOSER_PINYIN "composer_pinyin"
+#define DB_FIELD_MEDIA_COPYRIGHT_PINYIN "copyright_pinyin"
+#define DB_FIELD_MEDIA_DESCRIPTION_PINYIN "description_pinyin"
+#define DB_FIELD_MEDIA_AUTHOR_PINYIN "author_pinyin"
+#define DB_FIELD_MEDIA_PROVIDER_PINYIN "provider_pinyin"
+#define DB_FIELD_MEDIA_CONTENT_NAME_PINYIN "content_name_pinyin"
+#define DB_FIELD_MEDIA_CATEGORY_PINYIN "category_pinyin"
+#define DB_FIELD_MEDIA_LOCATION_TAG_PINYIN "location_tag_pinyin"
+#define DB_FIELD_MEDIA_AGE_RATING_PINYIN "age_rating_pinyin"
+#define DB_FIELD_MEDIA_KEYWORD_PINYIN "keyword_pinyin"
+
/* DB field for folder */
#define DB_FIELD_FOLDER_ID "folder_uuid"
#define DB_FIELD_FOLDER_PATH "path"
#define DB_FIELD_FOLDER_NAME "name"
#define DB_FIELD_FOLDER_MODIFIED_TIME "modified_time"
#define DB_FIELD_FOLDER_STORAGE_TYPE "storage_type"
+#define DB_FIELD_FOLDER_NAME_PINYIN "name_pinyin"
/* DB field for playlist */
#define DB_FIELD_PLAYLIST_ID "playlist_id"
/* 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 WHERE media_uuid='%q'"
+#define UPDATE_IMAGE_META_FROM_MEDIA "UPDATE "DB_TABLE_MEDIA" SET orientation=%d, weather=%Q WHERE media_uuid='%q'"
/* 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, is_drm, storage_type"
#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, burst_id"
+ 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, album_artist, genre, composer, year, recorded_date, copyright, track_num, bitrate, duration, played_count, last_played_time, last_played_position, samplerate, channel, burst_id, timeline, weather, sync_status"
#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'"
extern "C" {
#endif /* __cplusplus */
+#include <stdbool.h>
/**
*@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);
*/
int video_meta_get_artist(video_meta_h video, char **artist);
+/**
+ * @brief Gets the video's album_artist.
+ * If the value is an empty string, the method returns "Unknown".
+ *
+ * @remarks @a album_artist must be released with free() by you.
+ *
+ * @param [in] video The handle to video metadata
+ * @param [out] album_artist The album_artist of video metadata
+ * @return 0 on success, otherwise a negative error value.
+ * @retval #MEDIA_CONTENT_ERROR_NONE Successful
+ * @retval #MEDIA_CONTENT_ERROR_INVALID_PARAMETER Invalid parameter
+ * @retval #MEDIA_CONTENT_ERROR_OUT_OF_MEMORY Out of memory
+ */
+int video_meta_get_album_artist(video_meta_h video, char **album_artist);
/**
* @brief Gets the video genre.
Name: capi-content-media-content
Summary: A Media content library in SLP C API
-Version: 0.2.59
+Version: 0.2.60
Release: 0
Group: Multimedia/API
License: Apache-2.0
SAFE_FREE(_audio->title);
SAFE_FREE(_audio->album);
SAFE_FREE(_audio->artist);
+ SAFE_FREE(_audio->album_artist);
SAFE_FREE(_audio->genre);
SAFE_FREE(_audio->composer);
SAFE_FREE(_audio->year);
}
}
+ if(STRING_VALID(_src->album_artist))
+ {
+ _dst->album_artist = strdup(_src->album_artist);
+ if(_dst->album_artist == NULL)
+ {
+ audio_meta_destroy((audio_meta_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->genre))
{
_dst->genre = strdup(_src->genre);
}
_dst->bitrate = _src->bitrate;
+ _dst->bitpersample = _src->bitpersample;
_dst->samplerate = _src->samplerate;
_dst->channel = _src->channel;
_dst->duration = _src->duration;
return ret;
}
+int audio_meta_get_album_artist(audio_meta_h audio, char **album_artist_name)
+{
+ int ret = MEDIA_CONTENT_ERROR_NONE;
+ audio_meta_s *_audio = (audio_meta_s*)audio;
+
+ if(_audio)
+ {
+ if(STRING_VALID(_audio->album_artist))
+ {
+ *album_artist_name = strdup(_audio->album_artist);
+ if(*album_artist_name == NULL)
+ {
+ media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
+ return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
+ }
+ }
+ else
+ {
+ *album_artist_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 audio_meta_get_genre(audio_meta_h audio, char **genre_name)
{
int ret = MEDIA_CONTENT_ERROR_NONE;
return ret;
}
+int audio_meta_get_bitpersample(audio_meta_h audio, int *bitpersample)
+{
+ int ret = MEDIA_CONTENT_ERROR_NONE;
+ audio_meta_s *_audio = (audio_meta_s*)audio;
+
+ if(_audio && bitpersample)
+ {
+ *bitpersample = _audio->bitpersample;
+ 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 audio_meta_get_sample_rate(audio_meta_h audio, int *sample_rate)
{
int ret = MEDIA_CONTENT_ERROR_NONE;
ret = _media_filter_attribute_add(g_attr_handle, MEDIA_MODIFIED_TIME, DB_FIELD_MEDIA_MODIFIED_TIME);
media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
+ ret = _media_filter_attribute_add(g_attr_handle, MEDIA_TIMELINE, DB_FIELD_MEDIA_TIMELINE);
+ media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
+
ret = _media_filter_attribute_add(g_attr_handle, MEDIA_THUMBNAIL_PATH, DB_FIELD_MEDIA_THUMBNAIL_PATH);
media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
ret = _media_filter_attribute_add(g_attr_handle, MEDIA_ARTIST, DB_FIELD_MEDIA_ARTIST);
media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
+ ret = _media_filter_attribute_add(g_attr_handle, MEDIA_ALBUM_ARTIST, DB_FIELD_MEDIA_ALBUM_ARTIST);
+ media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
+
ret = _media_filter_attribute_add(g_attr_handle, MEDIA_GENRE, DB_FIELD_MEDIA_GENRE);
media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
ret = _media_filter_attribute_add(g_attr_handle, MEDIA_KEYWORD, DB_FIELD_MEDIA_KEYWORD);
media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
+ ret = _media_filter_attribute_add(g_attr_handle, MEDIA_WEATHER, DB_FIELD_MEDIA_WEATHER);
+ media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
+
ret = _media_filter_attribute_add(g_attr_handle, MEDIA_IS_DRM, DB_FIELD_MEDIA_IS_DRM);
media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
ret = _media_filter_attribute_add(g_attr_handle, MEDIA_STORAGE_TYPE, DB_FIELD_MEDIA_STORAGE_TYPE);
media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
+ /* Pinyin*/
+ ret = _media_filter_attribute_add(g_attr_handle, MEDIA_FILE_NAME_PINYIN, DB_FIELD_MEDIA_FILE_NAME_PINYIN);
+ media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
+
+ ret = _media_filter_attribute_add(g_attr_handle, MEDIA_TITLE_PINYIN, DB_FIELD_MEDIA_TITLE_PINYIN);
+ media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
+
+ ret = _media_filter_attribute_add(g_attr_handle, MEDIA_ALBUM_PINYIN, DB_FIELD_MEDIA_ALBUM_PINYIN);
+ media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
+
+ ret = _media_filter_attribute_add(g_attr_handle, MEDIA_ARTIST_PINYIN, DB_FIELD_MEDIA_ARTIST_PINYIN);
+ media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
+
+ ret = _media_filter_attribute_add(g_attr_handle, MEDIA_ALBUM_ARTIST_PINYIN, DB_FIELD_MEDIA_ALBUM_ARTIST_PINYIN);
+ media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
+
+ ret = _media_filter_attribute_add(g_attr_handle, MEDIA_GENRE_PINYIN, DB_FIELD_MEDIA_GENRE_PINYIN);
+ media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
+
+ ret = _media_filter_attribute_add(g_attr_handle, MEDIA_COMPOSER_PINYIN, DB_FIELD_MEDIA_COMPOSER_PINYIN);
+ media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
+
+ ret = _media_filter_attribute_add(g_attr_handle, MEDIA_COPYRIGHT_PINYIN, DB_FIELD_MEDIA_COPYRIGHT_PINYIN);
+ media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
+
+ ret = _media_filter_attribute_add(g_attr_handle, MEDIA_DESCRIPTION_PINYIN, DB_FIELD_MEDIA_DESCRIPTION_PINYIN);
+ media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
+
+ ret = _media_filter_attribute_add(g_attr_handle, MEDIA_AUTHOR_PINYIN, DB_FIELD_MEDIA_AUTHOR_PINYIN);
+ media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
+
+ ret = _media_filter_attribute_add(g_attr_handle, MEDIA_PROVIDER_PINYIN, DB_FIELD_MEDIA_PROVIDER_PINYIN);
+ media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
+
+ ret = _media_filter_attribute_add(g_attr_handle, MEDIA_CONTENT_NAME_PINYIN, DB_FIELD_MEDIA_CONTENT_NAME_PINYIN);
+ media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
+
+ ret = _media_filter_attribute_add(g_attr_handle, MEDIA_CATEGORY_PINYIN, DB_FIELD_MEDIA_CATEGORY_PINYIN);
+ media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
+
+ ret = _media_filter_attribute_add(g_attr_handle, MEDIA_LOCATION_TAG_PINYIN, DB_FIELD_MEDIA_LOCATION_TAG_PINYIN);
+ media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
+
+ ret = _media_filter_attribute_add(g_attr_handle, MEDIA_AGE_RATING_PINYIN, DB_FIELD_MEDIA_AGE_RATING_PINYIN);
+ media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
+
+ ret = _media_filter_attribute_add(g_attr_handle, MEDIA_KEYWORD_PINYIN, DB_FIELD_MEDIA_KEYWORD_PINYIN);
+ media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
+
/* Playlist*/
ret = _media_filter_attribute_add(g_attr_handle, PLAYLIST_NAME, DB_FIELD_PLAYLIST_NAME);
media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
ret = _media_filter_attribute_add(g_alias_attr_handle, MEDIA_MODIFIED_TIME, DB_TABLE_ALIAS_MEDIA"."DB_FIELD_MEDIA_MODIFIED_TIME);
media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
+ ret = _media_filter_attribute_add(g_alias_attr_handle, MEDIA_TIMELINE, DB_TABLE_ALIAS_MEDIA"."DB_FIELD_MEDIA_TIMELINE);
+ media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
+
ret = _media_filter_attribute_add(g_alias_attr_handle, MEDIA_THUMBNAIL_PATH, DB_TABLE_ALIAS_MEDIA"."DB_FIELD_MEDIA_THUMBNAIL_PATH);
media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
ret = _media_filter_attribute_add(g_alias_attr_handle, MEDIA_ARTIST, DB_TABLE_ALIAS_MEDIA"."DB_FIELD_MEDIA_ARTIST);
media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
+ ret = _media_filter_attribute_add(g_alias_attr_handle, MEDIA_ALBUM_ARTIST, DB_TABLE_ALIAS_MEDIA"."DB_FIELD_MEDIA_ALBUM_ARTIST);
+ media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
+
ret = _media_filter_attribute_add(g_alias_attr_handle, MEDIA_GENRE, DB_TABLE_ALIAS_MEDIA"."DB_FIELD_MEDIA_GENRE);
media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
ret = _media_filter_attribute_add(g_alias_attr_handle, MEDIA_BITRATE, DB_TABLE_ALIAS_MEDIA"."DB_FIELD_MEDIA_BITRATE);
media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
+ ret = _media_filter_attribute_add(g_alias_attr_handle, MEDIA_BITPERSAMPLE, DB_TABLE_ALIAS_MEDIA"."DB_FIELD_MEDIA_BITPERSAMPLE);
+ media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
+
ret = _media_filter_attribute_add(g_alias_attr_handle, MEDIA_SAMPLERATE, DB_TABLE_ALIAS_MEDIA"."DB_FIELD_MEDIA_SAMPLERATE);
media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
ret = _media_filter_attribute_add(g_alias_attr_handle, MEDIA_AGE_RATING, DB_TABLE_ALIAS_MEDIA"."DB_FIELD_MEDIA_AGE_RATING);
media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
- ret = _media_filter_attribute_add(g_alias_attr_handle, MEDIA_KEYWORD, DB_TABLE_ALIAS_MEDIA"."MEDIA_KEYWORD);
+ ret = _media_filter_attribute_add(g_alias_attr_handle, MEDIA_KEYWORD, DB_TABLE_ALIAS_MEDIA"."DB_FIELD_MEDIA_KEYWORD);
+ media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
+
+ ret = _media_filter_attribute_add(g_alias_attr_handle, MEDIA_WEATHER, DB_TABLE_ALIAS_MEDIA"."DB_FIELD_MEDIA_WEATHER);
media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
ret = _media_filter_attribute_add(g_alias_attr_handle, MEDIA_IS_DRM, DB_TABLE_ALIAS_MEDIA"."DB_FIELD_MEDIA_IS_DRM);
ret = _media_filter_attribute_add(g_alias_attr_handle, MEDIA_STORAGE_TYPE, DB_TABLE_ALIAS_MEDIA"."DB_FIELD_MEDIA_STORAGE_TYPE);
media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
+ /* Pinyin*/
+ ret = _media_filter_attribute_add(g_alias_attr_handle, MEDIA_FILE_NAME_PINYIN, DB_TABLE_ALIAS_MEDIA"."DB_FIELD_MEDIA_FILE_NAME_PINYIN);
+ media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
+
+ ret = _media_filter_attribute_add(g_alias_attr_handle, MEDIA_TITLE_PINYIN, DB_TABLE_ALIAS_MEDIA"."DB_FIELD_MEDIA_TITLE_PINYIN);
+ media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
+
+ ret = _media_filter_attribute_add(g_alias_attr_handle, MEDIA_ALBUM_PINYIN, DB_TABLE_ALIAS_MEDIA"."DB_FIELD_MEDIA_ALBUM_PINYIN);
+ media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
+
+ ret = _media_filter_attribute_add(g_alias_attr_handle, MEDIA_ARTIST_PINYIN, DB_TABLE_ALIAS_MEDIA"."DB_FIELD_MEDIA_ARTIST_PINYIN);
+ media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
+
+ ret = _media_filter_attribute_add(g_alias_attr_handle, MEDIA_ALBUM_ARTIST_PINYIN, DB_TABLE_ALIAS_MEDIA"."DB_FIELD_MEDIA_ALBUM_ARTIST_PINYIN);
+ media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
+
+ ret = _media_filter_attribute_add(g_alias_attr_handle, MEDIA_GENRE_PINYIN, DB_TABLE_ALIAS_MEDIA"."DB_FIELD_MEDIA_GENRE_PINYIN);
+ media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
+
+ ret = _media_filter_attribute_add(g_alias_attr_handle, MEDIA_COMPOSER_PINYIN, DB_TABLE_ALIAS_MEDIA"."DB_FIELD_MEDIA_COMPOSER_PINYIN);
+ media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
+
+ ret = _media_filter_attribute_add(g_alias_attr_handle, MEDIA_COPYRIGHT_PINYIN, DB_TABLE_ALIAS_MEDIA"."DB_FIELD_MEDIA_COPYRIGHT_PINYIN);
+ media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
+
+ ret = _media_filter_attribute_add(g_alias_attr_handle, MEDIA_DESCRIPTION_PINYIN, DB_TABLE_ALIAS_MEDIA"."DB_FIELD_MEDIA_DESCRIPTION_PINYIN);
+ media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
+
+ ret = _media_filter_attribute_add(g_alias_attr_handle, MEDIA_AUTHOR_PINYIN, DB_TABLE_ALIAS_MEDIA"."DB_FIELD_MEDIA_AUTHOR_PINYIN);
+ media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
+
+ ret = _media_filter_attribute_add(g_alias_attr_handle, MEDIA_PROVIDER_PINYIN, DB_TABLE_ALIAS_MEDIA"."DB_FIELD_MEDIA_PROVIDER_PINYIN);
+ media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
+
+ ret = _media_filter_attribute_add(g_alias_attr_handle, MEDIA_CONTENT_NAME_PINYIN, DB_TABLE_ALIAS_MEDIA"."DB_FIELD_MEDIA_CONTENT_NAME_PINYIN);
+ media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
+
+ ret = _media_filter_attribute_add(g_alias_attr_handle, MEDIA_CATEGORY_PINYIN, DB_TABLE_ALIAS_MEDIA"."DB_FIELD_MEDIA_CATEGORY_PINYIN);
+ media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
+
+ ret = _media_filter_attribute_add(g_alias_attr_handle, MEDIA_LOCATION_TAG_PINYIN, DB_TABLE_ALIAS_MEDIA"."DB_FIELD_MEDIA_LOCATION_TAG_PINYIN);
+ media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
+
+ ret = _media_filter_attribute_add(g_alias_attr_handle, MEDIA_AGE_RATING_PINYIN, DB_TABLE_ALIAS_MEDIA"."DB_FIELD_MEDIA_AGE_RATING_PINYIN);
+ media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
+
+ ret = _media_filter_attribute_add(g_alias_attr_handle, MEDIA_KEYWORD_PINYIN, DB_TABLE_ALIAS_MEDIA"."DB_FIELD_MEDIA_KEYWORD_PINYIN);
+ media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
+
/* Folder */
ret = _media_filter_attribute_add(g_alias_attr_handle, FOLDER_ID, DB_TABLE_ALIAS_FOLDER"."DB_FIELD_FOLDER_ID);
media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
ret = _media_filter_attribute_add(g_alias_attr_handle, FOLDER_STORAGE_TYPE, DB_TABLE_ALIAS_FOLDER"."DB_FIELD_FOLDER_STORAGE_TYPE);
media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
+ 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);
+
/* 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);
return;
}
+static int __media_content_check_dir(const char *path)
+{
+ DIR *dp = NULL;
+
+ dp = opendir(path);
+ if (dp == NULL) {
+ media_content_error("error [%s, %s]", path, strerror(errno));
+ if (errno == EACCES || errno == EPERM) {
+ return MEDIA_CONTENT_ERROR_PERMISSION_DENIED;
+ } else {
+ return MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
+ }
+ }
+
+ closedir(dp);
+
+ 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;
+ bool ignore_dir = FALSE;
if (!STRING_VALID(path)) {
media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
return MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
}
+ ret = _media_util_check_ignore_dir(path, &ignore_dir);
+ if(ignore_dir) {
+ media_content_error("Invalid folder path");
+ return MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
+ }
+
+ ret = __media_content_check_dir(path);
+ 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) {
return DB_FIELD_MEDIA_TITLE;
case MEDIA_CONTENT_GROUP_ARTIST:
return DB_FIELD_MEDIA_ARTIST;
+ case MEDIA_CONTENT_GROUP_ALBUM_ARTIST:
+ return DB_FIELD_MEDIA_ALBUM_ARTIST;
case MEDIA_CONTENT_GROUP_GENRE:
return DB_FIELD_MEDIA_GENRE;
case MEDIA_CONTENT_GROUP_COMPOSER:
return DB_FIELD_MEDIA_AGE_RATING;
case MEDIA_CONTENT_GROUP_KEYWORD:
return DB_FIELD_MEDIA_KEYWORD;
+ case MEDIA_CONTENT_GROUP_WEATHER:
+ return DB_FIELD_MEDIA_WEATHER;
default:
return NULL;
}
{
media_folder_s *_folder = (media_folder_s*)folder;
char *return_sql = NULL;
+ char *name_pinyin = NULL;
+ bool pinyin_support = FALSE;
- return_sql = sqlite3_mprintf("%q='%q', %q='%q', %q=%d ",
+ /*Update Pinyin If Support Pinyin*/
+ media_svc_check_pinyin_support(&pinyin_support);
+ if(pinyin_support)
+ media_svc_get_pinyin(_content_get_db_handle(), _folder->name, &name_pinyin);
+
+ return_sql = sqlite3_mprintf("%q='%q', %q='%q', %q=%d, %q='%q'",
DB_FIELD_FOLDER_PATH, _folder->path,
DB_FIELD_FOLDER_NAME, _folder->name,
- DB_FIELD_FOLDER_MODIFIED_TIME, _folder->modified_time);
+ DB_FIELD_FOLDER_MODIFIED_TIME, _folder->modified_time,
+ DB_FIELD_FOLDER_NAME_PINYIN, name_pinyin);
+ SAFE_FREE(name_pinyin);
return return_sql;
}
SAFE_FREE(_folder->path);
SAFE_FREE(_folder->name);
+ SAFE_FREE(folder_path);
_folder->path = strdup(new_folder_path);
if(_folder->path == NULL)
SAFE_FREE(_image->media_id);
SAFE_FREE(_image->date_taken);
SAFE_FREE(_image->title);
+ SAFE_FREE(_image->weather);
SAFE_FREE(_image->burst_id);
SAFE_FREE(_image);
}
}
+ if(STRING_VALID(_src->weather))
+ {
+ _dst->weather = strdup(_src->weather);
+ if(_dst->weather == NULL)
+ {
+ media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
+ image_meta_destroy((image_meta_h)_dst);
+ return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
+ }
+ }
+
if(STRING_VALID(_src->burst_id))
{
_dst->burst_id = strdup(_src->burst_id);
return ret;
}
+
int image_meta_set_orientation(image_meta_h image, media_content_orientation_e orientation)
{
int ret = MEDIA_CONTENT_ERROR_NONE;
if(_image != NULL && STRING_VALID(_image->media_id))
{
- sql = sqlite3_mprintf(UPDATE_IMAGE_META_FROM_MEDIA, _image->orientation, _image->media_id);
+ sql = sqlite3_mprintf(UPDATE_IMAGE_META_FROM_MEDIA, _image->orientation, _image->weather, _image->media_id);
ret = _content_query_sql(sql);
sqlite3_free(sql);
}
return true;
}
+
+typedef enum {
+ MEDIA_INFO_UUID = 0,
+ MEDIA_INFO_PATH,
+ MEDIA_INFO_FILE_NAME,
+ MEDIA_INFO_TYPE,
+ MEDIA_INFO_MIME_TYPE,
+ MEDIA_INFO_SIZE,
+ MEDIA_INFO_ADDED_TIME,
+ MEDIA_INFO_MODIFIED_TIME,
+ MEDIA_INFO_THUMBNAIL_PATH,
+ MEDIA_INFO_DESCRIPTION,
+ MEDIA_INFO_RATING, //10
+ MEDIA_INFO_FAVOURITE,
+ MEDIA_INFO_AUTHOR,
+ MEDIA_INFO_PROVIDER,
+ MEDIA_INFO_CONTENT_NAME,
+ MEDIA_INFO_CATEGORY,
+ MEDIA_INFO_LOCATION_TAG,
+ MEDIA_INFO_AGE_RATING,
+ MEDIA_INFO_KEYWORD,
+ MEDIA_INFO_IS_DRM,
+ MEDIA_INFO_STORAGE_TYPE, //20
+ MEDIA_INFO_LONGITUDE,
+ MEDIA_INFO_LATITUDE,
+ MEDIA_INFO_ALTITUDE,
+ MEDIA_INFO_WIDTH,
+ MEDIA_INFO_HEIGHT,
+ MEDIA_INFO_DATETAKEN,
+ MEDIA_INFO_ORIENTATION,
+ MEDIA_INFO_TITLE,
+ MEDIA_INFO_ALBUM,
+ MEDIA_INFO_ARTIST, //30
+ MEDIA_INFO_ALBUM_ARTIST,
+ MEDIA_INFO_GENRE,
+ MEDIA_INFO_COMPOSER,
+ MEDIA_INFO_YEAR,
+ MEDIA_INFO_RECORDED_DATE,
+ MEDIA_INFO_COPYRIGHT,
+ MEDIA_INFO_TRACK_NUM,
+ MEDIA_INFO_BITRATE,
+ MEDIA_INFO_BITPERSAMPLE,
+ MEDIA_INFO_DURATION,
+ MEDIA_INFO_PLAYED_COUNT, //40
+ MEDIA_INFO_LAST_PLAYED_TIME,
+ MEDIA_INFO_LAST_PLAYED_POSITION,
+ MEDIA_INFO_SAMPLERATE,
+ MEDIA_INFO_CHANNEL,
+ MEDIA_INFO_BURST_ID,
+ MEDIA_INFO_TIMELINE,
+ MEDIA_INFO_WEATHER,
+ MEDIA_INFO_SYNC_STATUS,
+ MEDIA_INFO_ITEM_MAX,
+} media_info_item_e;
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,
media_info_s *_media = (media_info_s*)media;
- if(STRING_VALID((const char *)sqlite3_column_text(stmt, 0)))
- _media->media_id = strdup((const char *)sqlite3_column_text(stmt, 0));
+ if(STRING_VALID((const char *)sqlite3_column_text(stmt, MEDIA_INFO_UUID)))
+ _media->media_id = strdup((const char *)sqlite3_column_text(stmt, MEDIA_INFO_UUID));
+
+ if(STRING_VALID((const char *)sqlite3_column_text(stmt, MEDIA_INFO_PATH)))
+ _media->file_path = strdup((const char *)sqlite3_column_text(stmt, MEDIA_INFO_PATH));
+
+ if(STRING_VALID((const char *)sqlite3_column_text(stmt, MEDIA_INFO_FILE_NAME)))
+ _media->display_name = strdup((const char *)sqlite3_column_text(stmt, MEDIA_INFO_FILE_NAME));
+
+ _media->media_type = (int)sqlite3_column_int(stmt, MEDIA_INFO_TYPE);
- if(STRING_VALID((const char *)sqlite3_column_text(stmt, 1)))
- _media->file_path = strdup((const char *)sqlite3_column_text(stmt, 1));
+ if(STRING_VALID((const char *)sqlite3_column_text(stmt, MEDIA_INFO_MIME_TYPE)))
+ _media->mime_type = strdup((const char *)sqlite3_column_text(stmt, MEDIA_INFO_MIME_TYPE));
- if(STRING_VALID((const char *)sqlite3_column_text(stmt, 2)))
- _media->display_name = strdup((const char *)sqlite3_column_text(stmt, 2));
+ _media->size = (unsigned long long)sqlite3_column_int64(stmt, MEDIA_INFO_SIZE);
- _media->media_type = (int)sqlite3_column_int(stmt, 3);
+ _media->added_time = (int)sqlite3_column_int(stmt, MEDIA_INFO_ADDED_TIME);
- if(STRING_VALID((const char *)sqlite3_column_text(stmt, 4)))
- _media->mime_type = strdup((const char *)sqlite3_column_text(stmt, 4));
+ _media->modified_time = (int)sqlite3_column_int(stmt, MEDIA_INFO_MODIFIED_TIME);
- _media->size = (unsigned long long)sqlite3_column_int64(stmt, 5);
+ if(STRING_VALID((const char *)sqlite3_column_text(stmt, MEDIA_INFO_THUMBNAIL_PATH)))
+ _media->thumbnail_path= strdup((const char *)sqlite3_column_text(stmt, MEDIA_INFO_THUMBNAIL_PATH));
- _media->added_time = (int)sqlite3_column_int(stmt, 6);
+ if(STRING_VALID((const char *)sqlite3_column_text(stmt, MEDIA_INFO_DESCRIPTION)))
+ _media->description = strdup((const char *)sqlite3_column_text(stmt, MEDIA_INFO_DESCRIPTION));
- _media->modified_time = (int)sqlite3_column_int(stmt, 7);
+ _media->rating = (int)sqlite3_column_int(stmt, MEDIA_INFO_RATING);
- if(STRING_VALID((const char *)sqlite3_column_text(stmt, 8)))
- _media->thumbnail_path= strdup((const char *)sqlite3_column_text(stmt, 8));
+ _media->favourite = (int)sqlite3_column_int(stmt, MEDIA_INFO_FAVOURITE);
- if(STRING_VALID((const char *)sqlite3_column_text(stmt, 9)))
- _media->description = strdup((const char *)sqlite3_column_text(stmt, 9));
+ if(STRING_VALID((const char *)sqlite3_column_text(stmt, MEDIA_INFO_AUTHOR)))
+ _media->author = strdup((const char *)sqlite3_column_text(stmt, MEDIA_INFO_AUTHOR));
- _media->rating = (int)sqlite3_column_int(stmt,10);
+ if(STRING_VALID((const char *)sqlite3_column_text(stmt, MEDIA_INFO_PROVIDER)))
+ _media->provider = strdup((const char *)sqlite3_column_text(stmt, MEDIA_INFO_PROVIDER));
- _media->favourite = (int)sqlite3_column_int(stmt, 11);
+ if(STRING_VALID((const char *)sqlite3_column_text(stmt, MEDIA_INFO_CONTENT_NAME)))
+ _media->content_name = strdup((const char *)sqlite3_column_text(stmt, MEDIA_INFO_CONTENT_NAME));
- if(STRING_VALID((const char *)sqlite3_column_text(stmt, 12)))
- _media->author = strdup((const char *)sqlite3_column_text(stmt, 12));
+ if(STRING_VALID((const char *)sqlite3_column_text(stmt, MEDIA_INFO_CATEGORY)))
+ _media->category = strdup((const char *)sqlite3_column_text(stmt, MEDIA_INFO_CATEGORY));
- if(STRING_VALID((const char *)sqlite3_column_text(stmt, 13)))
- _media->provider = strdup((const char *)sqlite3_column_text(stmt, 13));
+ if(STRING_VALID((const char *)sqlite3_column_text(stmt, MEDIA_INFO_LOCATION_TAG)))
+ _media->location_tag = strdup((const char *)sqlite3_column_text(stmt, MEDIA_INFO_LOCATION_TAG));
- if(STRING_VALID((const char *)sqlite3_column_text(stmt, 14)))
- _media->content_name = strdup((const char *)sqlite3_column_text(stmt, 14));
+ if(STRING_VALID((const char *)sqlite3_column_text(stmt, MEDIA_INFO_AGE_RATING)))
+ _media->age_rating = strdup((const char *)sqlite3_column_text(stmt, MEDIA_INFO_AGE_RATING));
- if(STRING_VALID((const char *)sqlite3_column_text(stmt, 15)))
- _media->category = strdup((const char *)sqlite3_column_text(stmt, 15));
+ if(STRING_VALID((const char *)sqlite3_column_text(stmt, MEDIA_INFO_KEYWORD)))
+ _media->keyword = strdup((const char *)sqlite3_column_text(stmt, MEDIA_INFO_KEYWORD));
- if(STRING_VALID((const char *)sqlite3_column_text(stmt, 16)))
- _media->location_tag = strdup((const char *)sqlite3_column_text(stmt, 16));
+ _media->is_drm = (int)sqlite3_column_int(stmt, MEDIA_INFO_IS_DRM);
- if(STRING_VALID((const char *)sqlite3_column_text(stmt, 17)))
- _media->age_rating = strdup((const char *)sqlite3_column_text(stmt, 17));
+ _media->storage_type = (int)sqlite3_column_int(stmt, MEDIA_INFO_STORAGE_TYPE);
- if(STRING_VALID((const char *)sqlite3_column_text(stmt, 18)))
- _media->keyword = strdup((const char *)sqlite3_column_text(stmt, 18));
+ _media->longitude = (double)sqlite3_column_double(stmt, MEDIA_INFO_LONGITUDE);
+ _media->latitude = (double)sqlite3_column_double(stmt, MEDIA_INFO_LATITUDE);
+ _media->altitude = (double)sqlite3_column_double(stmt, MEDIA_INFO_ALTITUDE);
- _media->is_drm = (int)sqlite3_column_int(stmt, 19);
+ if(STRING_VALID((const char *)sqlite3_column_text(stmt, MEDIA_INFO_TITLE)))
+ _media->title = strdup((const char *)sqlite3_column_text(stmt, MEDIA_INFO_TITLE));
- _media->storage_type = (int)sqlite3_column_int(stmt, 20);
+ _media->timeline = (double)sqlite3_column_double(stmt, MEDIA_INFO_TIMELINE);
- _media->longitude = (double)sqlite3_column_double(stmt, 21);
- _media->latitude = (double)sqlite3_column_double(stmt, 22);
- _media->altitude = (double)sqlite3_column_double(stmt, 23);
+ if(STRING_VALID((const char *)sqlite3_column_text(stmt, MEDIA_INFO_WEATHER)))
+ _media->weather = strdup((const char *)sqlite3_column_text(stmt, MEDIA_INFO_WEATHER));
+
+ _media->sync_status = (int)sqlite3_column_int(stmt, MEDIA_INFO_SYNC_STATUS);
- if(STRING_VALID((const char *)sqlite3_column_text(stmt, 28)))
- _media->title = strdup((const char *)sqlite3_column_text(stmt, 28));
if(_media->media_type == MEDIA_CONTENT_TYPE_IMAGE) {
_media->image_meta = (image_meta_s *)calloc(1, sizeof(image_meta_s));
if(STRING_VALID(_media->media_id))
_media->image_meta->media_id = strdup(_media->media_id);
- _media->image_meta->width = sqlite3_column_int(stmt, 24);
- _media->image_meta->height = sqlite3_column_int(stmt, 25);
+ _media->image_meta->width = sqlite3_column_int(stmt, MEDIA_INFO_WIDTH);
+ _media->image_meta->height = sqlite3_column_int(stmt, MEDIA_INFO_HEIGHT);
- if(STRING_VALID((const char *)sqlite3_column_text(stmt, 26)))
- _media->image_meta->date_taken = strdup((const char *)sqlite3_column_text(stmt, 26));
-
- _media->image_meta->orientation = sqlite3_column_int(stmt, 27);
+ if(STRING_VALID((const char *)sqlite3_column_text(stmt, MEDIA_INFO_DATETAKEN)))
+ _media->image_meta->date_taken = strdup((const char *)sqlite3_column_text(stmt, MEDIA_INFO_DATETAKEN));
+
+ _media->image_meta->orientation = sqlite3_column_int(stmt, MEDIA_INFO_ORIENTATION);
- if(STRING_VALID((const char *)sqlite3_column_text(stmt, 28)))
- _media->image_meta->title = strdup((const char *)sqlite3_column_text(stmt, 28));
+ if(STRING_VALID((const char *)sqlite3_column_text(stmt, MEDIA_INFO_TITLE)))
+ _media->image_meta->title = strdup((const char *)sqlite3_column_text(stmt, MEDIA_INFO_TITLE));
- if(STRING_VALID((const char *)sqlite3_column_text(stmt, 44)))
- _media->image_meta->burst_id = strdup((const char *)sqlite3_column_text(stmt, 44));
+ if(STRING_VALID((const char *)sqlite3_column_text(stmt, MEDIA_INFO_BURST_ID)))
+ _media->image_meta->burst_id = strdup((const char *)sqlite3_column_text(stmt, MEDIA_INFO_BURST_ID));
+
+ if(STRING_VALID((const char *)sqlite3_column_text(stmt, MEDIA_INFO_WEATHER)))
+ _media->image_meta->weather = strdup((const char *)sqlite3_column_text(stmt, MEDIA_INFO_WEATHER));
}
} else if(_media->media_type == MEDIA_CONTENT_TYPE_VIDEO) {
if(STRING_VALID(_media->media_id))
_media->video_meta->media_id = strdup(_media->media_id);
- if(STRING_VALID((const char *)sqlite3_column_text(stmt, 28)))
- _media->video_meta->title = strdup((const char *)sqlite3_column_text(stmt, 28));
+ _media->video_meta->width = sqlite3_column_int(stmt, MEDIA_INFO_WIDTH);
+ _media->video_meta->height = sqlite3_column_int(stmt, MEDIA_INFO_HEIGHT);
+
+ if(STRING_VALID((const char *)sqlite3_column_text(stmt, MEDIA_INFO_TITLE)))
+ _media->video_meta->title = strdup((const char *)sqlite3_column_text(stmt, MEDIA_INFO_TITLE));
- if(STRING_VALID((const char *)sqlite3_column_text(stmt, 29)))
- _media->video_meta->album = strdup((const char *)sqlite3_column_text(stmt, 29));
+ if(STRING_VALID((const char *)sqlite3_column_text(stmt, MEDIA_INFO_ALBUM)))
+ _media->video_meta->album = strdup((const char *)sqlite3_column_text(stmt, MEDIA_INFO_ALBUM));
- if(STRING_VALID((const char *)sqlite3_column_text(stmt, 30)))
- _media->video_meta->artist = strdup((const char *)sqlite3_column_text(stmt, 30));
+ if(STRING_VALID((const char *)sqlite3_column_text(stmt, MEDIA_INFO_ARTIST)))
+ _media->video_meta->artist = strdup((const char *)sqlite3_column_text(stmt, MEDIA_INFO_ARTIST));
- if(STRING_VALID((const char *)sqlite3_column_text(stmt, 31)))
- _media->video_meta->genre = strdup((const char *)sqlite3_column_text(stmt, 31));
+ if(STRING_VALID((const char *)sqlite3_column_text(stmt, MEDIA_INFO_ALBUM_ARTIST)))
+ _media->video_meta->album_artist = strdup((const char *)sqlite3_column_text(stmt, MEDIA_INFO_ALBUM_ARTIST));
- if(STRING_VALID((const char *)sqlite3_column_text(stmt, 32)))
- _media->video_meta->composer = strdup((const char *)sqlite3_column_text(stmt, 32));
+ if(STRING_VALID((const char *)sqlite3_column_text(stmt, MEDIA_INFO_GENRE)))
+ _media->video_meta->genre = strdup((const char *)sqlite3_column_text(stmt, MEDIA_INFO_GENRE));
- if(STRING_VALID((const char *)sqlite3_column_text(stmt, 33)))
- _media->video_meta->year = strdup((const char *)sqlite3_column_text(stmt, 33));
+ if(STRING_VALID((const char *)sqlite3_column_text(stmt, MEDIA_INFO_COMPOSER)))
+ _media->video_meta->composer = strdup((const char *)sqlite3_column_text(stmt, MEDIA_INFO_COMPOSER));
- if(STRING_VALID((const char *)sqlite3_column_text(stmt, 34)))
- _media->video_meta->recorded_date = strdup((const char *)sqlite3_column_text(stmt, 34));
+ if(STRING_VALID((const char *)sqlite3_column_text(stmt, MEDIA_INFO_YEAR)))
+ _media->video_meta->year = strdup((const char *)sqlite3_column_text(stmt, MEDIA_INFO_YEAR));
- if(STRING_VALID((const char *)sqlite3_column_text(stmt, 35)))
- _media->video_meta->copyright = strdup((const char *)sqlite3_column_text(stmt, 35));
+ if(STRING_VALID((const char *)sqlite3_column_text(stmt, MEDIA_INFO_RECORDED_DATE)))
+ _media->video_meta->recorded_date = strdup((const char *)sqlite3_column_text(stmt, MEDIA_INFO_RECORDED_DATE));
- if(STRING_VALID((const char *)sqlite3_column_text(stmt, 36)))
- _media->video_meta->track_num = strdup((const char *)sqlite3_column_text(stmt, 36));
+ if(STRING_VALID((const char *)sqlite3_column_text(stmt, MEDIA_INFO_COPYRIGHT)))
+ _media->video_meta->copyright = strdup((const char *)sqlite3_column_text(stmt, MEDIA_INFO_COPYRIGHT));
- _media->video_meta->bitrate = sqlite3_column_int(stmt, 37);
- _media->video_meta->duration = sqlite3_column_int(stmt, 38);
- _media->video_meta->played_count = sqlite3_column_int(stmt, 39);
- _media->video_meta->played_time = sqlite3_column_int(stmt, 40);
- _media->video_meta->played_position = sqlite3_column_int(stmt, 41);
- _media->video_meta->width = sqlite3_column_int(stmt, 24);
- _media->video_meta->height = sqlite3_column_int(stmt, 25);
+ if(STRING_VALID((const char *)sqlite3_column_text(stmt, MEDIA_INFO_TRACK_NUM)))
+ _media->video_meta->track_num = strdup((const char *)sqlite3_column_text(stmt, MEDIA_INFO_TRACK_NUM));
+
+ _media->video_meta->bitrate = sqlite3_column_int(stmt, MEDIA_INFO_BITRATE);
+ _media->video_meta->duration = sqlite3_column_int(stmt, MEDIA_INFO_DURATION);
+ _media->video_meta->played_count = sqlite3_column_int(stmt, MEDIA_INFO_PLAYED_COUNT);
+ _media->video_meta->played_time = sqlite3_column_int(stmt, MEDIA_INFO_LAST_PLAYED_TIME);
+ _media->video_meta->played_position = sqlite3_column_int(stmt, MEDIA_INFO_LAST_PLAYED_POSITION);
}
}
if(STRING_VALID(_media->media_id))
_media->audio_meta->media_id = strdup(_media->media_id);
- if(STRING_VALID((const char *)sqlite3_column_text(stmt, 28)))
- _media->audio_meta->title = strdup((const char *)sqlite3_column_text(stmt, 28));
+ if(STRING_VALID((const char *)sqlite3_column_text(stmt, MEDIA_INFO_TITLE)))
+ _media->audio_meta->title = strdup((const char *)sqlite3_column_text(stmt, MEDIA_INFO_TITLE));
+
+ if(STRING_VALID((const char *)sqlite3_column_text(stmt, MEDIA_INFO_ALBUM)))
+ _media->audio_meta->album = strdup((const char *)sqlite3_column_text(stmt, MEDIA_INFO_ALBUM));
- if(STRING_VALID((const char *)sqlite3_column_text(stmt, 29)))
- _media->audio_meta->album = strdup((const char *)sqlite3_column_text(stmt, 29));
+ if(STRING_VALID((const char *)sqlite3_column_text(stmt, MEDIA_INFO_ARTIST)))
+ _media->audio_meta->artist = strdup((const char *)sqlite3_column_text(stmt, MEDIA_INFO_ARTIST));
- if(STRING_VALID((const char *)sqlite3_column_text(stmt, 30)))
- _media->audio_meta->artist = strdup((const char *)sqlite3_column_text(stmt, 30));
+ if(STRING_VALID((const char *)sqlite3_column_text(stmt, MEDIA_INFO_ALBUM_ARTIST)))
+ _media->audio_meta->album_artist = strdup((const char *)sqlite3_column_text(stmt, MEDIA_INFO_ALBUM_ARTIST));
- if(STRING_VALID((const char *)sqlite3_column_text(stmt, 31)))
- _media->audio_meta->genre = strdup((const char *)sqlite3_column_text(stmt, 31));
+ if(STRING_VALID((const char *)sqlite3_column_text(stmt, MEDIA_INFO_GENRE)))
+ _media->audio_meta->genre = strdup((const char *)sqlite3_column_text(stmt, MEDIA_INFO_GENRE));
- if(STRING_VALID((const char *)sqlite3_column_text(stmt, 32)))
- _media->audio_meta->composer = strdup((const char *)sqlite3_column_text(stmt, 32));
+ if(STRING_VALID((const char *)sqlite3_column_text(stmt, MEDIA_INFO_COMPOSER)))
+ _media->audio_meta->composer = strdup((const char *)sqlite3_column_text(stmt, MEDIA_INFO_COMPOSER));
- if(STRING_VALID((const char *)sqlite3_column_text(stmt, 33)))
- _media->audio_meta->year = strdup((const char *)sqlite3_column_text(stmt, 33));
+ if(STRING_VALID((const char *)sqlite3_column_text(stmt, MEDIA_INFO_YEAR)))
+ _media->audio_meta->year = strdup((const char *)sqlite3_column_text(stmt, MEDIA_INFO_YEAR));
- if(STRING_VALID((const char *)sqlite3_column_text(stmt, 34)))
- _media->audio_meta->recorded_date = strdup((const char *)sqlite3_column_text(stmt, 34));
+ if(STRING_VALID((const char *)sqlite3_column_text(stmt, MEDIA_INFO_RECORDED_DATE)))
+ _media->audio_meta->recorded_date = strdup((const char *)sqlite3_column_text(stmt, MEDIA_INFO_RECORDED_DATE));
- if(STRING_VALID((const char *)sqlite3_column_text(stmt, 35)))
- _media->audio_meta->copyright = strdup((const char *)sqlite3_column_text(stmt, 35));
+ if(STRING_VALID((const char *)sqlite3_column_text(stmt, MEDIA_INFO_COPYRIGHT)))
+ _media->audio_meta->copyright = strdup((const char *)sqlite3_column_text(stmt, MEDIA_INFO_COPYRIGHT));
- if(STRING_VALID((const char *)sqlite3_column_text(stmt, 36)))
- _media->audio_meta->track_num = strdup((const char *)sqlite3_column_text(stmt, 36));
+ if(STRING_VALID((const char *)sqlite3_column_text(stmt, MEDIA_INFO_TRACK_NUM)))
+ _media->audio_meta->track_num = strdup((const char *)sqlite3_column_text(stmt, MEDIA_INFO_TRACK_NUM));
- _media->audio_meta->bitrate = sqlite3_column_int(stmt, 37);
- _media->audio_meta->duration = sqlite3_column_int(stmt, 38);
- _media->audio_meta->played_count = sqlite3_column_int(stmt, 39);
- _media->audio_meta->played_time = sqlite3_column_int(stmt, 40);
- _media->audio_meta->played_position = sqlite3_column_int(stmt, 41);
- _media->audio_meta->samplerate = sqlite3_column_int(stmt, 42);
- _media->audio_meta->channel = sqlite3_column_int(stmt, 43);
+ _media->audio_meta->bitrate = sqlite3_column_int(stmt, MEDIA_INFO_BITRATE);
+ _media->audio_meta->bitpersample = sqlite3_column_int(stmt, MEDIA_INFO_BITPERSAMPLE);
+ _media->audio_meta->duration = sqlite3_column_int(stmt, MEDIA_INFO_DURATION);
+ _media->audio_meta->played_count = sqlite3_column_int(stmt, MEDIA_INFO_PLAYED_COUNT);
+ _media->audio_meta->played_time = sqlite3_column_int(stmt, MEDIA_INFO_LAST_PLAYED_TIME);
+ _media->audio_meta->played_position = sqlite3_column_int(stmt, MEDIA_INFO_LAST_PLAYED_POSITION);
+ _media->audio_meta->samplerate = sqlite3_column_int(stmt, MEDIA_INFO_SAMPLERATE);
+ _media->audio_meta->channel = sqlite3_column_int(stmt, MEDIA_INFO_CHANNEL);
}
}
SAFE_FREE(_media->age_rating);
SAFE_FREE(_media->keyword);
SAFE_FREE(_media->title);
+ SAFE_FREE(_media->weather);
if(_media->image_meta) {
SAFE_FREE(_media->image_meta->media_id);
SAFE_FREE(_media->image_meta->date_taken);
SAFE_FREE(_media->image_meta->burst_id);
+ SAFE_FREE(_media->image_meta->title);
+ SAFE_FREE(_media->image_meta->weather);
SAFE_FREE(_media->image_meta);
} else if(_media->video_meta) {
SAFE_FREE(_media->video_meta->title);
SAFE_FREE(_media->video_meta->album);
SAFE_FREE(_media->video_meta->artist);
+ SAFE_FREE(_media->video_meta->album_artist);
SAFE_FREE(_media->video_meta->genre);
SAFE_FREE(_media->video_meta->composer);
SAFE_FREE(_media->video_meta->year);
SAFE_FREE(_media->audio_meta->title);
SAFE_FREE(_media->audio_meta->album);
SAFE_FREE(_media->audio_meta->artist);
+ SAFE_FREE(_media->audio_meta->album_artist);
SAFE_FREE(_media->audio_meta->genre);
SAFE_FREE(_media->audio_meta->composer);
SAFE_FREE(_media->audio_meta->year);
return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
}
}
+
+ if(STRING_VALID(_src->weather))
+ {
+ _dst->weather = strdup(_src->weather);
+ if(_dst->weather == 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->title))
{
_dst->title = strdup(_src->title);
_dst->size = _src->size;
_dst->added_time = _src->added_time;
_dst->modified_time = _src->modified_time;
+ _dst->timeline = _src->timeline;
_dst->longitude = _src->longitude;
_dst->latitude = _src->latitude;
_dst->altitude = _src->altitude;
_dst->favourite = _src->favourite;
_dst->is_drm = _src->is_drm;
_dst->storage_type = _src->storage_type;
+ _dst->sync_status = _src->sync_status;
if(_src->media_type == MEDIA_CONTENT_TYPE_IMAGE && _src->image_meta) {
_dst->image_meta = (image_meta_s *)calloc(1, sizeof(image_meta_s));
return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
}
}
+
+ if(STRING_VALID(_src->image_meta->weather))
+ {
+ _dst->image_meta->weather = strdup(_src->image_meta->weather);
+ if(_dst->image_meta->weather == 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->image_meta->width = _src->image_meta->width;
_dst->image_meta->height = _src->image_meta->height;
_dst->image_meta->orientation = _src->image_meta->orientation;
_image->burst_id = strdup(_media->image_meta->burst_id);
}
+ if(STRING_VALID(_media->image_meta->weather)) {
+ _image->weather = strdup(_media->image_meta->weather);
+ }
+
*image = (image_meta_h)_image;
return ret;
return ret;
}
+int media_info_get_timeline(media_info_h media, time_t* time)
+{
+ int ret = MEDIA_CONTENT_ERROR_NONE;
+ media_info_s *_media = (media_info_s*)media;
+ if(_media && time)
+ {
+ *time = _media->timeline;
+ 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_get_thumbnail_path(media_info_h media, char **path)
{
int ret = MEDIA_CONTENT_ERROR_NONE;
return ret;
}
+int media_info_get_weather(media_info_h media, char **weather)
+{
+ int ret = MEDIA_CONTENT_ERROR_NONE;
+ media_info_s *_media = (media_info_s*)media;
+
+ if(_media && weather)
+ {
+ if(STRING_VALID(_media->weather))
+ {
+ *weather = strdup(_media->weather);
+ if(*weather == NULL)
+ {
+ media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
+ return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
+ }
+ }
+ else
+ {
+ *weather = 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_get_rating(media_info_h media, int *rating)
{
int ret = MEDIA_CONTENT_ERROR_NONE;
return ret;
}
+int media_info_set_weather(media_info_h media, const char *weather)
+{
+ int ret = MEDIA_CONTENT_ERROR_NONE;
+ media_info_s *_media = (media_info_s*)media;
+
+ if(_media != NULL)
+ {
+ SAFE_FREE(_media->weather);
+
+ if(STRING_VALID(weather))
+ {
+ _media->weather = strdup(weather);
+
+ if(_media->weather == NULL)
+ {
+ media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
+ return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
+ }
+ }
+ else
+ {
+ _media->weather = NULL;
+ }
+ }
+ else
+ {
+ media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
+ ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
+ }
+
+ return ret;
+}
+
int media_info_set_rating(media_info_h media, int rating)
{
int ret = MEDIA_CONTENT_ERROR_NONE;
char *test_sql = sqlite3_mprintf("%f, %f, %f", _media->longitude, _media->latitude, _media->altitude);
sqlite3_free(test_sql);
+ /*Update Pinyin If Support Pinyin*/
+ char *file_name_pinyin = NULL;
+ char *description_pinyin = NULL;
+ char *author_pinyin = NULL;
+ char *provider_pinyin = NULL;
+ char *content_name_pinyin = NULL;
+ char *category_pinyin = NULL;
+ char *location_tag_pinyin = NULL;
+ char *age_rating_pinyin = NULL;
+ char *keyword_pinyin = NULL;
+ bool pinyin_support = FALSE;
+
+ /*Update Pinyin If Support Pinyin*/
+ media_svc_check_pinyin_support(&pinyin_support);
+ if(pinyin_support)
+ {
+ if(STRING_VALID(_media->display_name))
+ media_svc_get_pinyin(_content_get_db_handle(), _media->display_name, &file_name_pinyin);
+ if(STRING_VALID(_media->description))
+ media_svc_get_pinyin(_content_get_db_handle(), _media->description, &description_pinyin);
+ if(STRING_VALID(_media->author))
+ media_svc_get_pinyin(_content_get_db_handle(), _media->author, &author_pinyin);
+ if(STRING_VALID(_media->provider))
+ media_svc_get_pinyin(_content_get_db_handle(), _media->provider, &provider_pinyin);
+ if(STRING_VALID(_media->content_name))
+ media_svc_get_pinyin(_content_get_db_handle(), _media->content_name, &content_name_pinyin);
+ if(STRING_VALID(_media->category))
+ media_svc_get_pinyin(_content_get_db_handle(), _media->category, &category_pinyin);
+ if(STRING_VALID(_media->location_tag))
+ media_svc_get_pinyin(_content_get_db_handle(), _media->location_tag, &location_tag_pinyin);
+ if(STRING_VALID(_media->age_rating))
+ media_svc_get_pinyin(_content_get_db_handle(), _media->age_rating, &age_rating_pinyin);
+ if(STRING_VALID(_media->keyword))
+ media_svc_get_pinyin(_content_get_db_handle(), _media->keyword, &keyword_pinyin);
+ }
+
set_sql = sqlite3_mprintf("file_name=%Q, added_time=%d, description=%Q, longitude=%f, latitude=%f, altitude=%f, \
- rating=%d, favourite=%d, author=%Q, provider=%Q, content_name=%Q, category=%Q, location_tag=%Q, age_rating=%Q, keyword=%Q",
+ 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",
_media->display_name, _media->added_time, _media->description, _media->longitude, _media->latitude, _media->altitude, _media->rating, _media->favourite,
- _media->author, _media->provider, _media->content_name, _media->category, _media->location_tag, _media->age_rating, _media->keyword);
+ _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);
len = snprintf(sql, sizeof(sql), "UPDATE %s SET %s WHERE media_uuid='%s'", DB_TABLE_MEDIA, set_sql, _media->media_id);
sqlite3_free(set_sql);
+
+ SAFE_FREE(description_pinyin);
+ SAFE_FREE(author_pinyin);
+ SAFE_FREE(provider_pinyin);
+ SAFE_FREE(content_name_pinyin);
+ SAFE_FREE(category_pinyin);
+ SAFE_FREE(location_tag_pinyin);
+ SAFE_FREE(age_rating_pinyin);
+ SAFE_FREE(keyword_pinyin);
+
if (len > 0) {
sql[len] = '\0';
} else {
return MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
}
+
ret = _content_query_sql(sql);
if (ret == MEDIA_CONTENT_ERROR_NONE) {
/* Send notification for this update */
if(_playlist)
{
SAFE_FREE(_playlist->name);
+ SAFE_FREE(_playlist->thumbnail_path);
SAFE_FREE(_playlist);
ret = MEDIA_CONTENT_ERROR_NONE;
return MEDIA_CONTENT_ERROR_NONE;
}
+
+int _media_util_check_ignore_dir(const char *dir_path, bool *ignore)
+{
+ int ret = MEDIA_CONTENT_ERROR_NONE;
+ media_svc_storage_type_e storage_type = 0;
+ char *scan_ignore = ".scan_ignore";
+ bool find = false;
+
+ media_content_info("dir_path : %s", dir_path);
+
+ if(!STRING_VALID(dir_path))
+ {
+ media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
+ return MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
+ }
+
+ *ignore = FALSE;
+ /*1. Check Hidden Directory*/
+ if(strstr(dir_path, "/."))
+ {
+ *ignore = TRUE;
+ media_content_info("hidden path");
+ return MEDIA_CONTENT_ERROR_NONE;
+ }
+
+ /*2. Check Scan Ignore Directory*/
+ ret = media_svc_get_storage_type(dir_path, &storage_type);
+ if(ret != MEDIA_INFO_ERROR_NONE)
+ {
+ media_content_error("media_svc_get_storage_type failed : %d", ret);
+ return _content_error_capi(MEDIA_CONTENT_TYPE, ret);
+ }
+
+ DIR *dp = NULL;
+ struct dirent entry;
+ struct dirent *result = NULL;
+
+ char *leaf_path = NULL;
+ char search_path[4096] = {0, };
+
+ strncpy(search_path, dir_path, strlen(dir_path));
+ while(STRING_VALID(search_path))
+ {
+ dp = opendir(search_path);
+ if(dp == NULL)
+ {
+ media_content_error("Fail Open Directory");
+ return MEDIA_CONTENT_ERROR_INVALID_OPERATION;
+ }
+
+ while (!readdir_r(dp, &entry, &result))
+ {
+ if (result == NULL)
+ break;
+
+ 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);
+ find = TRUE;
+ break;
+ }
+ else
+ {
+ //media_content_info("entry.d_name[%s]", entry.d_name);
+ continue;
+ }
+ }
+
+ if (dp) closedir(dp);
+ dp = NULL;
+
+ if(find)
+ {
+ *ignore = TRUE;
+ break;
+ }
+ else
+ {
+ /*If root path, Stop Scanning*/
+ if((storage_type == MEDIA_SVC_STORAGE_INTERNAL) && (strcmp(search_path, MEDIA_ROOT_PATH_INTERNAL) == 0))
+ {
+ //media_content_debug("Internal root path. Stop Scanning. Not found Ignore information");
+ break;
+ }
+ else if((storage_type == MEDIA_SVC_STORAGE_EXTERNAL) && (strcmp(search_path, MEDIA_ROOT_PATH_SDCARD) == 0))
+ {
+ //media_content_debug("Enternal root path. Stop Scanning. Not found Ignore information");
+ break;
+ }
+
+ leaf_path = strrchr(search_path, '/');
+ if(leaf_path != NULL)
+ {
+ int seek_len = leaf_path -search_path;
+ search_path[seek_len] = '\0';
+ //media_content_info("go to other dir [%s]", search_path);
+ }
+ else
+ {
+ media_content_debug("Fail to find leaf path");
+ break;
+ }
+ }
+ }
+
+ return MEDIA_CONTENT_ERROR_NONE;
+}
SAFE_FREE(_video->title);
SAFE_FREE(_video->album);
SAFE_FREE(_video->artist);
+ SAFE_FREE(_video->album_artist);
SAFE_FREE(_video->genre);
SAFE_FREE(_video->composer);
SAFE_FREE(_video->year);
}
}
+ if(STRING_VALID(_src->album_artist))
+ {
+ _dst->album_artist = strdup(_src->album_artist);
+ if(_dst->album_artist == NULL)
+ {
+ video_meta_destroy((video_meta_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->genre))
{
_dst->genre = strdup(_src->genre);
}
+int video_meta_get_album_artist(video_meta_h video, char **album_artist)
+{
+ int ret = MEDIA_CONTENT_ERROR_NONE;
+ video_meta_s *_video = (video_meta_s*)video;
+ if(_video)
+ {
+ if(STRING_VALID(_video->album_artist))
+ {
+ char *new_string = strdup(_video->album_artist);
+ if(NULL == new_string)
+ {
+ media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
+ return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
+ }
+ *album_artist = new_string;
+ }
+ else
+ {
+ *album_artist = 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 video_meta_get_genre(video_meta_h video, char **genre)
{
int ret = MEDIA_CONTENT_ERROR_NONE;
#define test_audio_id "0f999626-6218-450c-a4ad-181a3bab6ebf"
#define test_video_id "c1a92494-cc5b-4d74-aa7d-253199234548"
#define test_image_id "db1c184c-6f31-43b4-b924-8c00ac5b6197"
+media_folder_h g_folder = NULL;
bool get_audio_meta(audio_meta_h audio)
{
media_content_debug("artist : [%s]", c_value);
SAFE_FREE(c_value);
+ ret = audio_meta_get_album_artist(audio, &c_value);
+ if(ret != MEDIA_CONTENT_ERROR_NONE)
+ media_content_error("error when get meta : [%d]", ret);
+ media_content_debug("album_artist : [%s]", c_value);
+ SAFE_FREE(c_value);
+
ret = audio_meta_get_genre(audio, &c_value);
if(ret != MEDIA_CONTENT_ERROR_NONE)
media_content_error("error when get meta : [%d]", ret);
media_content_debug("artist : [%s]", c_value);
SAFE_FREE(c_value);
+ ret = video_meta_get_album_artist(video, &c_value);
+ if(ret != MEDIA_CONTENT_ERROR_NONE)
+ media_content_error("error when get meta : [%d]", ret);
+ media_content_debug("album_artist : [%s]", c_value);
+ SAFE_FREE(c_value);
+
ret = video_meta_get_genre(video, &c_value);
if(ret != MEDIA_CONTENT_ERROR_NONE)
media_content_error("error when get meta : [%d]", ret);
media_content_error("error when get info : [%d]", ret);
media_content_debug("media_id : [%s]", media_id);
+ ret = media_info_get_file_path(media, &c_value);
+ if(ret != MEDIA_CONTENT_ERROR_NONE)
+ media_content_error("error when get info : [%d]", ret);
+ media_content_debug("file_path : [%s]", c_value);
+ SAFE_FREE(c_value);
+
#if 1
if(media_type == MEDIA_CONTENT_TYPE_MUSIC)
{
media_content_orientation_e orientation = 0;
bool is_burst_shot = false;
char *burst_id = NULL;
+ char *weather = NULL;
if(media_info_get_image(media, &image) == MEDIA_CONTENT_ERROR_NONE)
{
media_content_error("error when get info : [%d]", ret);
media_content_debug("modified_time : [%d]", t_value);
+ ret = media_info_get_timeline(media, &t_value);
+ if(ret != MEDIA_CONTENT_ERROR_NONE)
+ media_content_error("error when get info : [%d]", ret);
+ media_content_debug("timeline : [%d]", t_value);
+
ret = media_info_get_rating(media, &i_value);
if(ret != MEDIA_CONTENT_ERROR_NONE)
media_content_error("error when get info : [%d]", ret);
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");
+ return ret;
+
+ ret = media_info_get_weather(media, &c_value);
+ if(ret != MEDIA_CONTENT_ERROR_NONE)
+ 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");
if(folder != NULL)
{
- media_folder_clone(_folder, folder);
+ if(_folder != NULL)
+ media_folder_clone(_folder, folder);
if(media_folder_get_folder_id(folder, &folder_id) != MEDIA_CONTENT_ERROR_NONE)
{
}
media_content_debug("album_name : [%s]", album_name);
+ SAFE_FREE(album_name);
if(media_album_get_artist(album, &artist) != MEDIA_CONTENT_ERROR_NONE)
{
}
media_content_debug("artist : [%s]", artist);
+ SAFE_FREE(artist);
if(media_album_get_album_art(album, &album_art) != MEDIA_CONTENT_ERROR_NONE)
{
}
media_content_debug("album_art : [%s]", album_art);
-
- SAFE_FREE(album_name);
- SAFE_FREE(artist);
SAFE_FREE(album_art);
if(media_album_get_media_count_from_db(album_id, filter, &media_count) != MEDIA_CONTENT_ERROR_NONE)
} else if(media_type == MEDIA_CONTENT_TYPE_VIDEO) {
video_meta_h video_handle;
- char *title = NULL, *artist = NULL, *album = NULL;
+ char *title = NULL, *artist = NULL, *album = NULL, *album_artist = NULL;
int duration = 0;
time_t time_played = 0;
ret = video_meta_get_album(video_handle, &album);
if(ret != MEDIA_CONTENT_ERROR_NONE)
media_content_error("error video_meta_get_album : [%d]", ret);
+ ret = video_meta_get_album_artist(video_handle, &album_artist);
+ if(ret != MEDIA_CONTENT_ERROR_NONE)
+ media_content_error("error video_meta_get_album_artist : [%d]", ret);
ret = video_meta_get_duration(video_handle, &duration);
if(ret != MEDIA_CONTENT_ERROR_NONE)
media_content_error("error video_meta_get_duration : [%d]", ret);
media_content_error("error video_meta_get_played_time : [%d]", ret);
media_content_debug("This is Video");
- media_content_debug("Title: %s, Album: %s, Artist: %s\nDuration: %d, Played time: %d", title, artist, album, duration, time_played);
+ media_content_debug("Title: %s, Album: %s, Artist: %s, Album_artist: %s \n Duration: %d, Played time: %d", title, album, artist, album_artist, duration, time_played);
}
SAFE_FREE(title);
SAFE_FREE(artist);
SAFE_FREE(album);
+ SAFE_FREE(album_artist);
ret = video_meta_destroy(video_handle);
if(ret != MEDIA_CONTENT_ERROR_NONE)
} else if(media_type == MEDIA_CONTENT_TYPE_VIDEO) {
video_meta_h video_handle;
- char *title = NULL, *artist = NULL, *album = NULL;
+ char *title = NULL, *artist = NULL, *album = NULL, *album_artist = NULL;;
int duration = 0;
time_t time_played;
ret = video_meta_get_album(video_handle, &album);
if(ret != MEDIA_CONTENT_ERROR_NONE)
media_content_error("error video_meta_get_album : [%d]", ret);
+ ret = video_meta_get_album_artist(video_handle, &album_artist);
+ if(ret != MEDIA_CONTENT_ERROR_NONE)
+ media_content_error("error video_meta_get_album_artist : [%d]", ret);
ret = video_meta_get_duration(video_handle, &duration);
if(ret != MEDIA_CONTENT_ERROR_NONE)
media_content_error("error video_meta_get_duration : [%d]", ret);
media_content_error("error video_meta_get_played_time : [%d]", ret);
media_content_debug("This is Video");
- media_content_debug("Title: %s, Album: %s, Artist: %s\nDuration: %d, Played time: %d\n", title, artist, album, duration, time_played);
+ media_content_debug("Title: %s, Album: %s, Artist: %s, Album_artist: %s \n Duration: %d, Played time: %d\n", title, album, artist, album_artist, duration, time_played);
}
SAFE_FREE(title);
SAFE_FREE(artist);
SAFE_FREE(album);
+ SAFE_FREE(album_artist);
ret = video_meta_destroy(video_handle);
if(ret != MEDIA_CONTENT_ERROR_NONE)
test_filter_destroy();
+ /* fix prevent: Resource Leak */
+ SAFE_FREE(folder_id);
+
+ return ret;
+}
+
+bool folder_update_cb(media_folder_h folder, void *user_data)
+{
+ char *folder_id = NULL;
+ char *folder_path = NULL;
+ char *folder_name = NULL;
+ bool ret = true;
+
+ if(folder != NULL)
+ {
+ ret = media_folder_get_folder_id(folder, &folder_id);
+ media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
+ media_content_debug("folder_id = [%s]", folder_id);
+ SAFE_FREE(folder_id);
+
+ ret = media_folder_get_path(folder, &folder_path);
+ media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
+ media_content_debug("folder_path = [%s]", folder_path);
+ SAFE_FREE(folder_path);
+
+ ret = media_folder_get_name(folder, &folder_name);
+ media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
+ media_content_debug("folder_name = [%s]", folder_name);
+ SAFE_FREE(folder_name);
+
+ ret = media_folder_clone(&g_folder, folder);
+ media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
+
+ ret = true;
+ }
+ else
+ {
+ ret = false;
+ }
+
+ return ret;
+}
+
+
+int test_folder_update(void)
+{
+ int ret = MEDIA_CONTENT_ERROR_NONE;
+ filter_h filter;
+ int folder_count = 0;
+
+ media_content_debug("\n============Folder Update Test============\n\n");
+
+ 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_folder_get_folder_count_from_db(filter, &folder_count);
+
+ media_content_debug("Folder count : %d", folder_count);
+
+ ret = media_folder_foreach_folder_from_db(filter, folder_update_cb, NULL);
+
+ media_filter_destroy(filter);
+
+ ret = media_folder_set_name(g_folder, "test_folder");
+
+ ret = media_folder_update_to_db(g_folder);
+
+ ret = media_folder_destroy(g_folder);
+
return ret;
}
}
#endif
}
+
+ /* fix prevent: Resource Leak */
+ SAFE_FREE(media_id);
+ SAFE_FREE(media_path);
}
return MEDIA_CONTENT_ERROR_NONE;
int test_insert(void)
{
int ret = MEDIA_CONTENT_ERROR_NONE;
- //char *path = "/opt/media/Images/Default.jpg";
- char *path = tzplatform_mkpath(TZ_USER_CONTENT, "Others/other.txt");
+ char *path = "/opt/usr/media/Images/Default.jpg";
+ //char *path = "/opt/usr/media/Others/other.txt";
//char *path = NULL;
media_info_h media_item = NULL;
media_content_debug("\n============DB Insert Test============\n\n");
media_content_error("media_info_create_thumbnail failed: %d", ret);
}
+ /* fix prevent: Resource leak */
+ SAFE_FREE(media_id);
+
return true;
}
if(g_cnt == g_media_cnt)
g_main_loop_quit(g_loop);
+ /* fix prevent: Resource leak */
+ SAFE_FREE(media_id);
+
return true;
}
if(ret != MEDIA_CONTENT_ERROR_NONE)
return ret;
+ ret = test_folder_update();
+ if(ret != MEDIA_CONTENT_ERROR_NONE)
+ return ret;
+
ret = test_playlist_operation();
if(ret != MEDIA_CONTENT_ERROR_NONE)
return ret;
projects / platform / core / api / media-content.git / commitdiff