Revise background scan routine

Change-Id: I30b25bb2d04a4fb7ffdfca652c39f95cd2400872
Signed-off-by: Taesub Kim <taesub.kim@samsung.com>

diff --git a/include/wifi-background-scan.h b/include/wifi-background-scan.h
index 486fc1c..ed2584e 100755 (executable)
--- a/include/wifi-background-scan.h
+++ b/include/wifi-background-scan.h
@@ -26,18 +26,41 @@ extern "C" {
 
 #include "wifi.h"
 
+#if defined TIZEN_WEARABLE
+#define SCAN_PERIODIC_DELAY            15
+#define SCAN_EXPONENTIAL_MIN   5
+#define SCAN_EXPONENTIAL_MAX   320
+#else
+#define SCAN_PERIODIC_DELAY            10
+#define SCAN_EXPONENTIAL_MIN   4
+#define SCAN_EXPONENTIAL_MAX   128
+#endif
+
+enum {
+       WIFI_BGSCAN_MODE_EXPONENTIAL = 0x00,
+       WIFI_BGSCAN_MODE_PERIODIC,
+       WIFI_BGSCAN_MODE_MAX,
+};
+
 void netconfig_wifi_bgscan_start(gboolean immediate_scan);
 void netconfig_wifi_bgscan_stop(void);
 gboolean netconfig_wifi_get_bgscan_state(void);
+guint netconfig_wifi_bgscan_get_mode(void);
 
 gboolean netconfig_wifi_get_scanning(void);
 void netconfig_wifi_set_scanning(gboolean scanning);
+
+void netconfig_wifi_set_bgscan_pause(gboolean pause);
+gboolean netconfig_wifi_bgscan_set_interval(guint interval);
+void netconfig_wifi_bgscan_get_interval(guint *interval);
 gboolean netconfig_wifi_is_bgscan_paused(void);
 void netconfig_wifi_set_bgscan_pause(gboolean pause);
 
 gboolean handle_set_bgscan(Wifi *wifi, GDBusMethodInvocation *context, guint scan_mode);
 gboolean handle_resume_bgscan(Wifi *wifi, GDBusMethodInvocation *context);
 gboolean handle_pause_bgscan(Wifi *wifi, GDBusMethodInvocation *context);
+gboolean handle_reset_bgscan_interval(Wifi *wifi, GDBusMethodInvocation *context);
+
 gboolean handle_get_autoscan(Wifi *wifi, GDBusMethodInvocation *context);
 gboolean handle_get_autoscanmode(Wifi *wifi, GDBusMethodInvocation *context);
 

diff --git a/include/wifi-state.h b/include/wifi-state.h
index 7e1e453..ee53aa6 100755 (executable)
--- a/include/wifi-state.h
+++ b/include/wifi-state.h
@@ -76,6 +76,9 @@ void                                  wifi_state_get_connected_essid(gchar **essid);
 
 gboolean                               handle_get_wifi_state(Wifi *wifi, GDBusMethodInvocation *context);
 
+char                                   *_convert_wifi_technology_state_to_string(wifi_tech_state_e wifi_tech_state_type);
+char                                   *_convert_wifi_service_state_to_string(wifi_service_state_e wifi_service_state_type);
+
 
 #ifdef __cplusplus
 }

diff --git a/interfaces/netconfig-iface-wifi.xml b/interfaces/netconfig-iface-wifi.xml
index 23dbabd..9874bfc 100755 (executable)
--- a/interfaces/netconfig-iface-wifi.xml
+++ b/interfaces/netconfig-iface-wifi.xml
@@ -24,6 +24,8 @@
                </method>
                <method name="PauseBgscan">
                </method>
+               <method name="ResetBgscanInterval">
+               </method>
                <method name="FlushBss">
                </method>
                <method name="GetAutoscan">

