Use sqlite3 instead of void type

Change-Id: I79ac6ad6dfa3cba5ce89bb44936836bcb4b43ad9
Signed-off-by: Minje Ahn <minje.ahn@samsung.com>

diff --git a/include/media_controller_db.h b/include/media_controller_db.h
index 6bed141..a53cde1 100644 (file)
--- a/include/media_controller_db.h
+++ b/include/media_controller_db.h
@@ -20,10 +20,10 @@
 #include <bundle.h>
 #include <media_controller_db_util.h>
 
-gboolean mc_db_is_server_table_exist(void *handle, const char *server_name);
-gboolean _mc_db_is_activated_client(void *handle, const char *client_name);
-gboolean _mc_db_is_activated_server(void *handle, const char *server_name);
-gboolean _mc_db_is_latest_server(void *handle, const char *server_name);
+gboolean mc_db_is_server_table_exist(sqlite3 *handle, const char *server_name);
+gboolean _mc_db_is_activated_client(sqlite3 *handle, const char *client_name);
+gboolean _mc_db_is_activated_server(sqlite3 *handle, const char *server_name);
+gboolean _mc_db_is_latest_server(sqlite3 *handle, const char *server_name);
 int mc_db_update_playback_info(const char *table_name, const media_controller_playback_s playback);
 int mc_db_update_whole_metadata(const char *server_name,
                                                const char *title, const char *artist, const char *album, const char *author, const char *genre, const char *duration, const char *date,
@@ -33,24 +33,24 @@ int mc_db_update_repeat_mode(const char *table_name, int repeat_mode);
 int mc_db_update_icon_uri(const char *server_name, const char *uri);
 int mc_db_update_ability_supported(const char *server_name, const media_controller_ability_s ability);
 
-int mc_db_get_latest_server_name(void *handle, char **latest_server_name);
-int mc_db_get_server_state(void *handle, const char *server_name, mc_server_state_e *state);
-int mc_db_get_playback_info(void *handle, const char *server_name, mc_playback_h *playback);
-int mc_db_get_metadata_info(void *handle, const char *server_name, mc_metadata_h *metadata);
-int mc_db_get_shuffle_mode(void *handle, const char *server_name, mc_shuffle_mode_e *mode);
-int mc_db_get_repeat_mode(void *handle, const char *server_name, mc_repeat_mode_e *mode);
-int mc_db_get_icon_uri(void *handle, const char *server_name, char **uri);
-int mc_db_get_ability_supported(void *handle, const char *server_name, mc_server_receive_event_e ability, mc_ability_support_e *supported);
-int mc_db_get_pb_action_ability(void *handle, const char *server_name, mc_playback_ability_h *ability);
-int _mc_db_get_playlist_count(void *handle, const char *server_name);
-int mc_db_get_foreach_playlist(void *handle, const char *server_name, mc_playlist_cb callback, void *user_data);
-gboolean _mc_db_is_playlist_exist(void *handle, const char *server_name, const char *playlist_name);
-int mc_db_get_playlist_by_name(void *handle, mc_priv_type_e type, const char *controller_name, const char *playlist_name, mc_playlist_h *playlist);
-int _mc_db_get_playlist_item_count(void *handle, const char *server_name, char *playlist_name);
-int mc_db_get_playlist_item(void *handle, const char *server_name, char *playlist_name, mc_playlist_item_cb callback, void *user_data);
+int mc_db_get_latest_server_name(sqlite3 *handle, char **latest_server_name);
+int mc_db_get_server_state(sqlite3 *handle, const char *server_name, mc_server_state_e *state);
+int mc_db_get_playback_info(sqlite3 *handle, const char *server_name, mc_playback_h *playback);
+int mc_db_get_metadata_info(sqlite3 *handle, const char *server_name, mc_metadata_h *metadata);
+int mc_db_get_shuffle_mode(sqlite3 *handle, const char *server_name, mc_shuffle_mode_e *mode);
+int mc_db_get_repeat_mode(sqlite3 *handle, const char *server_name, mc_repeat_mode_e *mode);
+int mc_db_get_icon_uri(sqlite3 *handle, const char *server_name, char **uri);
+int mc_db_get_ability_supported(sqlite3 *handle, const char *server_name, mc_server_receive_event_e ability, mc_ability_support_e *supported);
+int mc_db_get_pb_action_ability(sqlite3 *handle, const char *server_name, mc_playback_ability_h *ability);
+int _mc_db_get_playlist_count(sqlite3 *handle, const char *server_name);
+int mc_db_get_foreach_playlist(sqlite3 *handle, const char *server_name, mc_playlist_cb callback, void *user_data);
+gboolean _mc_db_is_playlist_exist(sqlite3 *handle, const char *server_name, const char *playlist_name);
+int mc_db_get_playlist_by_name(sqlite3 *handle, mc_priv_type_e type, const char *controller_name, const char *playlist_name, mc_playlist_h *playlist);
+int _mc_db_get_playlist_item_count(sqlite3 *handle, const char *server_name, char *playlist_name);
+int mc_db_get_playlist_item(sqlite3 *handle, const char *server_name, char *playlist_name, mc_playlist_item_cb callback, void *user_data);
 
-int mc_db_foreach_server_list(void *handle, mc_activated_server_cb callback, void *user_data);
-int mc_db_foreach_client_list(void *handle, mc_activated_client_cb callback, void *user_data);
+int mc_db_foreach_server_list(sqlite3 *handle, mc_activated_server_cb callback, void *user_data);
+int mc_db_foreach_client_list(sqlite3 *handle, mc_activated_client_cb callback, void *user_data);
 int mc_db_update_latest_server_table(const char *server_name);
 int mc_db_remove_playlist(const char *server_name, const char *playlist_name);
 int mc_db_update_playlist(const char *server_name, const char *playlist_name, bundle_raw *bundle_data, int bundle_size);

diff --git a/include/media_controller_private.h b/include/media_controller_private.h
index 7eb0222..30015af 100644 (file)
--- a/include/media_controller_private.h
+++ b/include/media_controller_private.h
@@ -324,7 +324,7 @@ typedef enum {
 
 typedef struct {
        char *server_name;
-       void* db_handle;
+       sqlite3 *db_handle;
 
        GDBusConnection* dconn;
        int dref_count;
@@ -348,7 +348,7 @@ typedef struct {
 
 typedef struct {
        char            *client_name;
-       void            *db_handle;
+       sqlite3         *db_handle;
 
        GDBusConnection *dconn;
        int             dref_count;

diff --git a/src/media_controller_db.c b/src/media_controller_db.c
index e304652..efb0b52 100644 (file)
--- a/src/media_controller_db.c
+++ b/src/media_controller_db.c
@@ -54,12 +54,11 @@ static int __mc_db_update_db(mc_priv_type_e priv_type, const char *sql_str)
        return mc_ipc_send_message_to_server(MC_MSG_DB_UPDATE, priv_type, sql_str);
 }
 
-static int __mc_db_get_int_value_of_key(void *handle, const char *server_name, const char *key, int *value)
+static int __mc_db_get_int_value_of_key(sqlite3 *handle, const char *server_name, const char *key, int *value)
 {
        int ret = MEDIA_CONTROLLER_ERROR_NONE;
        char *sql_str = NULL;
        sqlite3_stmt *stmt = NULL;
-       sqlite3 *db_handle = (sqlite3 *)handle;
 
        mc_retvm_if(handle == NULL, MEDIA_CONTROLLER_ERROR_INVALID_PARAMETER, "Handle is NULL");
        mc_retvm_if(server_name == NULL, MEDIA_CONTROLLER_ERROR_INVALID_PARAMETER, "server_name is NULL");
@@ -69,14 +68,14 @@ static int __mc_db_get_int_value_of_key(void *handle, const char *server_name, c
        sql_str = sqlite3_mprintf(SELECT_KEY_FROM_SERVER, key, server_name);
        mc_retvm_if(!MC_STRING_VALID(sql_str), MEDIA_CONTROLLER_ERROR_INVALID_OPERATION, "SQL string is null");
 
-       ret = sqlite3_prepare_v2(db_handle, sql_str, strlen(sql_str), &stmt, NULL);
+       ret = sqlite3_prepare_v2(handle, sql_str, strlen(sql_str), &stmt, NULL);
        SQLITE3_SAFE_FREE(sql_str);
-       mc_retvm_if(SQLITE_OK != ret, MEDIA_CONTROLLER_ERROR_INVALID_OPERATION, "prepare error [%s]", sqlite3_errmsg(db_handle));
+       mc_retvm_if(SQLITE_OK != ret, MEDIA_CONTROLLER_ERROR_INVALID_OPERATION, "prepare error [%s]", sqlite3_errmsg(handle));
 
        if (sqlite3_step(stmt) == SQLITE_ROW) {
                *value = sqlite3_column_int(stmt, 0);
        } else {
-               mc_error("end of row [%s]", sqlite3_errmsg(db_handle));
+               mc_error("end of row [%s]", sqlite3_errmsg(handle));
                SQLITE3_FINALIZE(stmt);
                return MEDIA_CONTROLLER_ERROR_INVALID_OPERATION;
        }
@@ -86,12 +85,11 @@ static int __mc_db_get_int_value_of_key(void *handle, const char *server_name, c
        return MEDIA_CONTROLLER_ERROR_NONE;
 }
 
-static int __mc_db_get_ulonglong_value_of_key(void *handle, const char *server_name, const char *key, unsigned long long *value)
+static int __mc_db_get_ulonglong_value_of_key(sqlite3 *handle, const char *server_name, const char *key, unsigned long long *value)
 {
        int ret = MEDIA_CONTROLLER_ERROR_NONE;
        char *sql_str = NULL;
        sqlite3_stmt *stmt = NULL;
-       sqlite3 *db_handle = (sqlite3 *)handle;
 
        mc_retvm_if(handle == NULL, MEDIA_CONTROLLER_ERROR_INVALID_PARAMETER, "Handle is NULL");
        mc_retvm_if(server_name == NULL, MEDIA_CONTROLLER_ERROR_INVALID_PARAMETER, "server_name is NULL");
@@ -101,14 +99,14 @@ static int __mc_db_get_ulonglong_value_of_key(void *handle, const char *server_n
        sql_str = sqlite3_mprintf(SELECT_KEY_FROM_SERVER, key, server_name);
        mc_retvm_if(!MC_STRING_VALID(sql_str), MEDIA_CONTROLLER_ERROR_INVALID_OPERATION, "SQL string is null");
 
-       ret = sqlite3_prepare_v2(db_handle, sql_str, strlen(sql_str), &stmt, NULL);
+       ret = sqlite3_prepare_v2(handle, sql_str, strlen(sql_str), &stmt, NULL);
        SQLITE3_SAFE_FREE(sql_str);
-       mc_retvm_if(SQLITE_OK != ret, MEDIA_CONTROLLER_ERROR_INVALID_OPERATION, "prepare error [%s]", sqlite3_errmsg(db_handle));
+       mc_retvm_if(SQLITE_OK != ret, MEDIA_CONTROLLER_ERROR_INVALID_OPERATION, "prepare error [%s]", sqlite3_errmsg(handle));
 
        if (sqlite3_step(stmt) == SQLITE_ROW) {
                *value = (unsigned long long)sqlite3_column_int64(stmt, 0);
        } else {
-               mc_error("end of row [%s]", sqlite3_errmsg(db_handle));
+               mc_error("end of row [%s]", sqlite3_errmsg(handle));
                SQLITE3_FINALIZE(stmt);
                return MEDIA_CONTROLLER_ERROR_INVALID_OPERATION;
        }
@@ -118,12 +116,11 @@ static int __mc_db_get_ulonglong_value_of_key(void *handle, const char *server_n
        return MEDIA_CONTROLLER_ERROR_NONE;
 }
 
-static int __mc_db_get_text_value_of_key(void *handle, const char *server_name, const char *key, char **value)
+static int __mc_db_get_text_value_of_key(sqlite3 *handle, const char *server_name, const char *key, char **value)
 {
        int ret = MEDIA_CONTROLLER_ERROR_NONE;
        char *sql_str = NULL;
        sqlite3_stmt *stmt = NULL;
-       sqlite3 *db_handle = (sqlite3 *)handle;
 
        mc_retvm_if(handle == NULL, MEDIA_CONTROLLER_ERROR_INVALID_PARAMETER, "Handle is NULL");
        mc_retvm_if(server_name == NULL, MEDIA_CONTROLLER_ERROR_INVALID_PARAMETER, "server_name is NULL");
@@ -133,14 +130,14 @@ static int __mc_db_get_text_value_of_key(void *handle, const char *server_name,
        sql_str = sqlite3_mprintf(SELECT_KEY_FROM_SERVER, key, server_name);
        mc_retvm_if(!MC_STRING_VALID(sql_str), MEDIA_CONTROLLER_ERROR_INVALID_OPERATION, "SQL string is null");
 
-       ret = sqlite3_prepare_v2(db_handle, sql_str, strlen(sql_str), &stmt, NULL);
+       ret = sqlite3_prepare_v2(handle, sql_str, strlen(sql_str), &stmt, NULL);
        SQLITE3_SAFE_FREE(sql_str);
-       mc_retvm_if(SQLITE_OK != ret, MEDIA_CONTROLLER_ERROR_INVALID_OPERATION, "prepare error [%s]", sqlite3_errmsg(db_handle));
+       mc_retvm_if(SQLITE_OK != ret, MEDIA_CONTROLLER_ERROR_INVALID_OPERATION, "prepare error [%s]", sqlite3_errmsg(handle));
 
        if (sqlite3_step(stmt) == SQLITE_ROW) {
                *value = g_strdup((const char *)sqlite3_column_text(stmt, 0));
        } else {
-               mc_error("end of row [%s]", sqlite3_errmsg(db_handle));
+               mc_error("end of row [%s]", sqlite3_errmsg(handle));
                SQLITE3_FINALIZE(stmt);
                return MEDIA_CONTROLLER_ERROR_INVALID_OPERATION;
        }
@@ -150,23 +147,22 @@ static int __mc_db_get_text_value_of_key(void *handle, const char *server_name,
        return MEDIA_CONTROLLER_ERROR_NONE;
 }
 
-static int __mc_db_get_count(void *handle, const char *sql_str)
+static int __mc_db_get_count(sqlite3 *handle, const char *sql_str)
 {
        int ret = MEDIA_CONTROLLER_ERROR_NONE;
-       sqlite3 *db_handle = (sqlite3 *)handle;
        sqlite3_stmt *stmt = NULL;
        int count = 0;
 
        mc_retvm_if(handle == NULL, 0, "invalid handle");
        mc_retvm_if(sql_str == NULL, 0, "invalid sql_str");
 
-       ret = sqlite3_prepare_v2(db_handle, sql_str, strlen(sql_str), &stmt, NULL);
-       mc_retvm_if(SQLITE_OK != ret, 0, "prepare error [%s]", sqlite3_errmsg(db_handle));
+       ret = sqlite3_prepare_v2(handle, sql_str, strlen(sql_str), &stmt, NULL);
+       mc_retvm_if(SQLITE_OK != ret, 0, "prepare error [%s]", sqlite3_errmsg(handle));
 
        if (sqlite3_step(stmt) == SQLITE_ROW)
                count = sqlite3_column_int(stmt, 0);
        else
-               mc_error("end of row [%s]", sqlite3_errmsg(db_handle));
+               mc_error("end of row [%s]", sqlite3_errmsg(handle));
 
        SQLITE3_FINALIZE(stmt);
 
@@ -304,12 +300,11 @@ int mc_db_update_ability_supported(const char *server_name, const media_controll
        return ret;
 }
 
-int mc_db_get_latest_server_name(void *handle, char **latest_server_name)
+int mc_db_get_latest_server_name(sqlite3 *handle, char **latest_server_name)
 {
        int ret = MEDIA_CONTROLLER_ERROR_NONE;
        char *sql_str = NULL;
        sqlite3_stmt *stmt = NULL;
-       sqlite3 *db_handle = (sqlite3 *)handle;
 
        mc_retvm_if(handle == NULL, MEDIA_CONTROLLER_ERROR_INVALID_PARAMETER, "Handle is NULL");
 
@@ -318,27 +313,26 @@ int mc_db_get_latest_server_name(void *handle, char **latest_server_name)
        sql_str = sqlite3_mprintf(SELECT_NAME_FROM_LATEST, MC_DB_TABLE_LATEST_SERVER);
        mc_retvm_if(!MC_STRING_VALID(sql_str), MEDIA_CONTROLLER_ERROR_INVALID_OPERATION, "SQL string is null");
 
-       ret = sqlite3_prepare_v2(db_handle, sql_str, strlen(sql_str), &stmt, NULL);
+       ret = sqlite3_prepare_v2(handle, sql_str, strlen(sql_str), &stmt, NULL);
        SQLITE3_SAFE_FREE(sql_str);
-       mc_retvm_if(SQLITE_OK != ret, MEDIA_CONTROLLER_ERROR_INVALID_OPERATION, "prepare error [%s]", sqlite3_errmsg(db_handle));
+       mc_retvm_if(SQLITE_OK != ret, MEDIA_CONTROLLER_ERROR_INVALID_OPERATION, "prepare error [%s]", sqlite3_errmsg(handle));
 
        if (sqlite3_step(stmt) == SQLITE_ROW)
                *latest_server_name = g_strdup((const char *)sqlite3_column_text(stmt, 0));
        else
-               mc_error("[No-Error] No latest server [%s]", sqlite3_errmsg(db_handle));
+               mc_error("[No-Error] No latest server [%s]", sqlite3_errmsg(handle));
 
        SQLITE3_FINALIZE(stmt);
 
        return MEDIA_CONTROLLER_ERROR_NONE;
 }
 
-int mc_db_get_playback_info(void *handle, const char *server_name, mc_playback_h *playback)
+int mc_db_get_playback_info(sqlite3 *handle, const char *server_name, mc_playback_h *playback)
 {
        int ret = MEDIA_CONTROLLER_ERROR_NONE;
        media_controller_playback_s *_playback = NULL;
        char *sql_str = NULL;
        sqlite3_stmt *stmt = NULL;
-       sqlite3 *db_handle = (sqlite3 *)handle;
 
        mc_retvm_if(handle == NULL, MEDIA_CONTROLLER_ERROR_INVALID_PARAMETER, "Handle is NULL");
        mc_retvm_if(server_name == NULL, MEDIA_CONTROLLER_ERROR_INVALID_PARAMETER, "server_name is NULL");
@@ -347,9 +341,9 @@ int mc_db_get_playback_info(void *handle, const char *server_name, mc_playback_h
        sql_str = sqlite3_mprintf(SELECT_PLAY_INFO_FROM_SERVER, server_name);
        mc_retvm_if(!MC_STRING_VALID(sql_str), MEDIA_CONTROLLER_ERROR_INVALID_OPERATION, "SQL string is null");
 
-       ret = sqlite3_prepare_v2(db_handle, sql_str, strlen(sql_str), &stmt, NULL);
+       ret = sqlite3_prepare_v2(handle, sql_str, strlen(sql_str), &stmt, NULL);
        SQLITE3_SAFE_FREE(sql_str);
-       mc_retvm_if(SQLITE_OK != ret, MEDIA_CONTROLLER_ERROR_INVALID_OPERATION, "prepare error [%s]", sqlite3_errmsg(db_handle));
+       mc_retvm_if(SQLITE_OK != ret, MEDIA_CONTROLLER_ERROR_INVALID_OPERATION, "prepare error [%s]", sqlite3_errmsg(handle));
 
        if (sqlite3_step(stmt) == SQLITE_ROW) {
                _playback = (media_controller_playback_s *)calloc(1, sizeof(media_controller_playback_s));
@@ -364,7 +358,7 @@ int mc_db_get_playback_info(void *handle, const char *server_name, mc_playback_h
 
                *playback = (mc_playback_h)_playback;
        } else {
-               mc_error("end of row [%s]", sqlite3_errmsg(db_handle));
+               mc_error("end of row [%s]", sqlite3_errmsg(handle));
                SQLITE3_FINALIZE(stmt);
                return MEDIA_CONTROLLER_ERROR_INVALID_OPERATION;
        }
@@ -403,12 +397,11 @@ static int __mc_db_get_metadata(sqlite3_stmt *stmt, int col, mc_metadata_h *meta
        return MEDIA_CONTROLLER_ERROR_NONE;
 }
 
-int mc_db_get_metadata_info(void *handle, const char *server_name, mc_metadata_h *metadata)
+int mc_db_get_metadata_info(sqlite3 *handle, const char *server_name, mc_metadata_h *metadata)
 {
        int ret = MEDIA_CONTROLLER_ERROR_NONE;
        char *sql_str = NULL;
        sqlite3_stmt *stmt = NULL;
-       sqlite3 *db_handle = (sqlite3 *)handle;
 
        mc_retvm_if(handle == NULL, MEDIA_CONTROLLER_ERROR_INVALID_PARAMETER, "Handle is NULL");
        mc_retvm_if(server_name == NULL, MEDIA_CONTROLLER_ERROR_INVALID_PARAMETER, "server_name is NULL");
@@ -417,14 +410,14 @@ int mc_db_get_metadata_info(void *handle, const char *server_name, mc_metadata_h
        sql_str = sqlite3_mprintf(SELECT_FROM_SERVER, server_name);
        mc_retvm_if(!MC_STRING_VALID(sql_str), MEDIA_CONTROLLER_ERROR_INVALID_OPERATION, "SQL string is null");
 
-       ret = sqlite3_prepare_v2(db_handle, sql_str, strlen(sql_str), &stmt, NULL);
+       ret = sqlite3_prepare_v2(handle, sql_str, strlen(sql_str), &stmt, NULL);
        SQLITE3_SAFE_FREE(sql_str);
-       mc_retvm_if(SQLITE_OK != ret, MEDIA_CONTROLLER_ERROR_INVALID_OPERATION, "prepare error [%s]", sqlite3_errmsg(db_handle));
+       mc_retvm_if(SQLITE_OK != ret, MEDIA_CONTROLLER_ERROR_INVALID_OPERATION, "prepare error [%s]", sqlite3_errmsg(handle));
 
        if (sqlite3_step(stmt) == SQLITE_ROW) {
                ret = __mc_db_get_metadata(stmt, MC_SERVER_FIELD_TITLE, metadata);
        } else {
-               mc_error("end of row [%s]", sqlite3_errmsg(db_handle));
+               mc_error("end of row [%s]", sqlite3_errmsg(handle));
                ret = MEDIA_CONTROLLER_ERROR_NONE;
        }
 
@@ -433,27 +426,27 @@ int mc_db_get_metadata_info(void *handle, const char *server_name, mc_metadata_h
        return ret;
 }
 
-int mc_db_get_server_state(void *handle, const char *server_name, mc_server_state_e *state)
+int mc_db_get_server_state(sqlite3 *handle, const char *server_name, mc_server_state_e *state)
 {
        return __mc_db_get_int_value_of_key(handle, server_name, "server_state", (int *)state);
 }
 
-int mc_db_get_shuffle_mode(void *handle, const char *server_name, mc_shuffle_mode_e *mode)
+int mc_db_get_shuffle_mode(sqlite3 *handle, const char *server_name, mc_shuffle_mode_e *mode)
 {
        return __mc_db_get_int_value_of_key(handle, server_name, "shuffle_mode", (int *)mode);
 }
 
-int mc_db_get_repeat_mode(void *handle, const char *server_name, mc_repeat_mode_e *mode)
+int mc_db_get_repeat_mode(sqlite3 *handle, const char *server_name, mc_repeat_mode_e *mode)
 {
        return __mc_db_get_int_value_of_key(handle, server_name, "repeat_mode", (int *)mode);
 }
 
-int mc_db_get_icon_uri(void *handle, const char *server_name, char **uri)
+int mc_db_get_icon_uri(sqlite3 *handle, const char *server_name, char **uri)
 {
        return __mc_db_get_text_value_of_key(handle, server_name, "icon_uri", uri);
 }
 
-static int __mc_db_get_ability(void *handle, const char *server_name, unsigned long long *decided, unsigned long long *supported)
+static int __mc_db_get_ability(sqlite3 *handle, const char *server_name, unsigned long long *decided, unsigned long long *supported)
 {
        int ret = MEDIA_CONTROLLER_ERROR_NONE;
        unsigned long long _decided = 0;
@@ -475,7 +468,7 @@ static int __mc_db_get_ability(void *handle, const char *server_name, unsigned l
 
 }
 
-int mc_db_get_ability_supported(void *handle, const char *server_name, mc_server_receive_event_e ability, mc_ability_support_e *supported)
+int mc_db_get_ability_supported(sqlite3 *handle, const char *server_name, mc_server_receive_event_e ability, mc_ability_support_e *supported)
 {
        int ret = MEDIA_CONTROLLER_ERROR_NONE;
        unsigned long long _decided = 0;
@@ -501,7 +494,7 @@ int mc_db_get_ability_supported(void *handle, const char *server_name, mc_server
        return ret;
 }
 
-int mc_db_get_pb_action_ability(void *handle, const char *server_name, mc_playback_ability_h *ability)
+int mc_db_get_pb_action_ability(sqlite3 *handle, const char *server_name, mc_playback_ability_h *ability)
 {
        int ret = MEDIA_CONTROLLER_ERROR_NONE;
        media_controller_ability_s *basic_ability = NULL;
@@ -524,7 +517,7 @@ int mc_db_get_pb_action_ability(void *handle, const char *server_name, mc_playba
        return ret;
 }
 
-int _mc_db_get_playlist_count(void *handle, const char *server_name)
+int _mc_db_get_playlist_count(sqlite3 *handle, const char *server_name)
 {
        char *sql_str = NULL;
        int count = 0;
@@ -541,10 +534,9 @@ int _mc_db_get_playlist_count(void *handle, const char *server_name)
        return count;
 }
 
-int mc_db_get_foreach_playlist(void *handle, const char *server_name, mc_playlist_cb callback, void *user_data)
+int mc_db_get_foreach_playlist(sqlite3 *handle, const char *server_name, mc_playlist_cb callback, void *user_data)
 {
        int ret = MEDIA_CONTROLLER_ERROR_NONE;
-       sqlite3 *db_handle = (sqlite3 *)handle;
        char *sql_str = NULL;
        sqlite3_stmt *stmt = NULL;
 
@@ -555,9 +547,9 @@ int mc_db_get_foreach_playlist(void *handle, const char *server_name, mc_playlis
        sql_str = sqlite3_mprintf(SELECT_NAME_FROM_PLAYLIST, MC_DB_TABLE_PLAYLIST, server_name);
        mc_retvm_if(!MC_STRING_VALID(sql_str), MEDIA_CONTROLLER_ERROR_INVALID_OPERATION, "SQL string is null");
 
-       ret = sqlite3_prepare_v2(db_handle, sql_str, strlen(sql_str), &stmt, NULL);
+       ret = sqlite3_prepare_v2(handle, sql_str, strlen(sql_str), &stmt, NULL);
        SQLITE3_SAFE_FREE(sql_str);
-       mc_retvm_if(SQLITE_OK != ret, MEDIA_CONTROLLER_ERROR_INVALID_OPERATION, "prepare error [%s]", sqlite3_errmsg(db_handle));
+       mc_retvm_if(SQLITE_OK != ret, MEDIA_CONTROLLER_ERROR_INVALID_OPERATION, "prepare error [%s]", sqlite3_errmsg(handle));
 
        while (sqlite3_step(stmt) == SQLITE_ROW) {
                mc_playlist_s *_playlist = (mc_playlist_s *)calloc(1, sizeof(mc_playlist_s));
@@ -583,7 +575,7 @@ int mc_db_get_foreach_playlist(void *handle, const char *server_name, mc_playlis
        return MEDIA_CONTROLLER_ERROR_NONE;
 }
 
-gboolean _mc_db_is_playlist_exist(void *handle, const char *server_name, const char *playlist_name)
+gboolean _mc_db_is_playlist_exist(sqlite3 *handle, const char *server_name, const char *playlist_name)
 {
        char *sql_str = NULL;
        int count = 0;
@@ -604,7 +596,7 @@ gboolean _mc_db_is_playlist_exist(void *handle, const char *server_name, const c
        return FALSE;
 }
 
-int mc_db_get_playlist_by_name(void *handle, mc_priv_type_e type, const char *controller_name, const char *playlist_name, mc_playlist_h *playlist)
+int mc_db_get_playlist_by_name(sqlite3 *handle, mc_priv_type_e type, const char *controller_name, const char *playlist_name, mc_playlist_h *playlist)
 {
        int ret = MEDIA_CONTROLLER_ERROR_NONE;
        gboolean is_exist = FALSE;
@@ -638,7 +630,7 @@ int mc_db_get_playlist_by_name(void *handle, mc_priv_type_e type, const char *co
        return ret;
 }
 
-int _mc_db_get_playlist_item_count(void *handle, const char *server_name, char *playlist_name)
+int _mc_db_get_playlist_item_count(sqlite3 *handle, const char *server_name, char *playlist_name)
 {
        char *sql_str = NULL;
        int count = 0;
@@ -656,10 +648,9 @@ int _mc_db_get_playlist_item_count(void *handle, const char *server_name, char *
        return count;
 }
 
-int mc_db_get_playlist_item(void *handle, const char *server_name, char *playlist_name, mc_playlist_item_cb callback, void *user_data)
+int mc_db_get_playlist_item(sqlite3 *handle, const char *server_name, char *playlist_name, mc_playlist_item_cb callback, void *user_data)
 {
        int ret = MEDIA_CONTROLLER_ERROR_NONE;
-       sqlite3 *db_handle = (sqlite3 *)handle;
        char *sql_str = NULL;
        sqlite3_stmt *stmt = NULL;
        char *index = NULL;
@@ -673,9 +664,9 @@ int mc_db_get_playlist_item(void *handle, const char *server_name, char *playlis
        sql_str = sqlite3_mprintf(SELECT_ITEM_FROM_PLAYLIST, MC_DB_TABLE_PLAYLIST, server_name, playlist_name);
        mc_retvm_if(!MC_STRING_VALID(sql_str), MEDIA_CONTROLLER_ERROR_INVALID_OPERATION, "SQL string is null");
 
-       ret = sqlite3_prepare_v2(db_handle, sql_str, strlen(sql_str), &stmt, NULL);
+       ret = sqlite3_prepare_v2(handle, sql_str, strlen(sql_str), &stmt, NULL);
        SQLITE3_SAFE_FREE(sql_str);
-       mc_retvm_if(SQLITE_OK != ret, MEDIA_CONTROLLER_ERROR_INVALID_OPERATION, "prepare error [%s]", sqlite3_errmsg(db_handle));
+       mc_retvm_if(SQLITE_OK != ret, MEDIA_CONTROLLER_ERROR_INVALID_OPERATION, "prepare error [%s]", sqlite3_errmsg(handle));
 
        while (sqlite3_step(stmt) == SQLITE_ROW) {
                ret = __mc_db_get_metadata(stmt, 3, &_metadata);        //0 : server_name, 1 : playlist_name, 2 : item_index, from 3 : metadata such as title, artist
@@ -702,7 +693,7 @@ int mc_db_get_playlist_item(void *handle, const char *server_name, char *playlis
        return MEDIA_CONTROLLER_ERROR_NONE;
 }
 
-gboolean mc_db_is_server_table_exist(void *handle, const char *server_name)
+gboolean mc_db_is_server_table_exist(sqlite3 *handle, const char *server_name)
 {
        char *sql_str = NULL;
        int count = 0;
@@ -730,7 +721,7 @@ gboolean mc_db_is_server_table_exist(void *handle, const char *server_name)
        return TRUE;
 }
 
-gboolean _mc_db_is_activated_client(void *handle, const char *client_name)
+gboolean _mc_db_is_activated_client(sqlite3 *handle, const char *client_name)
 {
        char *sql_str = NULL;
        int count = 0;
@@ -756,7 +747,7 @@ gboolean _mc_db_is_activated_client(void *handle, const char *client_name)
        return TRUE;
 }
 
-gboolean _mc_db_is_activated_server(void *handle, const char *server_name)
+gboolean _mc_db_is_activated_server(sqlite3 *handle, const char *server_name)
 {
        char *sql_str = NULL;
        int count = 0;
@@ -782,7 +773,7 @@ gboolean _mc_db_is_activated_server(void *handle, const char *server_name)
        return TRUE;
 }
 
-gboolean _mc_db_is_latest_server(void *handle, const char *server_name)
+gboolean _mc_db_is_latest_server(sqlite3 *handle, const char *server_name)
 {
        char *sql_str = NULL;
        int count = 0;
@@ -807,25 +798,24 @@ gboolean _mc_db_is_latest_server(void *handle, const char *server_name)
 }
 
 
-int mc_db_foreach_server_list(void *handle, mc_activated_server_cb callback, void *user_data)
+int mc_db_foreach_server_list(sqlite3 *handle, mc_activated_server_cb callback, void *user_data)
 {
        int ret = MEDIA_CONTROLLER_ERROR_NONE;
-       sqlite3 *db_handle = (sqlite3 *)handle;
        char *sql_str = NULL;
        sqlite3_stmt *stmt = NULL;
        int idx = 0;
 
-       mc_retvm_if(db_handle == NULL, MEDIA_CONTROLLER_ERROR_INVALID_PARAMETER, "Handle is NULL");
+       mc_retvm_if(handle == NULL, MEDIA_CONTROLLER_ERROR_INVALID_PARAMETER, "Handle is NULL");
 
        sql_str = sqlite3_mprintf(SELECT_NAME_FROM_SERVER, MC_DB_TABLE_SERVER_LIST);
        mc_retvm_if(!MC_STRING_VALID(sql_str), MEDIA_CONTROLLER_ERROR_INVALID_OPERATION, "SQL string is null");
-       ret = sqlite3_prepare_v2(db_handle, sql_str, strlen(sql_str), &stmt, NULL);
+       ret = sqlite3_prepare_v2(handle, sql_str, strlen(sql_str), &stmt, NULL);
        SQLITE3_SAFE_FREE(sql_str);
-       mc_retvm_if(SQLITE_OK != ret, MEDIA_CONTROLLER_ERROR_INVALID_OPERATION, "prepare error [%s]", sqlite3_errmsg(db_handle));
+       mc_retvm_if(SQLITE_OK != ret, MEDIA_CONTROLLER_ERROR_INVALID_OPERATION, "prepare error [%s]", sqlite3_errmsg(handle));
 
        ret = sqlite3_step(stmt);
        if (SQLITE_ROW != ret) {
-               mc_error("[No-Error] There is no server list [%s]", sqlite3_errmsg(db_handle));
+               mc_error("[No-Error] There is no server list [%s]", sqlite3_errmsg(handle));
                SQLITE3_FINALIZE(stmt);
                return MEDIA_CONTROLLER_ERROR_NONE;
        }
@@ -858,25 +848,24 @@ int mc_db_foreach_server_list(void *handle, mc_activated_server_cb callback, voi
        return MEDIA_CONTROLLER_ERROR_NONE;
 }
 
-int mc_db_foreach_client_list(void *handle, mc_activated_client_cb callback, void *user_data)
+int mc_db_foreach_client_list(sqlite3 *handle, mc_activated_client_cb callback, void *user_data)
 {
        int ret = MEDIA_CONTROLLER_ERROR_NONE;
-       sqlite3 *db_handle = (sqlite3 *)handle;
        char *sql_str = NULL;
        sqlite3_stmt *stmt = NULL;
        int idx = 0;
 
-       mc_retvm_if(db_handle == NULL, MEDIA_CONTROLLER_ERROR_INVALID_PARAMETER, "Handle is NULL");
+       mc_retvm_if(handle == NULL, MEDIA_CONTROLLER_ERROR_INVALID_PARAMETER, "Handle is NULL");
 
        sql_str = sqlite3_mprintf("SELECT client_name FROM '%q';", MC_DB_TABLE_CLIENT_LIST);
        mc_retvm_if(!MC_STRING_VALID(sql_str), MEDIA_CONTROLLER_ERROR_INVALID_OPERATION, "SQL string is null");
-       ret = sqlite3_prepare_v2(db_handle, sql_str, strlen(sql_str), &stmt, NULL);
+       ret = sqlite3_prepare_v2(handle, sql_str, strlen(sql_str), &stmt, NULL);
        SQLITE3_SAFE_FREE(sql_str);
-       mc_retvm_if(SQLITE_OK != ret, MEDIA_CONTROLLER_ERROR_INVALID_OPERATION, "prepare error [%s]", sqlite3_errmsg(db_handle));
+       mc_retvm_if(SQLITE_OK != ret, MEDIA_CONTROLLER_ERROR_INVALID_OPERATION, "prepare error [%s]", sqlite3_errmsg(handle));
 
        ret = sqlite3_step(stmt);
        if (SQLITE_ROW != ret) {
-               mc_error("[No-Error] There is no client list [%s]", sqlite3_errmsg(db_handle));
+               mc_error("[No-Error] There is no client list [%s]", sqlite3_errmsg(handle));
                SQLITE3_FINALIZE(stmt);
                return MEDIA_CONTROLLER_ERROR_NONE;
        }

diff --git a/src/media_controller_playlist.c b/src/media_controller_playlist.c
index ca32df3..134007b 100755 (executable)
--- a/src/media_controller_playlist.c
+++ b/src/media_controller_playlist.c
@@ -112,7 +112,7 @@ int _mc_playlist_update(mc_priv_type_e type, const char *server_name, mc_playlis
 {
        int ret = MEDIA_CONTROLLER_ERROR_NONE;
        mc_playlist_s *_playlist = (mc_playlist_s*)playlist;
-       void* db_handle = NULL;
+       sqlite3 *db_handle = NULL;
        gboolean is_exist = FALSE;
        bundle_raw *bundle_data = NULL;
        int bundle_size = 0;
@@ -241,7 +241,7 @@ int mc_playlist_get_name(mc_playlist_h playlist, char **playlist_name)
 int mc_playlist_get_playlist_count(const char *app_id, int *playlist_count)
 {
        int ret = MEDIA_CONTROLLER_ERROR_NONE;
-       void* db_handle = NULL;
+       sqlite3 *db_handle = NULL;
 
        mc_retvm_if(!MC_STRING_VALID(app_id), MEDIA_CONTROLLER_ERROR_INVALID_PARAMETER, "Invalid app_id");
        mc_retvm_if(playlist_count == NULL, MEDIA_CONTROLLER_ERROR_INVALID_PARAMETER, "invalid playlist_count");
@@ -262,7 +262,7 @@ int mc_playlist_get_playlist_count(const char *app_id, int *playlist_count)
 int mc_playlist_foreach_playlist(const char *app_id, mc_playlist_cb callback, void *user_data)
 {
        int ret = MEDIA_CONTROLLER_ERROR_NONE;
-       void* db_handle = NULL;
+       sqlite3 *db_handle = NULL;
 
        mc_retvm_if(!MC_STRING_VALID(app_id), MEDIA_CONTROLLER_ERROR_INVALID_PARAMETER, "Invalid app_id");
        mc_retvm_if(callback == NULL, MEDIA_CONTROLLER_ERROR_INVALID_PARAMETER, "invalid callback");
@@ -284,7 +284,7 @@ int mc_playlist_get_item_count(mc_playlist_h playlist, int *item_count)
 {
        int ret = MEDIA_CONTROLLER_ERROR_NONE;
        mc_playlist_s *_playlist = (mc_playlist_s*)playlist;
-       void* db_handle = NULL;
+       sqlite3 *db_handle = NULL;
 
        mc_retvm_if(_playlist == NULL, MEDIA_CONTROLLER_ERROR_INVALID_PARAMETER, "invalid playlist");
        mc_retvm_if(item_count == NULL, MEDIA_CONTROLLER_ERROR_INVALID_PARAMETER, "invalid item_count");
@@ -306,7 +306,7 @@ int mc_playlist_foreach_item(mc_playlist_h playlist, mc_playlist_item_cb callbac
 {
        int ret = MEDIA_CONTROLLER_ERROR_NONE;
        mc_playlist_s *_playlist = (mc_playlist_s*)playlist;
-       void* db_handle = NULL;
+       sqlite3 *db_handle = NULL;
 
        mc_retvm_if(_playlist == NULL, MEDIA_CONTROLLER_ERROR_INVALID_PARAMETER, "invalid playlist");
        mc_retvm_if(callback == NULL, MEDIA_CONTROLLER_ERROR_INVALID_PARAMETER, "invalid callback");
@@ -327,7 +327,7 @@ int mc_playlist_foreach_item(mc_playlist_h playlist, mc_playlist_item_cb callbac
 int mc_playlist_get_playlist(const char *app_id, const char *playlist_name, mc_playlist_h *playlist)
 {
        int ret = MEDIA_CONTROLLER_ERROR_NONE;
-       void* db_handle = NULL;
+       sqlite3 *db_handle = NULL;
 
        mc_retvm_if(!MC_STRING_VALID(app_id), MEDIA_CONTROLLER_ERROR_INVALID_PARAMETER, "invalid app_id");
        mc_retvm_if(!MC_STRING_VALID(playlist_name), MEDIA_CONTROLLER_ERROR_INVALID_PARAMETER, "invalid playlist_name");

diff --git a/svc/include/media_controller_db_util.h b/svc/include/media_controller_db_util.h
index 615e894..c0d320a 100644 (file)
--- a/svc/include/media_controller_db_util.h
+++ b/svc/include/media_controller_db_util.h
@@ -20,15 +20,15 @@
 #include <glib.h>
 
 char *mc_db_get_db_path(uid_t uid);
-int mc_db_connect(void **handle, uid_t uid, gboolean needwrite);
-int mc_db_disconnect(void *handle);
+int mc_db_connect(sqlite3 **handle, uid_t uid, gboolean needwrite);
+int mc_db_disconnect(sqlite3 *handle);
 
-int mc_db_util_check_integrity(void *handle);
+int mc_db_util_check_integrity(sqlite3 *handle);
 int mc_db_util_remove_db(uid_t uid);
-int mc_db_util_create_tables(void *handle);
-int mc_db_util_update_db(void *handle, const char *sql_str);
-int mc_db_util_delete_whole_server_tables(void *handle);
-int mc_db_util_init_latest_server_table(void *handle);
+int mc_db_util_create_tables(sqlite3 *handle);
+int mc_db_util_update_db(sqlite3 *handle, const char *sql_str);
+int mc_db_util_delete_whole_server_tables(sqlite3 *handle);
+int mc_db_util_init_latest_server_table(sqlite3 *handle);
 int mc_db_parse_and_update_db(uid_t uid, const char *data, int data_size);
 int mc_db_add_application(uid_t uid, const char *app_id, mc_priv_type_e priv_type);
 int mc_db_remove_application(uid_t uid, const char *app_id, mc_priv_type_e priv_type);

diff --git a/svc/media_controller_db_util.c b/svc/media_controller_db_util.c
index e91146f..e2e13ee 100644 (file)
--- a/svc/media_controller_db_util.c
+++ b/svc/media_controller_db_util.c
@@ -118,10 +118,9 @@ static int __mc_db_disable_journal_mode(sqlite3 *handle)
        return MEDIA_CONTROLLER_ERROR_NONE;
 }
 
-static int __mc_foreach_table_list(void *handle, GList **list)
+static int __mc_foreach_table_list(sqlite3 *handle, GList **list)
 {
        int ret = MEDIA_CONTROLLER_ERROR_NONE;
-       sqlite3 *db_handle = (sqlite3 *)handle;
        char *sql_str = NULL;
        sqlite3_stmt *stmt = NULL;
 
@@ -130,9 +129,9 @@ static int __mc_foreach_table_list(void *handle, GList **list)
        sql_str = sqlite3_mprintf(DB_SELECT_ALL_SERVER_LIST_EXCEPT_LATEST, MC_DB_TABLE_LATEST_SERVER);
        mc_retvm_if(!MC_STRING_VALID(sql_str), MEDIA_CONTROLLER_ERROR_INVALID_OPERATION, "SQL string is null");
 
-       ret = sqlite3_prepare_v2(db_handle, sql_str, strlen(sql_str), &stmt, NULL);
+       ret = sqlite3_prepare_v2(handle, sql_str, strlen(sql_str), &stmt, NULL);
        SQLITE3_SAFE_FREE(sql_str);
-       mc_retvm_if(SQLITE_OK != ret, MEDIA_CONTROLLER_ERROR_INVALID_OPERATION, "prepare error [%s]", sqlite3_errmsg(db_handle));
+       mc_retvm_if(SQLITE_OK != ret, MEDIA_CONTROLLER_ERROR_INVALID_OPERATION, "prepare error [%s]", sqlite3_errmsg(handle));
 
        ret = sqlite3_step(stmt);
        while (SQLITE_ROW == ret) {
@@ -154,7 +153,7 @@ static int __mc_foreach_table_list(void *handle, GList **list)
        return MEDIA_CONTROLLER_ERROR_NONE;
 }
 
-static int __mc_db_util_delete_server_table(void *handle, const char *server_name)
+static int __mc_db_util_delete_server_table(sqlite3 *handle, const char *server_name)
 {
        int ret = MEDIA_CONTROLLER_ERROR_NONE;
        char *sql_str = NULL;
@@ -240,10 +239,9 @@ static int __mc_create_playlist_table(sqlite3 *handle)
        return ret;
 }
 
-static char * __mc_db_get_latest_server_name(void *handle)
+static char * __mc_db_get_latest_server_name(sqlite3 *handle)
 {
        int ret = MEDIA_CONTROLLER_ERROR_NONE;
-       sqlite3 *db_handle = (sqlite3 *)handle;
        char *sql_str = NULL;
        sqlite3_stmt *stmt = NULL;
        char *server_name = NULL;
@@ -253,15 +251,15 @@ static char * __mc_db_get_latest_server_name(void *handle)
        sql_str = sqlite3_mprintf("SELECT server_name FROM '%q';", MC_DB_TABLE_LATEST_SERVER);
        mc_retvm_if(!MC_STRING_VALID(sql_str), NULL, "SQL string is null");
 
-       ret = sqlite3_prepare_v2(db_handle, sql_str, strlen(sql_str), &stmt, NULL);
+       ret = sqlite3_prepare_v2(handle, sql_str, strlen(sql_str), &stmt, NULL);
        SQLITE3_SAFE_FREE(sql_str);
-       mc_retvm_if(SQLITE_OK != ret, NULL, "prepare error [%s]", sqlite3_errmsg(db_handle));
+       mc_retvm_if(SQLITE_OK != ret, NULL, "prepare error [%s]", sqlite3_errmsg(handle));
 
        if (sqlite3_step(stmt) == SQLITE_ROW) {
                server_name = g_strdup((char *)sqlite3_column_text(stmt, 0));
                mc_secure_debug("latest_server_name : [%s]", server_name);
        } else {
-               mc_error("[No-Error] No latest server [%s]", sqlite3_errmsg(db_handle));
+               mc_error("[No-Error] No latest server [%s]", sqlite3_errmsg(handle));
        }
 
        SQLITE3_FINALIZE(stmt);
@@ -269,7 +267,7 @@ static char * __mc_db_get_latest_server_name(void *handle)
        return server_name;
 }
 
-static gboolean __mc_db_is_latest(void *handle, const char *server_name)
+static gboolean __mc_db_is_latest(sqlite3 *handle, const char *server_name)
 {
        gboolean is_latest = FALSE;
        char *latest_server_name = NULL;
@@ -283,7 +281,7 @@ static gboolean __mc_db_is_latest(void *handle, const char *server_name)
        return is_latest;
 }
 
-static int __mc_update_latest_server_info(void *handle, const char *server_name, mc_server_state_e server_state, mc_playback_states_e playback_state, gboolean update_server_name)
+static int __mc_update_latest_server_info(sqlite3 *handle, const char *server_name, mc_server_state_e server_state, mc_playback_states_e playback_state, gboolean update_server_name)
 {
        int ret = MEDIA_CONTROLLER_ERROR_NONE;
        char *sql_str = NULL;
@@ -318,7 +316,7 @@ static int __mc_update_latest_server_info(void *handle, const char *server_name,
        return ret;
 }
 
-static int __mc_db_activate_server_table(void *db_handle, const char *app_id)
+static int __mc_db_activate_server_table(sqlite3 *db_handle, const char *app_id)
 {
        int ret = MEDIA_CONTROLLER_ERROR_NONE;
        char *sql_str = NULL;
@@ -341,7 +339,7 @@ static int __mc_db_activate_server_table(void *db_handle, const char *app_id)
        return ret;
 }
 
-static int __mc_db_deactivate_server_table(void *db_handle, const char *app_id)
+static int __mc_db_deactivate_server_table(sqlite3 *db_handle, const char *app_id)
 {
        int ret = MEDIA_CONTROLLER_ERROR_NONE;
 
@@ -364,7 +362,7 @@ static int __mc_db_deactivate_server_table(void *db_handle, const char *app_id)
        return ret;
 }
 
-static int __mc_db_insert_to_list(void *db_handle, const char *app_id, mc_priv_type_e priv_type)
+static int __mc_db_insert_to_list(sqlite3 *db_handle, const char *app_id, mc_priv_type_e priv_type)
 {
        int ret = MEDIA_CONTROLLER_ERROR_NONE;
        char *sql_str = NULL;
@@ -398,7 +396,7 @@ static int __mc_db_insert_to_list(void *db_handle, const char *app_id, mc_priv_t
        return ret;
 }
 
-static int __mc_db_delete_from_list(void *db_handle, const char *app_id, mc_priv_type_e priv_type)
+static int __mc_db_delete_from_list(sqlite3 *db_handle, const char *app_id, mc_priv_type_e priv_type)
 {
        int ret = MEDIA_CONTROLLER_ERROR_NONE;
        char *sql_str = NULL;
@@ -446,7 +444,7 @@ char *mc_db_get_db_path(uid_t uid)
        return db_path;
 }
 
-int mc_db_connect(void **handle, uid_t uid, gboolean needwrite)
+int mc_db_connect(sqlite3 **handle, uid_t uid, gboolean needwrite)
 {
        int ret = SQLITE_OK;
        sqlite3 *db_handle = NULL;
@@ -488,31 +486,29 @@ int mc_db_connect(void **handle, uid_t uid, gboolean needwrite)
        return MEDIA_CONTROLLER_ERROR_NONE;
 }
 
-int mc_db_disconnect(void *handle)
+int mc_db_disconnect(sqlite3 *handle)
 {
        int ret = SQLITE_OK;
-       sqlite3 *db_handle = (sqlite3 *)handle;
 
-       mc_retvm_if(db_handle == NULL, MEDIA_CONTROLLER_ERROR_INVALID_PARAMETER, "Handle is NULL");
+       mc_retvm_if(handle == NULL, MEDIA_CONTROLLER_ERROR_INVALID_PARAMETER, "Handle is NULL");
 
-       ret = sqlite3_close_v2(db_handle);
-       mc_retvm_if(SQLITE_OK != ret, MEDIA_CONTROLLER_ERROR_INVALID_OPERATION, "SQL Error[%s] when db open", sqlite3_errmsg(db_handle));
+       ret = sqlite3_close_v2(handle);
+       mc_retvm_if(SQLITE_OK != ret, MEDIA_CONTROLLER_ERROR_INVALID_OPERATION, "SQL Error[%s] when db open", sqlite3_errmsg(handle));
 
        return MEDIA_CONTROLLER_ERROR_NONE;
 }
 
-int mc_db_util_check_integrity(void *handle)
+int mc_db_util_check_integrity(sqlite3 *handle)
 {
        int ret = 0;
-       sqlite3 *db_handle = (sqlite3 *)handle;
        sqlite3_stmt *stmt = NULL;
        const char integrity_check_query[] = "PRAGMA integrity_check";
 
-       mc_retvm_if(db_handle == NULL, MEDIA_CONTROLLER_ERROR_INVALID_PARAMETER, "Handle is NULL");
+       mc_retvm_if(handle == NULL, MEDIA_CONTROLLER_ERROR_INVALID_PARAMETER, "Handle is NULL");
 
-       ret = sqlite3_prepare_v2(db_handle, integrity_check_query, strlen(integrity_check_query), &stmt, NULL);
+       ret = sqlite3_prepare_v2(handle, integrity_check_query, strlen(integrity_check_query), &stmt, NULL);
        if (ret != SQLITE_OK) {
-               mc_error("prepare error, ret = %d, error = %s", ret, sqlite3_errmsg(db_handle));
+               mc_error("prepare error, ret = %d, error = %s", ret, sqlite3_errmsg(handle));
                return MEDIA_CONTROLLER_ERROR_INVALID_OPERATION;
        }
 
@@ -569,42 +565,40 @@ int mc_db_util_remove_db(uid_t uid)
        return ret;
 }
 
-int mc_db_util_create_tables(void *handle)
+int mc_db_util_create_tables(sqlite3 *handle)
 {
        int ret = MEDIA_CONTROLLER_ERROR_NONE;
-       sqlite3 *db_handle = (sqlite3 *)handle;
 
-       mc_retvm_if(db_handle == NULL, MEDIA_CONTROLLER_ERROR_INVALID_PARAMETER, "Handle is NULL");
+       mc_retvm_if(handle == NULL, MEDIA_CONTROLLER_ERROR_INVALID_PARAMETER, "Handle is NULL");
 
-       ret = __mc_create_latest_server_table(db_handle);
+       ret = __mc_create_latest_server_table(handle);
        mc_retvm_if(ret != MEDIA_CONTROLLER_ERROR_NONE, ret, "create latest_server table failed!err= [%d]", ret);
 
-       ret = __mc_create_server_list_table(db_handle);
+       ret = __mc_create_server_list_table(handle);
        mc_retvm_if(ret != MEDIA_CONTROLLER_ERROR_NONE, ret, "create server_list table failed!err= [%d]", ret);
 
-       ret = __mc_create_client_list_table(db_handle);
+       ret = __mc_create_client_list_table(handle);
        mc_retvm_if(ret != MEDIA_CONTROLLER_ERROR_NONE, ret, "create client_list table failed!err= [%d]", ret);
 
-       ret = __mc_create_playlist_table(db_handle);
+       ret = __mc_create_playlist_table(handle);
        mc_retvm_if(ret != MEDIA_CONTROLLER_ERROR_NONE, ret, "create playlist table failed!err= [%d]", ret);
 
        return MEDIA_CONTROLLER_ERROR_NONE;
 }
 
-int mc_db_util_update_db(void *handle, const char *sql_str)
+int mc_db_util_update_db(sqlite3 *handle, const char *sql_str)
 {
        int ret = MEDIA_CONTROLLER_ERROR_NONE;
        char *err_msg = NULL;
-       sqlite3 *db_handle = (sqlite3 *)handle;
 
        mc_retvm_if(handle == NULL, MEDIA_CONTROLLER_ERROR_INVALID_PARAMETER, "Handle is NULL");
        mc_retvm_if(sql_str == NULL, MEDIA_CONTROLLER_ERROR_INVALID_PARAMETER, "sql_str is NULL");
 
        mc_secure_debug("Update query [%s]", sql_str);
 
-       ret = sqlite3_exec(db_handle, sql_str, NULL, NULL, &err_msg);
+       ret = sqlite3_exec(handle, sql_str, NULL, NULL, &err_msg);
        if (SQLITE_OK != ret) {
-               mc_error("failed to update db[%s]", sqlite3_errmsg(db_handle));
+               mc_error("failed to update db[%s]", sqlite3_errmsg(handle));
                SQLITE3_SAFE_FREE(err_msg);
                return MEDIA_CONTROLLER_ERROR_INVALID_OPERATION;
        }
@@ -612,7 +606,7 @@ int mc_db_util_update_db(void *handle, const char *sql_str)
        return MEDIA_CONTROLLER_ERROR_NONE;
 }
 
-int mc_db_util_delete_whole_server_tables(void *handle)
+int mc_db_util_delete_whole_server_tables(sqlite3 *handle)
 {
        int ret = MEDIA_CONTROLLER_ERROR_NONE;
        GList *table_list = NULL;
@@ -635,7 +629,7 @@ int mc_db_util_delete_whole_server_tables(void *handle)
        return ret;
 }
 
-int mc_db_util_init_latest_server_table(void *handle)
+int mc_db_util_init_latest_server_table(sqlite3 *handle)
 {
        int ret = MEDIA_CONTROLLER_ERROR_NONE;
        char *latest_server_name = NULL;
@@ -706,7 +700,7 @@ int mc_db_parse_and_update_db(uid_t uid, const char *data, int data_size)
        int i_value_1 = 0;
        int i_value_2 = 0;
        unsigned long long llu_value = 0, llu_value2 = 0;
-       void* _db_handle = NULL;
+       sqlite3* _db_handle = NULL;
 
        mc_retvm_if(data == NULL, MEDIA_CONTROLLER_ERROR_INVALID_PARAMETER, "data is NULL");
        mc_retvm_if(data_size <= 0 , MEDIA_CONTROLLER_ERROR_INVALID_PARAMETER, "invalid data_size");
@@ -908,7 +902,7 @@ int mc_db_parse_and_update_db(uid_t uid, const char *data, int data_size)
 int mc_db_add_application(uid_t uid, const char *app_id, const mc_priv_type_e priv_type)
 {
        int ret = MEDIA_CONTROLLER_ERROR_NONE;
-       void *db_handle = NULL;
+       sqlite3 *db_handle = NULL;
 
        mc_debug_fenter();
 
@@ -947,7 +941,7 @@ int mc_db_add_application(uid_t uid, const char *app_id, const mc_priv_type_e pr
 int mc_db_remove_application(uid_t uid, const char *app_id, const mc_priv_type_e priv_type)
 {
        int ret = MEDIA_CONTROLLER_ERROR_NONE;
-       void *db_handle = NULL;
+       sqlite3 *db_handle = NULL;
 
        mc_retvm_if(app_id == NULL, MEDIA_CONTROLLER_ERROR_INVALID_PARAMETER, "invalid app_id");
        mc_retvm_if((priv_type != MC_PRIV_TYPE_SERVER) && (priv_type != MC_PRIV_TYPE_CLIENT), MEDIA_CONTROLLER_ERROR_INVALID_PARAMETER, "invalid priv_type[%d]", priv_type);

diff --git a/svc/media_controller_svc.c b/svc/media_controller_svc.c
index b08dc8e..f92084f 100644 (file)
--- a/svc/media_controller_svc.c
+++ b/svc/media_controller_svc.c
@@ -237,7 +237,7 @@ static void _mc_service_deinit(mc_service_t *data)
 static int _mc_service_check_db(uid_t uid)
 {
        int res = MEDIA_CONTROLLER_ERROR_NONE;
-       void *db_handle = NULL;
+       sqlite3 *db_handle = NULL;
        char *db_path = NULL;
        struct stat buf;
 
@@ -291,7 +291,7 @@ static int _mc_service_check_db(uid_t uid)
 static int _mc_service_reset_db(uid_t uid)
 {
        int res = MEDIA_CONTROLLER_ERROR_NONE;
-       void *db_handle = NULL;
+       sqlite3 *db_handle = NULL;
 
        /* Connect media controller DB*/
        res = mc_db_connect(&db_handle, uid, TRUE);