Change 'coupled-sink-ip' attribute and api name.

1. 'coupled-sink-ip' removed. it will be handled on sink.
2. API 'scmirroring_sink_set_coupled_ip' is changed to 'scmirroring_sink_set_coupled_sink'.

Change-Id: I0ff0439fce39795df765cabbc64812d1c7252a82
Signed-off-by: Hyunsoo Park <hance.park@samsung.com>

diff --git a/include/scmirroring_internal.h b/include/scmirroring_internal.h
index ec6ca0aff720460ba771feebbcbddcb23eea8e2a..2a726c2a9c91db876ef218d235bfb772eb701a54 100644 (file)
--- a/include/scmirroring_internal.h
+++ b/include/scmirroring_internal.h
@@ -74,18 +74,19 @@ typedef enum {
 typedef void(*scmirroring_state_cb)(scmirroring_error_e error, scmirroring_state_e state, void *user_data);
 
 /**
- * @brief Called when user wants to set 'coupled_sink_ip'.
+ * @brief Called when user wants to set 'stats' and 'address' of coupled sink.
  *
  * @details This callback is called for state and error of screen mirroring.
  *
- * @param[in] scmirroring_sink     screen mirroring sink handle
- * @param[in] coupled_ip           ip address which is coupled with primary sink. e.g secondary sink
+ * @param[in] scmirroring_sink     Screen mirroring sink handle
+ * @param[in] status               Status which indicates whether primary sink is coupled or not.
+ * @param[in] address              Mac address of coupled sink.
  *
- * @pre scmirroring_src_create()
+ * @pre scmirroring_sink_create()
  *
- * @see scmirroring_src_create()
+ * @see scmirroring_sink_create()
  */
-int scmirroring_sink_set_coupled_ip(scmirroring_sink_h scmirroring_sink, char* coupled_ip);
+int scmirroring_sink_set_coupled_sink(scmirroring_sink_h scmirroring_sink, gint status, gchar* address);
 
 #ifdef __cplusplus
 }

