Added support to get wifi-sharing client information.

Change-Id: I943055879bae2cc83d89322e4a9af051d4894523
Signed-off-by: Niraj Kumar Goit <niraj.g@samsung.com>

diff --git a/include/tethering.h b/include/tethering.h
index c550901..fe43b64 100644 (file)
--- a/include/tethering.h
+++ b/include/tethering.h
@@ -67,6 +67,7 @@ typedef enum {
     TETHERING_TYPE_BT,  /**< BT type */
     TETHERING_TYPE_P2P,  /**< P2P type */
     TETHERING_TYPE_WIFI_SHARING,  /**< Wi-Fi Sharing */
+    TETHERING_TYPE_MAX,  /**< Maximum */
 } tethering_type_e;
 
 /**

diff --git a/include/tethering_private.h b/include/tethering_private.h
index 06b3268..6e685de 100644 (file)
--- a/include/tethering_private.h
+++ b/include/tethering_private.h
@@ -116,7 +116,6 @@ int _tethering_check_feature_supported(const char* feature, ...);
 /**
 * Common configuration
 */
-#define TETHERING_TYPE_MAX             5       /**< All, USB, Wi-Fi, BT, Wi-Fi AP */
 #define TETHERING_STR_INFO_LEN 40      /**< length of the ip or mac address */
 
 /**
@@ -334,6 +333,10 @@ typedef struct {
        unsigned int txpower;
 } _softap_settings_t;
 
+typedef struct {
+       bool flag;
+} tethering_request_table_t;
+
 void _tethering_add_handle(tethering_h handle);
 void _tethering_remove_handle(tethering_h handle);
 bool _tethering_check_handle(tethering_h handle);

diff --git a/src/tethering.c b/src/tethering.c
index 65e9301..cd44ae7 100755 (executable)
--- a/src/tethering.c
+++ b/src/tethering.c
@@ -135,6 +135,7 @@ static __tethering_sig_t sigs[] = {
        {0, SIGNAL_NAME_DHCP_STATUS, __handle_dhcp} };
 
 static int retry = 0;
+static __thread tethering_request_table_t request_table[TETHERING_TYPE_MAX];
 
 static void __send_dbus_signal(GDBusConnection *conn, const char *signal_name, const char *arg)
 {
@@ -159,6 +160,7 @@ static bool __any_tethering_is_enabled(tethering_h tethering)
 {
        if (tethering_is_enabled(tethering, TETHERING_TYPE_USB) ||
                        tethering_is_enabled(tethering, TETHERING_TYPE_WIFI) ||
+                       tethering_is_enabled(tethering, TETHERING_TYPE_WIFI_SHARING) ||
                        tethering_is_enabled(tethering, TETHERING_TYPE_BT) ||
                        tethering_is_enabled(tethering, TETHERING_TYPE_P2P))
                return true;
@@ -369,9 +371,12 @@ static void __handle_dhcp(GDBusConnection *connection, const gchar *sender_name,
 
        if (ap_type == MOBILE_AP_TYPE_USB)
                type = TETHERING_TYPE_USB;
-       else if (ap_type == MOBILE_AP_TYPE_WIFI)
-               type = TETHERING_TYPE_WIFI;
-       else if (ap_type == MOBILE_AP_TYPE_BT)
+       else if (ap_type == MOBILE_AP_TYPE_WIFI) {
+               if (request_table[TETHERING_TYPE_WIFI_SHARING].flag)
+                       type = TETHERING_TYPE_WIFI_SHARING;
+               else
+                       type = TETHERING_TYPE_WIFI;
+       } else if (ap_type == MOBILE_AP_TYPE_BT)
                type = TETHERING_TYPE_BT;
        else if (ap_type == MOBILE_AP_TYPE_P2P)
                type = TETHERING_TYPE_P2P;
@@ -768,10 +773,17 @@ static void __wifi_enabled_cfm_cb(GObject *source_object, GAsyncResult *res,
        GError *g_error = NULL;
        GVariant *g_var;
        guint info;
+       tethering_type_e type = 0;
        tethering_error_e error;
        __tethering_h *th = (__tethering_h *)user_data;
-       tethering_enabled_cb ecb = th->enabled_cb[TETHERING_TYPE_WIFI];
-       void *data = th->enabled_user_data[TETHERING_TYPE_WIFI];
+
+       if (request_table[TETHERING_TYPE_WIFI_SHARING].flag)
+               type = TETHERING_TYPE_WIFI_SHARING;
+       else
+               type = TETHERING_TYPE_WIFI;
+
+       tethering_enabled_cb ecb = th->enabled_cb[type];
+       void *data = th->enabled_user_data[type];
 
        if (!_tethering_check_handle((tethering_h)user_data))
                return;
@@ -782,7 +794,7 @@ static void __wifi_enabled_cfm_cb(GObject *source_object, GAsyncResult *res,
                if (g_error->code == G_DBUS_ERROR_NO_REPLY &&
                                ++retry < TETHERING_ERROR_RECOVERY_MAX) {
                        g_error_free(g_error);
-                       tethering_enable((tethering_h)th, TETHERING_TYPE_WIFI);
+                       tethering_enable((tethering_h)th, type);
                        return;
                } else if (g_error->code == G_DBUS_ERROR_ACCESS_DENIED)
                        error = TETHERING_ERROR_PERMISSION_DENIED;
@@ -808,7 +820,7 @@ static void __wifi_enabled_cfm_cb(GObject *source_object, GAsyncResult *res,
                INFO("-\n");
                return;
        }
-       ecb(error, TETHERING_TYPE_WIFI, true, data);
+       ecb(error, type, true, data);
        g_variant_unref(g_var);
        INFO("-\n");
 }
@@ -1386,7 +1398,8 @@ static bool __check_precondition(tethering_type_e type)
        vconf_get_int(VCONFKEY_NETWORK_STATUS, &dnet_status);
        if ((dnet_status == VCONFKEY_NETWORK_WIFI
                        && type != TETHERING_TYPE_WIFI)
-               || dnet_status == VCONFKEY_NETWORK_ETHERNET)
+               || (dnet_status == VCONFKEY_NETWORK_ETHERNET
+                       && type != TETHERING_TYPE_WIFI_SHARING))
                return TRUE;
 
        ERR("Network is not available!");
@@ -1628,10 +1641,13 @@ API int tethering_enable(tethering_h tethering, tethering_type_e type)
                         set.max_connected);
 
                char key[TETHERING_WIFI_KEY_MAX_LEN + 1] = {0, };
-               if (type == TETHERING_TYPE_WIFI_SHARING)
+               if (type == TETHERING_TYPE_WIFI_SHARING) {
                        g_strlcpy(key, "wifi_sharing", TETHERING_WIFI_KEY_MAX_LEN);
-               else
+                       request_table[TETHERING_TYPE_WIFI_SHARING].flag = true;
+               } else {
                        g_strlcpy(key, "wifi_tether", TETHERING_WIFI_KEY_MAX_LEN);
+                       request_table[TETHERING_TYPE_WIFI].flag = true;
+               }
 
                g_dbus_proxy_call(proxy, "enable_wifi_tethering",
                                g_variant_new("(ssssiiiiiii)", key, set.ssid, set.key, set.mode,
@@ -1779,10 +1795,13 @@ API int tethering_ipv6_enable(tethering_h tethering, tethering_type_e type)
                        set.max_connected);
 
                char key[TETHERING_WIFI_KEY_MAX_LEN + 1] = {0, };
-               if (type == TETHERING_TYPE_WIFI_SHARING)
+               if (type == TETHERING_TYPE_WIFI_SHARING) {
                        g_strlcpy(key, "wifi_sharing", TETHERING_WIFI_KEY_MAX_LEN);
-               else
+                       request_table[TETHERING_TYPE_WIFI_SHARING].flag = true;
+               } else {
                        g_strlcpy(key, "wifi_tether", TETHERING_WIFI_KEY_MAX_LEN);
+                       request_table[TETHERING_TYPE_WIFI_SHARING].flag = true;
+               }
 
                g_dbus_proxy_call(proxy, "enable_wifi_tethering",
                                g_variant_new("(ssssiiiiiii)", key, set.ssid, set.key, set.mode,
@@ -2011,6 +2030,7 @@ API bool tethering_is_enabled(tethering_h tethering, tethering_type_e type)
                break;
 
        case TETHERING_TYPE_WIFI:
+       case TETHERING_TYPE_WIFI_SHARING:
                vconf_type = VCONFKEY_MOBILE_HOTSPOT_MODE_WIFI;
                break;
 
@@ -2362,7 +2382,8 @@ API int tethering_foreach_connected_clients(tethering_h tethering, tethering_typ
 {
        CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
        if (type == TETHERING_TYPE_USB) CHECK_FEATURE_SUPPORTED(TETHERING_USB_FEATURE);
-       else if (type == TETHERING_TYPE_WIFI) CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
+       else if (type == TETHERING_TYPE_WIFI || type == TETHERING_TYPE_WIFI_SHARING)
+               CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
        else if (type == TETHERING_TYPE_BT) CHECK_FEATURE_SUPPORTED(TETHERING_BT_FEATURE);
 
        _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
@@ -2406,9 +2427,13 @@ API int tethering_foreach_connected_clients(tethering_h tethering, tethering_typ
                                interface = g_variant_get_int32(value);
                                if (interface == MOBILE_AP_TYPE_USB)
                                        client.interface = TETHERING_TYPE_USB;
-                               else if (interface == MOBILE_AP_TYPE_WIFI)
-                                       client.interface = TETHERING_TYPE_WIFI;
-                               else if (interface == MOBILE_AP_TYPE_BT)
+                               else if (interface == MOBILE_AP_TYPE_WIFI) {
+                                       if (request_table[TETHERING_TYPE_WIFI_SHARING].flag)
+                                               client.interface = TETHERING_TYPE_WIFI_SHARING;
+                                       else
+                                               client.interface = TETHERING_TYPE_WIFI;
+
+                               } else if (interface == MOBILE_AP_TYPE_BT)
                                        client.interface = TETHERING_TYPE_BT;
                                else if (interface == MOBILE_AP_TYPE_P2P)
                                        client.interface = TETHERING_TYPE_P2P;
@@ -2491,7 +2516,8 @@ API int tethering_set_enabled_cb(tethering_h tethering, tethering_type_e type, t
        INFO("+ type: %d\n", type);
        CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
        if (type == TETHERING_TYPE_USB) CHECK_FEATURE_SUPPORTED(TETHERING_USB_FEATURE);
-       else if (type == TETHERING_TYPE_WIFI) CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
+       else if (type == TETHERING_TYPE_WIFI || type == TETHERING_TYPE_WIFI_SHARING)
+               CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
        else if (type == TETHERING_TYPE_BT) CHECK_FEATURE_SUPPORTED(TETHERING_BT_FEATURE);
 
        _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
@@ -2510,7 +2536,7 @@ API int tethering_set_enabled_cb(tethering_h tethering, tethering_type_e type, t
        }
 
        /* TETHERING_TYPE_ALL */
