Added API to check wifi-sharing is supported or not.

Added API to check if wifi-sharing is supported or not.
If support is available pass 'wifi-sharing' as parameter
to dbus method 'enable_wifi_tethering' to enable sharing.

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

diff --git a/include/tethering.h b/include/tethering.h
index 423c98b8055201893df26464c160b691e7d6bdde..c55090110c8e3eda08474d5e82245396d639f5c7 100644 (file)
--- a/include/tethering.h
+++ b/include/tethering.h
@@ -66,6 +66,7 @@ typedef enum {
     TETHERING_TYPE_WIFI,  /**< Wi-Fi type */
     TETHERING_TYPE_BT,  /**< BT type */
     TETHERING_TYPE_P2P,  /**< P2P type */
+    TETHERING_TYPE_WIFI_SHARING,  /**< Wi-Fi Sharing */
 } tethering_type_e;
 
 /**
@@ -1386,6 +1387,21 @@ int tethering_wifi_push_wps_button(tethering_h tethering);
  */
 int tethering_wifi_set_wps_pin(tethering_h tethering, const char *wps_pin);
 
+/**
+ * @brief Checks whether wifi-sharing is supported or not.
+ * @since_tizen 6.0
+ * @privlevel platform
+ * @privilege %http://tizen.org/privilege/tethering.admin
+ * @param[in]  tethering  The tethering handle
+ * @param[out] supported @c true if wifi-sharing is supported, \n @c false if wifi-sharing is unsupported
+ * @return  0 on success, otherwise a negative error value
+ * @retval  #TETHERING_ERROR_NONE  Successful
+ * @retval  #TETHERING_ERROR_INVALID_PARAMETER  Invalid parameter
+ * @retval  #TETHERING_ERROR_PERMISSION_DENIED  Permission denied
+ * @retval  #TETHERING_ERROR_OPERATION_FAILED  Operation failed
+ */
+int tethering_wifi_is_sharing_supported(tethering_h tethering, bool *supported);
+
 
 /**
  * @}

diff --git a/src/tethering.c b/src/tethering.c
index 5df933d275cd363184dfca486438553777b9abdc..65e930129adbb69367d4e7655997f4c4ad062af3 100755 (executable)
--- a/src/tethering.c
+++ b/src/tethering.c
@@ -1575,7 +1575,8 @@ API int tethering_enable(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,
@@ -1609,7 +1610,8 @@ API int tethering_enable(tethering_h tethering, tethering_type_e type)
                                (GAsyncReadyCallback) __usb_enabled_cfm_cb, (gpointer)tethering);
                break;
 
-       case TETHERING_TYPE_WIFI: {
+       case TETHERING_TYPE_WIFI:
+       case TETHERING_TYPE_WIFI_SHARING: {
                _softap_settings_t set = {"", "", "", 0, false};
 
                ret = __prepare_wifi_settings(tethering, &set);
@@ -1625,8 +1627,16 @@ API int tethering_enable(tethering_h tethering, tethering_type_e type)
                         set.ssid, set.key, set.channel, set.mode, set.txpower, set.sec_type,
                         set.max_connected);
 
+               char key[TETHERING_WIFI_KEY_MAX_LEN + 1] = {0, };
+               if (type == TETHERING_TYPE_WIFI_SHARING)
+                       g_strlcpy(key, "wifi_sharing", TETHERING_WIFI_KEY_MAX_LEN);
+               else
+                       g_strlcpy(key, "wifi_tether", TETHERING_WIFI_KEY_MAX_LEN);
+
                g_dbus_proxy_call(proxy, "enable_wifi_tethering",
-                               g_variant_new("(sssiiiiiii)", set.ssid, set.key, set.mode, set.channel, set.visibility, set.mac_filter, set.max_connected, set.sec_type, set.txpower, TETHERING_ADDRESS_FAMILY_IPV4),
+                               g_variant_new("(ssssiiiiiii)", key, set.ssid, set.key, set.mode,
+                               set.channel, set.visibility, set.mac_filter, set.max_connected,
+                               set.sec_type, set.txpower, TETHERING_ADDRESS_FAMILY_IPV4),
                                G_DBUS_CALL_FLAGS_NONE, -1, th->cancellable,
                                (GAsyncReadyCallback) __wifi_enabled_cfm_cb, (gpointer)tethering);
                break;
@@ -1684,9 +1694,9 @@ API int tethering_enable(tethering_h tethering, tethering_type_e type)
                                sigs[E_SIGNAL_WIFI_TETHER_ON].sig_id);
 
                g_dbus_proxy_call(proxy, "enable_wifi_tethering",
-                               g_variant_new("(sssiiiiii)", set.ssid, set.key, set.mode,
+                               g_variant_new("(ssssiiiiiii)", "wifi_tether", set.ssid, set.key, set.mode,
                                set.channel, set.visibility, set.mac_filter, set.max_connected,
-                               set.sec_type, TETHERING_ADDRESS_FAMILY_IPV4),
+                               set.sec_type, set.txpower, TETHERING_ADDRESS_FAMILY_IPV4),
                                G_DBUS_CALL_FLAGS_NONE, -1, th->cancellable,
                                (GAsyncReadyCallback) __wifi_enabled_cfm_cb, (gpointer)tethering);
 
@@ -1750,7 +1760,8 @@ API int tethering_ipv6_enable(tethering_h tethering, tethering_type_e type)
                break;
        }
 
-       case TETHERING_TYPE_WIFI: {
+       case TETHERING_TYPE_WIFI:
+       case TETHERING_TYPE_WIFI_SHARING: {
                _softap_settings_t set = {"", "", "", 0, false, false, 0, 0};
 
                ret = __prepare_wifi_settings(tethering, &set);
@@ -1767,10 +1778,18 @@ API int tethering_ipv6_enable(tethering_h tethering, tethering_type_e type)
                        set.ssid, set.key, set.channel, set.mode, set.txpower, set.sec_type,
                        set.max_connected);
 
+               char key[TETHERING_WIFI_KEY_MAX_LEN + 1] = {0, };
+               if (type == TETHERING_TYPE_WIFI_SHARING)
+                       g_strlcpy(key, "wifi_sharing", TETHERING_WIFI_KEY_MAX_LEN);
+               else
+                       g_strlcpy(key, "wifi_tether", TETHERING_WIFI_KEY_MAX_LEN);
+
                g_dbus_proxy_call(proxy, "enable_wifi_tethering",
-                       g_variant_new("(sssiiiiiii)", set.ssid, set.key, set.mode, set.channel, set.visibility, set.mac_filter, set.max_connected, set.sec_type, set.txpower, TETHERING_ADDRESS_FAMILY_IPV6),
-                       G_DBUS_CALL_FLAGS_NONE, -1, th->cancellable,
-                       (GAsyncReadyCallback) __wifi_enabled_cfm_cb, (gpointer)tethering);
+                               g_variant_new("(ssssiiiiiii)", key, set.ssid, set.key, set.mode,
+                               set.channel, set.visibility, set.mac_filter, set.max_connected,
+                               set.sec_type, set.txpower, TETHERING_ADDRESS_FAMILY_IPV6),
+                               G_DBUS_CALL_FLAGS_NONE, -1, th->cancellable,
+                               (GAsyncReadyCallback) __wifi_enabled_cfm_cb, (gpointer)tethering);
                break;
         }
 
@@ -1828,6 +1847,7 @@ API int tethering_ipv6_disable(tethering_h tethering, tethering_type_e type)
                break;
 
        case TETHERING_TYPE_WIFI:
+       case TETHERING_TYPE_WIFI_SHARING:
                DBG("Disable wifi tethering..");
                g_dbus_connection_signal_unsubscribe(connection,
                                sigs[E_SIGNAL_WIFI_TETHER_OFF].sig_id);
@@ -1899,6 +1919,7 @@ API int tethering_disable(tethering_h tethering, tethering_type_e type)
                break;
 
        case TETHERING_TYPE_WIFI:
+       case TETHERING_TYPE_WIFI_SHARING:
 
                g_dbus_connection_signal_unsubscribe(connection,
                                sigs[E_SIGNAL_WIFI_TETHER_OFF].sig_id);
@@ -4452,4 +4473,68 @@ API int tethering_wifi_set_wps_pin(tethering_h tethering, const char *wps_pin)
        return TETHERING_ERROR_NONE;
 }
 
+API int tethering_wifi_is_sharing_supported(tethering_h tethering, bool *supported)
+{
+       CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
+       CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
+
+       _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
+                       "parameter(tethering) is NULL\n");
+       _retvm_if(supported == NULL, TETHERING_ERROR_INVALID_PARAMETER,
+                       "parameter(supported) is NULL\n");
+
+       /** Check if wifi-sharing is supported */
+       __tethering_h *th = (__tethering_h *)tethering;
+       GDBusProxy *proxy = th->client_bus_proxy;
+
+       int ret = TETHERING_ERROR_NONE;
+       int count = 0;
+       gchar *key = NULL;
+       GVariant *value = NULL;
+       GVariantIter *iter = NULL;
+       GVariantIter *sub_iter = NULL;
+       GVariant *parameters = NULL;
+       GError *error = NULL;
+
+       parameters = g_dbus_proxy_call_sync(proxy, "get_wifi_interfaces",
+                       NULL, G_DBUS_CALL_FLAGS_NONE, -1, NULL, &error);
+
+       if (!parameters && error) {
+               ERR("g_dbus_proxy_call_sync failed because  %s\n", error->message);
+
+               if (error->code == G_DBUS_ERROR_ACCESS_DENIED)
+                       ret = TETHERING_ERROR_PERMISSION_DENIED;
+               else
+                       ret = TETHERING_ERROR_OPERATION_FAILED;
+
+               g_error_free(error);
+               goto error;
+       }
 
