Modify code not to send sqlite query directly to the daemon regarding the playlist

Change-Id: I025ce9f1eb3a0736b8c95829731b0bf991c0c046

diff --git a/include/media_controller_db.h b/include/media_controller_db.h
index 6946079..5b3997d 100644 (file)
--- a/include/media_controller_db.h
+++ b/include/media_controller_db.h
@@ -53,7 +53,7 @@ int mc_db_foreach_server_list(void *handle, mc_activated_server_cb callback, voi
 int mc_db_foreach_client_list(void *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, GList *query_list);
+int mc_db_update_playlist(const char *server_name, const char *playlist_name, bundle_raw *bundle_data, int bundle_size);
 int _mc_db_add_playlist(const char *server_name, const char *playlist_name);
 
 

diff --git a/include/media_controller_private.h b/include/media_controller_private.h
index e2e7158..5d66f81 100644 (file)
--- a/include/media_controller_private.h
+++ b/include/media_controller_private.h
@@ -204,8 +204,7 @@ extern "C" {
 #define MC_DB_CMD_ADD_PLAYLIST         "DB_CMD_ADD_PLAYLIST"                   /* Add new Server Playlist*/
 #define MC_DB_CMD_UPDATE_ICON          "DB_CMD_UPDATE_ICON"                    /* Update Server Icon*/
 #define MC_DB_CMD_UPDATE_ABILITY               "DB_CMD_UPDATE_ABILITY"                 /* Update Server abilities*/
-
-#define MC_DB_CMD_REMOVE_PLAYLIST      "DB_CMD_REMOVE_PLAYLIST"                /* Remove Server State*/
+#define MC_DB_CMD_REMOVE_PLAYLIST      "DB_CMD_REMOVE_PLAYLIST"                /* Remove Playlist*/
 
 
 #define DEFAULT_USER_UID 5001  /* owner */

diff --git a/src/media_controller_db.c b/src/media_controller_db.c
index 9fc7968..ac1f3c5 100644 (file)
--- a/src/media_controller_db.c
+++ b/src/media_controller_db.c
@@ -1051,43 +1051,20 @@ int mc_db_remove_playlist(const char *server_name, const char *playlist_name)
        return ret;
 }
 
-int mc_db_update_playlist(const char *server_name, const char *playlist_name, GList *query_list)
+int mc_db_update_playlist(const char *server_name, const char *playlist_name, bundle_raw *bundle_data, int bundle_size)
 {
        int ret = MEDIA_CONTROLLER_ERROR_NONE;
        char *sql_str = NULL;
-       char *temp_buf = NULL;
-       unsigned int list_len = 0;
-       unsigned int query_len = 0;
-       unsigned int idx = 0;
 
-       mc_retvm_if(server_name == NULL, MEDIA_CONTROLLER_ERROR_INVALID_PARAMETER, "server_name is NULL");
-       mc_retvm_if(playlist_name == NULL, MEDIA_CONTROLLER_ERROR_INVALID_PARAMETER, "playlist_name is NULL");
-       mc_retvm_if(query_list == NULL, MEDIA_CONTROLLER_ERROR_INVALID_PARAMETER, "query_list is NULL");
-
-       list_len = g_list_length(query_list);
-
-       for (idx = 0; idx < list_len; idx++) {
-               char *query = NULL;
-               query = g_list_nth_data(query_list, idx);
-               if (query != NULL)
-                       query_len += strlen(query);
-       }
-
-       temp_buf = (char *)calloc(1, query_len + 1);
-
-       for (idx = 0; idx < list_len; idx++) {
-               char *query = NULL;
-               query = g_list_nth_data(query_list, idx);
-               if (query != NULL)
-                       g_strlcat(temp_buf, query, query_len + 1);
-       }
+       mc_retvm_if(!server_name, MEDIA_CONTROLLER_ERROR_INVALID_PARAMETER, "server_name is NULL");
+       mc_retvm_if(!playlist_name, MEDIA_CONTROLLER_ERROR_INVALID_PARAMETER, "playlist_name is NULL");
+       mc_retvm_if(!bundle_data, MEDIA_CONTROLLER_ERROR_INVALID_PARAMETER, "bundle_data is NULL");
 
-       sql_str = g_strdup_printf("%s%s%s%s%s%s%s", MC_DB_CMD_UPDATE_PLAYLIST, MC_STRING_DELIMITER, server_name,
-                                               MC_STRING_DELIMITER, playlist_name, MC_STRING_DELIMITER, temp_buf);
+       sql_str = g_strdup_printf("%s%s%s%s%s%s%d%s%s", MC_DB_CMD_UPDATE_PLAYLIST, MC_STRING_DELIMITER, server_name,
+                                               MC_STRING_DELIMITER, playlist_name, MC_STRING_DELIMITER, bundle_size, MC_STRING_DELIMITER, bundle_data);
 
        ret = __mc_db_update_db(MC_PRIV_TYPE_SERVER, sql_str);
 
-       MC_SAFE_FREE(temp_buf);
        MC_SAFE_FREE(sql_str);
 
        return ret;

diff --git a/src/media_controller_playlist.c b/src/media_controller_playlist.c
index 87ebc5d..ca32df3 100755 (executable)
--- a/src/media_controller_playlist.c
+++ b/src/media_controller_playlist.c
@@ -18,7 +18,6 @@
 #include "media_controller_db.h"
 
 #define MAX_PLAYLIST_LEN 100
-#define MC_META_LIST   "title, artist, album, author, genre, duration, date, copyright, description, track_num, picture, season, episode, resolution"
 
 
 typedef struct {
@@ -43,24 +42,80 @@ static void __item_destroy(gpointer data)
                __release_playlist_item(item);
 }
 
-static void __query_destroy(gpointer data)
+static int __get_bundle_data(GList *playlist, bundle_raw **bundle_data, int *bundle_size)
 {
-       char *query_str = (char *)data;
+       int ret = MEDIA_CONTROLLER_ERROR_NONE;
+       bundle *bundle = NULL;
+       mc_playlist_item_s *item = NULL;
+       char *meta = NULL;
+       int idx = 0;
+       int length = 0;
+       bundle_raw *raw_data = NULL;
+       int size_r = 0;
+
+       mc_retvm_if(!playlist, MEDIA_CONTROLLER_ERROR_INVALID_PARAMETER, "invalid playlist");
+       mc_retvm_if(!bundle_data, MEDIA_CONTROLLER_ERROR_INVALID_PARAMETER, "invalid bundle_data");
+       mc_retvm_if(!bundle_size, MEDIA_CONTROLLER_ERROR_INVALID_PARAMETER, "invalid bundle_size");
+
+       length = g_list_length(playlist);
+       mc_retvm_if(!length, MEDIA_CONTROLLER_ERROR_INVALID_PARAMETER, "invalid playlist length");
+
+       bundle = bundle_create();
+       mc_retvm_if(!bundle, MEDIA_CONTROLLER_ERROR_INVALID_PARAMETER, "fail to bundle_create");
+
+       for (idx = 0; idx < length; idx++) {
+               item = (mc_playlist_item_s*)g_list_nth_data(playlist, idx);
+
+               if (item && item->index && item->metadata) {
+                       meta = g_strdup_printf("%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s",
+                                       item->metadata->title, MC_STRING_DELIMITER,
+                                       item->metadata->artist, MC_STRING_DELIMITER,
+                                       item->metadata->album, MC_STRING_DELIMITER,
+                                       item->metadata->author, MC_STRING_DELIMITER,
+                                       item->metadata->genre, MC_STRING_DELIMITER,
+                                       item->metadata->duration, MC_STRING_DELIMITER,
+                                       item->metadata->date, MC_STRING_DELIMITER,
+                                       item->metadata->copyright, MC_STRING_DELIMITER,
+                                       item->metadata->description, MC_STRING_DELIMITER,
+                                       item->metadata->track_num, MC_STRING_DELIMITER,
+                                       item->metadata->picture, MC_STRING_DELIMITER,
+                                       item->metadata->season, MC_STRING_DELIMITER,
+                                       item->metadata->episode, MC_STRING_DELIMITER,
+                                       item->metadata->resolution);
+
+                       if (meta) {
+                               ret = bundle_add_str(bundle, item->index, meta);
+                               MC_SAFE_G_FREE(meta);
+                               if (ret != BUNDLE_ERROR_NONE)
+                                       mc_error("fail to bundle_add_str[%d]", idx);
+                       }
+               } else {
+                       mc_error("wrong playlist item");
+               }
+       }
 
-       SQLITE3_SAFE_FREE(query_str);
+       ret = bundle_encode(bundle, &raw_data, &size_r);
+       if ((ret == BUNDLE_ERROR_NONE) && raw_data && (size_r != 0)) {
+               *bundle_data = raw_data;
+               *bundle_size = size_r;
+       } else {
+               mc_error("fail to bundle_encode[%d]", ret);
+               ret = MEDIA_CONTROLLER_ERROR_INVALID_OPERATION;
+       }
+
+       bundle_free(bundle);
+
+       return ret;
 }
 
 int _mc_playlist_update(mc_priv_type_e type, const char *server_name, mc_playlist_h playlist)
 {
        int ret = MEDIA_CONTROLLER_ERROR_NONE;
-       GList *query_list = NULL;
-       int length = 0;
-       int idx = 0;
-       char *sql_str = NULL;
-       mc_playlist_item_s *_item = NULL;
        mc_playlist_s *_playlist = (mc_playlist_s*)playlist;
        void* db_handle = NULL;
        gboolean is_exist = FALSE;
+       bundle_raw *bundle_data = NULL;
+       int bundle_size = 0;
 
        mc_retvm_if(!_playlist, MEDIA_CONTROLLER_ERROR_INVALID_PARAMETER, "invalid playlist");
        mc_retvm_if(!server_name, MEDIA_CONTROLLER_ERROR_INVALID_PARAMETER, "invalid server_name");
@@ -70,33 +125,17 @@ int _mc_playlist_update(mc_priv_type_e type, const char *server_name, mc_playlis
        _playlist->server_name = g_strdup(server_name);
 
        if (_playlist->item_list != NULL) {
-               length = g_list_length(_playlist->item_list);
-
-               for (idx = 0; idx < length; idx++) {
-                       _item = (mc_playlist_item_s*)g_list_nth_data(_playlist->item_list, idx);
+               ret = __get_bundle_data(_playlist->item_list, &bundle_data, &bundle_size);
 
-                       if (_item != NULL && _item->index != NULL && _item->metadata != NULL) {
-                               sql_str = sqlite3_mprintf("INSERT INTO '%q' (server_name, playlist_name, item_index, %s) VALUES (%Q, %Q, %Q, %Q, %Q, %Q, %Q, %Q, %Q, %Q, %Q, %Q, %Q, %Q, %Q, %Q, %Q);",
-                                       MC_DB_TABLE_PLAYLIST, MC_META_LIST, _playlist->server_name, _playlist->playlist_name, _item->index,
-                                       _item->metadata->title, _item->metadata->artist, _item->metadata->album, _item->metadata->author, _item->metadata->genre, _item->metadata->duration, _item->metadata->date,
-                                       _item->metadata->copyright, _item->metadata->description, _item->metadata->track_num, _item->metadata->picture, _item->metadata->season, _item->metadata->episode, _item->metadata->resolution);
-
-                               if (sql_str != NULL)
-                                       query_list = g_list_append(query_list, sql_str);
-                               else
-                                       mc_error("wrong playlist query");
-                       } else {
-                               mc_error("wrong playlist item");
-                       }
-               }
-
-               ret = mc_db_update_playlist(server_name, _playlist->playlist_name, query_list);
                g_list_free_full(_playlist->item_list, __item_destroy);
                _playlist->item_list = NULL;
-               g_list_free_full(query_list, __query_destroy);
 
-               return ret;
+               mc_retvm_if(ret != MEDIA_CONTROLLER_ERROR_NONE, ret, "__get_bundle_data failed");
 
+               ret = mc_db_update_playlist(server_name, _playlist->playlist_name, bundle_data, bundle_size);
+               MC_SAFE_FREE(bundle_data);
+
+               return ret;
        } else {
                ret = mc_db_connect(&db_handle, getuid(), FALSE);
                mc_retvm_if(db_handle == NULL, MEDIA_CONTROLLER_ERROR_INVALID_OPERATION, "fail to mc_db_connect [%d]", ret);

diff --git a/svc/media_controller_db_util.c b/svc/media_controller_db_util.c
index 007cf1f..3b1254f 100644 (file)
--- a/svc/media_controller_db_util.c
+++ b/svc/media_controller_db_util.c
@@ -34,6 +34,7 @@
 #define DB_DELETE_FROM_CLIENT_LIST     "DELETE FROM "MC_DB_TABLE_CLIENT_LIST" WHERE (client_name = '%q');"
 #define DB_UPDATE_STATE_PLAYBACK               "UPDATE '%q' SET server_state=%d, playback_state=%d;"
 #define DB_DROP_TABLE                          "DROP TABLE IF EXISTS '%q';"
+#define DB_META_LIST   "title, artist, album, author, genre, duration, date, copyright, description, track_num, picture, season, episode, resolution"
 #define DB_META_FIELD          "title TEXT, artist TEXT, album TEXT, author TEXT, genre TEXT, duration INTEGER DEFAULT 0, date TEXT, copyright TEXT, description TEXT, track_num TEXT, picture TEXT, season TEXT, episode TEXT, resolution TEXT, "
 #define DB_CREATE_SERVER_TABLE                         "DROP TABLE IF EXISTS '%q'; CREATE TABLE IF NOT EXISTS '%q' (\
                                server_name                     TEXT PRIMARY KEY, \
@@ -683,6 +684,38 @@ static const char * __replace_null(const char *data)
                return data;
 }
 
+static void  __playlist_cb(const char *key, const int type, const bundle_keyval_t *kv, void *user_data)
+{
+       void *basic_val = NULL;
+       size_t basic_size = 0;
+       gchar **params = NULL;
+       GList **query_list = (GList**)user_data;
+       char *sql_str = NULL;
+
+       mc_retm_if(!key, "invalid key");
+       mc_retm_if(!kv, "invalid kv");
+       mc_retm_if(!query_list, "invalid query_list");
+
+       bundle_keyval_get_basic_val((bundle_keyval_t *)kv, &basic_val, &basic_size);
+
+       //mc_secure_debug("Key [%s], Type [%d], basic_val [%s]", key, type, (char *)basic_val);
+
+       params = g_strsplit(basic_val, MC_STRING_DELIMITER, 0);
+       mc_retm_if(params == NULL, "invalid playlist data");
+
+       sql_str = sqlite3_mprintf("INSERT INTO '%q' (server_name, playlist_name, item_index, %s) VALUES (%Q, %Q, %Q, %Q, %Q, %Q, %Q, %Q, %Q, %Q, %Q, %Q, %Q, %Q, %Q, %Q, %Q);",
+                               MC_DB_TABLE_PLAYLIST, DB_META_LIST, g_list_nth_data(*query_list, 0), g_list_nth_data(*query_list, 1), key,
+                               __replace_null(params[0]), __replace_null(params[1]), __replace_null(params[2]), __replace_null(params[3]), __replace_null(params[4]),
+                               __replace_null(params[5]), __replace_null(params[6]), __replace_null(params[7]), __replace_null(params[8]), __replace_null(params[9]),
+                               __replace_null(params[10]), __replace_null(params[11]), __replace_null(params[12]), __replace_null(params[13]));
+
+       g_strfreev(params);
+
+       mc_secure_debug("sql_str [%s]", sql_str);
+
+       *query_list = g_list_append(*query_list, sql_str);
+}
+
 int mc_db_parse_and_update_db(uid_t uid, const char *data, int data_size)
 {
        int ret = MEDIA_CONTROLLER_ERROR_NONE;
@@ -693,7 +726,6 @@ int mc_db_parse_and_update_db(uid_t uid, const char *data, int data_size)
        int i_value_2 = 0;
        unsigned long long llu_value = 0, llu_value2 = 0;
        void* _db_handle = NULL;
-       gboolean is_query_from_client = FALSE;
 
        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");
@@ -769,15 +801,60 @@ int mc_db_parse_and_update_db(uid_t uid, const char *data, int data_size)
                sql_str = sqlite3_mprintf("INSERT INTO '%q' (server_name, playlist_name) VALUES (%Q, %Q);", MC_DB_TABLE_PLAYLIST, params[1], params[2]);
 
        } else if (strncmp(MC_DB_CMD_UPDATE_PLAYLIST, params[0], strlen(MC_DB_CMD_UPDATE_PLAYLIST)) == 0) {
-               if (params[2] == NULL || params[3] == NULL) {
+               bundle *bundle = NULL;
+               GList *query_list = NULL;
+               int list_len = 0;
+               int total_query_len = 0;
+               int i = 0;
+
+               if (!params[2] || !params[3] || !params[4]) {
                        mc_error("invalid query");
                        ret = MEDIA_CONTROLLER_ERROR_INVALID_OPERATION;
                        goto ERROR;
                }
 
-               sql_str = params[3];
-               is_query_from_client = TRUE;
+               mc_safe_strtoi(params[3], &i_value);
+               bundle = bundle_decode((bundle_raw *)params[4], i_value);
+               if (!bundle) {
+                       mc_error("invalid bundle_data");
+                       ret = MEDIA_CONTROLLER_ERROR_INVALID_OPERATION;
+                       goto ERROR;
+               }
+
+               mc_debug("bundle item count [%d]", bundle_get_count(bundle));
+
+               query_list = g_list_append(query_list, params[1]);      //server_name
+               query_list = g_list_append(query_list, params[2]);      //playlist_name
+
+               bundle_foreach(bundle, __playlist_cb, &query_list);
+               bundle_free(bundle);
+
+               list_len = g_list_length(query_list);
+               if (list_len < 3) {
+                       mc_error("invalid query_list len [%d]", list_len);
+                       ret = MEDIA_CONTROLLER_ERROR_INVALID_OPERATION;
+                       goto ERROR;
+               }
 
+               for (i = 2; i < list_len; i++) {
+                       char *query = NULL;
+                       query = g_list_nth_data(query_list, i);
+                       if (query != NULL)
+                               total_query_len += strlen(query);
+               }
+
+               sql_str = (char *)calloc(1, total_query_len + 1);
+
+               for (i = 2; i < list_len; i++) {
+                       char *query = NULL;
+                       query = g_list_nth_data(query_list, i);
+                       if (query != NULL) {
+                               g_strlcat(sql_str, query, total_query_len + 1);
+                               SQLITE3_SAFE_FREE(query);
+                       }
+               }
+
+               query_list = NULL;
        } else if (strncmp(MC_DB_CMD_UPDATE_ICON, params[0], strlen(MC_DB_CMD_UPDATE_ICON)) == 0) {
                if (params[2])
                        sql_str = sqlite3_mprintf("UPDATE '%q' SET icon_uri=%Q;", params[1], params[2]);
@@ -837,12 +914,14 @@ ERROR:
                                mc_safe_strtoi(params[2], &i_value);
                                ret = __mc_update_latest_server_info(NULL, params[1], MC_SERVER_STATE_ACTIVATE, i_value, FALSE);
                        }
+               } else if (strncmp(MC_DB_CMD_UPDATE_PLAYLIST, params[0], strlen(MC_DB_CMD_UPDATE_PLAYLIST)) == 0) {
+                       MC_SAFE_FREE(sql_str);
                }
 
                mc_db_disconnect(_db_handle);
 
-               if (!is_query_from_client)
-                       SQLITE3_SAFE_FREE(sql_str);
+               SQLITE3_SAFE_FREE(sql_str);
+
        }
 
        g_strfreev(params);