From d8bbb1ddff17d69ab622d24afe8feaf441454cdd Mon Sep 17 00:00:00 2001 From: Hyunsoo Park Date: Thu, 15 Nov 2018 21:53:07 +0900 Subject: [PATCH] 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 --- include/scmirroring_internal.h | 13 +++++------ include/scmirroring_private.h | 4 ---- src/scmirroring_primary_sink.c | 16 ++++---------- src/scmirroring_secondary_sink.c | 13 +++++------ src/scmirroring_sink.c | 11 ++++------ src/scmirroring_src.c | 6 ++---- test_sink/scmirroring_primary_sink_test.c | 24 ++++----------------- test_sink/scmirroring_secondary_sink_test.c | 2 +- test_sink/scmirroring_sink_test.c | 7 +++--- 9 files changed, 30 insertions(+), 66 deletions(-) diff --git a/include/scmirroring_internal.h b/include/scmirroring_internal.h index ec6ca0a..2a726c2 100644 --- 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 296338a..7f78fb0 100644 --- 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 0b135a6..a73da9d 100644 --- 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 139142f..56d1937 100644 --- 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 93c2842..4f85b3c 100644 --- 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 b6eecd8..2d9ef9b 100644 --- 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 8716612..6ca83af 100644 --- a/test_sink/scmirroring_primary_sink_test.c +++ b/test_sink/scmirroring_primary_sink_test.c @@ -15,6 +15,7 @@ */ #include #include +#include #include #include @@ -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 6aff3ab..52f2fb6 100644 --- 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 878a5b2..c936dde 100644 --- 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); -- 2.34.1