diff --git a/resources/etc/dbus-1/system.d/net-config.conf b/resources/etc/dbus-1/system.d/net-config.conf
index ada7f0f..cf85aef 100755 (executable)
--- a/resources/etc/dbus-1/system.d/net-config.conf
+++ b/resources/etc/dbus-1/system.d/net-config.conf
@@ -55,6 +55,7 @@
                <check send_destination="net.netconfig" send_interface="net.netconfig.wifi" send_member="SetBgscan" privilege="http://tizen.org/privilege/network.set" />
                <check send_destination="net.netconfig" send_interface="net.netconfig.wifi" send_member="ResumeBgscan" privilege="http://tizen.org/privilege/network.set" />
                <check send_destination="net.netconfig" send_interface="net.netconfig.wifi" send_member="PauseBgscan" privilege="http://tizen.org/privilege/network.set" />
+               <check send_destination="net.netconfig" send_interface="net.netconfig.wifi" send_member="ResetBgscanInterval" privilege="http://tizen.org/privilege/network.set" /
                <check send_destination="net.netconfig" send_interface="net.netconfig.wifi" send_member="GetPasspoint" privilege="http://tizen.org/privilege/network.get" />
                <check send_destination="net.netconfig" send_interface="net.netconfig.wifi" send_member="SetPasspoint" privilege="http://tizen.org/privilege/network.set" />
                <check send_destination="net.netconfig" send_interface="net.netconfig.wifi" send_member="LaunchDirect" privilege="http://tizen.org/privilege/wifidirect" />

