#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 (mode != WIFI_BGSCAN_MODE_EXPONENTIAL && mode != WIFI_BGSCAN_MODE_PERIODIC) {
+ ERR("Invalid scan mode [%d]", mode);
+ return FALSE;
+ }
- if (is_set_mode != TRUE)
- return bgscan_mode;
+ struct bgscan_data *data = __netconfig_wifi_bgscan_get_data();
+ data->mode = mode;
- if (mode < WIFI_BGSCAN_MODE_MAX)
- bgscan_mode = mode;
+ return TRUE;
+}
- DBG("Wi-Fi background scan mode set %d", bgscan_mode);
+static gboolean _set_scan_reset_interval(guint interval)
+{
+ if ((interval < SCAN_EXPONENTIAL_MIN) || (interval > SCAN_EXPONENTIAL_MAX)) {
+ ERR("Invalid interval [%d]", interval);
+ return FALSE;
+ }
- return bgscan_mode;
+ struct bgscan_data *data = __netconfig_wifi_bgscan_get_data();
+ data->time = interval;
+ return TRUE;
}
-static void __netconfig_wifi_bgscan_set_mode(guint mode)
+static guint _get_scan_reset_interval(void)
{
- __netconfig_wifi_bgscan_mode(TRUE, mode);
+ struct bgscan_data *data = __netconfig_wifi_bgscan_get_data();
+
+ return data->time;;
}
-static guint __netconfig_wifi_bgscan_get_mode(void)
+static void __netconfig_wifi_scan_request_reply(GObject *source_object,
+ GAsyncResult *res, gpointer user_data)
{
- return __netconfig_wifi_bgscan_mode(FALSE, -1);
+ GVariant *reply;
+ GDBusConnection *conn = NULL;
+ GError *error = NULL;
+
+ conn = G_DBUS_CONNECTION(source_object);
+ reply = g_dbus_connection_call_finish(conn, res, &error);
+
+ if (reply == NULL) {
+ if (error != NULL) {
+ ERR("Fail to request status [%d: %s]", error->code, error->message);
+ netconfig_wifi_set_scanning(FALSE);
+ g_error_free(error);
+ } else {
+ ERR("Fail to request scan");
+ netconfig_wifi_set_scanning(FALSE);
+ }
+ } else {
+ DBG("Successfully requested");
+ g_variant_unref(reply);
+ }
+
+ netconfig_gdbus_pending_call_unref();
}
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, NULL);
- if (reply != TRUE)
+ CONNMAN_TECHNOLOGY_INTERFACE, "Scan", NULL, __netconfig_wifi_scan_request_reply);
+ 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;
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;
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 */
- vconf_get_int(VCONFKEY_PM_STATE, &pm_state);
+ 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;
- wifi_tech_state = wifi_state_get_technology_state();
+ if (data->timer_id > 0)
+ __netconfig_wifi_bgscan_stop_timer(data);
+
+ wifi_tech_state = wifi_state_get_technology_state(FALSE);
+ 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);
+}
+
+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;
+}
- return ((timer_data->timer_id > (guint)0) ? TRUE : FALSE);
+void netconfig_wifi_bgscan_get_interval(guint *interval)
+{
+ *interval = _get_scan_reset_interval();
}
gboolean netconfig_wifi_get_scanning(void)
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 */
- vconf_get_int(VCONFKEY_PM_STATE, &pm_state);
+ netconfig_vconf_get_int(VCONFKEY_PM_STATE, &pm_state);
if (pm_state >= VCONFKEY_PM_STATE_LCDOFF)
netconfig_wifi_bgscan_start(FALSE);
else
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)
+{
+
+ gboolean autoscan = 0;
+
+ autoscan = netconfig_wifi_is_bgscan_paused();
+
+ wifi_complete_get_autoscan(wifi, context, autoscan);
+ return TRUE;
+}
+
+gboolean handle_get_autoscanmode(Wifi *wifi, GDBusMethodInvocation *context)
+{
+ guint autoscanmode = 0;
+
+ autoscanmode = netconfig_wifi_bgscan_get_mode();
+
+ wifi_complete_get_autoscanmode(wifi, context, autoscanmode);
+ return TRUE;
+}
+