webrtc_test: Refine signaling server structure

[Version] 0.3.146
[Issue Type] Improvement

Change-Id: I52224bc3a3949368231f0b54388dd9d1aa5d22d0
Signed-off-by: Sangchul Lee <sc11.lee@samsung.com>

diff --git a/packaging/capi-media-webrtc.spec b/packaging/capi-media-webrtc.spec
index 04a9bdc792c6e4b88f8d605c3e82ebed0560b2d3..6954298d3d31f1fa32cf5fd08aa82d37527294be 100644 (file)
--- a/packaging/capi-media-webrtc.spec
+++ b/packaging/capi-media-webrtc.spec
@@ -1,6 +1,6 @@
 Name:       capi-media-webrtc
 Summary:    A WebRTC library in Tizen Native API
-Version:    0.3.145
+Version:    0.3.146
 Release:    0
 Group:      Multimedia/API
 License:    Apache-2.0

diff --git a/test/webrtc_test.c b/test/webrtc_test.c
index e1c46fb892e4baed29ade290d4e56fe47b037df3..64ef3de2cf7929de139ab6899eeefb83d64c379c 100644 (file)
--- a/test/webrtc_test.c
+++ b/test/webrtc_test.c
@@ -1862,7 +1862,7 @@ static void _websocket_connection_send_text_for_room(connection_s *conn, int rem
        RET_IF(!message, "message is NULL");
 
        message_for_room = g_strdup_printf ("ROOM_PEER_MSG %d %s", remote_peer_id, message);
-       soup_websocket_connection_send_text(g_ad.signaling_server.ws_conn, message_for_room);
+       soup_websocket_connection_send_text(g_ad.signaling_server.public.ws_conn, message_for_room);
        g_free(message_for_room);
 }
 