+       g_variant_get(parameters, "(a(a{sv}))", &iter);
+       if (iter == NULL) {
+               g_variant_unref(parameters);
+               ret = TETHERING_ERROR_OPERATION_FAILED;
+               goto error;
+       }
+
+       while (g_variant_iter_loop(iter, "(a{sv})", &sub_iter)) {
+               while (g_variant_iter_loop(sub_iter, "{sv}", &key, &value)) {
+                       if (g_strcmp0(key, "IfName") == 0) {
+                               const gchar *interface = g_variant_get_string(value, NULL);
+                               ERR("interface: %s\n", interface);
+                               if (strncmp(interface, "wlan", 4) == 0)
+                                       count++;
+                       }
+               }
+       }
+       g_variant_unref(parameters);
+
+       if (count > 1)
+               *supported = true;
+       else
+               *supported = false;
+
+error:
+       return ret;
+}

diff --git a/tools/tethering_test.c b/tools/tethering_test.c
index 9c153ff53309c1aa2b288f88022f9043f332eb0d..0fd3b6518ad78fb3e5e48416ecd267a1945c1284 100755 (executable)
--- a/tools/tethering_test.c
+++ b/tools/tethering_test.c
@@ -618,7 +618,7 @@ bool __get_tethering_type(tethering_type_e *type)
        int sel;
        int ret;
 