-       for (ti = TETHERING_TYPE_USB; ti <= TETHERING_TYPE_P2P; ti++) {
+       for (ti = TETHERING_TYPE_USB; ti < TETHERING_TYPE_MAX; ti++) {
                th->enabled_cb[ti] = callback;
                th->enabled_user_data[ti] = user_data;
        }
@@ -2535,7 +2561,8 @@ API int tethering_unset_enabled_cb(tethering_h tethering, tethering_type_e type)
 {
        CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
        if (type == TETHERING_TYPE_USB) CHECK_FEATURE_SUPPORTED(TETHERING_USB_FEATURE);
-       else if (type == TETHERING_TYPE_WIFI) CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
+       else if (type == TETHERING_TYPE_WIFI || type == TETHERING_TYPE_WIFI_SHARING)
+               CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
        else if (type == TETHERING_TYPE_BT) CHECK_FEATURE_SUPPORTED(TETHERING_BT_FEATURE);
 
        _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
@@ -2552,7 +2579,7 @@ API int tethering_unset_enabled_cb(tethering_h tethering, tethering_type_e type)
        }
 
        /* TETHERING_TYPE_ALL */
-       for (ti = TETHERING_TYPE_USB; ti <= TETHERING_TYPE_P2P; ti++) {
+       for (ti = TETHERING_TYPE_USB; ti < TETHERING_TYPE_MAX; ti++) {
                th->enabled_cb[ti] = NULL;
                th->enabled_user_data[ti] = NULL;
        }
@@ -2579,7 +2606,8 @@ API int tethering_set_disabled_cb(tethering_h tethering, tethering_type_e type,
        INFO("+ type: %d\n", type);
        CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
        if (type == TETHERING_TYPE_USB) CHECK_FEATURE_SUPPORTED(TETHERING_USB_FEATURE);
-       else if (type == TETHERING_TYPE_WIFI) CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
+       else if (type == TETHERING_TYPE_WIFI || type == TETHERING_TYPE_WIFI_SHARING)
+               CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
        else if (type == TETHERING_TYPE_BT) CHECK_FEATURE_SUPPORTED(TETHERING_BT_FEATURE);
 
        _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
@@ -2598,7 +2626,7 @@ API int tethering_set_disabled_cb(tethering_h tethering, tethering_type_e type,
        }
 
        /* TETHERING_TYPE_ALL */
-       for (ti = TETHERING_TYPE_USB; ti <= TETHERING_TYPE_P2P; ti++) {
+       for (ti = TETHERING_TYPE_USB; ti < TETHERING_TYPE_MAX; ti++) {
                th->disabled_cb[ti] = callback;
                th->disabled_user_data[ti] = user_data;
        }
@@ -2622,7 +2650,8 @@ API int tethering_unset_disabled_cb(tethering_h tethering, tethering_type_e type
 {
        CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
        if (type == TETHERING_TYPE_USB) CHECK_FEATURE_SUPPORTED(TETHERING_USB_FEATURE);
-       else if (type == TETHERING_TYPE_WIFI) CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
+       else if (type == TETHERING_TYPE_WIFI || type == TETHERING_TYPE_WIFI_SHARING)
+               CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
        else if (type == TETHERING_TYPE_BT) CHECK_FEATURE_SUPPORTED(TETHERING_BT_FEATURE);
 
        _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
@@ -2639,7 +2668,7 @@ API int tethering_unset_disabled_cb(tethering_h tethering, tethering_type_e type
        }
 
        /* TETHERING_TYPE_ALL */
-       for (ti = TETHERING_TYPE_USB; ti <= TETHERING_TYPE_P2P; ti++) {
+       for (ti = TETHERING_TYPE_USB; ti < TETHERING_TYPE_MAX; ti++) {
                th->disabled_cb[ti] = NULL;
                th->disabled_user_data[ti] = NULL;
        }
@@ -2666,7 +2695,8 @@ API int tethering_set_connection_state_changed_cb(tethering_h tethering, tetheri
        INFO("+ type: %d\n", type);
        CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
        if (type == TETHERING_TYPE_USB) CHECK_FEATURE_SUPPORTED(TETHERING_USB_FEATURE);
-       else if (type == TETHERING_TYPE_WIFI) CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
+       else if (type == TETHERING_TYPE_WIFI || type == TETHERING_TYPE_WIFI_SHARING)
+               CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
        else if (type == TETHERING_TYPE_BT) CHECK_FEATURE_SUPPORTED(TETHERING_BT_FEATURE);
 
        _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
@@ -2685,7 +2715,7 @@ API int tethering_set_connection_state_changed_cb(tethering_h tethering, tetheri
        }
 
        /* TETHERING_TYPE_ALL */
-       for (ti = TETHERING_TYPE_USB; ti <= TETHERING_TYPE_P2P; ti++) {
+       for (ti = TETHERING_TYPE_USB; ti < TETHERING_TYPE_MAX; ti++) {
                th->changed_cb[ti] = callback;
                th->changed_user_data[ti] = user_data;
        }
@@ -2709,7 +2739,8 @@ API int tethering_unset_connection_state_changed_cb(tethering_h tethering, tethe
 {
        CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
        if (type == TETHERING_TYPE_USB) CHECK_FEATURE_SUPPORTED(TETHERING_USB_FEATURE);
-       else if (type == TETHERING_TYPE_WIFI) CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
+       else if (type == TETHERING_TYPE_WIFI || type == TETHERING_TYPE_WIFI_SHARING)
+               CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
        else if (type == TETHERING_TYPE_BT) CHECK_FEATURE_SUPPORTED(TETHERING_BT_FEATURE);
 
        _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
@@ -2726,7 +2757,7 @@ API int tethering_unset_connection_state_changed_cb(tethering_h tethering, tethe
        }
 
        /* TETHERING_TYPE_ALL */
-       for (ti = TETHERING_TYPE_USB; ti <= TETHERING_TYPE_P2P; ti++) {
+       for (ti = TETHERING_TYPE_USB; ti < TETHERING_TYPE_MAX; ti++) {
                th->changed_cb[ti] = NULL;
                th->changed_user_data[ti] = NULL;
        }

diff --git a/tools/tethering_test.c b/tools/tethering_test.c
index 0fd3b65..02670f2 100755 (executable)
--- a/tools/tethering_test.c
+++ b/tools/tethering_test.c
@@ -130,6 +130,10 @@ static const char *__convert_tethering_type_to_str(const tethering_type_e type)
                g_strlcpy(str_buf, "P2P Tethering", sizeof(str_buf));
                break;
 
+       case TETHERING_TYPE_WIFI_SHARING:
+               g_strlcpy(str_buf, "Wi-Fi Sharing", sizeof(str_buf));
+               break;
+
        default:
                g_strlcpy(str_buf, "Unknown", sizeof(str_buf));
                break;