diff --git a/src/signal-handler.c b/src/signal-handler.c
index bc6d658..116ce50 100755 (executable)
--- a/src/signal-handler.c
+++ b/src/signal-handler.c
@@ -498,7 +498,6 @@ static void _supplicant_properties_changed(GDBusConnection *conn,
                const gchar *name, const gchar *path, const gchar *interface,
                const gchar *sig, GVariant *param, gpointer user_data)
 {
-       DBG("Properties changed handling!");
        gchar *key;
        GVariantIter *iter;
        GVariant *variant;

diff --git a/src/wifi-background-scan.c b/src/wifi-background-scan.c
index 91301f2..09874ef 100755 (executable)
--- a/src/wifi-background-scan.c
+++ b/src/wifi-background-scan.c
@@ -27,66 +27,59 @@
 #include "wifi-state.h"
 #include "wifi-background-scan.h"
 
-#if defined TIZEN_WEARABLE
-#define SCAN_PERIODIC_DELAY            15
-#define SCAN_EXPONENTIAL_MIN   5
-#define SCAN_EXPONENTIAL_MAX   320
-#else
-#define SCAN_PERIODIC_DELAY            10
-#define SCAN_EXPONENTIAL_MIN   4
-#define SCAN_EXPONENTIAL_MAX   128
-#endif
-
-enum {
-       WIFI_BGSCAN_MODE_EXPONENTIAL = 0x00,
-       WIFI_BGSCAN_MODE_PERIODIC,
-       WIFI_BGSCAN_MODE_MAX,
-};
-
-struct bgscan_timer_data {
+struct bgscan_data {
        guint time;
        guint mode;
        guint timer_id;
+       gboolean paused;
 };
 
 static gboolean netconfig_wifi_scanning = FALSE;
-static gboolean netconfig_bgscan_paused = FALSE;
 
-static struct bgscan_timer_data *__netconfig_wifi_bgscan_get_bgscan_data(void)
+static gboolean __netconfig_wifi_bgscan_next_scan(gpointer data);
+
+static struct bgscan_data *__netconfig_wifi_bgscan_get_data(void)
 {
-       static struct bgscan_timer_data timer_data = {
-                                       SCAN_EXPONENTIAL_MIN, WIFI_BGSCAN_MODE_EXPONENTIAL, 0};
+       static struct bgscan_data data = {
+               SCAN_EXPONENTIAL_MIN, WIFI_BGSCAN_MODE_EXPONENTIAL, 0, FALSE};
 
-       return &timer_data;
+       return &data;
 }
 
-static guint __netconfig_wifi_bgscan_mode(gboolean is_set_mode, guint mode)
+static gboolean __netconfig_wifi_bgscan_set_mode(guint mode)
 {
-       static guint bgscan_mode = WIFI_BGSCAN_MODE_EXPONENTIAL;
-
-       if (is_set_mode != TRUE)
-               return bgscan_mode;
-
-       if (mode < WIFI_BGSCAN_MODE_MAX)
-               bgscan_mode = mode;
+       if (mode != WIFI_BGSCAN_MODE_EXPONENTIAL && mode != WIFI_BGSCAN_MODE_PERIODIC) {
+               ERR("Invalid scan mode [%d]", mode);
+               return FALSE;
+       }
 
-       DBG("Wi-Fi background scan mode set %d", bgscan_mode);
+       struct bgscan_data *data = __netconfig_wifi_bgscan_get_data();
+       data->mode = mode;
 
-       return bgscan_mode;
+       return TRUE;
 }
 
-static void __netconfig_wifi_bgscan_set_mode(guint mode)
+static gboolean _set_scan_reset_interval(guint interval)
 {
-       __netconfig_wifi_bgscan_mode(TRUE, mode);
+       if ((interval < SCAN_EXPONENTIAL_MIN) || (interval > SCAN_EXPONENTIAL_MAX)) {
+               ERR("Invalid interval [%d]", interval);
+               return FALSE;
+       }
+
+       struct bgscan_data *data = __netconfig_wifi_bgscan_get_data();
+       data->time = interval;
+       return TRUE;
 }
 
-static guint __netconfig_wifi_bgscan_get_mode(void)
+static guint _get_scan_reset_interval(void)
 {
-       return __netconfig_wifi_bgscan_mode(FALSE, -1);
-}
+       struct bgscan_data *data = __netconfig_wifi_bgscan_get_data();
 
-static void __netconfig_wifi_scan_request_reply(GObject *source_object, GAsyncResult *res, gpointer user_data)
+       return data->time;;
+}
 
+static void __netconfig_wifi_scan_request_reply(GObject *source_object,
+               GAsyncResult *res, gpointer user_data)
 {
        GVariant *reply;
        GDBusConnection *conn = NULL;
@@ -115,41 +108,45 @@ static void __netconfig_wifi_scan_request_reply(GObject *source_object, GAsyncRe
 static gboolean __netconfig_wifi_bgscan_request_connman_scan(int retries)
 {
        gboolean reply = FALSE;
-       guint state = wifi_state_get_service_state();
-
-       if (state == NETCONFIG_WIFI_CONNECTED)
-               if (__netconfig_wifi_bgscan_get_mode() == WIFI_BGSCAN_MODE_EXPONENTIAL)
-                       return TRUE;
-
-       if (state == NETCONFIG_WIFI_ASSOCIATION || state == NETCONFIG_WIFI_CONFIGURATION) {
-               /* During Wi-Fi connecting, Wi-Fi can be disappeared.
-                * After 1 sec, try scan even if connecting state */
-               if (retries < 2)
-                       return FALSE;
-       }
 
        netconfig_wifi_set_scanning(TRUE);
 
        reply = netconfig_invoke_dbus_method_nonblock(CONNMAN_SERVICE,
                        CONNMAN_WIFI_TECHNOLOGY_PREFIX,
                        CONNMAN_TECHNOLOGY_INTERFACE, "Scan", NULL, __netconfig_wifi_scan_request_reply);
-       if (reply != TRUE)
+       if (reply != TRUE) {
+               ERR("Failed to send Scan request to connman");
                netconfig_wifi_set_scanning(FALSE);
+       }
 
        return reply;
 }
 
-static gboolean __netconfig_wifi_bgscan_next_scan(gpointer data);
-
 static gboolean __netconfig_wifi_bgscan_immediate_scan(gpointer data)
 {
        static int retries = 0;
+       guint state = wifi_state_get_service_state();
 
 #if !defined TIZEN_WEARABLE
-       if (netconfig_wifi_is_bgscan_paused())
+       if (netconfig_wifi_is_bgscan_paused()) {
                return FALSE;
+       }
 #endif
 
+       if (state == NETCONFIG_WIFI_CONNECTED) {
+               if (netconfig_wifi_bgscan_get_mode() == WIFI_BGSCAN_MODE_EXPONENTIAL) {
+                       DBG("Wi-Fi state is connected, scan is paused");
+                       return FALSE;
+               }
+       } else if (state == NETCONFIG_WIFI_ASSOCIATION || state == NETCONFIG_WIFI_CONFIGURATION) {
+               /* During WIFI connecting, WIFI can be disappeared.
+                * After 1 sec, try scan even if connecting state */
+               if (retries < 2) {
+                       retries++;
+                       return TRUE;
+               }
+       }
+
        if (__netconfig_wifi_bgscan_request_connman_scan(retries) == TRUE) {
                retries = 0;
                return FALSE;
@@ -163,52 +160,46 @@ static gboolean __netconfig_wifi_bgscan_immediate_scan(gpointer data)
        return TRUE;
 }
 
-static void __netconfig_wifi_bgscan_start_timer(gboolean immediate_scan,
-               struct bgscan_timer_data *data)
+static void __netconfig_wifi_bgscan_start_timer(gboolean immediate_scan)
 {
-       if (!data)
-               return;
+       struct bgscan_data *data = __netconfig_wifi_bgscan_get_data();
 
        netconfig_stop_timer(&(data->timer_id));
 
-       data->mode = __netconfig_wifi_bgscan_get_mode();
-
-       if (data->time < SCAN_EXPONENTIAL_MIN)
-               data->time = SCAN_EXPONENTIAL_MIN;
-
        switch (data->mode) {
        case WIFI_BGSCAN_MODE_EXPONENTIAL:
-               if (immediate_scan == TRUE) {
-                       if ((data->time * 2) > SCAN_EXPONENTIAL_MAX)
-                               data->time = SCAN_EXPONENTIAL_MAX;
-                       else
-                               data->time = data->time * 2;
-               }
-
+               if (data->time < SCAN_EXPONENTIAL_MIN ||
+                       data->time == SCAN_PERIODIC_DELAY)
+                       data->time = SCAN_EXPONENTIAL_MIN;
                break;
        case WIFI_BGSCAN_MODE_PERIODIC:
-               if ((data->time * 2) > SCAN_PERIODIC_DELAY)
-                       data->time = SCAN_PERIODIC_DELAY;
-               else
-                       data->time = data->time * 2;
-
+               data->time = SCAN_PERIODIC_DELAY;
                break;
        default:
                DBG("Invalid Wi-Fi background scan mode[%d]", data->mode);
                return;
        }
 
-       if (immediate_scan == TRUE)
-               g_timeout_add(500, __netconfig_wifi_bgscan_immediate_scan, NULL);
+       if (immediate_scan)
+               DBG("Scan immediately[%d], mode[%d](0 exponential / 1 periodic)", immediate_scan, data->mode);
+       else
+               DBG("Scan immediately[%d], mode[%d](0 exponential / 1 periodic), next[%d]", immediate_scan, data->mode, data->time);
 
-       DBG("Scan immediately[%d], mode[%d], next[%d]",
-                               immediate_scan, data->mode, data->time);
+       if (immediate_scan)
+               g_timeout_add(500, __netconfig_wifi_bgscan_immediate_scan, NULL);
 
        netconfig_start_timer_seconds(data->time,
                                __netconfig_wifi_bgscan_next_scan, data, &(data->timer_id));
+       if (data->mode == WIFI_BGSCAN_MODE_EXPONENTIAL && immediate_scan) {
+               data->time = data->time * 2;
+               if (data->time > SCAN_EXPONENTIAL_MAX)
+                       data->time = SCAN_EXPONENTIAL_MAX;
+       }
+
+       //DBG("Scan immediately[%d], mode[%d](0 exponential / 1 periodic), next[%d]", immediate_scan, data->mode, data->time);
 }
 
-static void __netconfig_wifi_bgscan_stop_timer(struct bgscan_timer_data *data)
+static void __netconfig_wifi_bgscan_stop_timer(struct bgscan_data *data)
 {
        if (data == NULL)
                return;
@@ -218,73 +209,103 @@ static void __netconfig_wifi_bgscan_stop_timer(struct bgscan_timer_data *data)
 
 static gboolean __netconfig_wifi_bgscan_next_scan(gpointer data)
 {
-       struct bgscan_timer_data *timer = (struct bgscan_timer_data *)data;
        int pm_state = VCONFKEY_PM_STATE_NORMAL;
 
-       if (timer == NULL)
-               return FALSE;
-
        /* In case of LCD off, we don't need Wi-Fi scan */
        netconfig_vconf_get_int(VCONFKEY_PM_STATE, &pm_state);
        if (pm_state >= VCONFKEY_PM_STATE_LCDOFF)
                return TRUE;
 
-       __netconfig_wifi_bgscan_start_timer(TRUE, timer);
+       __netconfig_wifi_bgscan_start_timer(TRUE);
 
        return FALSE;
 }
 
 void netconfig_wifi_set_bgscan_pause(gboolean pause)
 {
+       struct bgscan_data *data = __netconfig_wifi_bgscan_get_data();
        DBG("[%s] Wi-Fi background scan", pause ? "Pause" : "Resume");
-       netconfig_bgscan_paused = pause;
+       data->paused = pause;
 }
 
 gboolean netconfig_wifi_is_bgscan_paused(void)
 {
-       DBG("Wi-Fi background scan is [%s]", netconfig_bgscan_paused ? "Paused" : "Runnable");
-       return netconfig_bgscan_paused;
+       struct bgscan_data *data = __netconfig_wifi_bgscan_get_data();
+       DBG("Wi-Fi background scan is [%s]", data->paused ? "Paused" : "Runnable");
+       return data->paused;
 }
 
 void netconfig_wifi_bgscan_start(gboolean immediate_scan)
 {
        wifi_tech_state_e wifi_tech_state;
-       struct bgscan_timer_data *timer_data =
-                       __netconfig_wifi_bgscan_get_bgscan_data();
+       wifi_service_state_e wifi_service_state;
+       struct bgscan_data *data =
+                       __netconfig_wifi_bgscan_get_data();
 
-       if (timer_data == NULL)
+       if (data == NULL)
                return;
 
+       if (data->timer_id > 0)
+               __netconfig_wifi_bgscan_stop_timer(data);
+
        wifi_tech_state = wifi_state_get_technology_state();
+       wifi_service_state = wifi_state_get_service_state();
+       DBG("wifi tech state [%s] service state [%s]",
+               _convert_wifi_technology_state_to_string(wifi_tech_state),
+               _convert_wifi_service_state_to_string(wifi_service_state));
+
        if (wifi_tech_state < NETCONFIG_WIFI_TECH_POWERED)
                return;
 
-       DBG("Wi-Fi background scan started or re-started(%d)", immediate_scan);
+       if (data->mode == WIFI_BGSCAN_MODE_EXPONENTIAL &&
+               wifi_service_state == NETCONFIG_WIFI_CONNECTED)
+               return;
 
-       __netconfig_wifi_bgscan_start_timer(immediate_scan, timer_data);
+       DBG("Wi-Fi background scan started or re-started(%d)", immediate_scan);
+       __netconfig_wifi_bgscan_start_timer(immediate_scan);
 }
 
 void netconfig_wifi_bgscan_stop(void)
 {
-       struct bgscan_timer_data *timer_data =
-                       __netconfig_wifi_bgscan_get_bgscan_data();
+       struct bgscan_data *data =
+                       __netconfig_wifi_bgscan_get_data();
 
-       if (timer_data == NULL)
+       if (data == NULL)
                return;
 
-       DBG("Wi-Fi background scan stop");
+       DBG("Wi-Fi background scan stop [mode:%d]", data->mode);
 
-       timer_data->time = SCAN_EXPONENTIAL_MIN;
+       data->time = 0;
 
-       __netconfig_wifi_bgscan_stop_timer(timer_data);
+       __netconfig_wifi_bgscan_stop_timer(data);
 }
 
 gboolean netconfig_wifi_get_bgscan_state(void)
 {
-       struct bgscan_timer_data *timer_data =
-                       __netconfig_wifi_bgscan_get_bgscan_data();
+       struct bgscan_data *data =
+                       __netconfig_wifi_bgscan_get_data();
+       return ((data->timer_id > (guint)0) ? TRUE : FALSE);
+}
 
-       return ((timer_data->timer_id > (guint)0) ? TRUE : FALSE);
+guint netconfig_wifi_bgscan_get_mode(void)
+{
+       struct bgscan_data *data = __netconfig_wifi_bgscan_get_data();
+
+       return data->mode;
+}
+
+gboolean netconfig_wifi_bgscan_set_interval(guint interval)
+{
+       gboolean ret = FALSE;
+
+       ret = _set_scan_reset_interval(interval);
+
+       return ret;
+}
+
+void netconfig_wifi_bgscan_get_interval(guint *interval)
+{
+       *interval = _get_scan_reset_interval();
 }
 
 gboolean netconfig_wifi_get_scanning(void)
@@ -303,15 +324,19 @@ gboolean handle_set_bgscan(Wifi *wifi, GDBusMethodInvocation *context, guint sca
        gint old_mode = 0;
        int pm_state = VCONFKEY_PM_STATE_NORMAL;
 
-       old_mode = __netconfig_wifi_bgscan_get_mode();
+       old_mode = netconfig_wifi_bgscan_get_mode();
        if (old_mode == scan_mode) {
                wifi_complete_set_bgscan(wifi, context);
                return TRUE;
        }
 
-       __netconfig_wifi_bgscan_set_mode(scan_mode);
+       if (__netconfig_wifi_bgscan_set_mode(scan_mode) != TRUE) {
+               ERR("Invalid mode [%d]", scan_mode);
+               netconfig_error_invalid_parameter(context);
+               return TRUE;
+       }
 
-       netconfig_wifi_bgscan_stop();
+       INFO("scan mode is changed [%d]", scan_mode);
 
        /* In case of LCD off, we don't need Wi-Fi scan right now */
        netconfig_vconf_get_int(VCONFKEY_PM_STATE, &pm_state);
@@ -340,6 +365,15 @@ gboolean handle_pause_bgscan(Wifi *wifi, GDBusMethodInvocation *context)
        return TRUE;
 }
 
+gboolean handle_reset_bgscan_interval(Wifi *wifi, GDBusMethodInvocation *context)
+{
+
+       _set_scan_reset_interval(SCAN_EXPONENTIAL_MIN);
+
+       wifi_complete_reset_bgscan_interval(wifi, context);
+       return TRUE;
+}
+
 gboolean handle_get_autoscan(Wifi *wifi, GDBusMethodInvocation *context)
 {
 
@@ -355,7 +389,7 @@ gboolean handle_get_autoscanmode(Wifi *wifi, GDBusMethodInvocation *context)
 {
        guint autoscanmode = 0;
 
-       autoscanmode = __netconfig_wifi_bgscan_get_mode();
+       autoscanmode = netconfig_wifi_bgscan_get_mode();
 
        wifi_complete_get_autoscanmode(wifi, context, autoscanmode);
        return TRUE;

diff --git a/src/wifi-power.c b/src/wifi-power.c
index db8f9a4..5392086 100755 (executable)
--- a/src/wifi-power.c
+++ b/src/wifi-power.c
@@ -183,7 +183,7 @@ static int _remove_driver_and_supplicant(void)
 {
        int err = 0;
 
-       INFO("remove driver and supplicant");
+       DBG("remove driver and supplicant");
        if (wifi_firmware_recovery_mode != TRUE &&
                                        netconfig_wifi_is_bssid_scan_started() == TRUE) {
                DBG("Wi-Fi WPS mode");
@@ -555,10 +555,11 @@ static void __pm_state_changed_cb(keynode_t* node, void* user_data)
                netconfig_vconf_get_int(VCONFKEY_PM_STATE, &new_state);
 
        DBG("wifi state: %d (0 off / 1 on / 2 connected)", wifi_state);
-       DBG("Old PM state: %d, current: %d", prev_state, new_state);
+       DBG("Old PM state: %d, current: %d (1 normal / 2 lcddim / 3 lcdoff / 4 sleep)", prev_state, new_state);
 
        if ((new_state == VCONFKEY_PM_STATE_NORMAL) && (prev_state >= VCONFKEY_PM_STATE_LCDOFF)) {
                netconfig_wifi_bgscan_stop();
+               netconfig_wifi_bgscan_set_interval(SCAN_EXPONENTIAL_MIN);
                netconfig_wifi_bgscan_start(TRUE);
        }
 

diff --git a/src/wifi-state.c b/src/wifi-state.c
index 3e5448a..0bdd05e 100755 (executable)
--- a/src/wifi-state.c
+++ b/src/wifi-state.c
@@ -44,7 +44,7 @@ static GSList *notifier_list = NULL;
 static guint network_connected_popup_timer_id = 0;
 static gboolean block_network_connected_popup = FALSE;
 
-static const char *_convert_wifi_service_state_to_string(wifi_service_state_e wifi_service_state_type)
+char *_convert_wifi_service_state_to_string(wifi_service_state_e wifi_service_state_type)
 {
        switch (wifi_service_state_type) {
        case NETCONFIG_WIFI_UNKNOWN:
@@ -67,7 +67,7 @@ static const char *_convert_wifi_service_state_to_string(wifi_service_state_e wi
        return "Invalid parameter";
 }
 
-static const char *_convert_wifi_technology_state_to_string(wifi_tech_state_e wifi_tech_state_type)
+char *_convert_wifi_technology_state_to_string(wifi_tech_state_e wifi_tech_state_type)
 {
        switch (wifi_tech_state_type) {
        case NETCONFIG_WIFI_TECH_UNKNOWN:
@@ -486,6 +486,7 @@ void wifi_state_update_power_state(gboolean powered)
                        netconfig_set_system_event(SYS_EVT_WIFI_STATE, EKEY_WIFI_STATE, EVAL_WIFI_ON);
 
                        netconfig_wifi_bgscan_stop();
+                       netconfig_wifi_bgscan_set_interval(SCAN_EXPONENTIAL_MIN);
                        netconfig_wifi_bgscan_start(TRUE);
 
                        /* Add callback to track change in notification setting */
@@ -509,7 +510,6 @@ void wifi_state_update_power_state(gboolean powered)
 
                netconfig_set_system_event(SYS_EVT_WIFI_STATE, EKEY_WIFI_STATE, EVAL_WIFI_OFF);
 
-               netconfig_wifi_set_bgscan_pause(FALSE);
                netconfig_wifi_bgscan_stop();
 
                _set_bss_found(FALSE);
@@ -611,14 +611,12 @@ void wifi_state_set_service_state(wifi_service_state_e new_state)
 
                netconfig_wifi_indicator_stop();
 
-               netconfig_wifi_set_bgscan_pause(FALSE);
-
                netconfig_wifi_bgscan_stop();
+               netconfig_wifi_bgscan_set_interval(SCAN_EXPONENTIAL_MIN);
                netconfig_wifi_bgscan_start(TRUE);
        } else if ((old_state > NETCONFIG_WIFI_IDLE && old_state < NETCONFIG_WIFI_CONNECTED) && new_state == NETCONFIG_WIFI_IDLE) {
                /* in ipv6 case disconnect/association -> association */
                DBG("reset the bg scan period");
-               netconfig_wifi_set_bgscan_pause(FALSE);
 
                netconfig_wifi_bgscan_stop();
                netconfig_wifi_bgscan_start(TRUE);

diff --git a/src/wifi.c b/src/wifi.c
index 92376b0..972fa3d 100755 (executable)
--- a/src/wifi.c
+++ b/src/wifi.c
@@ -220,6 +220,8 @@ void wifi_object_create_and_init(void)
                        G_CALLBACK(handle_resume_bgscan), NULL);
        g_signal_connect(wifi_object, "handle-pause-bgscan",
                        G_CALLBACK(handle_pause_bgscan), NULL);
+       g_signal_connect(wifi_object, "handle-reset-bgscan-interval",
+                       G_CALLBACK(handle_reset_bgscan_interval), NULL);
 
        /* Auto Scan Mode */
        g_signal_connect(wifi_object, "handle-get-autoscan",