-       printf("Select tethering type (1:Wi-Fi, 2:BT, 3:USB 4:P2P 5:ALL)\n");
+       printf("Select tethering type (1:Wi-Fi, 2:Wi-Fi Sharing, 3:BT, 4:USB 5:P2P 6:ALL)\n");
        ret = scanf("%9d", &sel);
        if (ret < 0) {
                printf("scanf is failed!!\n");
@@ -630,15 +630,18 @@ bool __get_tethering_type(tethering_type_e *type)
                *type = TETHERING_TYPE_WIFI;
                break;
        case 2:
-               *type = TETHERING_TYPE_BT;
+               *type = TETHERING_TYPE_WIFI_SHARING;
                break;
        case 3:
-               *type = TETHERING_TYPE_USB;
+               *type = TETHERING_TYPE_BT;
                break;
        case 4:
-               *type = TETHERING_TYPE_P2P;
+               *type = TETHERING_TYPE_USB;
                break;
        case 5:
+               *type = TETHERING_TYPE_P2P;
+               break;
+       case 6:
                *type = TETHERING_TYPE_ALL;
                break;
        default:
@@ -694,6 +697,24 @@ static int test_tethering_enable(void)
        if (!__get_tethering_type(&type))
                return -1;
 
+       if (type == TETHERING_TYPE_WIFI_SHARING) {
+               bool supported = false;
+
+               ret = tethering_wifi_is_sharing_supported(th, &supported);
+
+               if (__is_err(ret) == true) {
+                       printf("Fail to get wifi sharing supported status\n");
+                       return -1;
+               }
+
+               if (!supported) {
+                       printf("wifi_sharing is not supported.\n");
+                       return -1;
+               }
+
+               printf("wifi_sharing is supported.\n");
+       }
+
        if (address_type)
                ret = tethering_ipv6_enable(th, type);
        else