diff --git a/include/scmirroring_private.h b/include/scmirroring_private.h
index 296338a4e5420a98ff0fc2965a74fbe6d8009fdf..7f78fb0a0881867945e8368e1642f96585ef3c1e 100644 (file)
--- a/include/scmirroring_private.h
+++ b/include/scmirroring_private.h
@@ -133,7 +133,6 @@ typedef struct {
        scmirroring_direct_streaming_e direct_streaming;
        char *filesrc;
        scmirroring_av_transport_e av_transport;
-       char *coupled_sink_ip;
 } scmirroring_src_s;
 
 typedef struct {
@@ -143,7 +142,6 @@ typedef struct {
        bool use_hdcp;
        scmirroring_sink_state_cb_s *scmirroring_sink_state_cb;
        unsigned int magic_num;
-       char *coupled_sink_ip;
 } scmirroring_sink_s;
 
 typedef struct {
@@ -167,7 +165,6 @@ typedef struct {
        scmirroring_direct_streaming_e direct_streaming;
        char *filesrc;
        scmirroring_av_transport_e av_transport;
-       char *coupled_sink_ip;
 } scmirroring_primary_sink_s;
 
 
@@ -178,7 +175,6 @@ typedef struct {
        bool use_hdcp;
        scmirroring_sink_state_cb_s *scmirroring_sink_state_cb;
        unsigned int magic_num;
-       char *coupled_sink_ip;
 } scmirroring_secondary_sink_s;
 
 #define WIFIDIRECT_DISPLAY_FEATURE "http://tizen.org/feature/network.wifi.direct.display"

diff --git a/src/scmirroring_primary_sink.c b/src/scmirroring_primary_sink.c
index 0b135a6edb3652bf9c9e5fa45de7a73cf61569b2..a73da9d2d36bfae957c07e3f27d746b75a605657 100644 (file)
--- a/src/scmirroring_primary_sink.c
+++ b/src/scmirroring_primary_sink.c
@@ -729,7 +729,7 @@ int scmirroring_primary_sink_get_current_state(scmirroring_primary_sink_h scmirr
        return __scmirroring_primary_sink_error_convert(__func__, result);
 }
 
-int scmirroring_primary_sink_set_coupled_ip(scmirroring_primary_sink_h scmirroring_primary_sink, char* coupled_ip)
+int scmirroring_primary_sink_set_coupled_sink(scmirroring_primary_sink_h scmirroring_primary_sink, gint status, gchar* address)
 {
        int ret = SCMIRRORING_ERROR_NONE;
        scmirroring_debug_fenter();
@@ -738,13 +738,9 @@ int scmirroring_primary_sink_set_coupled_ip(scmirroring_primary_sink_h scmirrori
        scmirroring_retvm_if(handle == NULL, SCMIRRORING_ERROR_INVALID_PARAMETER, "scmirroring_primary_sink is NULL");
        scmirroring_retvm_if(handle->magic_num != SCMIRRORING_MAGIC_NUMBER, SCMIRRORING_ERROR_INVALID_PARAMETER, "scmirroring_primary_sink is invalid handle");
 
-       if (coupled_ip == NULL) {
-               scmirroring_error("Invalid coupled ip parameter [%s]", coupled_ip);
-               return SCMIRRORING_ERROR_INVALID_PARAMETER;
-       }
-       scmirroring_debug("coupled_ip (%s)", coupled_ip);
+       scmirroring_debug("address [%s], status[%d]", address, status);
 
-       ret = mm_wfd_sink_set_coupled_ip(handle->mm_handle, coupled_ip);
+       ret = mm_wfd_sink_set_coupled_sink(handle->mm_handle, status, address);
        if (ret != MM_ERROR_NONE) {
                scmirroring_error("Fail to Set Coupled IP");
                return __scmirroring_primary_sink_error_convert(__func__, ret);
@@ -977,13 +973,10 @@ static void __scmirroring_primary_src_interpret(scmirroring_primary_sink_s *scmi
                } else {
                        scmirroring_debug("Current state is already %d", src_state);
                }
-
        }else{
-               scmirroring->coupled_sink_ip = response[1];
+               /* for coupled sink */
                error_code = SCMIRRORING_ERROR_NONE;
                src_state = SCMIRRORING_STATE_TEARDOWN_FOR_SINK;
-               scmirroring_debug("__scmirroring_primary_src_interpret sec_ip : %s", scmirroring->coupled_sink_ip);
-               scmirroring_debug("__scmirroring_primary_src_interpret is here %d : %d",error_code, src_state);
                __scmirroring_primary_src_set_callback_info(scmirroring, error_code, src_state);
        }
 
@@ -1186,7 +1179,6 @@ int scmirroring_primary_src_create(scmirroring_primary_sink_h *scmirroring)
        _scmirroring->server_name = g_strdup("scmirroring");
        _scmirroring->multisink = SCMIRRORING_MULTISINK_DISABLE;
        _scmirroring->av_transport = SCMIRRORING_AV_TRANSPORT_UDP;
-       _scmirroring->coupled_sink_ip = NULL;
 
        *scmirroring = (scmirroring_primary_sink_h)_scmirroring;
 

diff --git a/src/scmirroring_secondary_sink.c b/src/scmirroring_secondary_sink.c
index 139142f6e2aceea0336a8d326569d31a1a7464da..56d193799704ac7f219b199291d8e29717836b50 100644 (file)
--- a/src/scmirroring_secondary_sink.c
+++ b/src/scmirroring_secondary_sink.c
@@ -717,7 +717,7 @@ int scmirroring_secondary_sink_get_current_state(scmirroring_secondary_sink_h sc
        return __scmirroring_secondary_sink_error_convert(__func__, result);
 }
 
-int scmirroring_secondary_sink_set_coupled_ip(scmirroring_secondary_sink_h scmirroring_secondary_sink, char* coupled_ip)
+int scmirroring_secondary_sink_set_coupled_sink(scmirroring_secondary_sink_h scmirroring_secondary_sink, gint status, gchar* address)
 {
        int ret = SCMIRRORING_ERROR_NONE;
        scmirroring_debug_fenter();
@@ -726,15 +726,12 @@ int scmirroring_secondary_sink_set_coupled_ip(scmirroring_secondary_sink_h scmir
        scmirroring_retvm_if(handle == NULL, SCMIRRORING_ERROR_INVALID_PARAMETER, "scmirroring_secondary_sink is NULL");
        scmirroring_retvm_if(handle->magic_num != SCMIRRORING_MAGIC_NUMBER, SCMIRRORING_ERROR_INVALID_PARAMETER, "scmirroring_secondary_sink is invalid handle");
 
-       if (coupled_ip == NULL) {
-               scmirroring_error("Invalid coupled ip parameter [%s]", coupled_ip);
-               return SCMIRRORING_ERROR_INVALID_PARAMETER;
-       }
-       scmirroring_debug("coupled_ip (%s)", coupled_ip);
+       scmirroring_debug("status [%d], address[%s]", status, address);
+
+       ret = mm_wfd_sink_set_coupled_sink(handle->mm_handle, status, address);
 
-       ret = mm_wfd_sink_set_coupled_ip(handle->mm_handle, coupled_ip);
        if (ret != MM_ERROR_NONE) {
-               scmirroring_error("Fail to Set Coupled IP");
+               scmirroring_error("Fail to Set Coupled sink");
                return __scmirroring_secondary_sink_error_convert(__func__, ret);
        }
        ret = __scmirroring_secondary_sink_error_convert(__func__, ret);

diff --git a/src/scmirroring_sink.c b/src/scmirroring_sink.c
index 93c28429a08a60ac9b8d1e7503cfb708ea57dd05..4f85b3c5e5cfa18664cf44f26930cfafc72a6361 100644 (file)
--- a/src/scmirroring_sink.c
+++ b/src/scmirroring_sink.c
@@ -717,7 +717,7 @@ int scmirroring_sink_get_current_state(scmirroring_sink_h scmirroring_sink, scmi
        return __scmirroring_sink_error_convert(__func__, result);
 }
 
-int scmirroring_sink_set_coupled_ip(scmirroring_sink_h scmirroring_sink, char* coupled_ip)
+int scmirroring_sink_set_coupled_sink(scmirroring_sink_h scmirroring_sink, gint status, gchar* address)
 {
        int ret = SCMIRRORING_ERROR_NONE;
        scmirroring_debug_fenter();
@@ -726,13 +726,10 @@ int scmirroring_sink_set_coupled_ip(scmirroring_sink_h scmirroring_sink, char* c
        scmirroring_retvm_if(handle == NULL, SCMIRRORING_ERROR_INVALID_PARAMETER, "scmirroring_sink is NULL");
        scmirroring_retvm_if(handle->magic_num != SCMIRRORING_MAGIC_NUMBER, SCMIRRORING_ERROR_INVALID_PARAMETER, "scmirroring_sink is invalid handle");
 
-       if (coupled_ip == NULL) {
-               scmirroring_error("Invalid coupled ip parameter [%s]", coupled_ip);
-               return SCMIRRORING_ERROR_INVALID_PARAMETER;
-       }
-       scmirroring_debug("coupled_ip (%s)", coupled_ip);
+       scmirroring_debug("status [%d], address[%s]", status, address);
+
+       ret = mm_wfd_sink_set_coupled_sink(handle->mm_handle, status, address);
 
-       ret = mm_wfd_sink_set_coupled_ip(handle->mm_handle, coupled_ip);
        if (ret != MM_ERROR_NONE) {
                scmirroring_error("Fail to Set Coupled IP");
                return __scmirroring_sink_error_convert(__func__, ret);

diff --git a/src/scmirroring_src.c b/src/scmirroring_src.c
index b6eecd85c876f793881cff9c305beabf973a7be0..2d9ef9b5bc25a82312d4cb027bdc5769f078f0c6 100644 (file)
--- a/src/scmirroring_src.c
+++ b/src/scmirroring_src.c
@@ -253,11 +253,10 @@ static void __scmirroring_src_interpret(scmirroring_src_s *scmirroring, char *bu
                }
 
        }else{
-               scmirroring->coupled_sink_ip = response[1];
+               /* for coupled sink */
                error_code = SCMIRRORING_ERROR_NONE;
                src_state = SCMIRRORING_STATE_TEARDOWN_FOR_SINK;
-               scmirroring_debug("__scmirroring_src_interpret sec_ip : %s", scmirroring->coupled_sink_ip);
-               scmirroring_debug("__scmirroring_src_interpret is here %d : %d",error_code, src_state);
+               scmirroring_debug("__scmirroring_src_interpret is here %d : %d", error_code, src_state);
                __scmirroring_src_set_callback_info(scmirroring, error_code, src_state);
        }
 
@@ -460,7 +459,6 @@ int scmirroring_src_create(scmirroring_src_h *scmirroring)
        _scmirroring->server_name = g_strdup("scmirroring");
        _scmirroring->multisink = SCMIRRORING_MULTISINK_DISABLE;
        _scmirroring->av_transport = SCMIRRORING_AV_TRANSPORT_UDP;
-       _scmirroring->coupled_sink_ip = NULL;
 
        *scmirroring = (scmirroring_src_h)_scmirroring;
 

diff --git a/test_sink/scmirroring_primary_sink_test.c b/test_sink/scmirroring_primary_sink_test.c
index 8716612247cbd4faff0e104781b6ff6e0aabe64d..6ca83af7bd862c921dd5abe84f6c26ae63ae6d22 100644 (file)
--- a/test_sink/scmirroring_primary_sink_test.c
+++ b/test_sink/scmirroring_primary_sink_test.c
@@ -15,6 +15,7 @@
 */
 #include <gio/gio.h>
 #include <scmirroring_private.h>
+#include <scmirroring_internal.h>
 
 #include <stdlib.h>
 #include <string.h>
@@ -55,7 +56,6 @@ gint g_resolution = 0;
 gint g_sinktype = SCMIRRORING_DISPLAY_TYPE_OVERLAY;
 
 gint g_menu = MAIN_MENU;
-gchar* sec_ip = NULL;
 GMainLoop *g_loop;
 
 #ifdef TEST_WITH_WIFI_DIRECT
@@ -496,10 +496,6 @@ static void scmirroring_source_state_callback(scmirroring_error_e error_code, sc
 
        //if state 8, copy it to sink's sec_ip and make coupled_state = coupled.
        if(state == 8){
-               scmirroring_primary_sink_s* scm = (scmirroring_primary_sink_s*) scmirroring_primary_sink;
-               g_print(" >> 8 and %s", scm->coupled_sink_ip);
-               sec_ip = g_strdup(scm->coupled_sink_ip);
-               g_print("sec_ip is : %s", sec_ip);
                g_print("Stop\n");
                int ret=0;
                ret = scmirroring_primary_src_stop(scmirroring_primary_sink);
@@ -1147,21 +1143,9 @@ static int __scmirroring_primary_sink_create(gpointer data)
                g_print("scmirroring_primary_sink_create fail [%d]", ret);
                return SCMIRRORING_ERROR_INVALID_OPERATION;
        }
-
-       if (sec_ip != NULL){
-               scmirroring_primary_sink_s *wfd_sink = (scmirroring_primary_sink_s *) scmirroring_primary_sink;
-               wfd_sink->coupled_sink_ip = sec_ip;
-               g_print("sec_ip in sink is : %s", wfd_sink->coupled_sink_ip);
-               scmirroring_sink_set_coupled_ip(wfd_sink,sec_ip);
-       }
-       else {
-               scmirroring_primary_sink_s *wfd_sink = (scmirroring_primary_sink_s *) scmirroring_primary_sink;
-               g_print("sec_ip is null and i set sec_ip to \"192.168.0.10\" for testing \n");
-               wfd_sink->coupled_sink_ip = strdup("192.168.0.10");
-               g_print("0set sec_ip is [%s] \n",wfd_sink->coupled_sink_ip);
-       }
-       scmirroring_primary_sink_s *wfd_sink = (scmirroring_primary_sink_s *) scmirroring_primary_sink;
-       g_print("1set sec_ip is [%s] \n",wfd_sink->coupled_sink_ip);
+       char address[50]={0};
+       strncpy(address,"00:00:00:00:00",50);
+       scmirroring_sink_set_coupled_sink(scmirroring_primary_sink,0,address);
 
        if (g_sinktype != -1) {
                if (g_sinktype == SCMIRRORING_DISPLAY_TYPE_OVERLAY) {

diff --git a/test_sink/scmirroring_secondary_sink_test.c b/test_sink/scmirroring_secondary_sink_test.c
index 6aff3abe2d73309dbcc7f7cffd2b42acf26aeb47..52f2fb6482f5503947d9187d0c4b234d253d91da 100644 (file)
--- a/test_sink/scmirroring_secondary_sink_test.c
+++ b/test_sink/scmirroring_secondary_sink_test.c
@@ -1070,7 +1070,7 @@ static int __scmirroring_secondary_sink_create(gpointer data)
        //char ip[50]={0};
        //strncpy(ip,"192.168.0.23",50);
        //g_print("IP is %s\n", ip);
-       //ret=scmirroring_sink_set_coupled_ip(g_scmirroring,ip);
+       //ret=scmirroring_sink_set_coupled_sink(g_scmirroring,0,"00:00:00:00:00");
        if (g_sinktype != -1) {
                if (g_sinktype == SCMIRRORING_DISPLAY_TYPE_OVERLAY) {
                        evas_object_show(g_evas);

diff --git a/test_sink/scmirroring_sink_test.c b/test_sink/scmirroring_sink_test.c
index 878a5b2443416a666663bf789195f53d27a93c92..c936dde5b77afaa52cf962cb76c266469e6e81fc 100644 (file)
--- a/test_sink/scmirroring_sink_test.c
+++ b/test_sink/scmirroring_sink_test.c
@@ -1067,10 +1067,9 @@ static int __scmirroring_sink_create(gpointer data)
                return SCMIRRORING_ERROR_INVALID_OPERATION;
        }
 
-       char ip[50]={0};
-       strncpy(ip,"192.168.0.23",50);
-       g_print("IP is %s\n", ip);
-       ret=scmirroring_sink_set_coupled_ip(g_scmirroring,ip);
+       char address[50]={0};
+       strncpy(address,"00:00:00:00:00",50);
+       ret=scmirroring_sink_set_coupled_sink(g_scmirroring,0,address);
        if (g_sinktype != -1) {
                if (g_sinktype == SCMIRRORING_DISPLAY_TYPE_OVERLAY) {
                        evas_object_show(g_evas);