#include <media_group.h>
#include <media_playlist.h>
#include <media_bookmark.h>
+#include <media_storage.h>
#ifdef __cplusplus
extern "C" {
--- /dev/null
+/*
+* Copyright (c) 2011 Samsung Electronics Co., Ltd All Rights Reserved
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+* http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+
+
+
+#ifndef __TIZEN_MEDIA_CONTENT_INTERNAL_H__
+#define __TIZEN_MEDIA_CONTENT_INTERNAL_H__
+
+#include <media_content_type.h>
+
+#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__*/
*/
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
*/
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);
/**
* @}
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;
#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"
#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 \
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);
/**
* @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
} \
} 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)
#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
--- /dev/null
+/*
+* Copyright (c) 2011 Samsung Electronics Co., Ltd All Rights Reserved
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+* http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+
+
+#ifndef __TIZEN_MEDIA_STORAGE_H__
+#define __TIZEN_MEDIA_STORAGE_H__
+
+
+#include <media_content_type.h>
+
+
+#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__ */
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))
{
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
{
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
{
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
{
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
{
{
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
{
{
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
{
{
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
{
{
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
{
{
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
{
{
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
{
{
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;
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
{
{
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;
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);
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;
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 */
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 {
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;
{
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);
}
{
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;
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;
}
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);
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);
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;
#include <media_info_private.h>
-static char *media_token[] =
+static const char *media_token[] =
{
" ",
"\"",
{
#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
{
/*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))
{
{
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 *)" ";
}
}
{
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 *)" ";
}
}
{
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);
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);
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);
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)
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)
{
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)
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);
}
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)
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)
{
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)
{
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)
{
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)
{
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)
{
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)
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)
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)
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)
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)
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)
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)
{
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
{
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;
}
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;
/* 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;
{
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;
}
}
_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);
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;
}
}
_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);
}
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
{
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
{
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
{
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))
{
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
{
{
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
{
{
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
{
{
int ret = MEDIA_CONTENT_ERROR_NONE;
media_folder_s *_folder = (media_folder_s*)folder;
+
if(_folder)
{
*time = _folder->modified_time;
{
int ret = MEDIA_CONTENT_ERROR_NONE;
media_folder_s *_folder = (media_folder_s*)folder;
+
if(_folder)
{
*storage_type = _folder->storage_type;
{
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
{
{
int ret = MEDIA_CONTENT_ERROR_NONE;
media_folder_s *_folder = (media_folder_s*)folder;
+
if(_folder)
{
*order = _folder->folder_order;
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);
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
{
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;
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
{
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
{
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
{
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))
{
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
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
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
{
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
{
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
{
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);
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++) {
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;
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);
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) {
}
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);
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);
}
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*));
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))
{
{
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);
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);
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);
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);
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
{
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
{
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
{
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
{
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
{
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
{
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
{
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
{
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
{
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
{
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
{
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
{
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
{
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
{
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
{
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
{
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
{
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
{
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
{
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
{
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
{
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
{
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
{
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
{
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
{
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
{
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)
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;
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
{
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
{
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
{
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
{
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
{
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
{
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
{
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
{
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
{
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
{
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
{
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
{
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
{
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);
/*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);
}
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)
{
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;
}
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);
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
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);
*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
}
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);
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;
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);
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
{
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
{
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;
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;
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;
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;
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;
ret = __media_playlist_update_play_order(_playlist->playlist_id, _playlist_item->playlist_member_id, _playlist_item->play_order);
}
break;
+
+ default :
+ break;
}
}
}
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)
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)
--- /dev/null
+ /*
+ * Copyright (c) 2011 Samsung Electronics Co., Ltd All Rights Reserved
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+#include <media_content.h>
+#include <media_info_private.h>
+
+static void __media_storage_get_detail(sqlite3_stmt* stmt, media_storage_h storage)
+{
+ media_storage_s *_storage = (media_storage_s*)storage;
+
+ if(STRING_VALID((const char *)sqlite3_column_text(stmt, 0)))
+ _storage->storage_id = strdup((const char *)sqlite3_column_text(stmt, 0));
+
+ if(STRING_VALID((const char *)sqlite3_column_text(stmt, 1)))
+ _storage->storage_name = strdup((const char *)sqlite3_column_text(stmt, 1));
+
+ if(STRING_VALID((const char *)sqlite3_column_text(stmt, 2)))
+ _storage->storage_path = strdup((const char *)sqlite3_column_text(stmt, 2));
+
+ if(STRING_VALID((const char *)sqlite3_column_text(stmt, 3)))
+ _storage->storage_account = strdup((const char *)sqlite3_column_text(stmt, 3));
+
+ _storage->storage_type = (int)sqlite3_column_int(stmt, 4);
+
+ return;
+}
+
+int media_storage_insert_to_db(const char *storage_name, const char *storage_path, const char *storage_account, media_content_storage_e storage_type, media_storage_h *storage)
+{
+ int ret = MEDIA_CONTENT_ERROR_NONE;
+ char *storage_uuid = NULL;
+ media_storage_s *_storage = NULL;
+
+ if(!STRING_VALID(storage_name))
+ {
+ media_content_error("Invalid Storage Name");
+ return MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
+ }
+
+ if(!STRING_VALID(storage_path))
+ {
+ media_content_error("Invalid path");
+ return MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
+ }
+
+ storage_uuid = media_info_generate_uuid();
+ if(storage_uuid == NULL)
+ {
+ media_content_error("Fail to get storage_id");
+ return MEDIA_CONTENT_ERROR_INVALID_OPERATION;
+ }
+
+ ret = media_svc_insert_storage(_content_get_db_handle(), storage_uuid, storage_name, storage_path, storage_account, storage_type, 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
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);
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;
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;
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;
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
{
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);
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;
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;
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;
ret = __media_tag_update_tag_name(_tag->tag_id, _tag_item->tag_name);
}
break;
+
+ default:
+ break;
}
}
}
{
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;
}
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))
{
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))
{
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
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
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
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
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
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
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
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
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
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
#include <stdlib.h>
#include <unistd.h>
#include <media_content.h>
+#include <media_content_internal.h>
#include <media_info_private.h>
#include <dlog.h>
#include <pthread.h>
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;
bool ret;
media_folder_h *_folder = (media_folder_h*)user_data;
+ media_content_debug("===========================");
if(folder != NULL)
{
if(_folder != NULL)
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);
media_content_error("[ERROR] media_folder_foreach_media_from_db is failed");
return false;
}
-
+#endif
SAFE_FREE(folder_id);
ret = true;
}
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) {
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);
//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);
int test_gallery_scenario(void)
{
int ret = MEDIA_CONTENT_ERROR_NONE;
- int i;
+ unsigned int i = 0;
filter_h filter = NULL;
int count;
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);
} 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);
}
/* 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);
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;
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) {
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;
/* 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);
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);
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);
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)
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) {
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;
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");
projects / platform / core / api / media-content.git / commitdiff