From: Minje Ahn Date: Thu, 9 Jul 2015 00:54:10 +0000 (+0900) Subject: Add storage API. X-Git-Tag: accepted/tizen/mobile/20150709.111114^0 X-Git-Url: http://review.tizen.org/git/?p=platform%2Fcore%2Fapi%2Fmedia-content.git;a=commitdiff_plain;h=3f0c2bc1beccd8b15b0426649b60e734568d7410 Add storage API. Change-Id: I4bacf863aae13c19fdc28f7fceab12657554ee57 Signed-off-by: Minje Ahn --- diff --git a/include/media_content.h b/include/media_content.h index 7cf9468..6423e5f 100755 --- a/include/media_content.h +++ b/include/media_content.h @@ -28,6 +28,7 @@ #include #include #include +#include #ifdef __cplusplus extern "C" { diff --git a/include/media_content_internal.h b/include/media_content_internal.h new file mode 100755 index 0000000..6e0accf --- /dev/null +++ b/include/media_content_internal.h @@ -0,0 +1,470 @@ +/* +* 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. +*/ + + + +#ifndef __TIZEN_MEDIA_CONTENT_INTERNAL_H__ +#define __TIZEN_MEDIA_CONTENT_INTERNAL_H__ + +#include + +#ifdef __cplusplus +extern "C" { +#endif /* __cplusplus */ + +/** + * @internal + * @file media_content_internal.h + * @brief This file contains API on main functional operations with storage that are related to media resources in the media database. \n + * Operations include: inserting a new storage in media to the media database, removing storage from database, \n + */ + +/** +* @internal +* @brief Insert media storage to database. +* @since_tizen 2.4 +* +* @remarks You must release @a storage using media_storage_destroy(). +* +* @privlevel platform +* @privilege %http://tizen.org/privilege/content.write +* +* @param[in] storage_name The storage name to insert to database +* @param[in] storage_path The storage path to insert to database +* @param[in] storage_account The storage account to insert to database +* @param[in] storage_type The storage type to insert to database +* @param[out] storage The media storage handle +* +* @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_DB_FAILED DB operation failed +* @retval #MEDIA_CONTENT_ERROR_PERMISSION_DENIED Permission denied +* +* @see media_storage_delete_from_db() +*/ +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); + +/** +* @internal +* @brief Deletes the database for media storage. +* @since_tizen 2.4 +* +* @privlevel platform +* @privilege %http://tizen.org/privilege/content.write +* +* @param[in] storage_id The storage ID to delete from database +* +* @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_DB_FAILED DB operation failed +* @retval #MEDIA_CONTENT_ERROR_PERMISSION_DENIED Permission denied +* +* @see media_storage_insert_to_db() +*/ +int media_storage_delete_from_db(const char *storage_id); + +/** + * @brief Gets the storage account of media storage. + * @since_tizen 2.4 + * + * @remarks You must release @a storage_account using free(). + * + * @param[in] storage The media storage handle + * @param[out] storage_account The storage account of the media storage + * + * @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_OUT_OF_MEMORY Out of memory + */ +int media_storage_get_storage_account(media_storage_h storage, char **storage_account); + +/** +* @internal +* @brief Creates the media info handle. +* @since_tizen 2.4 +* +* @remarks You must release @a media using media_info_destroy(). +* +* @param[out] media The media info handle +* +* @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_DB_FAILED DB operation failed +* @retval #MEDIA_CONTENT_ERROR_PERMISSION_DENIED Permission denied +* +* @see media_info_destroy() +*/ +int media_info_create_handle(media_info_h *media); + +/** +* @internal +* @brief Inserts media info to database with media info data. +* @since_tizen 2.4 +* +* @remarks You must release @a info using media_info_destroy(). +* +* @privlevel platform +* @privilege %http://tizen.org/privilege/content.write +* +* @param[in] media The media info handle +* @param[out] info The media info handle to get data from database +* +* @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_DB_FAILED DB operation failed +* @retval #MEDIA_CONTENT_ERROR_PERMISSION_DENIED Permission denied +*/ +int media_info_insert_to_db_with_data(media_info_h media, media_info_h *info); + +/** +* @internal +* @brief Sets the path of media info handle. +* @since_tizen 2.4 +* +* @param[in] media The media info handle +* @param[in] path The path of the media info +* +* @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_DB_FAILED DB operation failed +* @retval #MEDIA_CONTENT_ERROR_PERMISSION_DENIED Permission denied +* +* @post media_info_insert_to_db_with_data() +*/ +int media_info_set_path(media_info_h media, const char *path); + +/** +* @internal +* @brief Sets the MIME type of media info handle. +* @since_tizen 2.4 +* +* @param[in] media The media info handle +* @param[in] mime_type The MIME type of the media info +* +* @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_DB_FAILED DB operation failed +* @retval #MEDIA_CONTENT_ERROR_PERMISSION_DENIED Permission denied +* +* @post media_info_insert_to_db_with_data() +*/ +int media_info_set_mime_type(media_info_h media, const char *mime_type); + +/** +* @internal +* @brief Sets the title of media info handle. +* @since_tizen 2.4 +* +* @param[in] media The media info handle +* @param[in] title The title of media info handle +* +* @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_DB_FAILED DB operation failed +* @retval #MEDIA_CONTENT_ERROR_PERMISSION_DENIED Permission denied +* +* @post media_info_insert_to_db_with_data() +*/ +int media_info_set_title(media_info_h media, const char *title); + +/** +* @internal +* @brief Sets the album of media info handle. +* @since_tizen 2.4 +* +* @param[in] media The media info handle +* @param[in] album The album of media info handle +* +* @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_DB_FAILED DB operation failed +* @retval #MEDIA_CONTENT_ERROR_PERMISSION_DENIED Permission denied +* +* @post media_info_insert_to_db_with_data() +*/ +int media_info_set_album(media_info_h media, const char *album); + +/** +* @internal +* @brief Sets the artist of media info handle. +* @since_tizen 2.4 +* +* @param[in] media The media info handle +* @param[in] artist The artist of media info handle +* +* @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_DB_FAILED DB operation failed +* @retval #MEDIA_CONTENT_ERROR_PERMISSION_DENIED Permission denied +* +* @post media_info_insert_to_db_with_data() +*/ +int media_info_set_artist(media_info_h media, const char *artist); + +/** +* @internal +* @brief Sets the genre of media info handle. +* @since_tizen 2.4 +* +* @param[in] media The media info handle +* @param[in] genre The genre of media info handle +* +* @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_DB_FAILED DB operation failed +* @retval #MEDIA_CONTENT_ERROR_PERMISSION_DENIED Permission denied +* +* @post media_info_insert_to_db_with_data() +*/ +int media_info_set_genre(media_info_h media, const char *genre); + +/** +* @internal +* @brief Sets the recorded date of media info handle. +* @since_tizen 2.4 +* +* @param[in] media The media info handle +* @param[in] recorded_date The recorded date of media info handle +* +* @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_DB_FAILED DB operation failed +* @retval #MEDIA_CONTENT_ERROR_PERMISSION_DENIED Permission denied +* +* @post media_info_insert_to_db_with_data() +*/ +int media_info_set_recorded_date(media_info_h media, const char *recorded_date); + +/** +* @internal +* @brief Sets the thumbnail path of media info handle. +* @since_tizen 2.4 +* +* @param[in] media The media info handle +* @param[in] thumbnail_path The thumbnail path of media info handle +* +* @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_DB_FAILED DB operation failed +* @retval #MEDIA_CONTENT_ERROR_PERMISSION_DENIED Permission denied +* +* @post media_info_insert_to_db_with_data() +*/ +int media_info_set_thumbnail_path(media_info_h media, const char *thumbnail_path); + +/** +* @internal +* @brief Sets the size of media info handle. +* @since_tizen 2.4 +* +* @param[in] media The media info handle +* @param[in] size The size of media info handle +* +* @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_DB_FAILED DB operation failed +* @retval #MEDIA_CONTENT_ERROR_PERMISSION_DENIED Permission denied +* +* @post media_info_insert_to_db_with_data() +*/ +int media_info_set_size(media_info_h media, unsigned long long size); + +/** +* @internal +* @brief Sets the modified time of media info handle. +* @since_tizen 2.4 +* +* @param[in] media The media info handle +* @param[in] modified_time The modified time of media info handle +* +* @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_DB_FAILED DB operation failed +* @retval #MEDIA_CONTENT_ERROR_PERMISSION_DENIED Permission denied +* +* @post media_info_insert_to_db_with_data() +*/ +int media_info_set_modified_time(media_info_h media, time_t modified_time); + +/** +* @internal +* @brief Sets the media type of media info handle. +* @since_tizen 2.4 +* +* @param[in] media The media info handle +* @param[in] type The media type of media info handle +* +* @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_DB_FAILED DB operation failed +* @retval #MEDIA_CONTENT_ERROR_PERMISSION_DENIED Permission denied +* +* @post media_info_insert_to_db_with_data() +*/ +int media_info_set_media_type(media_info_h media, media_content_type_e type); + +/** +* @internal +* @brief Sets the duration of media info handle. +* @since_tizen 2.4 +* +* @param[in] media The media info handle +* @param[in] duration The duration of media info handle +* +* @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_DB_FAILED DB operation failed +* @retval #MEDIA_CONTENT_ERROR_PERMISSION_DENIED Permission denied +* +* @post media_info_insert_to_db_with_data() +*/ +int media_info_set_duration(media_info_h media, int duration); + +/** +* @internal +* @brief Sets the width of media info handle. +* @since_tizen 2.4 +* +* @param[in] media The media info handle +* @param[in] width The width of media info handle +* +* @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_DB_FAILED DB operation failed +* @retval #MEDIA_CONTENT_ERROR_PERMISSION_DENIED Permission denied +* +* @post media_info_insert_to_db_with_data() +*/ +int media_info_set_width(media_info_h media, int width); + +/** +* @internal +* @brief Sets the height of media info handle. +* @since_tizen 2.4 +* +* @param[in] media The media info handle +* @param[in] height The height of media info handle +* +* @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_DB_FAILED DB operation failed +* @retval #MEDIA_CONTENT_ERROR_PERMISSION_DENIED Permission denied +* +* @post media_info_insert_to_db_with_data() +*/ +int media_info_set_height(media_info_h media, int height); + +/** +* @internal +* @brief Sets the storage type of media info handle. +* @since_tizen 2.4 +* +* @param[in] media The media info handle +* @param[in] storage_type The storage type of media info handle +* +* @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_DB_FAILED DB operation failed +* @retval #MEDIA_CONTENT_ERROR_PERMISSION_DENIED Permission denied +* +* @post media_info_insert_to_db_with_data() +*/ +int media_info_set_storage_type(media_info_h media, media_content_storage_e storage_type); + +/** +* @internal +* @brief Sets the storage type of media info handle. +* @since_tizen 2.4 +* +* @param[in] media The media info handle +* @param[in] storage_id The storage id of media info handle +* +* @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_DB_FAILED DB operation failed +* @retval #MEDIA_CONTENT_ERROR_PERMISSION_DENIED Permission denied +* +* @post media_info_insert_to_db_with_data() +*/ +int media_info_set_storage_id(media_info_h media, const char *storage_id); + +#ifdef __cplusplus +} +#endif /* __cplusplus */ +#endif /*__TIZEN_MEDIA_CONTENT_INTERNAL_H__*/ diff --git a/include/media_content_type.h b/include/media_content_type.h index 3b51095..64cb4d2 100755 --- a/include/media_content_type.h +++ b/include/media_content_type.h @@ -241,6 +241,12 @@ typedef struct audio_meta_s *audio_meta_h; */ typedef struct filter_s *filter_h; +/** + * @ingroup CAPI_CONTENT_MEDIA_STORAGE_MODULE + * @brief The structure type for the Media storage handle. + * @since_tizen 2.4 + */ +typedef void *media_storage_h; /** * @ingroup CAPI_MEDIA_CONTENT_MODULE @@ -504,6 +510,26 @@ typedef bool (*media_album_cb)(media_album_h album, void *user_data); */ typedef bool (*media_group_cb)(const char *group_name, void *user_data); +/** + * @ingroup CAPI_CONTENT_MEDIA_STORAGE_MODULE + * @brief Called for every storage in the obtained list of storages. + * @since_tizen 2.4 + * + * @details Iterates over a media storage list. + * + * @remarks You should not destroy @a storage returned by this function. + * + * @param[in] storage The handle of the media storage + * @param[in] user_data The user data passed from the foreach function + * + * @return @c true to continue with the next iteration of the loop, + * otherwise @c false to break out of the loop + * + * @pre media_storage_foreach_storage_from_db() will invoke this function. + * + * @see media_storage_foreach_storage_from_db() + */ +typedef bool (*media_storage_cb)(media_storage_h storage, void *user_data); /** * @} diff --git a/include/media_info_private.h b/include/media_info_private.h index e5d280a..e13a32e 100755 --- a/include/media_info_private.h +++ b/include/media_info_private.h @@ -187,7 +187,7 @@ typedef struct char *path; char *name; time_t modified_time; - int storage_type; + media_content_storage_e storage_type; char *storage_uuid; int folder_order; }media_folder_s; @@ -391,7 +391,7 @@ typedef struct _media_content_cb_data { #define DB_TABLE_PLAYLIST_MAP "playlist_map" #define DB_TABLE_BOOKMARK "bookmark" #define DB_TABLE_STORAGE "storage" -#define DB_TABLE_MEDIA_VIEW "media" +#define DB_TABLE_MEDIA_VIEW "media_view" /* DB View */ #define DB_VIEW_PLAYLIST "playlist_view" @@ -517,7 +517,8 @@ typedef struct _media_content_cb_data { #define QUERY_KEYWORD_BRACKET ")" /* DB TABLE JOIN */ -#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 FOLDER_MEDIA_JOIN "("DB_TABLE_FOLDER" AS f LEFT OUTER JOIN '%s' AS m ON f.folder_uuid=m.folder_uuid AND m.validity=1) WHERE f.storage_uuid IN (SELECT storage_uuid FROM "DB_TABLE_STORAGE" WHERE validity=1) " +#define FOLDER_MEDIA_JOIN "("DB_TABLE_FOLDER" AS f LEFT OUTER JOIN '%s' AS m ON f.folder_uuid=m.folder_uuid AND m.validity=1) WHERE f.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 '%s' AS m \ @@ -645,6 +646,7 @@ int _media_db_get_group_item_by_id(int group_id, filter_h filter, media_info_cb 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, 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); /** @@ -679,7 +681,7 @@ int _media_filter_attribute_create(attribute_h *attr); * @see media_filter_attribute_remove() * */ -int _media_filter_attribute_add(attribute_h atrr, char *user_attr, char *platform_attr); +int _media_filter_attribute_add(attribute_h atrr, const char *user_attr, const char *platform_attr); /** * @internal @@ -754,6 +756,13 @@ int _media_filter_attribute_option_generate(attribute_h attr, filter_h filter, c } \ } while (0) +#define media_content_retvm_if(expr, val, fmt, arg...) do { \ + if(expr) { \ + LOGE(FONT_COLOR_RED"[%d]"fmt"",media_content_gettid(), ##arg); \ + return (val); \ + } \ + } while (0) + #define media_content_debug(fmt, arg...) do { \ LOGD(FONT_COLOR_RESET"[%d]"fmt"", media_content_gettid(), ##arg); \ } while (0) @@ -784,9 +793,9 @@ int _media_filter_attribute_option_generate(attribute_h attr, filter_h filter, c #define ERR_BUF_LENGTH 256 #define media_content_stderror(fmt) do { \ - char buf[ERR_BUF_LENGTH] = {0, }; \ - strerror_r(errno, buf, ERR_BUF_LENGTH); \ - LOGE(FONT_COLOR_RED fmt" : STANDARD ERROR [%s]", buf); \ + char media_content_stderror_buf[ERR_BUF_LENGTH] = {0, }; \ + strerror_r(errno, media_content_stderror_buf, ERR_BUF_LENGTH); \ + LOGE(FONT_COLOR_RED fmt" : STANDARD ERROR [%s]", media_content_stderror_buf); \ } while (0) #ifdef __cplusplus diff --git a/include/media_storage.h b/include/media_storage.h new file mode 100755 index 0000000..42a6596 --- /dev/null +++ b/include/media_storage.h @@ -0,0 +1,304 @@ +/* +* 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. +*/ + + +#ifndef __TIZEN_MEDIA_STORAGE_H__ +#define __TIZEN_MEDIA_STORAGE_H__ + + +#include + + +#ifdef __cplusplus +extern "C" { +#endif /* __cplusplus */ + +/** + * @file media_storage.h + * @brief This file contains API on main functional operations with storage that are related to media resources in the media database. \n + * Operations include: getting number of storages, cloning and destroying storage, getting storage`s ID, name, path and type. + */ + +/** + * @addtogroup CAPI_CONTENT_MEDIA_STORAGE_MODULE + * @{ + */ + +/** +* @brief Gets media storage from database. +* @since_tizen 2.4 +* +* @param[in] storage_id The storage id to get media storage info +* @param[out] storage The media storage handle +* +* @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_OUT_OF_MEMORY Out of memory +* @retval #MEDIA_CONTENT_ERROR_DB_FAILED DB Operation failed +* @retval #MEDIA_CONTENT_ERROR_DB_BUSY DB Operation busy +* @retval #MEDIA_CONTENT_ERROR_PERMISSION_DENIED Permission denied + +* +* @pre This function requires opened connection to content service by media_content_connect(). +* +* @see media_content_connect() +*/ +int media_storage_get_storage_info_from_db(const char *storage_id, media_storage_h *storage); + +/** +* @brief Gets the count of media storage for the passed @a filter from the media database. +* @since_tizen 2.4 +* +* @param[in] filter The handle to filter +* @param[out] storage_count The count of storage +* +* @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_INVALID_OPERATION Invalid operation +* @retval #MEDIA_CONTENT_ERROR_DB_FAILED DB Operation failed +* @retval #MEDIA_CONTENT_ERROR_DB_BUSY DB Operation busy +* @retval #MEDIA_CONTENT_ERROR_PERMISSION_DENIED Permission denied +* +* @pre This function requires opened connection to content service by media_content_connect(). +* +* @see media_content_connect() +*/ +int media_storage_get_storage_count_from_db(filter_h filter, int *storage_count); + +/** + * @brief Iterates through media storage from the media database. + * @details This function gets all media storage handles meeting the given @a filter. + * The @a callback function will be invoked for every retrieved media storage. + * If @c NULL is passed to the @a filter, then no filtering is applied. + * + * @since_tizen 2.4 + * + * @param[in] filter The media storage handle filter + * @param[in] callback The callback function to be invoked + * @param[in] user_data The user data to be passed to the callback function + * + * @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_OUT_OF_MEMORY Out of memory + * @retval #MEDIA_CONTENT_ERROR_DB_FAILED DB Operation failed + * @retval #MEDIA_CONTENT_ERROR_DB_BUSY DB Operation busy + * @retval #MEDIA_CONTENT_ERROR_PERMISSION_DENIED Permission denied + * + * @pre This function requires opened connection to content service by media_content_connect(). + * @post This function invokes media_storage_destroy(). + * + * @see media_content_connect() + * @see media_storage_destroy() + */ +int media_storage_foreach_storage_from_db(filter_h filter, media_storage_cb callback, void *user_data); + +/** + * @brief Gets the count of media files for the passed @a filter in the given @a storage from the media database. + * @since_tizen 2.4 + * + * @param[in] storage_id The ID of the media storage + * @param[in] filter The filter of the media content + * @param[out] media_count The count of media storage items + * + * @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_DB_FAILED DB Operation failed + * @retval #MEDIA_CONTENT_ERROR_DB_BUSY DB Operation busy + * @retval #MEDIA_CONTENT_ERROR_PERMISSION_DENIED Permission denied + * + * @pre This function requires opened connection to content service by media_content_connect(). + * + * @see media_content_connect() + */ +int media_storage_get_media_count_from_db(const char *storage_id, filter_h filter, int *media_count); + +/** + * @brief Iterates through the media files with an optional @a filter in the given @a storage from the media database. + * @details This function gets all media files associated with the given storage and + * meeting desired filter option and calls registered callback function for + * every retrieved media item. If @c NULL is passed to the @a filter, no filtering is applied. + * + * @since_tizen 2.4 + * + * @remarks Do not call updating DB function like media_info_update_to_db(), media_info_refresh_metadata_to_db(), audio_meta_update_to_db(), image_meta_update_to_db() and video_meta_update_to_db() in your callback function, + * your callback function is invoked as inline function. \n + * So, your callback function is in read state in SQLite. When you are in read state, sometimes you do not update DB. \n + * We do not recommend you call updating DB function in callback of foreach function. + * + * @param[in] storage_id The ID of the media storage + * @param[in] filter The handle to the media info filter + * @param[in] callback The callback function to be invoked + * @param[in] user_data The user data to be passed to the callback function + * + * @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_OUT_OF_MEMORY Out of memory + * @retval #MEDIA_CONTENT_ERROR_DB_FAILED DB Operation failed + * @retval #MEDIA_CONTENT_ERROR_DB_BUSY DB Operation busy + * @retval #MEDIA_CONTENT_ERROR_PERMISSION_DENIED Permission denied + * + * @pre This function requires opened connection to content service by media_content_connect(). + * @post This function invokes media_info_cb(). + * + * @see #media_info_cb + * @see media_content_connect() + * @see media_filter_create() + */ +int media_storage_foreach_media_from_db(const char *storage_id, filter_h filter, media_info_cb callback, void *user_data); + +/** + * @brief Destroys media storage handle. + * @details The function frees all resources related to the media storage handle. This handle + * can no longer be used to perform any operation. New media storage handle has to + * be created before the next usage. + * + * @since_tizen 2.4 + * + * @param[in] storage The media storage handle + * + * @return @c 0 on success, + * otherwise a negative error value + * + * @retval #MEDIA_CONTENT_ERROR_NONE Successful + * @retval #MEDIA_CONTENT_ERROR_INVALID_PARAMETER Invalid parameter + * + * @pre Get copy of media_storage_h handle by calling media_storage_clone(). + * + * @see media_storage_clone() + */ +int media_storage_destroy(media_storage_h storage); + +/** + * @brief Clones the media storage handle. + * + * @details This function copies the media storage handle from a source to the destination. + * There is no media_storage_create() function. The media_storage_h is created internally and + * available through media storage foreach function such as media_storage_foreach_storage_from_db(). + * To use this handle outside of these foreach functions, use this function. + * + * @since_tizen 2.4 + * + * @remarks You must release the destination handle using media_storage_destroy(). + * + * @param[out] dst The destination handle to the media storage + * @param[in] src The source handle to media storage + * + * @return @c 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 + * + * @see media_storage_destroy() + * @see media_storage_foreach_storage_from_db() + * @see media_storage_get_storage_info_from_db() + */ +int media_storage_clone(media_storage_h *dst, media_storage_h src); + +/** + * @brief Gets the storage id of media storage. + * @since_tizen 2.4 + * + * @remarks You must release @a storage_id using free(). + * + * @param[in] storage The media storage handle + * @param[out] storage_id The storage id of the media storage + * + * @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_OUT_OF_MEMORY Out of memory + */ +int media_storage_get_id(media_storage_h storage, char **storage_id); + +/** + * @brief Gets the storage name of media storage. + * @since_tizen 2.4 + * + * @remarks You must release @a storage_name using free(). + * + * @param[in] storage The media storage handle + * @param[out] storage_name The storage name of the media storage + * + * @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_OUT_OF_MEMORY Out of memory + */ +int media_storage_get_name(media_storage_h storage, char **storage_name); + +/** + * @brief Gets the storage path of media storage. + * @since_tizen 2.4 + * + * @remarks You must release @a storage_path using free(). + * + * @param[in] storage The media storage handle + * @param[out] storage_path The storage path of the media storage + * + * @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_OUT_OF_MEMORY Out of memory + */ +int media_storage_get_path(media_storage_h storage, char **storage_path); + +/** + * @brief Gets the storage type of media storage. + * @since_tizen 2.4 + * + * @param[in] storage The media storage handle + * @param[out] storage_type The storage type of the media storage + * + * @return @c 0 on success, + * otherwise a negative error value + * + * @retval #MEDIA_CONTENT_ERROR_NONE Successful + * @retval #MEDIA_CONTENT_ERROR_INVALID_PARAMETER Invalid parameter + */ +int media_storage_get_type(media_storage_h storage, media_content_storage_e *storage_type); + +/** + * @} + */ + +#ifdef __cplusplus +} +#endif /* __cplusplus */ + +#endif /* __TIZEN_MEDIA_STORAGE_H__ */ diff --git a/src/media_audio.c b/src/media_audio.c index ec607ef..d2970e6 100755 --- a/src/media_audio.c +++ b/src/media_audio.c @@ -57,13 +57,7 @@ int audio_meta_clone(audio_meta_h *dst, audio_meta_h src) if(_src != NULL) { audio_meta_s *_dst = (audio_meta_s*)calloc(1, sizeof(audio_meta_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; - } + media_content_retvm_if(_dst == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY"); if(STRING_VALID(_src->media_id)) { @@ -217,11 +211,7 @@ int audio_meta_get_media_id(audio_meta_h audio, char **media_id) if(STRING_VALID(_audio->media_id)) { *media_id = strdup(_audio->media_id); - if(*media_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_retvm_if(*media_id == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY"); } else { @@ -248,11 +238,7 @@ int audio_meta_get_album(audio_meta_h audio, char **album_name) if(STRING_VALID(_audio->album)) { *album_name = strdup(_audio->album); - if(*album_name == NULL) - { - media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY); - return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY; - } + media_content_retvm_if(*album_name == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY"); } else { @@ -280,11 +266,7 @@ int audio_meta_get_artist(audio_meta_h audio, char **artist_name) if(STRING_VALID(_audio->artist)) { *artist_name = strdup(_audio->artist); - if(*artist_name == NULL) - { - media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY); - return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY; - } + media_content_retvm_if(*artist_name == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY"); } else { @@ -312,11 +294,7 @@ int audio_meta_get_album_artist(audio_meta_h audio, char **album_artist_name) 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; - } + media_content_retvm_if(*album_artist_name == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY"); } else { @@ -338,16 +316,13 @@ int audio_meta_get_genre(audio_meta_h audio, char **genre_name) { int ret = MEDIA_CONTENT_ERROR_NONE; audio_meta_s *_audio = (audio_meta_s*)audio; + if(_audio) { if(STRING_VALID(_audio->genre)) { *genre_name = strdup(_audio->genre); - if(*genre_name == NULL) - { - media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY); - return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY; - } + media_content_retvm_if(*genre_name == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY"); } else { @@ -369,16 +344,13 @@ int audio_meta_get_composer(audio_meta_h audio, char **composer_name) { int ret = MEDIA_CONTENT_ERROR_NONE; audio_meta_s *_audio = (audio_meta_s*)audio; + if(_audio) { if(STRING_VALID(_audio->composer)) { *composer_name = strdup(_audio->composer); - if(*composer_name == NULL) - { - media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY); - return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY; - } + media_content_retvm_if(*composer_name == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY"); } else { @@ -400,16 +372,13 @@ int audio_meta_get_year(audio_meta_h audio, char **year) { int ret = MEDIA_CONTENT_ERROR_NONE; audio_meta_s *_audio = (audio_meta_s*)audio; + if(_audio) { if(STRING_VALID(_audio->year)) { *year = strdup(_audio->year); - if(*year == NULL) - { - media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY); - return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY; - } + media_content_retvm_if(*year == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY"); } else { @@ -431,16 +400,13 @@ int audio_meta_get_recorded_date(audio_meta_h audio, char **recorded_date) { int ret = MEDIA_CONTENT_ERROR_NONE; audio_meta_s *_audio = (audio_meta_s*)audio; + if(_audio) { if(STRING_VALID(_audio->recorded_date)) { *recorded_date = strdup(_audio->recorded_date); - if(*recorded_date == NULL) - { - media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY); - return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY; - } + media_content_retvm_if(*recorded_date == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY"); } else { @@ -462,16 +428,13 @@ int audio_meta_get_copyright(audio_meta_h audio, char **copyright) { int ret = MEDIA_CONTENT_ERROR_NONE; audio_meta_s *_audio = (audio_meta_s*)audio; + if(_audio) { if(STRING_VALID(_audio->copyright)) { *copyright = strdup(_audio->copyright); - if(*copyright == NULL) - { - media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY); - return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY; - } + media_content_retvm_if(*copyright == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY"); } else { @@ -493,16 +456,13 @@ int audio_meta_get_track_num(audio_meta_h audio, char **track_num) { int ret = MEDIA_CONTENT_ERROR_NONE; audio_meta_s *_audio = (audio_meta_s*)audio; + if(_audio) { if(STRING_VALID(_audio->track_num)) { *track_num = strdup(_audio->track_num); - if(*track_num == NULL) - { - media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY); - return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY; - } + media_content_retvm_if(*track_num == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY"); } else { diff --git a/src/media_bookmark.c b/src/media_bookmark.c index 466e6e3..f3c6a93 100755 --- a/src/media_bookmark.c +++ b/src/media_bookmark.c @@ -101,12 +101,7 @@ int media_bookmark_clone(media_bookmark_h *dst, media_bookmark_h src) { media_bookmark_s *_src = (media_bookmark_s*)src; media_bookmark_s *_dst = (media_bookmark_s*)calloc(1, sizeof(media_bookmark_s)); - - if(NULL == _dst) - { - media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY); - return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY; - } + media_content_retvm_if(_dst == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY"); _dst->bookmark_id = _src->bookmark_id; @@ -195,11 +190,7 @@ int media_bookmark_get_thumbnail_path(media_bookmark_h bookmark, char **path) if(STRING_VALID(_bookmark->thumbnail_path)) { *path = strdup(_bookmark->thumbnail_path); - if(*path == NULL) - { - media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY); - return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY; - } + media_content_retvm_if(*path == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY"); } else { diff --git a/src/media_content.c b/src/media_content.c index 43ab55d..ab2e0fd 100755 --- a/src/media_content.c +++ b/src/media_content.c @@ -562,61 +562,49 @@ int _content_query_prepare(sqlite3_stmt **stmt, char *select_query, char *condit { int len = 0; int err = MEDIA_CONTENT_ERROR_NONE; - char query[MAX_QUERY_SIZE]; + char query[MAX_QUERY_SIZE] = {0, }; memset(query, '\0', sizeof(query)); - if(db_handle == NULL) - { - media_content_error("DB_FAILED(0x%08x) database is not connected", MEDIA_CONTENT_ERROR_DB_FAILED); - return MEDIA_CONTENT_ERROR_DB_FAILED; + media_content_retvm_if(db_handle == NULL, MEDIA_CONTENT_ERROR_DB_FAILED, "database is not connected"); + media_content_retvm_if(!STRING_VALID(select_query), MEDIA_CONTENT_ERROR_INVALID_PARAMETER, "invalid select_query"); + + if(!STRING_VALID(condition_query)) { + condition_query = (char *)" "; } - if(STRING_VALID(select_query)) - { - if(!STRING_VALID(condition_query)) - { - condition_query = " "; - } + if(!STRING_VALID(option_query)) { + option_query = (char *)" "; - if(!STRING_VALID(option_query)) - { - option_query = " "; - } + } - //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 && 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; - } + //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 && 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_sec_debug("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) { - media_content_error(" BUSY ERROR"); - return MEDIA_CONTENT_ERROR_DB_BUSY; - } 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 + err = sqlite3_prepare_v2((sqlite3*)db_handle, query, strlen(query), stmt, NULL); + if(err != SQLITE_OK) { - media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER); - return MEDIA_CONTENT_ERROR_INVALID_PARAMETER; + 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) { + media_content_error(" BUSY ERROR"); + return MEDIA_CONTENT_ERROR_DB_BUSY; + } 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; + } } return MEDIA_CONTENT_ERROR_NONE; @@ -787,10 +775,7 @@ int media_content_scan_file(const char *path) 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_retvm_if(!STRING_VALID(path), MEDIA_CONTENT_ERROR_INVALID_PARAMETER, "invalid path"); media_content_sec_debug("Path : %s", path); @@ -801,10 +786,7 @@ int media_content_scan_file(const char *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; - } + media_content_retvm_if(ignore_dir, MEDIA_CONTENT_ERROR_INVALID_PARAMETER, "Invalid folder path"); media_svc_storage_type_e storage_type; @@ -813,7 +795,6 @@ int media_content_scan_file(const char *path) 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_check_item_exist_by_path(_content_get_db_handle(), path); if (ret == MS_MEDIA_ERR_NONE) { /* Refresh */ @@ -881,6 +862,7 @@ static int __media_content_check_dir(const char *path) if (dp == NULL) { 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 { @@ -899,28 +881,17 @@ int media_content_scan_folder(const char *path, bool is_recursive, media_scan_co 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; - } + media_content_retvm_if(!STRING_VALID(path), MEDIA_CONTENT_ERROR_INVALID_PARAMETER, "Invalid path"); ret = _media_util_check_ignore_dir(path, &ignore_dir); - if(ignore_dir) { - media_content_error("Invalid folder path"); - return MEDIA_CONTENT_ERROR_INVALID_PARAMETER; - } + media_content_retvm_if(ignore_dir, MEDIA_CONTENT_ERROR_INVALID_PARAMETER, "Invalid folder path"); ret = __media_content_check_dir(path); - if (ret == MEDIA_CONTENT_ERROR_PERMISSION_DENIED) { - return ret; - } + media_content_retvm_if(ret == MEDIA_CONTENT_ERROR_PERMISSION_DENIED, ret, "Permission Denied"); 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("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY); - return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY; - } + media_content_retvm_if(cb_data == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY"); cb_data->callback = callback; cb_data->user_data = user_data; @@ -937,7 +908,7 @@ int media_content_cancel_scan_folder(const char *path) { int ret = MEDIA_CONTENT_ERROR_NONE; - //ret = media_directory_scanning_cancel(path); + ret = media_directory_scanning_cancel(path, tzplatform_getuid(TZ_USER_NAME)); if(ret != MS_MEDIA_ERR_NONE) { media_content_error("media_directory_scanning_async failed : %d", ret); } @@ -972,21 +943,11 @@ int media_content_set_db_updated_cb(media_content_db_update_cb callback, void *u { 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; - } + media_content_retvm_if(callback == NULL, MEDIA_CONTENT_ERROR_INVALID_PARAMETER, "Invalid callback"); + media_content_retvm_if(g_noti_info != NULL, MEDIA_CONTENT_ERROR_INVALID_OPERATION, "Noti callback is already set"); 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 MEDIA_CONTENT_ERROR_OUT_OF_MEMORY; - } + media_content_retvm_if(g_noti_info == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY"); g_noti_info->update_noti_cb = callback; g_noti_info->user_data = user_data; diff --git a/src/media_db.c b/src/media_db.c index 7669d68..9d4b4ba 100755 --- a/src/media_db.c +++ b/src/media_db.c @@ -26,63 +26,63 @@ static char * __media_db_get_group_name(media_group_e group) switch(group) { case MEDIA_CONTENT_GROUP_DISPLAY_NAME: - return DB_FIELD_MEDIA_DISPLAY_NAME; + return (char *)DB_FIELD_MEDIA_DISPLAY_NAME; case MEDIA_CONTENT_GROUP_TYPE: - return DB_FIELD_MEDIA_TYPE; + return (char *)DB_FIELD_MEDIA_TYPE; case MEDIA_CONTENT_GROUP_MIME_TYPE: - return DB_FIELD_MEDIA_MIME_TYPE; + return (char *) DB_FIELD_MEDIA_MIME_TYPE; case MEDIA_CONTENT_GROUP_SIZE: - return DB_FIELD_MEDIA_SIZE; + return (char *) DB_FIELD_MEDIA_SIZE; case MEDIA_CONTENT_GROUP_ADDED_TIME: - return DB_FIELD_MEDIA_ADDED_TIME; + return (char *) DB_FIELD_MEDIA_ADDED_TIME; case MEDIA_CONTENT_GROUP_MODIFIED_TIME: - return DB_FIELD_MEDIA_MODIFIED_TIME; + return (char *) DB_FIELD_MEDIA_MODIFIED_TIME; case MEDIA_CONTENT_GROUP_TITLE: - return DB_FIELD_MEDIA_TITLE; + return (char *) DB_FIELD_MEDIA_TITLE; case MEDIA_CONTENT_GROUP_ARTIST: - return DB_FIELD_MEDIA_ARTIST; + return (char *) DB_FIELD_MEDIA_ARTIST; case MEDIA_CONTENT_GROUP_ALBUM_ARTIST: - return DB_FIELD_MEDIA_ALBUM_ARTIST; + return (char *) DB_FIELD_MEDIA_ALBUM_ARTIST; case MEDIA_CONTENT_GROUP_GENRE: - return DB_FIELD_MEDIA_GENRE; + return (char *) DB_FIELD_MEDIA_GENRE; case MEDIA_CONTENT_GROUP_COMPOSER: - return DB_FIELD_MEDIA_COMPOSER; + return (char *) DB_FIELD_MEDIA_COMPOSER; case MEDIA_CONTENT_GROUP_YEAR: - return DB_FIELD_MEDIA_YEAR; + return (char *) DB_FIELD_MEDIA_YEAR; case MEDIA_CONTENT_GROUP_RECORDED_DATE: - return DB_FIELD_MEDIA_RECORDED_DATE; + return (char *) DB_FIELD_MEDIA_RECORDED_DATE; case MEDIA_CONTENT_GROUP_COPYRIGHT: - return DB_FIELD_MEDIA_COPYRIGHT; + return (char *) DB_FIELD_MEDIA_COPYRIGHT; case MEDIA_CONTENT_GROUP_TRACK_NUM: - return DB_FIELD_MEDIA_TRACK_NUM; + return (char *) DB_FIELD_MEDIA_TRACK_NUM; case MEDIA_CONTENT_GROUP_DESCRIPTION: - return DB_FIELD_MEDIA_DESCRIPTION; + return (char *) DB_FIELD_MEDIA_DESCRIPTION; case MEDIA_CONTENT_GROUP_LONGITUDE: - return DB_FIELD_MEDIA_LONGITUDE; + return (char *) DB_FIELD_MEDIA_LONGITUDE; case MEDIA_CONTENT_GROUP_LATITUDE: - return DB_FIELD_MEDIA_LATITUDE; + return (char *) DB_FIELD_MEDIA_LATITUDE; case MEDIA_CONTENT_GROUP_ALTITUDE: - return DB_FIELD_MEDIA_ALTITUDE; + return (char *) DB_FIELD_MEDIA_ALTITUDE; case MEDIA_CONTENT_GROUP_BURST_IMAGE: - return DB_FIELD_MEDIA_BURST_ID; + return (char *) DB_FIELD_MEDIA_BURST_ID; case MEDIA_CONTENT_GROUP_RATING: - return DB_FIELD_MEDIA_RATING; + return (char *) DB_FIELD_MEDIA_RATING; case MEDIA_CONTENT_GROUP_AUTHOR: - return DB_FIELD_MEDIA_AUTHOR; + return (char *) DB_FIELD_MEDIA_AUTHOR; case MEDIA_CONTENT_GROUP_PROVIDER: - return DB_FIELD_MEDIA_PROVIDER; + return (char *) DB_FIELD_MEDIA_PROVIDER; case MEDIA_CONTENT_GROUP_CONTENT_NAME: - return DB_FIELD_MEDIA_CONTENT_NAME; + return (char *) DB_FIELD_MEDIA_CONTENT_NAME; case MEDIA_CONTENT_GROUP_CATEGORY: - return DB_FIELD_MEDIA_CATEGORY; + return (char *) DB_FIELD_MEDIA_CATEGORY; case MEDIA_CONTENT_GROUP_LOCATION_TAG: - return DB_FIELD_MEDIA_LOCATION_TAG; + return (char *) DB_FIELD_MEDIA_LOCATION_TAG; case MEDIA_CONTENT_GROUP_AGE_RATING: - return DB_FIELD_MEDIA_AGE_RATING; + return (char *) DB_FIELD_MEDIA_AGE_RATING; case MEDIA_CONTENT_GROUP_KEYWORD: - return DB_FIELD_MEDIA_KEYWORD; + return (char *) DB_FIELD_MEDIA_KEYWORD; case MEDIA_CONTENT_GROUP_WEATHER: - return DB_FIELD_MEDIA_WEATHER; + return (char *) DB_FIELD_MEDIA_WEATHER; default: return NULL; } @@ -109,10 +109,9 @@ static int __media_db_make_query(filter_h filter, attribute_h attr, char *select 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); @@ -207,6 +206,12 @@ int _media_db_get_group_count(filter_h filter, group_list_e group_type, int *gro return MEDIA_CONTENT_ERROR_INVALID_PARAMETER; } break; + default : + { + media_content_error("Invalid group type [%d]", group_type); + return MEDIA_CONTENT_ERROR_INVALID_PARAMETER; + } + break; } ret = __media_db_make_query(filter, attr, select_query, sizeof(select_query), &condition_query, &option_query); @@ -1134,6 +1139,71 @@ int _media_db_get_media_group_item(const char *group_name, filter_h filter, medi 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_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; + } + + 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); + + if(callback((media_storage_h)_storage, user_data) == false) + { + media_storage_destroy((media_storage_h) _storage); + break; + } + + 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; diff --git a/src/media_filter.c b/src/media_filter.c index 7725569..cc74a8f 100755 --- a/src/media_filter.c +++ b/src/media_filter.c @@ -17,7 +17,7 @@ #include -static char *media_token[] = +static const char *media_token[] = { " ", "\"", @@ -56,8 +56,8 @@ static bool __is_pinyin_needed(void) { #if 0 char *lang = NULL; - char *china = "zh_CN"; - char *hongkong = "zh_HK"; + const char *china = "zh_CN"; + const char *hongkong = "zh_HK"; #endif int ret = FALSE; #if 0 @@ -68,11 +68,8 @@ static bool __is_pinyin_needed(void) { /*Check Language Setting*/ lang = vconf_get_str(VCONFKEY_LANGSET); - if (lang == NULL) - { - media_content_error("Fail to get string of language set"); - return ret; - } + media_content_retvm_if(lang == NULL, ret, "Fail to get string of language set"); + if((strncmp(china, lang, strlen(china)) == 0) || (strncmp(hongkong, lang, strlen(hongkong)) == 0)) { @@ -89,11 +86,11 @@ static char *__get_order_str(media_content_order_e order_enum) { switch(order_enum) { case MEDIA_CONTENT_ORDER_ASC: - return "ASC"; + return (char *)"ASC"; case MEDIA_CONTENT_ORDER_DESC: - return "DESC"; + return (char *)"DESC"; default: - return " "; + return (char *)" "; } } @@ -101,15 +98,15 @@ static char *__get_collate_str(media_content_collation_e collate_type) { switch(collate_type) { case MEDIA_CONTENT_COLLATE_NOCASE: - return "NOCASE"; + return (char *)"NOCASE"; case MEDIA_CONTENT_COLLATE_RTRIM: - return "RTRIM"; + return (char *)"RTRIM"; case MEDIA_CONTENT_COLLATE_LOCALIZED: if(__is_pinyin_needed()) - return "NOCASE"; + return (char *)"NOCASE"; else - return "localized"; - default: return " "; + return (char *)"localized"; + default: return (char *)" "; } } @@ -153,18 +150,10 @@ static int __tokenize_operator(token_t *token, const char *str, int op_type) { token->type = op_type; int token_size = strlen(media_token[op_type]); - if(token_size == 0) - { - media_content_error("Invalid token_size. op_type[%d]", op_type); - return -1; - } + media_content_retvm_if(token_size == 0, -1, "Invalid token_size. op_type[%d]", op_type); token->str = (char*)calloc(token_size+1, sizeof(char)); - if(token->str == NULL) - { - media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY); - return -1; - } + media_content_retvm_if(token->str == NULL, -1, "OUT_OF_MEMORY"); strncpy(token->str, tmp, token_size); //media_content_debug("type : [%d] str : [%s]", token->type, token->str); @@ -186,11 +175,8 @@ static int __tokenize_string(token_t *token, const char *str, int size) if(token != NULL && STRING_VALID(tmp) && size > 0) { token->str = (char*)calloc(size+1, sizeof(char)); - if(token->str == NULL) - { - media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY); - return -1; - } + media_content_retvm_if(token->str == NULL, -1, "OUT_OF_MEMORY"); + token->type = UNKNOWN_TYPE; strncpy(token->str, tmp, size); //media_content_debug("type : [%d] str : [%s]", token->type, token->str); @@ -208,10 +194,7 @@ static int __tokenize_attribute(GList **token_list, const char *str) int ret = 0; int idx = 0; - if(!STRING_VALID(str)) { - media_content_error("Parameter string in invalid"); - return MEDIA_CONTENT_ERROR_INVALID_PARAMETER; - } + media_content_retvm_if(!STRING_VALID(str), MEDIA_CONTENT_ERROR_INVALID_PARAMETER, "Parameter string is invalid"); const char *tmp = str; const char *dst_ptr = str + strlen(str); @@ -228,11 +211,8 @@ static int __tokenize_attribute(GList **token_list, const char *str) 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; - } + media_content_retvm_if(token == NULL, -1, "OUT_OF_MEMORY"); + token->type = UNKNOWN_TYPE; token->str = (char*)calloc(idx+1, sizeof(char)); if(token->str == NULL) @@ -252,11 +232,8 @@ static int __tokenize_attribute(GList **token_list, const char *str) if(idx != 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; - } + media_content_retvm_if(token == NULL, -1, "OUT_OF_MEMORY"); + ret = __tokenize_string(token, tmp, idx); if (ret < 0) { @@ -292,11 +269,7 @@ static int __tokenize_attribute(GList **token_list, const char *str) if(*tmp) //remained string { 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; - } + media_content_retvm_if(token == NULL, -1, "OUT_OF_MEMORY"); ret = __tokenize_string(token, tmp, idx); if (ret < 0) @@ -326,10 +299,7 @@ static int __tokenize(GList **token_list, const char *str) int ret = 0; int idx = 0; - if(!STRING_VALID(str)) { - media_content_error("Parameter string in invalid"); - return MEDIA_CONTENT_ERROR_INVALID_PARAMETER; - } + media_content_retvm_if(!STRING_VALID(str), MEDIA_CONTENT_ERROR_INVALID_PARAMETER, "Parameter string is invalid"); const char *tmp = str; const char *dst_ptr = str + strlen(str); @@ -347,11 +317,8 @@ static int __tokenize(GList **token_list, const char *str) } 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; - } + media_content_retvm_if(token == NULL, -1, "OUT_OF_MEMORY"); + token->type = UNKNOWN_TYPE; token->str = (char*)calloc(idx+1, sizeof(char)); if(token->str == NULL) @@ -380,11 +347,8 @@ static int __tokenize(GList **token_list, const char *str) 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; - } + media_content_retvm_if(token == NULL, -1, "OUT_OF_MEMORY"); + token->str = (char*) calloc(j+1+1, sizeof(char)); if(token->str == NULL) { @@ -406,11 +370,8 @@ static int __tokenize(GList **token_list, const char *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; - } + media_content_retvm_if(token == NULL, -1, "OUT_OF_MEMORY"); + token->str = (char*) calloc(j+1,sizeof(char)); if(token->str == NULL) { @@ -440,11 +401,8 @@ static int __tokenize(GList **token_list, const char *str) 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; - } + media_content_retvm_if(token == NULL, -1, "OUT_OF_MEMORY"); + token->str = (char*) calloc(j+1+1, sizeof(char)); if(token->str == NULL) { @@ -466,11 +424,8 @@ static int __tokenize(GList **token_list, const char *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; - } + media_content_retvm_if(token == NULL, -1, "OUT_OF_MEMORY"); + token->str = (char*) calloc(j+1,sizeof(char)); if(token->str == NULL) { @@ -491,11 +446,8 @@ static int __tokenize(GList **token_list, const char *str) if(idx != 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; - } + media_content_retvm_if(token == NULL, -1, "OUT_OF_MEMORY"); + ret = __tokenize_string(token, tmp, idx); if (ret < 0) { @@ -531,11 +483,7 @@ static int __tokenize(GList **token_list, const char *str) if(idx != 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; - } + media_content_retvm_if(token == NULL, -1, "OUT_OF_MEMORY"); ret = __tokenize_string(token, tmp, idx); if (ret < 0) @@ -572,11 +520,7 @@ static int __tokenize(GList **token_list, const char *str) if(idx != 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; - } + media_content_retvm_if(token == NULL, -1, "OUT_OF_MEMORY"); ret = __tokenize_string(token, tmp, idx); if (ret < 0) @@ -613,11 +557,7 @@ static int __tokenize(GList **token_list, const char *str) if(idx != 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; - } + media_content_retvm_if(token == NULL, -1, "OUT_OF_MEMORY"); ret = __tokenize_string(token, tmp, idx); if (ret < 0) @@ -654,11 +594,7 @@ static int __tokenize(GList **token_list, const char *str) if(idx != 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; - } + media_content_retvm_if(token == NULL, -1, "OUT_OF_MEMORY"); ret = __tokenize_string(token, tmp, idx); if (ret < 0) @@ -695,11 +631,7 @@ static int __tokenize(GList **token_list, const char *str) if(idx != 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; - } + media_content_retvm_if(token == NULL, -1, "OUT_OF_MEMORY"); ret = __tokenize_string(token, tmp, idx); if (ret < 0) @@ -736,11 +668,7 @@ static int __tokenize(GList **token_list, const char *str) if(idx != 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; - } + media_content_retvm_if(token == NULL, -1, "OUT_OF_MEMORY"); ret = __tokenize_string(token, tmp, idx); if (ret < 0) @@ -777,11 +705,7 @@ static int __tokenize(GList **token_list, const char *str) if(*tmp) //remained string { 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; - } + media_content_retvm_if(token == NULL, -1, "OUT_OF_MEMORY"); ret = __tokenize_string(token, tmp, idx); if (ret < 0) @@ -810,61 +734,40 @@ int _media_filter_attribute_create(attribute_h *attr) { int ret = MEDIA_CONTENT_ERROR_NONE; - if(attr == NULL) - { - media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER); - return MEDIA_CONTENT_ERROR_INVALID_PARAMETER; - } + media_content_retvm_if(attr == NULL, MEDIA_CONTENT_ERROR_INVALID_PARAMETER, "invalid attr"); attribute_s *_attr = (attribute_s*)calloc(1, sizeof(attribute_s)); + media_content_retvm_if(_attr == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY"); - if(_attr == NULL) - { - media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY); - ret = MEDIA_CONTENT_ERROR_OUT_OF_MEMORY; - } - else - { - _attr->attr_map = g_hash_table_new (g_str_hash, g_str_equal); - *attr = (attribute_h)_attr; - } + _attr->attr_map = g_hash_table_new (g_str_hash, g_str_equal); + *attr = (attribute_h)_attr; return ret; } -int _media_filter_attribute_add(attribute_h attr, char *user_attr, char *platform_attr) +int _media_filter_attribute_add(attribute_h attr, const char *user_attr, const char *platform_attr) { int ret = MEDIA_CONTENT_ERROR_NONE; char *_user = NULL; char *_platform = NULL; attribute_s *_attr = (attribute_s*)attr; - if(_attr != NULL) - { - if(STRING_VALID(user_attr) && STRING_VALID(platform_attr)) - { - _user = strdup(user_attr); - if(_user == NULL) - { - media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY); - return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY; - } + media_content_retvm_if(_attr == NULL, MEDIA_CONTENT_ERROR_INVALID_PARAMETER, "invalid attr"); - _platform = strdup(platform_attr); - if(_platform == NULL) - { - SAFE_FREE(_user); - media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY); - return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY; - } + if(STRING_VALID(user_attr) && STRING_VALID(platform_attr)) + { + _user = strdup(user_attr); + media_content_retvm_if(_user == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY"); - g_hash_table_insert (_attr->attr_map, _user, _platform); - } - else + _platform = strdup(platform_attr); + if(_platform == NULL) { - media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER); - return MEDIA_CONTENT_ERROR_INVALID_PARAMETER; + SAFE_FREE(_user); + media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY); + return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY; } + + g_hash_table_insert (_attr->attr_map, _user, _platform); } else { @@ -880,104 +783,88 @@ int _media_filter_attribute_destory(attribute_h attr) int ret = MEDIA_CONTENT_ERROR_NONE; attribute_s *_attr = (attribute_s*)attr; - if(_attr != NULL) - { - if(_attr->attr_map != NULL) - { - g_hash_table_foreach(_attr->attr_map, __filter_attribute_free_value, NULL); - g_hash_table_destroy(_attr->attr_map); - } + media_content_retvm_if(_attr == NULL, MEDIA_CONTENT_ERROR_INVALID_PARAMETER, "invalid attr"); - SAFE_FREE(_attr); - } - else + if(_attr->attr_map != NULL) { - media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER); - return MEDIA_CONTENT_ERROR_INVALID_PARAMETER; + g_hash_table_foreach(_attr->attr_map, __filter_attribute_free_value, NULL); + g_hash_table_destroy(_attr->attr_map); } + SAFE_FREE(_attr); + return ret; } int _media_filter_attribute_generate(attribute_h attr, char *condition, media_content_collation_e collate_type, char **generated_condition) { - int idx = 0; + unsigned int idx = 0; GList *token_list = NULL; int size = 0; int ret = MEDIA_CONTENT_ERROR_NONE; int total_str_size = 0; token_t *token; - if((condition == NULL) || (generated_condition == NULL)) + media_content_retvm_if(condition == NULL, MEDIA_CONTENT_ERROR_INVALID_PARAMETER, "invalid condition"); + media_content_retvm_if(generated_condition == NULL, MEDIA_CONTENT_ERROR_INVALID_PARAMETER, "invalid generated_condition"); + media_content_retvm_if(attr == NULL, MEDIA_CONTENT_ERROR_DB_FAILED, "DB field mapping table doesn't exist. Check db connection"); + + if(__tokenize(&token_list, condition) < 0) { media_content_error("INVALID_PARAMETER(0x%08x):Invalid the condition", MEDIA_CONTENT_ERROR_INVALID_PARAMETER); return MEDIA_CONTENT_ERROR_INVALID_PARAMETER; } - if(attr != NULL) + for(idx = 0; idx < g_list_length(token_list); idx++) { - if(__tokenize(&token_list, condition) < 0) - { - media_content_error("INVALID_PARAMETER(0x%08x):Invalid the condition", MEDIA_CONTENT_ERROR_INVALID_PARAMETER); - return MEDIA_CONTENT_ERROR_INVALID_PARAMETER; - } + token = (token_t*)g_list_nth_data(token_list, idx); - for(idx = 0; idx < g_list_length(token_list); idx++) + if(token->type == UNKNOWN_TYPE) { - token = (token_t*)g_list_nth_data(token_list, idx); - - if(token->type == UNKNOWN_TYPE) + char *replace_str = __media_filter_replace_attr(attr, token->str); + if(STRING_VALID(replace_str)) { - char *replace_str = __media_filter_replace_attr(attr, token->str); - if(STRING_VALID(replace_str)) - { - SAFE_FREE(token->str); - token->str = replace_str; - } + SAFE_FREE(token->str); + token->str = replace_str; } - - total_str_size += strlen(token->str)+1; - //media_content_debug("[%d][type:%d]:%s", idx, token->type, token->str); } - //make the statment - size = total_str_size + COLLATE_STR_SIZE + 1; - * generated_condition = (char*)calloc(size, sizeof(char)); - - for(idx = 0; idx < g_list_length(token_list); idx++) - { - token = (token_t*)g_list_nth_data(token_list, idx); + total_str_size += strlen(token->str)+1; + //media_content_debug("[%d][type:%d]:%s", idx, token->type, token->str); + } - if((token != NULL) && STRING_VALID(token->str)) - { - SAFE_STRLCAT(*generated_condition, token->str, size); - SAFE_STRLCAT(*generated_condition, SPACE, size); + //make the statment + size = total_str_size + COLLATE_STR_SIZE + 1; + * generated_condition = (char*)calloc(size, sizeof(char)); - SAFE_FREE(token->str); - SAFE_FREE(token); - } - } + for(idx = 0; idx < g_list_length(token_list); idx++) + { + token = (token_t*)g_list_nth_data(token_list, idx); - 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); + if((token != NULL) && STRING_VALID(token->str)) + { + SAFE_STRLCAT(*generated_condition, token->str, size); SAFE_STRLCAT(*generated_condition, SPACE, size); + + SAFE_FREE(token->str); + SAFE_FREE(token); } + } - //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(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); + } - //if(*generated_condition != NULL) - // res = 1; + //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(token_list != NULL) - g_list_free(token_list); - } - else - { - media_content_error("DB field mapping table doesn't exist. Check db connection", MEDIA_CONTENT_ERROR_DB_FAILED); - return MEDIA_CONTENT_ERROR_DB_FAILED; - } + //if(*generated_condition != NULL) + // res = 1; + + if(token_list != NULL) + g_list_free(token_list); return ret; } @@ -991,17 +878,8 @@ int _media_filter_attribute_option_generate(attribute_h attr, filter_h filter, c int size = 0; //bool order_by = true; - if(filter == NULL) - { - media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER); - return MEDIA_CONTENT_ERROR_INVALID_PARAMETER; - } - - if(attr == NULL) - { - media_content_error("DB field mapping table doesn't exist. Check db connection", MEDIA_CONTENT_ERROR_DB_FAILED); - return MEDIA_CONTENT_ERROR_DB_FAILED; - } + media_content_retvm_if(attr == NULL, MEDIA_CONTENT_ERROR_INVALID_PARAMETER, "invalid attr"); + media_content_retvm_if(filter == NULL, MEDIA_CONTENT_ERROR_INVALID_PARAMETER, "invalid filter"); _filter = (filter_s*)filter; @@ -1010,7 +888,7 @@ int _media_filter_attribute_option_generate(attribute_h attr, filter_h filter, c /* Order by*/ if(STRING_VALID(_filter->order_keyword) && ((_filter->order_type == MEDIA_CONTENT_ORDER_ASC) ||(_filter->order_type == MEDIA_CONTENT_ORDER_DESC))) { - int idx = 0; + unsigned int idx = 0; int total_str_size = 0; GList *token_list = NULL; token_t *token; @@ -1109,32 +987,21 @@ int media_filter_create(filter_h *filter) { int ret = MEDIA_CONTENT_ERROR_NONE; - if(filter == NULL) - { - media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER); - return MEDIA_CONTENT_ERROR_INVALID_PARAMETER; - } + media_content_retvm_if(filter == NULL, MEDIA_CONTENT_ERROR_INVALID_PARAMETER, "invalid filter"); filter_s *_filter = (filter_s*)calloc(1, sizeof(filter_s)); + media_content_retvm_if(_filter == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY"); - if(_filter == NULL) - { - media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY); - ret = MEDIA_CONTENT_ERROR_OUT_OF_MEMORY; - } - else - { - _filter->storage_id = NULL; - _filter->condition = NULL; - _filter->order_keyword = NULL; - _filter->order_type = -1; - _filter->condition_collate_type = MEDIA_CONTENT_COLLATE_DEFAULT; - _filter->order_collate_type = MEDIA_CONTENT_COLLATE_DEFAULT; - _filter->offset = -1; - _filter->count = -1; - - *filter = (filter_h)_filter; - } + _filter->storage_id = NULL; + _filter->condition = NULL; + _filter->order_keyword = NULL; + _filter->order_type = -1; + _filter->condition_collate_type = MEDIA_CONTENT_COLLATE_DEFAULT; + _filter->order_collate_type = MEDIA_CONTENT_COLLATE_DEFAULT; + _filter->offset = -1; + _filter->count = -1; + + *filter = (filter_h)_filter; return ret; } @@ -1195,11 +1062,7 @@ int media_filter_set_condition(filter_h filter, const char *condition, media_con } _filter->condition = strdup(condition); - if(_filter->condition == NULL) - { - media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY); - return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY; - } + media_content_retvm_if(_filter->condition == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY"); media_content_sec_debug("Condition string : %s", _filter->condition); @@ -1228,12 +1091,8 @@ int media_filter_set_order(filter_h filter, media_content_order_e order_type, co if(STRING_VALID(order_keyword)) { _filter->order_keyword = strdup(order_keyword); + media_content_retvm_if(_filter->order_keyword == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY"); - if(_filter->order_keyword == NULL) - { - media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY); - return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY; - } _filter->order_type = order_type; _filter->order_collate_type = collate_type; } @@ -1265,11 +1124,7 @@ int media_filter_set_storage(filter_h filter, const char *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_retvm_if(_filter->storage_id == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY"); media_content_sec_debug("storage_id : %s", _filter->storage_id); } @@ -1311,11 +1166,7 @@ int media_filter_get_condition(filter_h filter, char **condition, media_content_ if(STRING_VALID(_filter->condition)) { *condition = strdup(_filter->condition); - if(*condition == NULL) - { - media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY); - return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY; - } + media_content_retvm_if(*condition == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY"); } else { @@ -1343,11 +1194,7 @@ int media_filter_get_order(filter_h filter, media_content_order_e* order_type, c if(STRING_VALID(_filter->order_keyword)) { *order_keyword = strdup(_filter->order_keyword); - if(*order_keyword == NULL) - { - media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY); - return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY; - } + media_content_retvm_if(*order_keyword == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY"); } else { @@ -1376,11 +1223,7 @@ int media_filter_get_storage(filter_h filter, char **storage_id) 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; - } + media_content_retvm_if(*storage_id == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY"); } else { diff --git a/src/media_folder.c b/src/media_folder.c index 1cac252..11f25b9 100755 --- a/src/media_folder.c +++ b/src/media_folder.c @@ -137,11 +137,7 @@ int media_folder_clone(media_folder_h *dst, media_folder_h src) if(_src != NULL) { media_folder_s *_dst = (media_folder_s*)calloc(1, sizeof(media_folder_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; - } + media_content_retvm_if(_dst == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY"); if(STRING_VALID(_src->folder_id)) { @@ -212,11 +208,7 @@ int media_folder_get_folder_id(media_folder_h folder, char **folder_id) if(STRING_VALID(_folder->folder_id)) { *folder_id = strdup(_folder->folder_id); - if(*folder_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_retvm_if(*folder_id == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY"); } else { @@ -237,16 +229,13 @@ int media_folder_get_path(media_folder_h folder, char **path) { int ret = MEDIA_CONTENT_ERROR_NONE; media_folder_s *_folder = (media_folder_s*)folder; + if(_folder) { if(STRING_VALID(_folder->path)) { *path = strdup(_folder->path); - if(*path == NULL) - { - media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY); - return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY; - } + media_content_retvm_if(*path == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY"); } else { @@ -269,16 +258,13 @@ int media_folder_get_name(media_folder_h folder, char **name) { int ret = MEDIA_CONTENT_ERROR_NONE; media_folder_s *_folder = (media_folder_s*)folder; + if(_folder) { if(STRING_VALID(_folder->name)) { *name = strdup(_folder->name); - if(*name == NULL) - { - media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY); - return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY; - } + media_content_retvm_if(*name == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY"); } else { @@ -300,6 +286,7 @@ int media_folder_get_modified_time(media_folder_h folder, time_t* time) { int ret = MEDIA_CONTENT_ERROR_NONE; media_folder_s *_folder = (media_folder_s*)folder; + if(_folder) { *time = _folder->modified_time; @@ -318,6 +305,7 @@ int media_folder_get_storage_type(media_folder_h folder, media_content_storage_e { int ret = MEDIA_CONTENT_ERROR_NONE; media_folder_s *_folder = (media_folder_s*)folder; + if(_folder) { *storage_type = _folder->storage_type; @@ -336,16 +324,13 @@ 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; - } + media_content_retvm_if(*storage_id == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY"); } else { @@ -367,6 +352,7 @@ 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; @@ -401,10 +387,14 @@ int media_folder_get_folder_from_db(const char *folder_id, media_folder_h *folde ret = _content_query_prepare(&stmt, select_query, NULL, NULL); media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret); + media_folder_s *_folder = NULL; + while(sqlite3_step(stmt) == SQLITE_ROW) { - media_folder_s *_folder = (media_folder_s*)calloc(1, sizeof(media_folder_s)); + if(_folder) + media_folder_destroy((media_folder_h)_folder); + _folder = (media_folder_s*)calloc(1, sizeof(media_folder_s)); if(_folder == NULL) { media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY); @@ -509,20 +499,11 @@ int media_folder_set_name(media_folder_h folder, const char *name) SAFE_FREE(_folder->name); SAFE_FREE(folder_path); _folder->path = strdup(new_folder_path); - - if(_folder->path == NULL) - { - media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY); - return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY; - } + media_content_retvm_if(_folder->path == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY"); } _folder->name = strdup(name); - if(_folder->name == NULL) - { - media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY); - return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY; - } + media_content_retvm_if(_folder->name == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY"); } else { diff --git a/src/media_group.c b/src/media_group.c index cc98ff2..84b7565 100755 --- a/src/media_group.c +++ b/src/media_group.c @@ -162,12 +162,7 @@ int media_album_clone(media_album_h *dst, media_album_h src) if(_src != NULL) { media_album_s *_dst = (media_album_s*)calloc(1, sizeof(media_album_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; - } + media_content_retvm_if(_dst == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY"); _dst->album_id = _src->album_id; @@ -246,11 +241,7 @@ int media_album_get_name(media_album_h album, char **name) if(STRING_VALID(_album->name)) { *name = strdup(_album->name); - if(*name == NULL) - { - media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY); - return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY; - } + media_content_retvm_if(*name == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY"); } else { @@ -278,11 +269,7 @@ int media_album_get_artist(media_album_h album, char **artist) if(STRING_VALID(_album->artist)) { *artist = strdup(_album->artist); - if(*artist == NULL) - { - media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY); - return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY; - } + media_content_retvm_if(*artist == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY"); } else { @@ -310,11 +297,7 @@ int media_album_get_album_art(media_album_h album, char **album_art) if(STRING_VALID(_album->album_art_path)) { *album_art = strdup(_album->album_art_path); - if(*album_art == NULL) - { - media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY); - return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY; - } + media_content_retvm_if(*album_art == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY"); } else { diff --git a/src/media_image.c b/src/media_image.c index a8ad9c5..ff06636 100755 --- a/src/media_image.c +++ b/src/media_image.c @@ -53,11 +53,7 @@ int image_meta_clone(image_meta_h *dst, image_meta_h src) if(_src != NULL) { image_meta_s *_dst = (image_meta_s*)calloc(1, sizeof(image_meta_s)); - if(NULL == _dst) - { - media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY); - return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY; - } + media_content_retvm_if(_dst == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY"); if(STRING_VALID(_src->media_id)) { @@ -165,11 +161,8 @@ int image_meta_get_media_id(image_meta_h image, char **media_id) if(STRING_VALID(_image->media_id)) { char *new_string = strdup(_image->media_id); - 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; - } + media_content_retvm_if(new_string == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY"); + *media_id = new_string; } else @@ -255,11 +248,8 @@ int image_meta_get_date_taken(image_meta_h image, char **date_taken) if(STRING_VALID(_image->date_taken)) { char *new_string = strdup(_image->date_taken); - 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; - } + media_content_retvm_if(new_string == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY"); + *date_taken = new_string; } else @@ -288,11 +278,7 @@ int image_meta_get_burst_id(image_meta_h image, char **burst_id) if(STRING_VALID(_image->burst_id)) { *burst_id = strdup(_image->burst_id); - if(*burst_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_retvm_if(*burst_id == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY"); } else { @@ -319,11 +305,7 @@ int image_meta_get_exposure_time(image_meta_h image, char **exposure_time) if(STRING_VALID(_image->exposure_time)) { *exposure_time = strdup(_image->exposure_time); - if(*exposure_time == NULL) - { - media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY); - return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY; - } + media_content_retvm_if(*exposure_time == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY"); } else { @@ -388,11 +370,7 @@ int image_meta_get_model(image_meta_h image, char **model) if(STRING_VALID(_image->model)) { *model = strdup(_image->model); - if(*model == NULL) - { - media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY); - return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY; - } + media_content_retvm_if(*model == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY"); } else { diff --git a/src/media_info.c b/src/media_info.c index 5425344..7ad6d87 100755 --- a/src/media_info.c +++ b/src/media_info.c @@ -30,11 +30,7 @@ static int __media_info_get_media_path_by_id_from_db(const char *media_id, char sqlite3_stmt *stmt = NULL; char *select_query = NULL; - if(!STRING_VALID(media_id)) - { - media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER); - return MEDIA_CONTENT_ERROR_INVALID_PARAMETER; - } + media_content_retvm_if(!STRING_VALID(media_id), MEDIA_CONTENT_ERROR_INVALID_PARAMETER, "invalid media_id"); select_query = sqlite3_mprintf(SELECT_MEDIA_PATH_BY_ID, media_id); @@ -148,7 +144,7 @@ static int __media_info_insert_batch(media_batch_insert_e insert_type, const cha int ret = MEDIA_CONTENT_ERROR_NONE; FILE *fp = NULL; char list_path[255] = {0,}; - int idx = 0; + unsigned int idx = 0; int nwrites = 0; for (idx = 0; idx < BATCH_REQUEST_MAX; idx++) { @@ -215,11 +211,7 @@ static int __media_info_insert_batch(media_batch_insert_e insert_type, const cha 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; - } + media_content_retvm_if(_cb_data == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY"); _cb_data->insert_completed_cb = completed_cb; _cb_data->user_data = user_data; @@ -457,11 +449,7 @@ int _media_info_get_media_info_from_db(const char *path, const char *storage_id, 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; - } + media_content_retvm_if(_media == NULL, MEDIA_CONTENT_ERROR_INVALID_PARAMETER, "invalid media"); select_query = sqlite3_mprintf(SELECT_MEDIA_BY_PATH, storage_id, path); @@ -488,31 +476,17 @@ int media_info_insert_to_db(const char *path, media_info_h *info) char *folder_path = NULL; int ret = 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; - } - - if(info == NULL) - { - media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER); - return MEDIA_CONTENT_ERROR_INVALID_PARAMETER; - } + media_content_retvm_if(!STRING_VALID(path), MEDIA_CONTENT_ERROR_INVALID_PARAMETER, "invalid path"); + media_content_retvm_if(info == NULL, MEDIA_CONTENT_ERROR_INVALID_PARAMETER, "invalid info"); ret = _media_util_check_file(path); - if (ret != MEDIA_CONTENT_ERROR_NONE) { - return ret; - } + media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret); 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; - } + media_content_retvm_if(ignore_dir, MEDIA_CONTENT_ERROR_INVALID_PARAMETER, "Invalid folder path"); ret = media_svc_check_item_exist_by_path(_content_get_db_handle(), path); if (ret == MS_MEDIA_ERR_DB_NO_RECORD) { @@ -544,11 +518,7 @@ int media_info_insert_to_db(const char *path, media_info_h *info) } 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_content_retvm_if(_media == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY"); ret = _media_info_get_media_info_from_db(path, DEFAULT_MEDIA_STORAGE_ID, (media_info_h)_media); @@ -562,34 +532,16 @@ int media_info_insert_batch_to_db( media_insert_completed_cb completed_cb, void *user_data) { - if (path_array == NULL) - { - media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER); - return MEDIA_CONTENT_ERROR_INVALID_PARAMETER; - } - - if (array_length <= 0) - { - media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER); - return MEDIA_CONTENT_ERROR_INVALID_PARAMETER; - } + media_content_retvm_if(path_array == NULL, MEDIA_CONTENT_ERROR_INVALID_PARAMETER, "Invalid path_array"); + media_content_retvm_if(array_length <= 0, MEDIA_CONTENT_ERROR_INVALID_PARAMETER, "Invalid array_length"); return __media_info_insert_batch(MEDIA_BATCH_INSERT_NORMAL, path_array, array_length, completed_cb, user_data); } int media_info_insert_burst_shot_to_db(const char **path_array, unsigned int array_length, media_insert_burst_shot_completed_cb callback, void *user_data) { - if (path_array == NULL) - { - media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER); - return MEDIA_CONTENT_ERROR_INVALID_PARAMETER; - } - - if (array_length <= 0) - { - media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER); - return MEDIA_CONTENT_ERROR_INVALID_PARAMETER; - } + media_content_retvm_if(path_array == NULL, MEDIA_CONTENT_ERROR_INVALID_PARAMETER, "Invalid path_array"); + media_content_retvm_if(array_length <= 0, MEDIA_CONTENT_ERROR_INVALID_PARAMETER, "Invalid array_length"); return __media_info_insert_batch(MEDIA_BATCH_INSERT_BURSTSHOT, path_array, array_length, callback, user_data); } @@ -681,11 +633,7 @@ int media_info_delete_batch_from_db(filter_h filter) char *condition_query = NULL; GArray *thumb_list = NULL; - if(filter == NULL) - { - media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER); - return MEDIA_CONTENT_ERROR_INVALID_PARAMETER; - } + media_content_retvm_if(filter == NULL, MEDIA_CONTENT_ERROR_INVALID_PARAMETER, "Invalid filter"); thumb_list = g_array_new(FALSE, FALSE, sizeof(char*)); @@ -830,12 +778,7 @@ int media_info_clone(media_info_h *dst, media_info_h src) if(_src != NULL) { media_info_s *_dst = (media_info_s*)calloc(1, sizeof(media_info_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; - } + media_content_retvm_if(_dst == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY"); if(STRING_VALID(_src->media_id)) { @@ -1391,11 +1334,7 @@ int media_info_foreach_media_from_db(filter_h filter, media_info_cb callback, vo { 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; - } + media_content_retvm_if(callback == NULL, MEDIA_CONTENT_ERROR_INVALID_PARAMETER, "Invalid callback"); ret = _media_db_get_group_item(NULL, filter, callback, user_data, MEDIA_GROUP_NONE); @@ -1476,31 +1415,12 @@ int media_info_get_image(media_info_h media, image_meta_h *image) 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_IMAGE) - { - media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER); - return MEDIA_CONTENT_ERROR_INVALID_PARAMETER; - } - - if(_media->image_meta == NULL) - { - media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER); - return MEDIA_CONTENT_ERROR_INVALID_PARAMETER; - } + media_content_retvm_if(_media == NULL, MEDIA_CONTENT_ERROR_INVALID_PARAMETER, "Invalid media"); + media_content_retvm_if(_media->media_type != MEDIA_CONTENT_TYPE_IMAGE, MEDIA_CONTENT_ERROR_INVALID_PARAMETER, "Invalid media_type"); + media_content_retvm_if(_media->image_meta == NULL, MEDIA_CONTENT_ERROR_INVALID_PARAMETER, "Invalid image_meta"); image_meta_s *_image = (image_meta_s*)calloc(1, sizeof(image_meta_s)); - - if(_image == NULL) - { - media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY); - return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY; - } + media_content_retvm_if(_image == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY"); if(STRING_VALID(_media->media_id)) { _image->media_id = strdup(_media->media_id); @@ -1547,31 +1467,12 @@ int media_info_get_video(media_info_h media, video_meta_h *video) 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_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER); - return MEDIA_CONTENT_ERROR_INVALID_PARAMETER; - } - - if(_media->video_meta == NULL) - { - media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER); - return MEDIA_CONTENT_ERROR_INVALID_PARAMETER; - } + media_content_retvm_if(_media == NULL, MEDIA_CONTENT_ERROR_INVALID_PARAMETER, "Invalid media"); + media_content_retvm_if(_media->media_type != MEDIA_CONTENT_TYPE_VIDEO, MEDIA_CONTENT_ERROR_INVALID_PARAMETER, "Invalid media_type"); + media_content_retvm_if(_media->video_meta == NULL, MEDIA_CONTENT_ERROR_INVALID_PARAMETER, "Invalid video_meta"); video_meta_s *_video = (video_meta_s*)calloc(1, sizeof(video_meta_s)); - - if(_video == NULL) - { - media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY); - return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY; - } + media_content_retvm_if(_video == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY"); if(STRING_VALID(_media->media_id)) { _video->media_id = strdup(_media->media_id); @@ -1627,31 +1528,13 @@ int media_info_get_audio(media_info_h media, audio_meta_h *audio) 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_MUSIC && _media->media_type != MEDIA_CONTENT_TYPE_SOUND) - { - media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER); - return MEDIA_CONTENT_ERROR_INVALID_PARAMETER; - } - if(_media->audio_meta == NULL) - { - media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER); - return MEDIA_CONTENT_ERROR_INVALID_PARAMETER; - } + media_content_retvm_if(_media == NULL, MEDIA_CONTENT_ERROR_INVALID_PARAMETER, "Invalid media"); + media_content_retvm_if(_media->media_type != MEDIA_CONTENT_TYPE_MUSIC && _media->media_type != MEDIA_CONTENT_TYPE_SOUND, MEDIA_CONTENT_ERROR_INVALID_PARAMETER, "Invalid media_type"); + media_content_retvm_if(_media->audio_meta == NULL, MEDIA_CONTENT_ERROR_INVALID_PARAMETER, "Invalid audio_meta"); audio_meta_s *_audio = (audio_meta_s*)calloc(1, sizeof(audio_meta_s)); - - if(_audio == NULL) - { - media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY); - return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY; - } + media_content_retvm_if(_audio == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY"); if(STRING_VALID(_media->media_id)) { _audio->media_id = strdup(_media->media_id); @@ -1712,11 +1595,7 @@ int media_info_get_media_id(media_info_h media, char **media_id) if(STRING_VALID(_media->media_id)) { *media_id = strdup(_media->media_id); - if(*media_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_retvm_if(*media_id == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY"); } else { @@ -1743,11 +1622,7 @@ int media_info_get_file_path(media_info_h media, char **path) if(STRING_VALID(_media->file_path)) { *path = strdup(_media->file_path); - if(*path == NULL) - { - media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY); - return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY; - } + media_content_retvm_if(*path == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY"); } else { @@ -1774,11 +1649,7 @@ int media_info_get_display_name(media_info_h media, char **name) if(STRING_VALID(_media->display_name)) { *name = strdup(_media->display_name); - if(*name == NULL) - { - media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY); - return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY; - } + media_content_retvm_if(*name == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY"); } else { @@ -1824,11 +1695,7 @@ int media_info_get_mime_type(media_info_h media, char **mime_type) if(STRING_VALID(_media->mime_type)) { *mime_type = strdup(_media->mime_type); - if(*mime_type == NULL) - { - media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY); - return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY; - } + media_content_retvm_if(*mime_type == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY"); } else { @@ -1927,11 +1794,7 @@ int media_info_get_thumbnail_path(media_info_h media, char **path) if(STRING_VALID(_media->thumbnail_path)) { *path = strdup(_media->thumbnail_path); - if(*path == NULL) - { - media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY); - return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY; - } + media_content_retvm_if(*path == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY"); } else { @@ -1959,11 +1822,7 @@ int media_info_get_title(media_info_h media, char **title) if(STRING_VALID(_media->title)) { *title = strdup(_media->title); - if(*title == NULL) - { - media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY); - return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY; - } + media_content_retvm_if(*title == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY"); } else { @@ -1990,11 +1849,7 @@ int media_info_get_description(media_info_h media, char **description) if(STRING_VALID(_media->description)) { *description = strdup(_media->description); - if(*description == NULL) - { - media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY); - return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY; - } + media_content_retvm_if(*description == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY"); } else { @@ -2077,11 +1932,7 @@ int media_info_get_weather(media_info_h media, char **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; - } + media_content_retvm_if(*weather == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY"); } else { @@ -2147,11 +1998,7 @@ int media_info_get_author(media_info_h media, char **author) if(STRING_VALID(_media->author)) { *author = strdup(_media->author); - if(*author == NULL) - { - media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY); - return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY; - } + media_content_retvm_if(*author == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY"); } else { @@ -2178,11 +2025,7 @@ int media_info_get_provider(media_info_h media, char **provider) if(STRING_VALID(_media->provider)) { *provider = strdup(_media->provider); - if(*provider == NULL) - { - media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY); - return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY; - } + media_content_retvm_if(*provider == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY"); } else { @@ -2209,11 +2052,7 @@ int media_info_get_content_name(media_info_h media, char **content_name) if(STRING_VALID(_media->content_name)) { *content_name = strdup(_media->content_name); - if(*content_name == NULL) - { - media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY); - return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY; - } + media_content_retvm_if(*content_name == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY"); } else { @@ -2240,11 +2079,7 @@ int media_info_get_category(media_info_h media, char **category) if(STRING_VALID(_media->category)) { *category = strdup(_media->category); - if(*category == NULL) - { - media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY); - return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY; - } + media_content_retvm_if(*category == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY"); } else { @@ -2271,11 +2106,7 @@ int media_info_get_location_tag(media_info_h media, char **location_tag) if(STRING_VALID(_media->location_tag)) { *location_tag = strdup(_media->location_tag); - if(*location_tag == NULL) - { - media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY); - return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY; - } + media_content_retvm_if(*location_tag == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY"); } else { @@ -2302,11 +2133,7 @@ int media_info_get_age_rating(media_info_h media, char **age_rating) if(STRING_VALID(_media->age_rating)) { *age_rating = strdup(_media->age_rating); - if(*age_rating == NULL) - { - media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY); - return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY; - } + media_content_retvm_if(*age_rating == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY"); } else { @@ -2333,11 +2160,7 @@ int media_info_get_keyword(media_info_h media, char **keyword) if(STRING_VALID(_media->keyword)) { *keyword = strdup(_media->keyword); - if(*keyword == NULL) - { - media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY); - return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY; - } + media_content_retvm_if(*keyword == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY"); } else { @@ -2364,11 +2187,7 @@ int media_info_get_storage_id(media_info_h media, char **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; - } + media_content_retvm_if(*storage_id == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY"); } else { @@ -2561,11 +2380,7 @@ int media_info_set_display_name(media_info_h media, const char *display_name) SAFE_FREE(_media->display_name); _media->display_name = strdup(display_name); - if(_media->display_name == NULL) - { - media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY); - return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY; - } + media_content_retvm_if(_media->display_name == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY"); } else { @@ -2588,12 +2403,7 @@ int media_info_set_description(media_info_h media, const char *description) if(STRING_VALID(description)) { _media->description = strdup(description); - - if(_media->description == NULL) - { - media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY); - return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY; - } + media_content_retvm_if(_media->description == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY"); } else { @@ -2675,12 +2485,7 @@ int media_info_set_weather(media_info_h media, const char *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; - } + media_content_retvm_if(_media->weather == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY"); } else { @@ -2768,11 +2573,7 @@ int media_info_set_author(media_info_h media, const char *author) if(STRING_VALID(author)) { _media->author = strdup(author); - if(_media->author == NULL) - { - media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY); - return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY; - } + media_content_retvm_if(_media->author == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY"); } else { @@ -2800,11 +2601,7 @@ int media_info_set_provider(media_info_h media, const char *provider) if(STRING_VALID(provider)) { _media->provider = strdup(provider); - if(_media->provider == NULL) - { - media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY); - return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY; - } + media_content_retvm_if(_media->provider == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY"); } else { @@ -2832,11 +2629,7 @@ int media_info_set_content_name(media_info_h media, const char *content_name) if(STRING_VALID(content_name)) { _media->content_name = strdup(content_name); - if(_media->content_name == NULL) - { - media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY); - return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY; - } + media_content_retvm_if(_media->content_name == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY"); } else { @@ -2864,11 +2657,7 @@ int media_info_set_category(media_info_h media, const char *category) if(STRING_VALID(category)) { _media->category = strdup(category); - if(_media->category == NULL) - { - media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY); - return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY; - } + media_content_retvm_if(_media->category == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY"); } else { @@ -2896,11 +2685,7 @@ int media_info_set_location_tag(media_info_h media, const char *location_tag) if(STRING_VALID(location_tag)) { _media->location_tag = strdup(location_tag); - if(_media->location_tag == NULL) - { - media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY); - return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY; - } + media_content_retvm_if(_media->location_tag == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY"); } else { @@ -2928,11 +2713,7 @@ int media_info_set_age_rating(media_info_h media, const char *age_rating) if(STRING_VALID(age_rating)) { _media->age_rating = strdup(age_rating); - if(_media->age_rating == NULL) - { - media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY); - return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY; - } + media_content_retvm_if(_media->age_rating == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY"); } else { @@ -2960,11 +2741,7 @@ int media_info_set_keyword(media_info_h media, const char *keyword) if(STRING_VALID(keyword)) { _media->keyword = strdup(keyword); - if(_media->keyword == NULL) - { - media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY); - return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY; - } + media_content_retvm_if(_media->keyword == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY"); } else { @@ -3132,18 +2909,13 @@ int media_info_move_to_db(media_info_h media, const char* dst_path) 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_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER); - return MEDIA_CONTENT_ERROR_INVALID_PARAMETER; - } + media_content_retvm_if(media == NULL, MEDIA_CONTENT_ERROR_INVALID_PARAMETER, "invalid media"); + media_content_retvm_if(!STRING_VALID(dst_path), MEDIA_CONTENT_ERROR_INVALID_PARAMETER, "invalid dst_path"); media_info_s *_media = (media_info_s*)media; ret = _media_util_check_file(dst_path); - if (ret != MEDIA_CONTENT_ERROR_NONE) { - return ret; - } + media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret); ret = media_svc_get_storage_type(_media->file_path, &src_storage_type, tzplatform_getuid(TZ_USER_NAME)); if(ret != MS_MEDIA_ERR_NONE) @@ -3171,11 +2943,7 @@ int media_info_create_thumbnail(media_info_h media, media_thumbnail_completed_cb 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; - } + media_content_retvm_if(_thumb_cb == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY"); _thumb_cb->handle = _media; _thumb_cb->user_data = user_data; @@ -3229,12 +2997,7 @@ static int __media_info_set_str_data(media_info_h media, media_info_item_e data_ 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; - } + media_content_retvm_if(_media->file_path == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY"); } else { @@ -3246,12 +3009,7 @@ static int __media_info_set_str_data(media_info_h media, media_info_item_e data_ 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; - } + media_content_retvm_if(_media->mime_type == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY"); } else { @@ -3263,12 +3021,7 @@ static int __media_info_set_str_data(media_info_h media, media_info_item_e data_ 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; - } + media_content_retvm_if(_media->thumbnail_path == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY"); } else { @@ -3280,12 +3033,7 @@ static int __media_info_set_str_data(media_info_h media, media_info_item_e data_ 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; - } + media_content_retvm_if(_media->title == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY"); } else { @@ -3297,12 +3045,7 @@ static int __media_info_set_str_data(media_info_h media, media_info_item_e data_ 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; - } + media_content_retvm_if(_media->storage_uuid == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY"); } else { @@ -3316,12 +3059,7 @@ static int __media_info_set_str_data(media_info_h media, media_info_item_e data_ 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; - } + media_content_retvm_if(_media->video_meta->album == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY"); } else { @@ -3334,12 +3072,7 @@ static int __media_info_set_str_data(media_info_h media, media_info_item_e data_ 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; - } + media_content_retvm_if(_media->audio_meta->album == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY"); } else { @@ -3359,12 +3092,7 @@ static int __media_info_set_str_data(media_info_h media, media_info_item_e data_ 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; - } + media_content_retvm_if(_media->video_meta->artist == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY"); } else { @@ -3377,12 +3105,7 @@ static int __media_info_set_str_data(media_info_h media, media_info_item_e data_ 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; - } + media_content_retvm_if(_media->audio_meta->artist == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY"); } else { @@ -3402,12 +3125,7 @@ static int __media_info_set_str_data(media_info_h media, media_info_item_e data_ 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; - } + media_content_retvm_if(_media->video_meta->genre == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY"); } else { @@ -3420,12 +3138,7 @@ static int __media_info_set_str_data(media_info_h media, media_info_item_e data_ 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; - } + media_content_retvm_if(_media->audio_meta->genre == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY"); } else { @@ -3445,12 +3158,7 @@ static int __media_info_set_str_data(media_info_h media, media_info_item_e data_ 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; - } + media_content_retvm_if(_media->video_meta->recorded_date == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY"); } else { @@ -3463,12 +3171,7 @@ static int __media_info_set_str_data(media_info_h media, media_info_item_e data_ 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; - } + media_content_retvm_if(_media->audio_meta->recorded_date == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY"); } else { @@ -3558,8 +3261,8 @@ int media_info_insert_to_db_with_data(media_info_h media, media_info_h *info) 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); + + ret = media_svc_insert_item_immediately_with_data(_content_get_db_handle(), svc_content_info, tzplatform_getuid(TZ_USER_NAME)); 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); @@ -3569,15 +3272,11 @@ int media_info_insert_to_db_with_data(media_info_h media, media_info_h *info) /*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; - } + media_content_retvm_if(_get_media == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY"); ret = _media_info_get_media_info_from_db(_media->file_path, _media->storage_uuid, (media_info_h)_get_media); @@ -3598,11 +3297,7 @@ int media_info_create_handle(media_info_h *media) } 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_content_retvm_if(_media == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY"); _media->audio_meta = (audio_meta_s *)calloc(1, sizeof(audio_meta_s)); if(_media->audio_meta == NULL) diff --git a/src/media_playlist.c b/src/media_playlist.c index b249ce9..13dffbb 100755 --- a/src/media_playlist.c +++ b/src/media_playlist.c @@ -190,12 +190,10 @@ 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; - } + media_content_retvm_if(ret != MEDIA_CONTENT_ERROR_NONE, FALSE, "media_info_get_media_id fail"); + return TRUE; } @@ -206,11 +204,7 @@ static bool __media_playlist_member_cb(int playlist_member_id, media_info_h medi 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; - } + media_content_retvm_if(ret != MEDIA_CONTENT_ERROR_NONE, FALSE, "media_info_get_file_path fail"); *list = g_list_append(*list, path); @@ -222,11 +216,7 @@ 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; - } + media_content_retvm_if(fp == NULL, MEDIA_CONTENT_ERROR_INVALID_OPERATION, "fopen fail"); fputs("", fp); // remove previous playlist @@ -240,11 +230,7 @@ static int __media_playlist_append_to_file(const char* playlist_path, const char FILE *fp = NULL; fp = fopen(playlist_path, "a"); // append only - if(fp == NULL) - { - media_content_stderror("fopen fail"); - return MEDIA_CONTENT_ERROR_INVALID_OPERATION; - } + media_content_retvm_if(fp == NULL, MEDIA_CONTENT_ERROR_INVALID_OPERATION, "fopen fail"); fputs(path, fp); @@ -270,11 +256,7 @@ static int __media_playlist_import_item_from_file(const char* playlist_path, cha *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; - } + media_content_retvm_if(fp == NULL, MEDIA_CONTENT_ERROR_INVALID_OPERATION, "fopen fail"); fseek(fp, 0, SEEK_END); // Move to the end of file file_size = ftell(fp); // Here we can find the size of file @@ -412,11 +394,7 @@ int media_playlist_insert_to_db(const char *name, media_playlist_h *playlist) } 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); - return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY; - } + media_content_retvm_if(_playlist == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY"); ret = __media_playlist_insert_playlist_record(name, &playlist_id); @@ -557,11 +535,7 @@ int media_playlist_clone(media_playlist_h *dst, media_playlist_h src) if(_src != NULL) { media_playlist_s *_dst = (media_playlist_s*)calloc(1, sizeof(media_playlist_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; - } + media_content_retvm_if(_dst == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY"); _dst->playlist_id = _src->playlist_id; @@ -604,9 +578,14 @@ int media_playlist_get_playlist_from_db(int playlist_id, media_playlist_h *playl ret = _content_query_prepare(&stmt, select_query, NULL, NULL); media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret); + media_playlist_s *_playlist = NULL; + while(sqlite3_step(stmt) == SQLITE_ROW) { - media_playlist_s *_playlist = (media_playlist_s*)calloc(1, sizeof(media_playlist_s)); + if(_playlist) + media_playlist_destroy((media_playlist_h)_playlist); + + _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); @@ -662,11 +641,7 @@ int media_playlist_get_name(media_playlist_h playlist, char **name) if(STRING_VALID(_playlist->name)) { *name = strdup(_playlist->name); - if(*name == NULL) - { - media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY); - return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY; - } + media_content_retvm_if(*name == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY"); } else { @@ -693,11 +668,7 @@ int media_playlist_get_thumbnail_path(media_playlist_h playlist, char **path) if(STRING_VALID(_playlist->thumbnail_path)) { *path = strdup(_playlist->thumbnail_path); - if(*path == NULL) - { - media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY); - return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY; - } + media_content_retvm_if(*path == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY"); } else { @@ -758,11 +729,7 @@ int media_playlist_set_name(media_playlist_h playlist, const char *playlist_name 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; - } + media_content_retvm_if(item == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY"); item->playlist_name = strdup(playlist_name); item->function = MEDIA_PLAYLIST_UPDATE_PLAYLIST_NAME; @@ -803,11 +770,7 @@ int media_playlist_set_thumbnail_path(media_playlist_h playlist, const char *pat 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; - } + media_content_retvm_if(item == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY"); item->thumbnail_path = strdup(path); item->function = MEDIA_PLAYLIST_UPDATE_THUMBNAIL_PATH; @@ -846,11 +809,7 @@ int media_playlist_set_play_order(media_playlist_h playlist, int playlist_member 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; - } + media_content_retvm_if(item == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY"); item->playlist_member_id = playlist_member_id; item->function = MEDIA_PLAYLIST_UPDATE_PLAY_ORDER; @@ -875,11 +834,7 @@ int media_playlist_add_media(media_playlist_h playlist, const char *media_id) 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; - } + media_content_retvm_if(item == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY"); item->media_id = strdup(media_id); item->function = MEDIA_PLAYLIST_ADD; @@ -911,11 +866,7 @@ int media_playlist_remove_media(media_playlist_h playlist, int playlist_member_i 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; - } + media_content_retvm_if(item == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY"); item->playlist_member_id = playlist_member_id; item->function = MEDIA_PLAYLIST_REMOVE; @@ -980,6 +931,9 @@ int media_playlist_update_to_db(media_playlist_h playlist) ret = __media_playlist_update_play_order(_playlist->playlist_id, _playlist_item->playlist_member_id, _playlist_item->play_order); } break; + + default : + break; } } } @@ -996,24 +950,11 @@ int media_playlist_import_from_file(const char *path, const char *playlist_name, 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; - } + media_content_retvm_if(!STRING_VALID(path), MEDIA_CONTENT_ERROR_INVALID_PARAMETER, "Invalid path"); + media_content_retvm_if(!STRING_VALID(playlist_name), MEDIA_CONTENT_ERROR_INVALID_PARAMETER, "Invalid playlist_name"); 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; - } + media_content_retvm_if(ret != MEDIA_CONTENT_ERROR_NONE, ret, "media_playlist_insert_to_db fail"); ret = __media_playlist_import_item_from_file(path, &import_item_list, &import_item_count); if(ret != MEDIA_CONTENT_ERROR_NONE) @@ -1094,32 +1035,14 @@ 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; + unsigned int idx = 0; - 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; - } + media_content_retvm_if(!STRING_VALID(path), MEDIA_CONTENT_ERROR_INVALID_PARAMETER, "Invalid path"); + media_content_retvm_if(_playlist == NULL, MEDIA_CONTENT_ERROR_INVALID_PARAMETER, "Invalid playlist"); + media_content_retvm_if(_playlist->playlist_id <= 0, MEDIA_CONTENT_ERROR_INVALID_PARAMETER, "Invalid playlist_id"); 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; - } + media_content_retvm_if(ret != MEDIA_CONTENT_ERROR_NONE, ret, "_media_db_get_playlist_item fail"); ret = __media_playlist_reset_file(path); if(ret != MEDIA_CONTENT_ERROR_NONE) diff --git a/src/media_storage.c b/src/media_storage.c new file mode 100755 index 0000000..24a3a19 --- /dev/null +++ b/src/media_storage.c @@ -0,0 +1,430 @@ + /* + * 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 +#include + +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, tzplatform_getuid(TZ_USER_NAME)); + 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)); + media_content_retvm_if(_storage == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "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, tzplatform_getuid(TZ_USER_NAME)); + + 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)); + media_content_retvm_if(_dst == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "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); + media_content_retvm_if(*storage_id == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "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); + media_content_retvm_if(*storage_name == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "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); + media_content_retvm_if(*storage_path == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "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); + media_content_retvm_if(*storage_account == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "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; +} \ No newline at end of file diff --git a/src/media_tag.c b/src/media_tag.c index d3a5f01..ba654d4 100755 --- a/src/media_tag.c +++ b/src/media_tag.c @@ -102,13 +102,11 @@ static int __media_tag_get_tag_info_from_db(const char *name, media_tag_h tag) int ret = MEDIA_CONTENT_ERROR_NONE; sqlite3_stmt *stmt = NULL; char *select_query = NULL; + int id = 0; + char *tag_name = NULL; media_tag_s *_tag = (media_tag_s*)tag; - if(_tag == NULL) - { - media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER); - return MEDIA_CONTENT_ERROR_INVALID_PARAMETER; - } + media_content_retvm_if(_tag == NULL, MEDIA_CONTENT_ERROR_INVALID_PARAMETER, "invalid tag"); select_query = sqlite3_mprintf(SELECT_TAG_BY_NAME, name); @@ -118,14 +116,20 @@ static int __media_tag_get_tag_info_from_db(const char *name, media_tag_h tag) while(sqlite3_step(stmt) == SQLITE_ROW) { - _tag->tag_id = (int)sqlite3_column_int(stmt,0); + id = (int)sqlite3_column_int(stmt,0); if(STRING_VALID((const char *)sqlite3_column_text(stmt, 1))) { - _tag->name = strdup((const char *)sqlite3_column_text(stmt, 1)); + if(tag_name) + SAFE_FREE(tag_name); + + tag_name = strdup((const char *)sqlite3_column_text(stmt, 1)); } } + _tag->tag_id = id; + _tag->name = tag_name; + SQLITE3_FINALIZE(stmt); return ret; @@ -149,11 +153,7 @@ int media_tag_insert_to_db(const char *tag_name, media_tag_h *tag) if(ret == MEDIA_CONTENT_ERROR_NONE) { media_tag_s *_tag = (media_tag_s*)calloc(1, sizeof(media_tag_s)); - if(_tag == NULL) - { - media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY); - return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY; - } + media_content_retvm_if(_tag == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY"); ret = __media_tag_get_tag_info_from_db(tag_name, (media_tag_h)_tag); *tag = (media_tag_h)_tag; @@ -273,12 +273,7 @@ int media_tag_clone(media_tag_h *dst, media_tag_h src) if((_src != NULL)) { _dst = (media_tag_s*)calloc(1, sizeof(media_tag_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; - } + media_content_retvm_if(_dst == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY"); _dst->tag_id = _src->tag_id; @@ -332,11 +327,7 @@ int media_tag_get_name(media_tag_h tag, char **name) if(STRING_VALID(_tag->name)) { *name = strdup(_tag->name); - if(*name == NULL) - { - media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY); - return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY; - } + media_content_retvm_if(*name == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY"); } else { @@ -373,10 +364,14 @@ int media_tag_get_tag_from_db(int tag_id, media_tag_h *tag) ret = _content_query_prepare(&stmt, select_query, NULL, NULL); media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret); + media_tag_s *_tag = NULL; + while(sqlite3_step(stmt) == SQLITE_ROW) { - media_tag_s *_tag = (media_tag_s*)calloc(1, sizeof(media_tag_s)); + if(_tag) + media_tag_destroy((media_tag_h)_tag); + _tag = (media_tag_s*)calloc(1, sizeof(media_tag_s)); if(_tag == NULL) { SQLITE3_FINALIZE(stmt); @@ -407,11 +402,7 @@ int media_tag_add_media(media_tag_h tag, const char *media_id) 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; - } + media_content_retvm_if(_item == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY"); _item->media_id = strdup(media_id); _item->function = MEDIA_TAG_ADD; @@ -442,11 +433,7 @@ int media_tag_remove_media(media_tag_h tag, const char *media_id) 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; - } + media_content_retvm_if(_item == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY"); _item->media_id = strdup(media_id); _item->function = MEDIA_TAG_REMOVE; @@ -479,11 +466,7 @@ int media_tag_set_name(media_tag_h tag, char *tag_name) 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; - } + media_content_retvm_if(_item == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY"); _item->tag_name = strdup(tag_name); _item->function = MEDIA_TAG_UPDATE_TAG_NAME; @@ -552,6 +535,9 @@ int media_tag_update_to_db(media_tag_h tag) ret = __media_tag_update_tag_name(_tag->tag_id, _tag_item->tag_name); } break; + + default: + break; } } } diff --git a/src/media_util_private.c b/src/media_util_private.c index 33f1928..224e85e 100755 --- a/src/media_util_private.c +++ b/src/media_util_private.c @@ -48,23 +48,19 @@ 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"; + const char *scan_ignore = ".scan_ignore"; bool find = false; media_content_sec_debug("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; - } + media_content_retvm_if(!STRING_VALID(dir_path), MEDIA_CONTENT_ERROR_INVALID_PARAMETER, "invalid dir_path"); *ignore = FALSE; /*1. Check Hidden Directory*/ if(strstr(dir_path, "/.")) { *ignore = TRUE; - media_content_info("hidden path"); + media_content_debug("hidden path"); return MEDIA_CONTENT_ERROR_NONE; } @@ -87,11 +83,7 @@ int _media_util_check_ignore_dir(const char *dir_path, bool *ignore) while(STRING_VALID(search_path)) { dp = opendir(search_path); - if(dp == NULL) - { - media_content_error("Fail Open Directory"); - return MEDIA_CONTENT_ERROR_INVALID_OPERATION; - } + media_content_retvm_if(dp == NULL, MEDIA_CONTENT_ERROR_INVALID_OPERATION, "Open Directory fail"); while (!readdir_r(dp, &entry, &result)) { diff --git a/src/media_video.c b/src/media_video.c index 4b8ad58..5e6b578 100755 --- a/src/media_video.c +++ b/src/media_video.c @@ -58,13 +58,7 @@ int video_meta_clone(video_meta_h *dst, video_meta_h src) if(_src != NULL) { video_meta_s *_dst = (video_meta_s*)calloc(1, sizeof(video_meta_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; - } + media_content_retvm_if(_dst == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY"); if(STRING_VALID(_src->media_id)) { @@ -217,11 +211,8 @@ int video_meta_get_media_id(video_meta_h video, char **media_id) if(STRING_VALID(_video->media_id)) { char *new_string = strdup(_video->media_id); - 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; - } + media_content_retvm_if(new_string == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY"); + *media_id = new_string; } else @@ -249,11 +240,8 @@ int video_meta_get_album(video_meta_h video, char **album) if(STRING_VALID(_video->album)) { char *new_string = strdup(_video->album); - 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; - } + media_content_retvm_if(new_string == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY"); + *album = new_string; } else @@ -281,11 +269,8 @@ int video_meta_get_artist(video_meta_h video, char **artist) if(STRING_VALID(_video->artist)) { char *new_string = strdup(_video->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; - } + media_content_retvm_if(new_string == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY"); + *artist = new_string; } else @@ -314,11 +299,8 @@ int video_meta_get_album_artist(video_meta_h video, char **album_artist) 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; - } + media_content_retvm_if(new_string == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY"); + *album_artist = new_string; } else @@ -347,11 +329,8 @@ int video_meta_get_genre(video_meta_h video, char **genre) if(STRING_VALID(_video->genre)) { char *new_string = strdup(_video->genre); - 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; - } + media_content_retvm_if(new_string == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY"); + *genre = new_string; } else @@ -379,11 +358,8 @@ int video_meta_get_composer(video_meta_h video, char **composer) if(STRING_VALID(_video->composer)) { char *new_string = strdup(_video->composer); - 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; - } + media_content_retvm_if(new_string == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY"); + *composer = new_string; } else @@ -411,11 +387,8 @@ int video_meta_get_year(video_meta_h video, char **year) if(STRING_VALID(_video->year)) { char *new_string = strdup(_video->year); - 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; - } + media_content_retvm_if(new_string == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY"); + *year = new_string; } else @@ -443,11 +416,8 @@ int video_meta_get_recorded_date(video_meta_h video, char **recorded_date) if(STRING_VALID(_video->recorded_date)) { char *new_string = strdup(_video->recorded_date); - 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; - } + media_content_retvm_if(new_string == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY"); + *recorded_date = new_string; } else @@ -475,11 +445,8 @@ int video_meta_get_copyright(video_meta_h video, char **copyright) if(STRING_VALID(_video->copyright)) { char *new_string = strdup(_video->copyright); - 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; - } + media_content_retvm_if(new_string == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY"); + *copyright = new_string; } else @@ -507,11 +474,8 @@ int video_meta_get_track_num(video_meta_h video, char **track_num) if(STRING_VALID(_video->track_num)) { char *new_string = strdup(_video->track_num); - 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; - } + media_content_retvm_if(new_string == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY"); + *track_num = new_string; } else diff --git a/test/media-content_test.c b/test/media-content_test.c index 0eddfc6..5993410 100755 --- a/test/media-content_test.c +++ b/test/media-content_test.c @@ -19,6 +19,7 @@ #include #include #include +#include #include #include #include @@ -537,7 +538,7 @@ bool media_item_cb(media_info_h media, void *user_data) bool folder_list_cb(media_folder_h folder, void *user_data) { - int item_count; + int item_count = 0; char *folder_id = NULL; char *str_val = NULL; int int_val = -1; @@ -545,6 +546,7 @@ bool folder_list_cb(media_folder_h folder, void *user_data) bool ret; media_folder_h *_folder = (media_folder_h*)user_data; + media_content_debug("==========================="); if(folder != NULL) { if(_folder != NULL) @@ -597,7 +599,7 @@ bool folder_list_cb(media_folder_h folder, void *user_data) return false; } media_content_debug("folder_order = [%d]", int_val); - +#if 1 if(media_folder_get_media_count_from_db(folder_id, g_filter, &item_count) != MEDIA_CONTENT_ERROR_NONE) { SAFE_FREE(folder_id); @@ -611,7 +613,7 @@ bool folder_list_cb(media_folder_h folder, void *user_data) media_content_error("[ERROR] media_folder_foreach_media_from_db is failed"); return false; } - +#endif SAFE_FREE(folder_id); ret = true; } @@ -785,7 +787,7 @@ bool album_list_cb(media_album_h album, void *user_data) filter_h filter = NULL; /*Set Filter*/ - char *condition = "MEDIA_TYPE=3"; /*MEDIA_TYPE 0-image, 1-video, 2-sound, 3-music, 4-other*/ + const char *condition = "MEDIA_TYPE=3"; /*MEDIA_TYPE 0-image, 1-video, 2-sound, 3-music, 4-other*/ ret = media_filter_create(&filter); if(ret != MEDIA_CONTENT_ERROR_NONE) { @@ -907,8 +909,8 @@ int test_filter_create(void) int ret = MEDIA_CONTENT_ERROR_NONE; /* Filter for media */ - 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*/ + const char *condition = "MEDIA_TYPE=3"; /*MEDIA_TYPE 0-image, 1-video, 2-sound, 3-music, 4-other*/ + //const 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); @@ -936,8 +938,8 @@ int test_filter_create(void) //ret = media_filter_set_storage(g_filter, "cfbf3d2c-71c5-4611-bccc-7cbac890146e"); /* Filter for group */ - //char *g_condition = "TAG_NAME like \"\%my\%\""; - //char *g_condition = "BOOKMARK_MARKED_TIME > 300"; + //const char *g_condition = "TAG_NAME like \"\%my\%\""; + //const char *g_condition = "BOOKMARK_MARKED_TIME > 300"; ret = media_filter_create(&g_filter_g); @@ -979,7 +981,7 @@ int test_connect_database(void) int test_gallery_scenario(void) { int ret = MEDIA_CONTENT_ERROR_NONE; - int i; + unsigned int i = 0; filter_h filter = NULL; int count; @@ -1182,7 +1184,7 @@ int test_gallery_scenario(void) GList *item_list = NULL; for(i = 0; i < g_list_length(folder_list); i++) { - int j = 0; + unsigned int j = 0; char *folder_id = NULL; char *folder_name = NULL; folder_handle = (media_folder_h)g_list_nth_data(folder_list, i); @@ -1306,7 +1308,7 @@ int test_gallery_scenario(void) } else { media_content_debug("media_info_foreach_bookmark_from_db success"); - int k = 0; + unsigned int k = 0; for(k = 0; k < g_list_length(bm_list); k++) { bm_handle = (media_bookmark_h)g_list_nth_data(bm_list, k); @@ -1325,7 +1327,7 @@ int test_gallery_scenario(void) } /* Remove bookmark list */ - int l = 0; + unsigned int l = 0; if(bm_list) { for(l = 0; l < g_list_length(bm_list); l++) { bm_handle = (media_bookmark_h)g_list_nth_data(bm_list, l); @@ -1375,7 +1377,7 @@ int test_gallery_scenario(void) return -1; } else { media_content_error("media_tag_foreach_media_from_db success"); - int j = 0; + unsigned int j = 0; media_info_h tag_media_handle; char *media_id = NULL; char *media_name = NULL; @@ -1479,7 +1481,7 @@ int test_get_all_music_files(void) filter_h filter; /*Set Filter*/ - char *condition = "MEDIA_TYPE=3"; /*0-image, 1-video, 2-sound, 3-music, 4-other*/ + const char *condition = "MEDIA_TYPE=3"; /*0-image, 1-video, 2-sound, 3-music, 4-other*/ ret = media_filter_create(&filter); if(ret != MEDIA_CONTENT_ERROR_NONE) { @@ -1731,9 +1733,9 @@ int test_playlist_operation(void) int playlist_id_1 = 0; int playlist_id_2 = 0; int playlist_id_3 = 0; - char *playlist_name_1 = "myPlaylist_1"; - char *playlist_name_2 = "myPlaylist_2"; - char *playlist_name_3 = "myPlaylist_3"; + const char *playlist_name_1 = "myPlaylist_1"; + const char *playlist_name_2 = "myPlaylist_2"; + const char *playlist_name_3 = "myPlaylist_3"; int playlist_count = 0; int media_count = 0; int order_1 = 0; @@ -1748,7 +1750,7 @@ int test_playlist_operation(void) /* Filter for playlist */ - char *condition = "(MEDIA_TYPE=1 or MEDIA_TYPE=3)"; /*0-image, 1-video, 2-sound, 3-music, 4-other*/ + const char *condition = "(MEDIA_TYPE=1 or MEDIA_TYPE=3)"; /*0-image, 1-video, 2-sound, 3-music, 4-other*/ ret = media_filter_create(&filter); ret = media_filter_set_condition(filter, condition, MEDIA_CONTENT_COLLATE_NOCASE); @@ -1898,16 +1900,16 @@ int test_tag_operation(void) int tag_id_1 = 0; int tag_id_2 = 0; int tag_id_3 = 0; - char *tag_name_1 = "myTag_1"; - char *tag_name_2 = "myTag_2"; - char *tag_name_3 = "myTag_3"; + const char *tag_name_1 = "myTag_1"; + const char *tag_name_2 = "myTag_2"; + const char *tag_name_3 = "myTag_3"; int tag_count = 0; int media_count = 0; filter_h filter; media_content_debug("\n============Tag Test============\n\n"); - char *g_condition = "TAG_NAME like \"%%my%%\""; + const char *g_condition = "TAG_NAME like \"%%my%%\""; ret = media_filter_create(&filter); @@ -2001,7 +2003,7 @@ int test_tag_operation(void) ret = media_tag_add_media(tag_2, test_video_id); if(ret != MEDIA_CONTENT_ERROR_NONE) media_content_error("error media_tag_add_media : [%d]", ret); - ret = media_tag_set_name(tag_2, "test_tag"); + ret = media_tag_set_name(tag_2, (char *)"test_tag"); if(ret != MEDIA_CONTENT_ERROR_NONE) media_content_error("error media_tag_set_name : [%d]", ret); ret = media_tag_update_to_db(tag_2); @@ -2044,7 +2046,7 @@ int test_bookmark_operation(void) media_content_debug("\n============Bookmark Test============\n\n"); - char *g_condition = "BOOKMARK_MARKED_TIME > 300"; + const char *g_condition = "BOOKMARK_MARKED_TIME > 300"; ret = media_filter_create(&filter); if(ret != MEDIA_CONTENT_ERROR_NONE) @@ -2090,7 +2092,7 @@ int test_album_list(void) filter_h filter; /*Set Filter*/ - char *condition = "MEDIA_TYPE=3"; /*0-image, 1-video, 2-sound, 3-music, 4-other*/ + const char *condition = "MEDIA_TYPE=3"; /*0-image, 1-video, 2-sound, 3-music, 4-other*/ ret = media_filter_create(&filter); if(ret != MEDIA_CONTENT_ERROR_NONE) { @@ -2164,7 +2166,7 @@ int test_group_operation(void) int test_update_operation() { int ret = MEDIA_CONTENT_ERROR_NONE; - int i; + unsigned int i = 0; media_info_h media_handle = NULL; GList *all_item_list = NULL; @@ -2275,8 +2277,8 @@ int test_update_operation() int test_insert(void) { int ret = MEDIA_CONTENT_ERROR_NONE; - char *path = "/opt/usr/media/Images/Default.jpg"; - //char *path = "/opt/usr/media/Others/other.txt"; + const char *path = "/opt/usr/media/Images/Default.jpg"; + //const 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");