@@ -1936,39 +1936,45 @@ static void __signaling_message_cb(webrtc_signaling_message_type_e type, const c
 
 static void _webrtc_signaling_connect(const char *ip, int port)
 {
-       int ret = WEBRTC_ERROR_NONE;
+       int ret;
 
-       if (strlen(g_ad.signaling_server.url) > 0) {
-               g_printerr("server[%s] is already set by 'ss'\n", g_ad.signaling_server.url);
+       if (strlen(g_ad.signaling_server.public.url) > 0) {
+               g_printerr("server[%s] is already set by 'ss'\n", g_ad.signaling_server.public.url);
                return;
        }
 
-       ret = webrtc_signaling_connect(ip, port, __signaling_message_cb, &g_ad.conns[0], &g_ad.signaling_server.signaling_client);
+       ret = webrtc_signaling_connect(ip, port, __signaling_message_cb, &g_ad.conns[0], &g_ad.signaling_server.private.client);
        RET_IF(ret != WEBRTC_ERROR_NONE, "ret[0x%x]", ret);
 
-       if (g_ad.signaling_server.private_ip)
-               free(g_ad.signaling_server.private_ip);
-       g_ad.signaling_server.private_ip = strdup(ip);
-       g_ad.signaling_server.port = port;
+       if (g_ad.signaling_server.private.ip)
+               free(g_ad.signaling_server.private.ip);
+       g_ad.signaling_server.private.ip = strdup(ip);
+       g_ad.signaling_server.private.port = port;
 
        g_print("webrtc_signaling_connect() success\n");
 }
 
 static void _webrtc_signaling_disconnect(void)
 {
-       int ret = WEBRTC_ERROR_NONE;
+       int ret;
 
-       ret = webrtc_signaling_disconnect(g_ad.signaling_server.signaling_client);
+       RET_IF(!g_ad.signaling_server.is_connected, "signaling server is not connected");
+
+       ret = webrtc_signaling_disconnect(g_ad.signaling_server.private.client);
        RET_IF(ret != WEBRTC_ERROR_NONE, "ret[0x%x]", ret);
 
        g_print("webrtc_signaling_disconnect() success\n");
+
+       g_ad.signaling_server.private.client = NULL;
 }
 
 static void _webrtc_signaling_request_session(int peer_id)
 {
-       int ret = WEBRTC_ERROR_NONE;
+       int ret;
+
+       RET_IF(!g_ad.signaling_server.is_connected, "signaling server is not connected");
 
-       ret = webrtc_signaling_request_session(g_ad.signaling_server.signaling_client, peer_id);
+       ret = webrtc_signaling_request_session(g_ad.signaling_server.private.client, peer_id);
        RET_IF(ret != WEBRTC_ERROR_NONE, "ret[0x%x]", ret);
 
        g_print("webrtc_signaling_request_session() success\n");
@@ -1976,12 +1982,12 @@ static void _webrtc_signaling_request_session(int peer_id)
 
 static void _webrtc_signaling_send_message(const char *message)
 {
-       int ret = WEBRTC_ERROR_NONE;
+       int ret;
 
        RET_IF(!message, "message is NULL");
-       RET_IF(!g_ad.signaling_server.signaling_client, "signaling_client is NULL");
+       RET_IF(!g_ad.signaling_server.is_connected, "signaling server is not connected");
 
-       ret = webrtc_signaling_send_message(g_ad.signaling_server.signaling_client, message);
+       ret = webrtc_signaling_send_message(g_ad.signaling_server.private.client, message);
        RET_IF(ret != WEBRTC_ERROR_NONE, "ret[0x%x]", ret);
 
        g_print("webrtc_signaling_send_message() success\n");
@@ -1995,12 +2001,16 @@ static void __ice_candidate_cb(webrtc_h webrtc, const char *candidate, void *use
        RET_IF(!conn, "conn is NULL");
 
        g_print("\n[to SERVER > ICE]\n%s\n", candidate);
-       if (g_ad.signaling_server.ws_conn) {
+
+       RET_IF(!g_ad.signaling_server.is_connected, "signaling server is not connected");
+
+       if (g_ad.signaling_server.public.ws_conn) {
                if (conn->is_for_room)
                        _websocket_connection_send_text_for_room(conn, conn->remote_peer_id, candidate);
                else
-                       soup_websocket_connection_send_text(g_ad.signaling_server.ws_conn, candidate);
-       } else if (g_ad.signaling_server.signaling_client && g_ad.signaling_server.is_connected) {
+                       soup_websocket_connection_send_text(g_ad.signaling_server.public.ws_conn, candidate);
+
+       } else if (g_ad.signaling_server.private.client) {
                _webrtc_signaling_send_message(candidate);
        }
 }
@@ -2534,7 +2544,7 @@ static void _setting_uri(gchar *dest_arr, char *uri)
        if (!uri)
                return;
 
-       if (g_ad.signaling_server.signaling_client) {
+       if (g_ad.signaling_server.private.client) {
                g_printerr("already set by 'scc'\n");
                return;
        }
@@ -2550,14 +2560,11 @@ static void _setting_uri(gchar *dest_arr, char *uri)
 
 static void _request_session(int remote_peer_id)
 {
-       if (!g_ad.signaling_server.ws_conn && !g_ad.signaling_server.is_connected) {
-               g_printerr("server[%s] is not connected\n", g_ad.signaling_server.url);
-               return;
-       }
+       RET_IF(!g_ad.signaling_server.is_connected, "signaling server is not connected");
 
-       if (g_ad.signaling_server.ws_conn) {
+       if (g_ad.signaling_server.public.ws_conn) {
                gchar *msg;
-               if (soup_websocket_connection_get_state(g_ad.signaling_server.ws_conn) != SOUP_WEBSOCKET_STATE_OPEN) {
+               if (soup_websocket_connection_get_state(g_ad.signaling_server.public.ws_conn) != SOUP_WEBSOCKET_STATE_OPEN) {
                        g_printerr("websocket is not opened\n");
                        return;
                }
@@ -2565,11 +2572,14 @@ static void _request_session(int remote_peer_id)
                msg = g_strdup_printf("SESSION %d", remote_peer_id);
 
                g_print("\n[to SERVER > %s]\n", msg);
-               soup_websocket_connection_send_text(g_ad.signaling_server.ws_conn, msg);
+               soup_websocket_connection_send_text(g_ad.signaling_server.public.ws_conn, msg);
                g_free(msg);
 
-       } else {
+       } else if (g_ad.signaling_server.private.client) {
                _webrtc_signaling_request_session(remote_peer_id);
+
+       } else {
+               g_printerr("Neither public nor private signaling server is connected\n");
        }
 }
 
@@ -2578,15 +2588,10 @@ static void _request_join_room(char *room_name)
        gchar *msg;
 
        RET_IF(!room_name, "room_name is NULL");
+       RET_IF(!g_ad.signaling_server.is_connected, "signaling server is not connected");
+       RET_IF(!g_ad.signaling_server.public.ws_conn, "ws_conn is NULL");
 
-       if (!g_ad.signaling_server.ws_conn && !g_ad.signaling_server.is_connected) {
-               g_printerr("server[%s] is not connected\n", g_ad.signaling_server.url);
-               return;
-       }
-
-       RET_IF(!g_ad.signaling_server.ws_conn, "ws_conn is NULL");
-
-       if (soup_websocket_connection_get_state(g_ad.signaling_server.ws_conn) != SOUP_WEBSOCKET_STATE_OPEN) {
+       if (soup_websocket_connection_get_state(g_ad.signaling_server.public.ws_conn) != SOUP_WEBSOCKET_STATE_OPEN) {
                g_printerr("websocket is not opened\n");
                return;
        }
@@ -2594,7 +2599,7 @@ static void _request_join_room(char *room_name)
        msg = g_strdup_printf("ROOM %s", room_name);
 
        g_print("\n[to SERVER > %s]\n", msg);
-       soup_websocket_connection_send_text(g_ad.signaling_server.ws_conn, msg);
+       soup_websocket_connection_send_text(g_ad.signaling_server.public.ws_conn, msg);
        g_free(msg);
 }
 
@@ -2602,19 +2607,18 @@ static void _send_local_description(bool is_offer)
 {
        char *desc;
 
-       if (!g_ad.signaling_server.ws_conn && !g_ad.signaling_server.is_connected) {
-               g_printerr("server[%s] is not connected\n", g_ad.signaling_server.url);
-               return;
-       }
+       RET_IF(!g_ad.signaling_server.is_connected, "signaling server is not connected");
 
        desc = is_offer ? g_ad.conns[0].offer : g_ad.conns[0].answer;
 
        g_print("\n[to SERVER > local description]\n%s\n", desc);
 
-       if (g_ad.signaling_server.ws_conn)
-               soup_websocket_connection_send_text(g_ad.signaling_server.ws_conn, desc);
-       else
+       if (g_ad.signaling_server.public.ws_conn)
+               soup_websocket_connection_send_text(g_ad.signaling_server.public.ws_conn, desc);
+       else if (g_ad.signaling_server.private.client)
                _webrtc_signaling_send_message(desc);
+       else
+               g_printerr("Neither public nor private signaling server is connected\n");
 }
 
 gulong _connect_signal(GObject *obj, const char *signal_name, GCallback callback, gpointer user_data)
@@ -3333,15 +3337,16 @@ static void __close_websocket(signaling_server_s *ss)
 {
        RET_IF(!ss, "ss is NULL");
 
-       g_print("close websocket, ws_conn[%p]\n", ss->ws_conn);
+       g_print("close websocket, ws_conn[%p]\n", ss->public.ws_conn);
 
-       if (soup_websocket_connection_get_state(ss->ws_conn) == SOUP_WEBSOCKET_STATE_OPEN)
-               soup_websocket_connection_close(ss->ws_conn, 1000, "");
+       if (soup_websocket_connection_get_state(ss->public.ws_conn) == SOUP_WEBSOCKET_STATE_OPEN)
+               soup_websocket_connection_close(ss->public.ws_conn, 1000, "");
        else
-               g_object_unref(ss->ws_conn);
+               g_object_unref(ss->public.ws_conn);
 
-       ss->ws_conn = NULL;
+       ss->public.ws_conn = NULL;
        ss->server_status = SERVER_STATUS_DISCONNECTED;
+       ss->is_connected = false;
 }
 
 static void __websocket_closed_cb(SoupWebsocketConnection *ws_conn, gpointer user_data)
@@ -3350,7 +3355,7 @@ static void __websocket_closed_cb(SoupWebsocketConnection *ws_conn, gpointer use
 
        RET_IF(!ss, "ss is NULL");
        RET_IF(!ws_conn, "ws_conn is NULL");
-       RET_IF(ss->ws_conn != ws_conn, "not matched ws_conn[%p, %p]", ss->ws_conn, ws_conn);
+       RET_IF(ss->public.ws_conn != ws_conn, "not matched ws_conn[%p, %p]", ss->public.ws_conn, ws_conn);
 
        __close_websocket(ss);
 }
@@ -3583,7 +3588,7 @@ static void __websocket_message_cb(SoupWebsocketConnection *ws_conn, SoupWebsock
 
        RET_IF(!conn, "conn is NULL");
        RET_IF(!ws_conn, "ws_conn is NULL");
-       RET_IF(g_ad.signaling_server.ws_conn != ws_conn, "not matched ws_conn[%p, %p]", g_ad.signaling_server.ws_conn, ws_conn);
+       RET_IF(g_ad.signaling_server.public.ws_conn != ws_conn, "not matched ws_conn[%p, %p]", g_ad.signaling_server.public.ws_conn, ws_conn);
        RET_IF(type != SOUP_WEBSOCKET_DATA_TEXT, "invalid data type(%d)", type);
 
        data = g_bytes_get_data(message, &size);
@@ -3656,15 +3661,16 @@ static void __websocket_connected_cb(SoupSession *session, GAsyncResult *res, vo
                g_error_free(error);
                return;
        }
-       g_print("\n[%s] is connected, conn[%p]\n", g_ad.signaling_server.url, conn);
+       g_print("\n[%s] is connected, conn[%p]\n", g_ad.signaling_server.public.url, conn);
 
-       g_ad.signaling_server.ws_conn = ws_conn;
+       g_ad.signaling_server.public.ws_conn = ws_conn;
        g_ad.signaling_server.server_status = SERVER_STATUS_CONNECTED;
 
        g_signal_connect(ws_conn, "closed", G_CALLBACK(__websocket_closed_cb), &g_ad.signaling_server);
        g_signal_connect(ws_conn, "message", G_CALLBACK(__websocket_message_cb), conn);
 
        g_ad.signaling_server.local_peer_id = __send_greeting_to_register(ws_conn);
+       g_ad.signaling_server.is_connected = true;
 }
 
 static void _connect_signaling_server(void)
@@ -3674,7 +3680,7 @@ static void _connect_signaling_server(void)
        SoupURI *proxy_uri;
        const char *https_aliases[] = {"wss", NULL};
 
-       RET_IF(g_ad.signaling_server.signaling_client, "already set by 'scc'");
+       RET_IF(g_ad.signaling_server.private.client, "already set by 'scc'");
 
        if (strlen(g_ad.proxy) == 0) {
                session = soup_session_new_with_options(SOUP_SESSION_SSL_STRICT, TRUE,
@@ -3690,9 +3696,9 @@ static void _connect_signaling_server(void)
                        soup_uri_free(proxy_uri);
        }
 
-       message = soup_message_new(SOUP_METHOD_GET, g_ad.signaling_server.url);
+       message = soup_message_new(SOUP_METHOD_GET, g_ad.signaling_server.public.url);
 
-       g_print("connecting to signaling server[%s]...\n", g_ad.signaling_server.url);
+       g_print("connecting to signaling server[%s]...\n", g_ad.signaling_server.public.url);
 
        soup_session_websocket_connect_async(session, message, NULL, NULL, NULL,
                (GAsyncReadyCallback) __websocket_connected_cb, &g_ad.conns[0]);
@@ -3702,27 +3708,30 @@ static void _webrtc_signaling_server_create(int port)
 {
        int ret = WEBRTC_ERROR_NONE;
 
-       ret = webrtc_signaling_server_create(port, &(g_ad.inner_signaling_server));
+       ret = webrtc_signaling_server_create(port, &(g_ad.signaling_server.private.server));
        RET_IF(ret != WEBRTC_ERROR_NONE, "ret[0x%x]", ret);
 
-       g_print("webrtc_signaling_server_create() success, port[%d] g_inner_signaling_server[%p]\n", port, g_ad.inner_signaling_server);
+       g_print("webrtc_signaling_server_create() success, port[%d] g_ad.signaling_server.private.server[%p]\n", port, g_ad.signaling_server.private.server);
+
+       g_ad.signaling_server.private.server_port = port;
 }
 
 static void _webrtc_signaling_server_destroy(void)
 {
        int ret = WEBRTC_ERROR_NONE;
 
-       ret = webrtc_signaling_server_destroy(g_ad.inner_signaling_server);
+       ret = webrtc_signaling_server_destroy(g_ad.signaling_server.private.server);
        RET_IF(ret != WEBRTC_ERROR_NONE, "ret[0x%x]", ret);
 
        g_print("webrtc_signaling_server_destroy() success\n");
+       g_ad.signaling_server.private.server = NULL;
 }
 
 static void _webrtc_signaling_server_start(void)
 {
        int ret = WEBRTC_ERROR_NONE;
 
-       ret = webrtc_signaling_server_start(g_ad.inner_signaling_server);
+       ret = webrtc_signaling_server_start(g_ad.signaling_server.private.server);
        RET_IF(ret != WEBRTC_ERROR_NONE, "ret[0x%x]", ret);
 
        g_print("webrtc_signaling_server_start() success\n");
@@ -3732,7 +3741,7 @@ static void _webrtc_signaling_server_stop(void)
 {
        int ret = WEBRTC_ERROR_NONE;
 
-       ret = webrtc_signaling_server_stop(g_ad.inner_signaling_server);
+       ret = webrtc_signaling_server_stop(g_ad.signaling_server.private.server);
        RET_IF(ret != WEBRTC_ERROR_NONE, "ret[0x%x]", ret);
 
        g_print("webrtc_signaling_server_stop() success\n");
@@ -4498,7 +4507,7 @@ static void app_setting_and_signaling(char *cmd)
 
        switch (g_ad.menu_status) {
        case CURRENT_STATUS_SETTING_SIGNALING_SERVER: {
-               _setting_uri(g_ad.signaling_server.url, cmd);
+               _setting_uri(g_ad.signaling_server.public.url, cmd);
                reset_menu_state();
                break;
        }
@@ -4569,8 +4578,8 @@ static void app_setting_and_signaling(char *cmd)
        case CURRENT_STATUS_PRIVATE_SIGNALING_SERVER_CONNECT: {
                static char *ip = NULL;
 
-               if (strlen(g_ad.signaling_server.url) > 0) {
-                       g_printerr("server[%s] is already set by 'ss'\n", g_ad.signaling_server.url);
+               if (strlen(g_ad.signaling_server.public.url) > 0) {
+                       g_printerr("server[%s] is already set by 'ss'\n", g_ad.signaling_server.public.url);
                        reset_menu_state();
                        break;
                }

diff --git a/test/webrtc_test_menu.c b/test/webrtc_test_menu.c
index d077c4bd99e9508a8e7396c032b5ffe5f7f30206..fd7cc536ab58a842d4f41cf9e59cbd5536e88e74 100644 (file)
--- a/test/webrtc_test_menu.c
+++ b/test/webrtc_test_menu.c
@@ -145,20 +145,27 @@ void display_handle_status(int index)
 void display_setting_status(void)
 {
        int len_proxy = strlen(get_appdata()->proxy);
-       int len_server = strlen(get_appdata()->signaling_server.url);
+       int len_server = strlen(get_appdata()->signaling_server.public.url);
        int i;
 
        if (len_proxy > 0)
                g_print("  proxy[%s]\n", get_appdata()->proxy);
+       if (get_appdata()->signaling_server.private.server)
+               g_print("  private signaling server[port:%d]\n", get_appdata()->signaling_server.private.server_port);
        if (get_appdata()->validate_feeding_data)
                g_print("  validate-feeding-data[on]\n");
        if (get_appdata()->validate_encoded_frame_cb)
                g_print("  validate-encoded-frame-cb[on]\n");
 
        if (len_server > 0)
-               g_print("  server[%s][%s]\n", get_appdata()->signaling_server.url, g_server_status_str[get_appdata()->signaling_server.server_status]);
-       if (get_appdata()->signaling_server.private_ip && get_appdata()->signaling_server.port > 0)
-               g_print("  server[%s:%d][%s]\n", get_appdata()->signaling_server.private_ip, get_appdata()->signaling_server.port, g_server_status_str[get_appdata()->signaling_server.server_status]);
+               g_print("  server[%s][%s]\n",
+                       get_appdata()->signaling_server.public.url,
+                       g_server_status_str[get_appdata()->signaling_server.server_status]);
+       if (get_appdata()->signaling_server.private.ip && get_appdata()->signaling_server.private.port > 0)
+               g_print("  server[%s:%d][%s]\n",
+                       get_appdata()->signaling_server.private.ip,
+                       get_appdata()->signaling_server.private.port,
+                       g_server_status_str[get_appdata()->signaling_server.server_status]);
        if (get_appdata()->signaling_server.local_peer_id > 0)
                g_print("  local peer id : %d\n", get_appdata()->signaling_server.local_peer_id);
        for (i = 0; i < MAX_CONNECTION_LEN; i++) {

diff --git a/test/webrtc_test_priv.h b/test/webrtc_test_priv.h
index ed7c09e2e2433faf1a01790e01bc34b476db9cdf..4caab16785f7b6c9330ddaa1fa752169d3f15217 100644 (file)
--- a/test/webrtc_test_priv.h
+++ b/test/webrtc_test_priv.h
@@ -241,17 +241,24 @@ typedef struct _connection_s {
        GstElement *appsrc_for_video;
 } connection_s;
 
-typedef struct _signaling_server_s {
-       gchar url[MAX_STRING_LEN];
-       SoupWebsocketConnection *ws_conn;
+typedef struct {
        int server_status;
        gint32 local_peer_id;
-
-       /* for private network - internal API */
-       webrtc_signaling_client_h signaling_client;
-       char *private_ip;
-       int port;
        bool is_connected;
+       struct {
+               gchar url[MAX_STRING_LEN];
+               SoupWebsocketConnection *ws_conn;
+       } public;
+       struct {
+               /* private signaling server */
+               webrtc_signaling_server_h server;
+               int server_port;
+
+               /* client handle connects to a server of ip/port below */
+               webrtc_signaling_client_h client;
+               char *ip;
+               int port;
+       } private;
 } signaling_server_s;
 
 typedef struct {
@@ -274,7 +281,6 @@ typedef struct {
 
        connection_s conns[MAX_CONNECTION_LEN];
        signaling_server_s signaling_server;
-       webrtc_signaling_server_h inner_signaling_server;
 
        gchar proxy[MAX_STRING_LEN];
        bool validate_feeding_data;