2 * Network Configuration Module
4 * Copyright (c) 2000 - 2012 Samsung Electronics Co., Ltd. All rights reserved.
6 * Licensed under the Apache License, Version 2.0 (the "License");
7 * you may not use this file except in compliance with the License.
8 * You may obtain a copy of the License at
10 * http://www.apache.org/licenses/LICENSE-2.0
12 * Unless required by applicable law or agreed to in writing, software
13 * distributed under the License is distributed on an "AS IS" BASIS,
14 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
15 * See the License for the specific language governing permissions and
16 * limitations under the License.
21 #include <vconf-keys.h>
27 #include "wifi-state.h"
28 #include "wifi-power.h"
29 #include "wifi-scan.h"
30 #include "netsupplicant.h"
31 #include "network-state.h"
32 #include "wifi-indicator.h"
33 #include "network-statistics.h"
34 #include "wifi-background-scan.h"
36 #define NETCONFIG_UPDATE_DEVICE_LIST_COUNT 3
37 #define NETCONFIG_UPDATE_DEVICE_LIST_TIMEOUT 1 * 1000
38 #define NETCONFIG_NETWORK_NOTIFICATION_TIMEOUT 15 * 1000
40 static gboolean new_bss_found = FALSE;
42 static guint network_update_timer_cnt = 0;
43 static guint network_update_timer_id = 0;
44 static guint network_noti_timer_id = 0;
46 static GSList *g_device_list = NULL;
47 static GSList *g_notifier_list = NULL;
49 static guint network_connected_popup_timer_id = 0;
50 static gboolean block_network_connected_popup = FALSE;
52 static void __device_free_data(gpointer data)
54 wifi_device_data_s *device_data = data;
56 g_free(device_data->interface_name);
57 g_free(device_data->mac_address);
62 static wifi_device_data_s *__device_get_data(const char *interface_name)
66 for (list = g_device_list; list; list = list->next) {
67 wifi_device_data_s *device_data = list->data;
68 if (g_strcmp0(device_data->interface_name, interface_name) == 0)
75 static wifi_device_data_s *__device_get_data_by_macaddr(const char *macaddr)
79 for (list = g_device_list; list; list = list->next) {
80 wifi_device_data_s *device_data = list->data;
81 if (g_ascii_strncasecmp(device_data->mac_address,
82 macaddr, MAC_ADDRESS_MAX_LEN) == 0)
89 char *_convert_wifi_service_state_to_string(wifi_service_state_e wifi_service_state_type)
91 switch (wifi_service_state_type) {
92 case NETCONFIG_WIFI_UNKNOWN:
94 case NETCONFIG_WIFI_IDLE:
96 case NETCONFIG_WIFI_ASSOCIATION:
98 case NETCONFIG_WIFI_CONFIGURATION:
99 return "configuration";
100 case NETCONFIG_WIFI_CONNECTED:
102 case NETCONFIG_WIFI_FAILURE:
105 ERR("Invalid wifi_service_state_e parameter");
109 return "Invalid parameter";
112 char *_convert_wifi_technology_state_to_string(wifi_tech_state_e wifi_tech_state_type)
114 switch (wifi_tech_state_type) {
115 case NETCONFIG_WIFI_TECH_UNKNOWN:
117 case NETCONFIG_WIFI_TECH_OFF:
119 case NETCONFIG_WIFI_TECH_WPS_ONLY:
121 case NETCONFIG_WIFI_TECH_POWERED:
123 case NETCONFIG_WIFI_TECH_CONNECTED:
126 ERR("Invalid wifi_tech_state_e parameter");
130 return "Invalid parameter";
133 static gboolean _block_network_connection_popup(gpointer data)
135 block_network_connected_popup = FALSE;
136 netconfig_stop_timer(&network_connected_popup_timer_id);
140 static void __set_wifi_connected_essid(void)
142 const char *essid_name = NULL;
143 const char *wifi_profile = netconfig_get_default_profile();
144 const char *wifi_ifname = netconfig_get_default_ifname();
146 if (wifi_state_get_service_state(wifi_ifname) != NETCONFIG_WIFI_CONNECTED)
149 if (wifi_profile == NULL ||
150 netconfig_is_wifi_profile(wifi_profile) != TRUE) {
151 ERR("Can't get Wi-Fi profile");
155 essid_name = netconfig_wifi_get_connected_essid(wifi_profile);
156 if (essid_name == NULL) {
157 ERR("Can't get Wi-Fi name");
161 netconfig_set_vconf_str(VCONFKEY_WIFI_CONNECTED_AP_NAME, essid_name, TRUE);
163 /* Block Network Connected popup for 3sec
164 * to avoid multiple popup's due to ready signals */
165 if (block_network_connected_popup == FALSE) {
166 block_network_connected_popup = TRUE;
167 netconfig_start_timer(3000, _block_network_connection_popup,
168 NULL, &network_connected_popup_timer_id);
169 __netconfig_pop_wifi_connected_poppup(essid_name);
173 static void __unset_wifi_connected_essid(void)
175 netconfig_set_vconf_str(VCONFKEY_WIFI_CONNECTED_AP_NAME, "", TRUE);
178 static const char *__get_wifi_connected_essid(void)
180 const char *essid_name = NULL;
181 const char *wifi_profile = netconfig_get_default_profile();
182 const char *wifi_ifname = netconfig_get_default_ifname();
184 if (wifi_state_get_service_state(wifi_ifname) != NETCONFIG_WIFI_CONNECTED)
187 if (wifi_profile == NULL || netconfig_is_wifi_profile(wifi_profile) != TRUE) {
188 ERR("Can't get Wi-Fi profile");
192 essid_name = netconfig_wifi_get_connected_essid(wifi_profile);
193 if (essid_name == NULL) {
194 ERR("Can't get Wi-Fi name");
201 static gboolean __is_wifi_profile_available(void)
203 GVariant *message = NULL;
204 GVariantIter *iter, *next;
207 message = netconfig_invoke_dbus_method(CONNMAN_SERVICE,
208 CONNMAN_MANAGER_PATH, CONNMAN_MANAGER_INTERFACE,
209 "GetServices", NULL);
210 if (message == NULL) {
211 ERR("Failed to get service list");
215 g_variant_get(message, "(a(oa{sv}))", &iter);
216 while (g_variant_iter_loop(iter, "(oa{sv})", &obj, &next)) {
217 if (obj == NULL || netconfig_is_wifi_profile((const gchar*)obj) == FALSE)
220 g_variant_iter_free(next);
225 g_variant_unref(message);
227 g_variant_iter_free(iter);
232 static gboolean __is_favorited(GVariantIter *array)
234 gboolean is_favorite = FALSE;
238 while (g_variant_iter_loop(array, "{sv}", &key, &var)) {
241 if (g_str_equal(key, "Favorite") != TRUE)
244 value = g_variant_get_boolean(var);
248 g_variant_unref(var);
255 static void _wifi_state_connected_activation(void)
257 /* Add activation of services when Wi-Fi is connected */
260 static void _wifi_state_changed(const char *interface_name,
261 wifi_service_state_e state)
266 for (list = g_notifier_list; list; ) {
267 wifi_state_notifier_s *notifier = list->data;
270 if (notifier->service) {
271 ifname = netconfig_get_ifname(notifier->service);
272 if (g_strcmp0(ifname, interface_name) != 0)
276 if (notifier->wifi_state_changed != NULL)
277 notifier->wifi_state_changed(notifier->notifier,
278 notifier->service, state, notifier->user_data);
282 static void _set_bss_found(gboolean found)
284 if (found != new_bss_found)
285 new_bss_found = found;
288 static gboolean _check_network_notification(gpointer data)
290 int qs_enable = 0, ug_state = 0;
291 static gboolean check_again = FALSE;
293 wifi_tech_state_e tech_state;
294 wifi_service_state_e service_state;
295 char *interface_name = data;
297 tech_state = wifi_state_get_technology_state(interface_name);
298 if (tech_state < NETCONFIG_WIFI_TECH_POWERED) {
299 DBG("Wi-Fi off or WPS only supported[%d]", tech_state);
303 service_state = wifi_state_get_service_state(interface_name);
304 if (service_state == NETCONFIG_WIFI_CONNECTED) {
305 DBG("Service state is connected");
307 } else if (service_state == NETCONFIG_WIFI_ASSOCIATION ||
308 service_state == NETCONFIG_WIFI_CONFIGURATION) {
309 DBG("Service state is connecting (check again : %d)", check_again);
317 if (__is_wifi_profile_available() == FALSE) {
318 netconfig_send_notification_to_net_popup(
319 NETCONFIG_DEL_FOUND_AP_NOTI, NULL);
323 netconfig_vconf_get_int(VCONFKEY_WIFI_ENABLE_QS, &qs_enable);
324 if (qs_enable != VCONFKEY_WIFI_QS_ENABLE) {
325 DBG("qs_enable != VCONFKEY_WIFI_QS_ENABLE");
329 netconfig_vconf_get_int(VCONFKEY_WIFI_UG_RUN_STATE, &ug_state);
330 if (ug_state == VCONFKEY_WIFI_UG_RUN_STATE_ON_FOREGROUND)
333 netconfig_send_notification_to_net_popup(NETCONFIG_ADD_FOUND_AP_NOTI, NULL);
335 _set_bss_found(FALSE);
338 netconfig_stop_timer(&network_noti_timer_id);
342 static char *_get_connman_favorite_service(void)
344 char *favorite_service = NULL;
345 GVariant *message = NULL;
347 GVariantIter *iter, *next;
349 message = netconfig_invoke_dbus_method(CONNMAN_SERVICE,
350 CONNMAN_MANAGER_PATH, CONNMAN_MANAGER_INTERFACE,
351 "GetServices", NULL);
352 if (message == NULL) {
353 ERR("Failed to get service list");
357 g_variant_get(message, "(a(oa{sv}))", &iter);
358 while (g_variant_iter_loop(iter, "(oa{sv})", &obj, &next)) {
359 if (obj == NULL || netconfig_is_wifi_profile(obj) == FALSE)
362 if (__is_favorited(next) == TRUE) {
363 favorite_service = g_strdup(obj);
365 g_variant_iter_free(next);
370 g_variant_iter_free(iter);
371 g_variant_unref(message);
373 return favorite_service;
376 static void __notification_value_changed_cb(keynode_t *node, void *user_data)
380 if (netconfig_vconf_get_int(VCONFKEY_WIFI_ENABLE_QS, &value) < 0)
383 if (value == VCONFKEY_WIFI_QS_DISABLE)
384 netconfig_send_notification_to_net_popup(NETCONFIG_DEL_FOUND_AP_NOTI, NULL);
387 static void _register_network_notification(void)
389 #if defined TIZEN_WEARABLE
392 vconf_notify_key_changed(VCONFKEY_WIFI_ENABLE_QS, __notification_value_changed_cb, NULL);
395 static void _deregister_network_notification(void)
397 #if defined TIZEN_WEARABLE
400 vconf_ignore_key_changed(VCONFKEY_WIFI_ENABLE_QS, __notification_value_changed_cb);
403 static void _set_power_lock(gboolean power_lock)
408 char state[] = "lcdoff";
409 char flag[] = "staycurstate";
410 char standby[] = "NULL";
412 char sleepmargin[] = "sleepmargin";
414 const char *lockstate = "lockstate";
415 const char *unlockstate = "unlockstate";
416 static gboolean old_state = FALSE;
417 const char *lock_method;
419 if (old_state == power_lock)
422 if (power_lock == TRUE) {
423 /* deviced power lock enable */
424 params = g_variant_new("(sssi)", state, flag, standby, timeout);
426 lock_method = lockstate;
428 /* deviced power lock disable */
429 params = g_variant_new("(ss)", state, sleepmargin);
431 lock_method = unlockstate;
434 reply = netconfig_invoke_dbus_method(
435 "org.tizen.system.deviced",
436 "/Org/Tizen/System/DeviceD/Display",
437 "org.tizen.system.deviced.display",
441 ERR("Failed to set_power_lock");
445 if (g_variant_is_of_type(reply, G_VARIANT_TYPE_INT32)) {
446 ret = g_variant_get_int32(reply);
448 ERR("Failed to set power lock %s with ret %d",
449 power_lock == TRUE ? "enable" : "disable", ret);
451 old_state = power_lock;
454 g_variant_unref(reply);
459 void wifi_state_emit_power_completed(const char *interface_name, gboolean power_on)
462 wifi_emit_power_on_completed((Wifi *)get_wifi_object(), interface_name);
464 wifi_emit_power_off_completed((Wifi *)get_wifi_object(), interface_name);
466 DBG("Successfully sent signal [%s %s]",
467 interface_name, (power_on) ? "powerOn" : "powerOff");
470 void wifi_state_emit_power_failed(const char *interface_name)
472 wifi_emit_power_operation_failed((Wifi *)get_wifi_object(), interface_name);
474 DBG("Successfully sent signal [%s PowerOperationFailed]", interface_name);
477 static void __update_wifi_state(void)
479 int wifi_state = VCONFKEY_WIFI_OFF;
480 int network_wifi_state = VCONFKEY_NETWORK_WIFI_OFF;
483 for (list = g_device_list; list; list = list->next) {
484 wifi_device_data_s *device_data = list->data;
485 if (device_data->powered) {
486 if (wifi_state < VCONFKEY_WIFI_UNCONNECTED)
487 wifi_state = VCONFKEY_WIFI_UNCONNECTED;
488 if (network_wifi_state < VCONFKEY_NETWORK_WIFI_NOT_CONNECTED)
489 network_wifi_state = VCONFKEY_NETWORK_WIFI_NOT_CONNECTED;
491 if (device_data->connected) {
492 wifi_state = VCONFKEY_WIFI_CONNECTED;
493 network_wifi_state = VCONFKEY_NETWORK_WIFI_CONNECTED;
497 netconfig_set_vconf_int(VCONFKEY_WIFI_STATE, wifi_state, TRUE);
498 netconfig_set_vconf_int(VCONFKEY_NETWORK_WIFI_STATE, network_wifi_state, TRUE);
501 void wifi_state_update_power_state(const char *interface_name, gboolean powered)
503 wifi_tech_state_e tech_state;
505 /* It's automatically updated by signal-handler
506 * DO NOT update manually
507 * It includes Wi-Fi state configuration
509 tech_state = wifi_state_get_technology_state(interface_name);
510 if (tech_state == NETCONFIG_WIFI_TECH_UNKNOWN)
511 wifi_state_update_device_list();
513 if (powered == TRUE) {
514 if (tech_state < NETCONFIG_WIFI_TECH_POWERED && netconfig_is_wifi_tethering_on() != TRUE) {
515 DBG("Wi-Fi turned on or waken up from power-save mode");
516 gchar *mac_addr = vconf_get_str(VCONFKEY_WIFI_BSSID_ADDRESS);
518 if (mac_addr != NULL) {
519 if (strlen(mac_addr) == 0)
520 netconfig_set_mac_address_from_file();
524 wifi_state_set_powered(interface_name, TRUE);
525 wifi_state_set_technology_state(interface_name, NETCONFIG_WIFI_TECH_POWERED);
527 wifi_state_emit_power_completed(interface_name, TRUE);
528 netconfig_battery_start_wifi();
530 netconfig_wifi_device_picker_service_start();
532 __update_wifi_state();
534 netconfig_set_system_event(SYS_EVT_WIFI_STATE, EKEY_WIFI_STATE, EVAL_WIFI_ON);
536 netconfig_wifi_bgscan_stop(interface_name);
537 netconfig_wifi_bgscan_set_exp_interval(interface_name, SCAN_EXPONENTIAL_MIN);
538 netconfig_wifi_bgscan_start(interface_name, TRUE);
540 /* Add callback to track change in notification setting */
541 _register_network_notification();
543 netconfig_setting_update_interface_for_last_powered(interface_name, TRUE);
545 } else if (tech_state > NETCONFIG_WIFI_TECH_OFF) {
546 DBG("Wi-Fi turned off or in power-save mode");
548 wifi_state_set_powered(interface_name, FALSE);
549 wifi_state_set_technology_state(interface_name, NETCONFIG_WIFI_TECH_WPS_ONLY);
551 netconfig_wifi_device_picker_service_stop();
553 wifi_power_driver_and_supplicant(interface_name, FALSE);
555 wifi_state_emit_power_completed(interface_name, FALSE);
556 netconfig_battery_end_wifi();
558 __update_wifi_state();
560 netconfig_set_system_event(SYS_EVT_WIFI_STATE, EKEY_WIFI_STATE, EVAL_WIFI_OFF);
562 netconfig_wifi_bgscan_stop(interface_name);
563 netconfig_wifi_scan_set_scanning(interface_name, FALSE);
565 _set_bss_found(FALSE);
567 /* Inform net-popup to remove the wifi found notification */
568 netconfig_send_notification_to_net_popup(NETCONFIG_DEL_FOUND_AP_NOTI, NULL);
569 netconfig_send_notification_to_net_popup(NETCONFIG_DEL_PORTAL_NOTI, NULL);
570 netconfig_send_notification_to_net_popup(NETCONFIG_DEL_IP_CONFLICT_NOTI, NULL);
572 _deregister_network_notification();
574 netconfig_setting_update_interface_for_last_powered(interface_name, FALSE);
578 char *wifi_get_favorite_service(void)
580 return _get_connman_favorite_service();
583 void wifi_start_timer_network_notification(const char *interface_name)
585 #if defined TIZEN_WEARABLE
586 /* In case of wearable device, no need to notify available Wi-Fi APs */
589 netconfig_start_timer(NETCONFIG_NETWORK_NOTIFICATION_TIMEOUT,
590 _check_network_notification, g_strdup(interface_name), &network_noti_timer_id);
593 void wifi_state_notifier_register(wifi_state_notifier_s *notifier)
595 DBG("register notifier");
597 g_notifier_list = g_slist_append(g_notifier_list, notifier);
600 void wifi_state_notifier_unregister(wifi_state_notifier_s *notifier)
602 DBG("un-register notifier");
604 g_notifier_list = g_slist_remove_all(g_notifier_list, notifier);
607 void wifi_state_notifier_cleanup(void)
609 g_slist_free_full(g_notifier_list, NULL);
612 void wifi_state_set_bss_found(gboolean found)
614 _set_bss_found(found);
617 gboolean wifi_state_is_bss_found(void)
619 return new_bss_found;
622 void __copy_device_statistics(wifi_device_data_s *dst_data, GSList *device_list)
626 for (list = device_list; list; list = list->next) {
627 wifi_device_data_s *org_data = list->data;
628 if (g_strcmp0(org_data->interface_name, dst_data->interface_name) == 0) {
629 dst_data->tx = org_data->tx;
630 dst_data->rx = org_data->rx;
631 dst_data->tx_diff = org_data->tx_diff;
632 dst_data->tx_diff = org_data->tx_diff;
638 gboolean wifi_state_update_device_list(void)
640 GVariant *message = NULL, *variant;
641 GVariantIter *iter, *next;
642 GSList *device_list = NULL;
645 gboolean updated = FALSE;
647 message = netconfig_invoke_dbus_method(CONNMAN_SERVICE,
648 CONNMAN_MANAGER_PATH, CONNMAN_MANAGER_INTERFACE,
649 "GetTechnologies", NULL);
650 if (message == NULL) {
651 ERR("Failed to get technologies");
655 DBG("Wi-Fi g_device_list: %p", g_device_list);
657 device_list = g_device_list;
658 g_device_list = NULL;
660 g_variant_get(message, "(a(oa{sv}))", &iter);
661 while (g_variant_iter_loop(iter, "(oa{sv})", &path, &next)) {
662 if (path == NULL || g_strcmp0(path, CONNMAN_WIFI_TECHNOLOGY_PREFIX) != 0)
665 while (g_variant_iter_loop(next, "{sv}", &key, &variant)) {
666 if (g_strcmp0(key, "Device.List") == 0) {
667 GVariantIter *list_iter;
671 wifi_device_data_s *device_data = NULL;
673 g_variant_get(variant, "a{sv}", &list_iter);
674 while(g_variant_iter_loop(list_iter, "{sv}", &dev_key, &dev_var)) {
675 if (g_variant_is_of_type(dev_var, G_VARIANT_TYPE_STRING)) {
676 if (g_strcmp0(dev_key, "Ifname") == 0) {
677 device_data = g_try_malloc0(sizeof(wifi_device_data_s));
679 g_variant_unref(dev_var);
683 sdata = g_variant_get_string(dev_var, NULL);
684 device_data->interface_name = g_strdup(sdata);
685 g_device_list = g_slist_append(g_device_list, device_data);
689 __copy_device_statistics(device_data, device_list);
691 } else if (g_strcmp0(dev_key, "MAC.Address") == 0) {
693 sdata = g_variant_get_string(dev_var, NULL);
694 device_data->mac_address = g_strdup(sdata);
696 DBG("Ifname[%s] MAC[%s] Powered[%d] Connected[%d]",
697 device_data->interface_name, device_data->mac_address,
698 device_data->powered, device_data->connected);
701 } else if (g_variant_is_of_type(dev_var, G_VARIANT_TYPE_BOOLEAN)) {
702 if (g_strcmp0(dev_key, "Powered") == 0) {
704 device_data->powered = g_variant_get_boolean(dev_var);
706 if (device_data->tech_state == NETCONFIG_WIFI_TECH_UNKNOWN)
707 device_data->tech_state = NETCONFIG_WIFI_TECH_OFF;
709 if (device_data->interface_name)
710 wifi_state_update_power_state(
711 device_data->interface_name, device_data->powered);
713 if (device_data->powered == TRUE)
714 device_data->tech_state = NETCONFIG_WIFI_TECH_POWERED;
716 device_data->tech_state = NETCONFIG_WIFI_TECH_OFF;
718 } else if (g_strcmp0(dev_key, "Connected") == 0) {
720 device_data->connected = g_variant_get_boolean(dev_var);
721 if (device_data->connected == TRUE)
722 device_data->tech_state = NETCONFIG_WIFI_TECH_CONNECTED;
728 g_variant_iter_free(list_iter);
733 g_variant_unref(message);
735 g_variant_iter_free(iter);
737 g_slist_free_full(device_list, __device_free_data);
739 if (network_update_timer_id && updated)
740 netconfig_stop_timer(&network_update_timer_id);
745 GSList *wifi_state_get_device_list(void)
747 return g_device_list;
750 static gboolean __state_update_device_list(gpointer data)
752 if (wifi_state_update_device_list() == FALSE) {
753 if (network_update_timer_cnt <
754 NETCONFIG_UPDATE_DEVICE_LIST_COUNT) {
755 network_update_timer_cnt++;
760 netconfig_stop_timer(&network_update_timer_id);
764 void wifi_state_set_service_state(const char *interface_name,
765 const char *service, wifi_service_state_e new_state)
767 static gboolean dhcp_stage = FALSE;
768 wifi_device_data_s *device_data = NULL;
769 wifi_service_state_e old_state = NETCONFIG_WIFI_UNKNOWN;
771 device_data = __device_get_data(interface_name);
775 old_state = device_data->service_state;
776 if (old_state == new_state)
779 device_data->service_state = new_state;
780 DBG("Wi-Fi service state, old state[%s] ==> new state[%s]",
781 _convert_wifi_service_state_to_string(old_state), _convert_wifi_service_state_to_string(new_state));
783 /* From association, temporarily disable Wi-Fi power saving */
784 if ((old_state < NETCONFIG_WIFI_ASSOCIATION || old_state == NETCONFIG_WIFI_FAILURE) && new_state == NETCONFIG_WIFI_ASSOCIATION) {
785 _set_power_lock(TRUE);
786 wifi_set_early_suspend(interface_name, FALSE);
788 } else if (dhcp_stage == TRUE && new_state != NETCONFIG_WIFI_CONFIGURATION) {
789 _set_power_lock(FALSE);
790 wifi_set_early_suspend(interface_name, TRUE);
794 if (new_state == NETCONFIG_WIFI_CONNECTED) {
795 netconfig_send_notification_to_net_popup(NETCONFIG_DEL_FOUND_AP_NOTI, NULL);
797 __update_wifi_state();
799 netconfig_set_system_event(SYS_EVT_WIFI_STATE, EKEY_WIFI_STATE, EVAL_WIFI_CONNECTED);
801 __set_wifi_connected_essid();
803 netconfig_wifi_indicator_start(interface_name, service);
804 } else if (old_state == NETCONFIG_WIFI_CONNECTED) {
805 netconfig_send_notification_to_net_popup(NETCONFIG_DEL_PORTAL_NOTI, NULL);
807 __unset_wifi_connected_essid();
809 __update_wifi_state();
811 netconfig_set_system_event(SYS_EVT_WIFI_STATE, EKEY_WIFI_STATE, EVAL_WIFI_ON);
813 netconfig_wifi_indicator_stop(interface_name);
815 netconfig_wifi_bgscan_stop(interface_name);
816 netconfig_wifi_bgscan_set_exp_interval(interface_name, SCAN_EXPONENTIAL_MIN);
817 netconfig_wifi_bgscan_start(interface_name, TRUE);
818 } else if ((old_state > NETCONFIG_WIFI_IDLE && old_state < NETCONFIG_WIFI_CONNECTED) && new_state == NETCONFIG_WIFI_IDLE) {
819 /* in ipv6 case disconnect/association -> association */
820 DBG("reset the bg scan period");
822 netconfig_wifi_bgscan_stop(interface_name);
823 netconfig_wifi_bgscan_start(interface_name, TRUE);
824 } else if (old_state == NETCONFIG_WIFI_FAILURE && new_state == NETCONFIG_WIFI_IDLE) {
825 DBG("reset the bg scan period, in failure case");
826 netconfig_wifi_bgscan_stop(interface_name);
827 netconfig_wifi_bgscan_set_exp_interval(interface_name, SCAN_EXPONENTIAL_MIN);
828 netconfig_wifi_bgscan_start(interface_name, FALSE);
831 _wifi_state_changed(interface_name, new_state);
833 if (new_state == NETCONFIG_WIFI_CONNECTED)
834 _wifi_state_connected_activation();
837 wifi_service_state_e wifi_state_get_service_state(const char *interface_name)
839 wifi_device_data_s *device_data = __device_get_data(interface_name);
841 return NETCONFIG_WIFI_UNKNOWN;
843 return device_data->service_state;
846 void wifi_state_set_technology_state(const char *interface_name, wifi_tech_state_e new_state)
848 wifi_device_data_s *device_data = NULL;
850 device_data = __device_get_data(interface_name);
852 if (device_data->tech_state == new_state)
855 DBG("Wi-Fi %s technology state, old state[%s] ==> new state[%s]", interface_name,
856 _convert_wifi_technology_state_to_string(device_data->tech_state),
857 _convert_wifi_technology_state_to_string(new_state));
859 device_data->tech_state = new_state;
863 wifi_tech_state_e wifi_state_get_technology_state(const char *interface_name)
865 wifi_device_data_s *device_data = NULL;
867 device_data = __device_get_data(interface_name);
869 DBG("Wi-Fi %s technology state [%s]", interface_name,
870 _convert_wifi_technology_state_to_string(device_data->tech_state));
872 return device_data->tech_state;
875 return NETCONFIG_WIFI_TECH_UNKNOWN;
878 void wifi_state_set_powered(const char *interface_name, gboolean powered)
880 wifi_device_data_s *device_data = __device_get_data(interface_name);
883 device_data->powered = powered;
884 DBG("Wi-Fi %s [%s]", interface_name, powered ? "enabled" : "disabled");
888 gboolean wifi_state_get_powered(const char *interface_name)
890 wifi_device_data_s *device_data = __device_get_data(interface_name);
894 return device_data->powered;
897 void wifi_state_set_connected(const char *interface_name, gboolean connected)
899 wifi_device_data_s *device_data = __device_get_data(interface_name);
902 device_data->connected = connected;
903 DBG("Wi-Fi %s [%s]", interface_name, connected ? "connected" : "disconnected");
907 gboolean wifi_state_get_connected(const char *interface_name)
909 wifi_device_data_s *device_data = __device_get_data(interface_name);
913 return device_data->connected;
916 gboolean wifi_state_is_existed(const char *interface_name)
918 wifi_device_data_s *device_data = __device_get_data(interface_name);
925 const char *wifi_state_get_interface_name(const char *mac_address)
927 wifi_device_data_s *device_data = __device_get_data_by_macaddr(mac_address);
931 return device_data->interface_name;
934 const char *wifi_state_get_mac_address(const char *interface_name)
936 wifi_device_data_s *device_data = __device_get_data(interface_name);
940 return device_data->mac_address;
943 void wifi_state_set_connected_essid(void)
945 __set_wifi_connected_essid();
948 void wifi_state_get_connected_essid(gchar **essid)
950 *essid = g_strdup(__get_wifi_connected_essid());
953 void wifi_state_initialize(void)
955 if (wifi_state_update_device_list() == FALSE)
956 netconfig_start_timer(NETCONFIG_UPDATE_DEVICE_LIST_TIMEOUT,
957 __state_update_device_list, NULL, &network_update_timer_id);
960 void wifi_state_deinitialize(void)
962 g_slist_free_full(g_device_list, __device_free_data);