sources/libraries/WlanManager/wlan_manager.c

   1 /*
   2  * Wi-Fi
   3  *
   4  * Copyright 2012 Samsung Electronics Co., Ltd
   5  *
   6  * Licensed under the Flora License, Version 1.1 (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
   9  *
  10  * http://www.tizenopensource.org/license
  11  *
  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.
  17  *
  18  */
  19
  20 #include <vconf-keys.h>
  21
  22 #include "common.h"
  23 #include "connection_manager.h"
  24 #include "wlan_manager.h"
  25 #include "common_utils.h"
  26 #include "wlan_connection.h"
  27 #include "wifi-engine-callback.h"
  28
  29 typedef enum {
  30         WLAN_MANAGER_REQ_TYPE_ACTIVATE,
  31         WLAN_MANAGER_REQ_TYPE_DEACTIVATE,
  32         WLAN_MANAGER_REQ_TYPE_SCAN,
  33         WLAN_MANAGER_REQ_TYPE_SPECIFIC_SCAN,
  34         WLAN_MANAGER_REQ_TYPE_SCAN_RESULT,
  35         WLAN_MANAGER_REQ_TYPE_CONNECT,
  36         WLAN_MANAGER_REQ_TYPE_WPS_CONNECT,
  37         WLAN_MANAGER_REQ_TYPE_BG_SCAN_START,
  38 } WLAN_MANAGER_REQUEST_TYPES;
  39
  40 typedef struct {
  41         WLAN_MANAGER_REQUEST_TYPES req_type;
  42         wifi_manager_ap_h ap;
  43         void *user_data;
  44 } wlan_mgr_req_data_t;
  45
  46 typedef struct {
  47         int state;
  48         wifi_manager_ap_h *ap;
  49 } ap_state_info_t;
  50
  51 wlan_mgr_req_data_t scan_req_data;
  52
  53 static void wlan_manager_register_cbs(void);
  54 static void wlan_manager_deregister_cbs(void);
  55
  56 static wlan_manager_object *manager_object = NULL;
  57
  58 static wifi_manager_device_state_e wifi_emulator_state = WIFI_MANAGER_DEVICE_STATE_DEACTIVATED;
  59
  60 wlan_manager_object *wlan_manager_get_singleton(void)
  61 {
  62         if (NULL == manager_object) {
  63                 manager_object = g_new0(wlan_manager_object, 1);
  64                 manager_object->message_func = NULL;
  65                 manager_object->refresh_func = NULL;
  66         }
  67
  68         return manager_object;
  69 }
  70
  71 void wlan_manager_set_refresh_callback(wlan_manager_ui_refresh_func_t func)
  72 {
  73         manager_object->refresh_func = func;
  74 }
  75
  76 void *wlan_manager_create(void)
  77 {
  78         wlan_manager_get_singleton();
  79
  80         return NULL;
  81 }
  82
  83 int wlan_manager_update_ap(wifi_manager_ap_h ap)
  84 {
  85         int rv = wifi_manager_update_ap(manager_object->wifi, ap);
  86         if (rv != WIFI_MANAGER_ERROR_NONE)
  87                 ERROR_LOG(COMMON_NAME_ERR, "Unable to update ap handle");
  88         return rv;
  89 }
  90
  91 int wlan_manager_is_activated(bool *activated)
  92 {
  93         return wifi_manager_is_activated(manager_object->wifi, activated);
  94 }
  95
  96 int wlan_manager_destroy(void)
  97 {
  98         int ret = WLAN_MANAGER_ERR_NONE;
  99
 100         if (manager_object == NULL) {
 101                 ERROR_LOG(COMMON_NAME_ERR, "Wlan manager object already destroyed");
 102                 return ret;
 103         }
 104
 105         wifi_manager_unset_device_state_changed_cb(manager_object->wifi);
 106
 107         wlan_manager_deregister_cbs();
 108
 109         wlan_connect_cleanup();
 110
 111         connection_manager_destroy();
 112
 113         ret = wifi_manager_deinitialize(manager_object->wifi);
 114
 115         if (manager_object != NULL) {
 116                 g_free(manager_object);
 117                 manager_object = NULL;
 118         }
 119
 120         return ret;
 121 }
 122
 123 int wlan_manager_start(void)
 124 {
 125         __COMMON_FUNC_ENTER__;
 126
 127         int ret = WLAN_MANAGER_ERR_NONE;
 128
 129         switch (wlan_initialize(&(manager_object->wifi))) {
 130         case WIFI_MANAGER_ERROR_NONE:
 131                 /* Register the callbacks */
 132                 wlan_manager_register_cbs();
 133                 connection_manager_create();
 134                 break;
 135
 136         case WIFI_MANAGER_ERROR_INVALID_OPERATION:
 137                 /* Register the callbacks */
 138                 wlan_manager_register_cbs();
 139                 ret = WLAN_MANAGER_ERR_ALREADY_REGISTERED;
 140                 break;
 141
 142         default:
 143                 ret = WLAN_MANAGER_ERR_UNKNOWN;
 144                 break;
 145         }
 146
 147         __COMMON_FUNC_EXIT__;
 148         return ret;
 149 }
 150
 151 int wlan_manager_forget(wifi_manager_ap_h ap)
 152 {
 153         return wifi_manager_forget_ap(manager_object->wifi, ap);
 154 }
 155
 156 static void wlan_manager_network_event_cb(
 157                 wifi_manager_error_e error_code, void *user_data)
 158 {
 159         __COMMON_FUNC_ENTER__;
 160
 161         wlan_mgr_req_data_t *req_data = (wlan_mgr_req_data_t *)user_data;
 162         if (req_data == NULL) {
 163                 ERROR_LOG(UG_NAME_ERR, "Request data is NULL !!!");
 164
 165                 __COMMON_FUNC_EXIT__;
 166                 return;
 167         }
 168
 169         wlan_mgr_event_info_t event_info;
 170         memset(&event_info, 0, sizeof(event_info));
 171
 172         switch (req_data->req_type) {
 173         case WLAN_MANAGER_REQ_TYPE_ACTIVATE:
 174                 /* fall through */
 175         case WLAN_MANAGER_REQ_TYPE_DEACTIVATE:
 176                 /* We will send POWER_ON_OK / POWER_OFF_OK response when we receive
 177                  * device state change. Lets just clean up the request data now.
 178                  */
 179                 goto exit;
 180                 /* fall through */
 181         case WLAN_MANAGER_REQ_TYPE_SCAN:
 182                 INFO_LOG(UG_NAME_NORMAL, "Scan Complete Event ");
 183                 if (WIFI_MANAGER_ERROR_NONE == error_code) {
 184                         event_info.event_type = WLAN_MANAGER_RESPONSE_TYPE_SCAN_OK;
 185                         manager_object->b_scan_blocked = FALSE;
 186                 } else {
 187                         goto exit;
 188                 }
 189
 190                 break;
 191
 192         case WLAN_MANAGER_REQ_TYPE_SPECIFIC_SCAN:
 193                 if (WIFI_MANAGER_ERROR_NONE == error_code)
 194                         event_info.event_type = WLAN_MANAGER_RESPONSE_TYPE_SPECIFIC_SCAN_OK;
 195                 else
 196                         event_info.event_type = WLAN_MANAGER_RESPONSE_TYPE_SPECIFIC_SCAN_FAIL;
 197
 198                 break;
 199
 200         case WLAN_MANAGER_REQ_TYPE_SCAN_RESULT:
 201                 if (WIFI_MANAGER_ERROR_NONE == error_code) {
 202                         event_info.event_type = WLAN_MANAGER_RESPONSE_TYPE_SCAN_RESULT_IND;
 203                         manager_object->message_func(&event_info, req_data->user_data);
 204                 }
 205
 206                 return; // The request data is static. So returning here.
 207
 208         case WLAN_MANAGER_REQ_TYPE_CONNECT:
 209                 event_info.ap = req_data->ap;
 210
 211                 if (WIFI_MANAGER_ERROR_NONE != error_code) {
 212                         if (error_code == WIFI_MANAGER_ERROR_INVALID_KEY) {
 213                                 event_info.event_type =
 214                                                 WLAN_MANAGER_RESPONSE_TYPE_CONNECTION_INVALID_KEY;
 215                         } else if (error_code == WIFI_MANAGER_ERROR_DHCP_FAILED) {
 216                                 event_info.event_type =
 217                                                 WLAN_MANAGER_RESPONSE_TYPE_DHCP_FAILED;
 218                         } else {
 219                                 event_info.event_type =
 220                                                 WLAN_MANAGER_RESPONSE_TYPE_CONNECTION_CONNECT_FAILED;
 221                         }
 222                 } else {
 223                         goto exit;
 224                 }
 225
 226                 break;
 227
 228         case WLAN_MANAGER_REQ_TYPE_WPS_CONNECT:
 229                 event_info.ap = req_data->ap;
 230
 231                 if (WIFI_MANAGER_ERROR_NONE != error_code)
 232                         event_info.event_type = WLAN_MANAGER_RESPONSE_TYPE_WPS_ENROLL_FAIL;
 233                 else
 234                         goto exit;
 235
 236                 break;
 237
 238         default:
 239                 goto exit;
 240         }
 241
 242         manager_object->message_func(&event_info, req_data->user_data);
 243
 244 exit:
 245         if (req_data != NULL) {
 246                 wifi_manager_ap_destroy(req_data->ap);
 247                 g_free(req_data);
 248         }
 249
 250         __COMMON_FUNC_EXIT__;
 251 }
 252
 253 static GSList *emul_timer_list = NULL;
 254 void wifi_emulator_create_event_timer(int evt_id, int itv, void *evt_cb, void *usr_data)
 255 {
 256         __COMMON_FUNC_ENTER__;
 257
 258         wifi_emul_timer_s *evt_info = NULL;
 259         evt_info = g_try_malloc0(sizeof(wifi_emul_timer_s));
 260         if (evt_info == NULL) {
 261                 ERROR_LOG(UG_NAME_ERR, "malloc fail");
 262                 return;
 263         }
 264
 265         wifi_emulator_remove_event_timer(evt_id);
 266
 267         evt_info->event_id = evt_id;
 268         evt_info->timer_id = g_timeout_add(itv, (GSourceFunc)evt_cb, (gpointer)usr_data);
 269
 270         INFO_LOG(UG_NAME_NORMAL, "Create emulator event timer. event id: %d, timer id: %d\n",
 271                                 evt_id, evt_info->timer_id);
 272
 273         emul_timer_list = g_slist_append(emul_timer_list, evt_info);
 274
 275         __COMMON_FUNC_EXIT__;
 276 }
 277
 278 void wifi_emulator_remove_event_timer(int evt_id)
 279 {
 280         __COMMON_FUNC_ENTER__;
 281
 282         GSList *list;
 283
 284         INFO_LOG(UG_NAME_NORMAL, "Remove emulator event timer. event id: %d\n", evt_id);
 285
 286         for (list = emul_timer_list; list; list = g_slist_next(list)) {
 287                 wifi_emul_timer_s *evt_info = list->data;
 288                 if (evt_info == NULL)
 289                         continue;
 290
 291                 if (evt_info->event_id == evt_id) {
 292                         g_source_remove(evt_info->timer_id);
 293                         emul_timer_list = g_slist_remove(emul_timer_list, evt_info);
 294                         g_free(evt_info);
 295                         break;
 296                 }
 297         }
 298
 299         __COMMON_FUNC_EXIT__;
 300 }
 301
 302 void wifi_emulator_remove_all_event_timer(void)
 303 {
 304         __COMMON_FUNC_ENTER__;
 305
 306         GSList *list;
 307
 308         for (list = emul_timer_list; list; list = g_slist_next(list)) {
 309                 wifi_emul_timer_s *evt_info = list->data;
 310                 if (evt_info == NULL)
 311                         continue;
 312
 313                 g_source_remove(evt_info->timer_id);
 314                 emul_timer_list = g_slist_remove(emul_timer_list, evt_info);
 315                 g_free(evt_info);
 316         }
 317
 318         g_slist_free(emul_timer_list);
 319         emul_timer_list = NULL;
 320
 321         __COMMON_FUNC_EXIT__;
 322 }
 323
 324 static void wlan_manager_disconnect_cb(wifi_manager_error_e error, void *user_data)
 325 {
 326         return;
 327 }
 328
 329 static void wlan_manager_device_state_changed_cb(
 330                 wifi_manager_device_state_e state, void *user_data)
 331 {
 332         __COMMON_FUNC_ENTER__;
 333
 334         wlan_mgr_event_info_t event_info;
 335         memset(&event_info, 0, sizeof(event_info));
 336
 337         switch (state) {
 338         case WIFI_MANAGER_DEVICE_STATE_ACTIVATED:
 339                 wlan_manager_set_autoscan_mode(WLAN_MANAGER_AUTOSCAN_MODE_PERIODIC);
 340                 wlan_manager_enable_scan_result_update();
 341                 wlan_manager_register_cbs();
 342                 event_info.event_type = WLAN_MANAGER_RESPONSE_TYPE_POWER_ON_OK;
 343                 if (_is_emulator())
 344                         wifi_emulator_state = WIFI_MANAGER_DEVICE_STATE_ACTIVATED;
 345                 break;
 346
 347         case WIFI_MANAGER_DEVICE_STATE_DEACTIVATED:
 348                 wlan_manager_deregister_cbs();
 349                 event_info.event_type = WLAN_MANAGER_RESPONSE_TYPE_POWER_OFF_OK;
 350                 if (_is_emulator())
 351                         wifi_emulator_state = WIFI_MANAGER_DEVICE_STATE_DEACTIVATED;
 352                 break;
 353
 354         default:
 355                 return;
 356         }
 357
 358         manager_object->message_func(&event_info, user_data);
 359
 360         __COMMON_FUNC_EXIT__;
 361 }
 362
 363 static void wlan_manager_connection_state_changed_cb(
 364                 wifi_manager_connection_state_e state, wifi_manager_ap_h ap, void *user_data)
 365 {
 366         __COMMON_FUNC_ENTER__;
 367
 368         wlan_mgr_event_info_t event_info;
 369         memset(&event_info, 0, sizeof(event_info));
 370
 371         event_info.ap = ap;
 372
 373         switch (state) {
 374         case WIFI_MANAGER_CONNECTION_STATE_FAILURE:
 375         case WIFI_MANAGER_CONNECTION_STATE_DISCONNECTED:  /**< Disconnected state */
 376                 event_info.event_type = WLAN_MANAGER_RESPONSE_TYPE_DISCONNECTION_OK;
 377                 break;
 378         case WIFI_MANAGER_CONNECTION_STATE_ASSOCIATION:  /**< Association state */
 379                 event_info.event_type = WLAN_MANAGER_RESPONSE_TYPE_CONNECTING;
 380                 break;
 381         case WIFI_MANAGER_CONNECTION_STATE_CONFIGURATION:  /**< Configuration state */
 382                 event_info.event_type = WLAN_MANAGER_RESPONSE_TYPE_CONFIGURATION;
 383                 break;
 384         case WIFI_MANAGER_CONNECTION_STATE_CONNECTED:  /**< Connected state */
 385                 event_info.event_type = WLAN_MANAGER_RESPONSE_TYPE_CONNECTION_OK;
 386                 break;
 387         default:
 388                 return;
 389         }
 390
 391         manager_object->message_func(&event_info, user_data);
 392
 393         __COMMON_FUNC_EXIT__;
 394 }
 395
 396 static void wlan_manager_rssi_level_changed_cb(
 397                 wifi_manager_rssi_level_e rssi_level, void *user_data)
 398 {
 399         __COMMON_FUNC_ENTER__;
 400
 401         wlan_mgr_event_info_t event_info;
 402
 403         memset(&event_info, 0, sizeof(event_info));
 404         event_info.event_type = WLAN_MANAGER_RESPONSE_TYPE_UPDATE_WIFI_RSSI;
 405         event_info.rssi_level = rssi_level;
 406
 407         manager_object->message_func(&event_info, user_data);
 408
 409         __COMMON_FUNC_EXIT__;
 410 }
 411
 412 static void wlan_manager_specific_scan_finished_cb(
 413                 wifi_manager_error_e error_code, void *user_data)
 414 {
 415         __COMMON_FUNC_ENTER__;
 416
 417         wlan_mgr_event_info_t event_info;
 418         memset(&event_info, 0, sizeof(event_info));
 419
 420         if (WIFI_MANAGER_ERROR_NONE == error_code) {
 421                 event_info.event_type = WLAN_MANAGER_RESPONSE_TYPE_SPECIFIC_SCAN_OK;
 422                 // Maybe bss_info_list is not used.
 423                 //event_info.bss_info_list = bss_info_list;
 424         } else {
 425                 event_info.event_type = WLAN_MANAGER_RESPONSE_TYPE_SPECIFIC_SCAN_FAIL;
 426         }
 427
 428         manager_object->message_func(&event_info, user_data);
 429
 430         __COMMON_FUNC_EXIT__;
 431 }
 432
 433 static void wlan_manager_register_cbs(void)
 434 {
 435         __COMMON_FUNC_ENTER__;
 436
 437         wifi_manager_set_device_state_changed_cb(manager_object->wifi, wlan_manager_device_state_changed_cb, NULL);
 438         wifi_manager_set_connection_state_changed_cb(manager_object->wifi, wlan_manager_connection_state_changed_cb, NULL);
 439         wifi_manager_set_rssi_level_changed_cb(manager_object->wifi, wlan_manager_rssi_level_changed_cb, NULL);
 440
 441         memset(&scan_req_data, 0, sizeof(scan_req_data));
 442         scan_req_data.req_type = WLAN_MANAGER_REQ_TYPE_SCAN_RESULT;
 443         wifi_manager_set_background_scan_cb(manager_object->wifi, wlan_manager_network_event_cb, &scan_req_data);
 444
 445         __COMMON_FUNC_EXIT__;
 446 }
 447
 448 static void wlan_manager_deregister_cbs(void)
 449 {
 450         __COMMON_FUNC_ENTER__;
 451
 452         /* NOTE:
 453          * We don't deregister the device state change cb here.
 454          * We need to continue to listen to the device state change, because it is
 455          * possible that the WiFi could be powered on / off from multiple entry
 456          * points like example: Quick panel WiFi icon, Wi-Fi UG, Setting Menu.
 457          *
 458          * We will deregister the device state change cb only on wlan manager
 459          * detsroy.
 460          */
 461
 462         wifi_manager_unset_background_scan_cb(manager_object->wifi);
 463         wifi_manager_unset_connection_state_changed_cb(manager_object->wifi);
 464         wifi_manager_unset_rssi_level_changed_cb(manager_object->wifi);
 465
 466         __COMMON_FUNC_EXIT__;
 467 }
 468
 469 void wlan_manager_set_message_callback(wlan_event_handler func)
 470 {
 471         manager_object->message_func = func;
 472 }
 473
 474 static bool wifi_found_ap_with_state_cb(wifi_manager_ap_h ap, void* user_data)
 475 {
 476         wifi_manager_connection_state_e state;
 477         ap_state_info_t *ap_state_info = (ap_state_info_t *)user_data;
 478         bool found_match = false;
 479
 480         if (WIFI_MANAGER_ERROR_NONE != wifi_manager_ap_get_connection_state(ap, &state))
 481                 return true; // continue with next AP
 482
 483         switch (ap_state_info->state) {
 484         case WLAN_MANAGER_UNCONNECTED:
 485                 if (WIFI_MANAGER_CONNECTION_STATE_DISCONNECTED == state ||
 486                                 WIFI_MANAGER_CONNECTION_STATE_FAILURE == state) {
 487                         /* Found a match, so terminate the loop */
 488                         found_match = true;
 489                 }
 490                 break;
 491         case WLAN_MANAGER_CONNECTING:
 492                 if (WIFI_MANAGER_CONNECTION_STATE_ASSOCIATION == state ||
 493                         WIFI_MANAGER_CONNECTION_STATE_CONFIGURATION == state) {
 494                         /* Found a match, so terminate the loop */
 495                         found_match = true;
 496                 }
 497                 break;
 498         case WLAN_MANAGER_CONNECTED:
 499                 if (WIFI_MANAGER_CONNECTION_STATE_CONNECTED == state) {
 500                         /* Found a match, so terminate the loop */
 501                         found_match = true;
 502                 }
 503                 break;
 504         default:
 505                 ERROR_LOG(COMMON_NAME_ERR, "Unknown Wi-Fi state: %d", ap_state_info->state);
 506                 return false;
 507         }
 508
 509         if (true == found_match) {
 510                 if (ap_state_info->ap)
 511                         wifi_manager_ap_clone(ap_state_info->ap, ap);
 512
 513                 INFO_LOG(COMMON_NAME_LIB, "Found an AP[%p] in the state %d", ap, ap_state_info->state);
 514                 return false;   // found the match, so terminate the loop.
 515         }
 516         return true;
 517 }
 518
 519 wifi_manager_ap_h wlan_manager_get_ap_with_state(int ap_state)
 520 {
 521         int ret_val = 0;
 522         ap_state_info_t ap_state_info;
 523         wifi_manager_ap_h ap = NULL;
 524
 525         ap_state_info.state = ap_state;
 526         ap_state_info.ap = &ap;
 527
 528         ret_val = wifi_manager_foreach_found_ap(manager_object->wifi, wifi_found_ap_with_state_cb, &ap_state_info);
 529         if (ret_val != WIFI_MANAGER_ERROR_NONE)
 530                 return NULL;
 531
 532         return ap;
 533 }
 534
 535 int wlan_manager_get_connected_ap(wifi_manager_ap_h *ap)
 536 {
 537         return wifi_manager_get_connected_ap(manager_object->wifi, ap);
 538 }
 539
 540 int wlan_manager_state_get(void)
 541 {
 542         int value = VCONFKEY_WIFI_OFF;
 543         int ret_val = 0;
 544
 545         if (_is_emulator()) {
 546                 value = common_util_get_system_registry(VCONFKEY_WIFI_STATE);
 547                 if (value == -1) {
 548                         ERROR_LOG(COMMON_NAME_ERR, "fail to get vconf key!");
 549                         return VCONFKEY_WIFI_OFF;
 550                 }
 551                 if (value == VCONFKEY_WIFI_UNCONNECTED)
 552                         ret_val = WLAN_MANAGER_UNCONNECTED;
 553                 else
 554                         ret_val = WLAN_MANAGER_OFF;
 555         } else {
 556                 if (!manager_object) {
 557                         ERROR_LOG(COMMON_NAME_ERR, "manager_object is NULL!!");
 558                         return WLAN_MANAGER_ERROR;
 559                 }
 560
 561                 wifi_manager_connection_state_e connection_state;
 562                 bool activated;
 563
 564                 if (WIFI_MANAGER_ERROR_NONE != wifi_manager_is_activated(manager_object->wifi, &activated)) {
 565                         return WLAN_MANAGER_ERROR;
 566                 } else if (false == activated) {
 567                         INFO_LOG(COMMON_NAME_LIB, "STATE: WIFI_OFF");
 568
 569                         return WLAN_MANAGER_OFF;
 570                 }
 571
 572                 ret_val = wifi_manager_get_connection_state(manager_object->wifi, &connection_state);
 573                 if (WIFI_MANAGER_ERROR_NONE != ret_val)
 574                         return WLAN_MANAGER_ERROR;
 575
 576
 577                 switch (connection_state) {
 578                 case WIFI_MANAGER_CONNECTION_STATE_FAILURE:
 579                 case WIFI_MANAGER_CONNECTION_STATE_DISCONNECTED:
 580                         INFO_LOG(COMMON_NAME_LIB, "STATE: WIFI_DISCONNECTED");
 581
 582                         ret_val = WLAN_MANAGER_UNCONNECTED;
 583                         break;
 584                 case WIFI_MANAGER_CONNECTION_STATE_ASSOCIATION:
 585                 case WIFI_MANAGER_CONNECTION_STATE_CONFIGURATION:
 586                         INFO_LOG(COMMON_NAME_LIB, "STATE: WIFI_CONNECTING");
 587
 588                         ret_val = WLAN_MANAGER_CONNECTING;
 589                         break;
 590                 case WIFI_MANAGER_CONNECTION_STATE_CONNECTED:
 591                         INFO_LOG(COMMON_NAME_LIB, "STATE: WIFI_CONNECTED");
 592
 593                         ret_val = WLAN_MANAGER_CONNECTED;
 594                         break;
 595                 default:
 596                         ERROR_LOG(COMMON_NAME_ERR, "Unknown state: %d", connection_state);
 597
 598                         ret_val = WLAN_MANAGER_ERROR;
 599                         break;
 600                 }
 601         }
 602
 603         return ret_val;
 604 }
 605
 606 int wlan_manager_power_on(void)
 607 {
 608         __COMMON_FUNC_ENTER__;
 609
 610         INFO_LOG(UG_NAME_REQ, "power on");
 611
 612 #if defined TIZEN_TETHERING_ENABLE
 613         int tethering =
 614                         common_util_get_system_registry("memory/mobile_hotspot/mode");
 615         if (tethering < 0) {
 616                 INFO_LOG(COMMON_NAME_LIB, "Fail to get tethering state");
 617         } else if (VCONFKEY_MOBILE_HOTSPOT_MODE_WIFI & tethering) {
 618                 INFO_LOG(COMMON_NAME_LIB, "Wi-Fi tethering is ON");
 619
 620                 __COMMON_FUNC_EXIT__;
 621                 return WLAN_MANAGER_ERR_WIFI_TETHERING_OCCUPIED;
 622         } else if (VCONFKEY_MOBILE_HOTSPOT_MODE_WIFI_AP & tethering) {
 623                 INFO_LOG(COMMON_NAME_LIB, "Wi-Fi AP tethering is ON");
 624
 625                 __COMMON_FUNC_EXIT__;
 626                 return WLAN_MANAGER_ERR_WIFI_AP_TETHERING_OCCUPIED;
 627         }
 628 #endif
 629
 630         if (!_is_emulator()) {
 631                 int ret = 0;
 632                 wlan_mgr_req_data_t *req_data = g_new0(wlan_mgr_req_data_t, 1);
 633                 req_data->req_type = WLAN_MANAGER_REQ_TYPE_ACTIVATE;
 634                 ret = wifi_manager_activate(manager_object->wifi, wlan_manager_network_event_cb, req_data);
 635                 if (WIFI_MANAGER_ERROR_NONE != ret && WIFI_MANAGER_ERROR_ALREADY_EXISTS != ret) {
 636                         ERROR_LOG(UG_NAME_REQ, "Power on request. Error Reason [%d]", ret);
 637                         g_free(req_data);
 638
 639                         if (WIFI_MANAGER_ERROR_SECURITY_RESTRICTED == ret)
 640                                 ret = common_utils_send_restriction_to_net_popup("Wi-Fi unavailable",
 641                                                 "toast_popup", "wifi");
 642
 643                         __COMMON_FUNC_EXIT__;
 644                         return WLAN_MANAGER_ERR_UNKNOWN;
 645                 }
 646         } else {
 647                 common_util_set_system_registry(VCONFKEY_WIFI_STATE, VCONFKEY_WIFI_UNCONNECTED);
 648         }
 649
 650         __COMMON_FUNC_EXIT__;
 651         return WLAN_MANAGER_ERR_NONE;
 652 }
 653
 654 int wlan_manager_power_off(void)
 655 {
 656         __COMMON_FUNC_ENTER__;
 657
 658         if (!_is_emulator()) {
 659                 wlan_mgr_req_data_t *req_data = g_new0(wlan_mgr_req_data_t, 1);
 660                 req_data->req_type = WLAN_MANAGER_REQ_TYPE_DEACTIVATE;
 661
 662                 int ret = wifi_manager_deactivate(manager_object->wifi, wlan_manager_network_event_cb, req_data);
 663                 if (WIFI_MANAGER_ERROR_NONE != ret && WIFI_MANAGER_ERROR_ALREADY_EXISTS != ret) {
 664                         ERROR_LOG(UG_NAME_REQ, "Power off request. Error Reason [%d]", ret);
 665
 666                         g_free(req_data);
 667
 668                         __COMMON_FUNC_EXIT__;
 669                         return WLAN_MANAGER_ERR_UNKNOWN;
 670                 }
 671         } else {
 672                 common_util_set_system_registry(VCONFKEY_WIFI_STATE, VCONFKEY_WIFI_OFF);
 673         }
 674
 675         __COMMON_FUNC_EXIT__;
 676         return WLAN_MANAGER_ERR_NONE;
 677 }
 678
 679 int wlan_manager_emulator_power_on(void)
 680 {
 681         wlan_manager_device_state_changed_cb(WIFI_MANAGER_DEVICE_STATE_ACTIVATED, NULL);
 682
 683         memset(&scan_req_data, 0, sizeof(scan_req_data));
 684         scan_req_data.req_type = WLAN_MANAGER_REQ_TYPE_SCAN_RESULT;
 685         wlan_manager_network_event_cb(WIFI_MANAGER_ERROR_NONE, &scan_req_data);
 686
 687         wifi_emulator_remove_event_timer(WIFI_EMUL_EVENT_TIMER_ACTIVATE);
 688
 689         return WLAN_MANAGER_ERR_NONE;
 690 }
 691
 692 int wlan_manager_emulator_power_off(void)
 693 {
 694         wlan_manager_device_state_changed_cb(WIFI_MANAGER_DEVICE_STATE_DEACTIVATED, NULL);
 695
 696         wifi_emulator_remove_all_event_timer();
 697
 698         return WLAN_MANAGER_ERR_NONE;
 699 }
 700
 701 int wlan_manager_wps_connect(wifi_manager_ap_h ap)
 702 {
 703         __COMMON_FUNC_ENTER__;
 704
 705         wlan_mgr_req_data_t *req_data = g_new0(wlan_mgr_req_data_t, 1);
 706         req_data->req_type = WLAN_MANAGER_REQ_TYPE_WPS_CONNECT;
 707         wifi_manager_ap_clone(&(req_data->ap), ap);
 708
 709         int ret = wlan_connect(req_data->ap, wlan_manager_network_event_cb,
 710                         req_data, WPS_BTN, NULL);
 711         if (WIFI_MANAGER_ERROR_NONE != ret) {
 712                 ERROR_LOG(UG_NAME_REQ, "WPS Connect failed. Error Reason [%d]", ret);
 713
 714                 wifi_manager_ap_destroy(req_data->ap);
 715
 716                 g_free(req_data);
 717
 718                 __COMMON_FUNC_EXIT__;
 719                 return WLAN_MANAGER_ERR_UNKNOWN;
 720         }
 721
 722         __COMMON_FUNC_EXIT__;
 723         return WLAN_MANAGER_ERR_NONE;
 724 }
 725
 726 int wlan_manager_wps_pin_connect(wifi_manager_ap_h ap, const char *pin)
 727 {
 728         __COMMON_FUNC_ENTER__;
 729
 730         wlan_mgr_req_data_t *req_data = g_new0(wlan_mgr_req_data_t, 1);
 731         req_data->req_type = WLAN_MANAGER_REQ_TYPE_WPS_CONNECT;
 732         wifi_manager_ap_clone(&(req_data->ap), ap);
 733
 734         int ret = wlan_connect(req_data->ap, wlan_manager_network_event_cb,
 735                         req_data, WPS_PIN, pin);
 736         if (WIFI_MANAGER_ERROR_NONE != ret) {
 737                 ERROR_LOG(UG_NAME_REQ, "WPS Connect failed. Error Reason [%d]", ret);
 738
 739                 wifi_manager_ap_destroy(req_data->ap);
 740
 741                 g_free(req_data);
 742
 743                 __COMMON_FUNC_EXIT__;
 744                 return WLAN_MANAGER_ERR_UNKNOWN;
 745         }
 746
 747         __COMMON_FUNC_EXIT__;
 748         return WLAN_MANAGER_ERR_NONE;
 749 }
 750
 751 void wlan_manager_ap_hidden_create(char *ssid, wifi_manager_ap_h *hidden_ap)
 752 {
 753         __COMMON_FUNC_ENTER__;
 754
 755         wifi_manager_ap_hidden_create(manager_object->wifi, ssid, hidden_ap);
 756
 757         __COMMON_FUNC_EXIT__;
 758         return;
 759 }
 760 int wlan_manager_ap_create(const char *essid, wifi_manager_ap_h *ap)
 761 {
 762         __COMMON_FUNC_ENTER__;
 763
 764         return wifi_manager_ap_create(manager_object->wifi, essid, ap);
 765
 766         __COMMON_FUNC_EXIT__;
 767 }
 768
 769
 770 int wlan_manager_connect(wifi_manager_ap_h ap)
 771 {
 772         __COMMON_FUNC_ENTER__;
 773
 774         int ret;
 775
 776         if (ap == NULL)
 777                 return WLAN_MANAGER_ERR_NOSERVICE;
 778
 779
 780         wlan_mgr_req_data_t *req_data = g_new0(wlan_mgr_req_data_t, 1);
 781         req_data->req_type = WLAN_MANAGER_REQ_TYPE_CONNECT;
 782         wifi_manager_ap_clone(&(req_data->ap), ap);
 783
 784         ret = wlan_connect(req_data->ap, wlan_manager_network_event_cb,
 785                         req_data, WPS_NONE, NULL);
 786         if (ret != WIFI_MANAGER_ERROR_NONE) {
 787                 ERROR_LOG(UG_NAME_REQ, "Connect failed. Error Reason [%d]", ret);
 788
 789                 wifi_manager_ap_destroy(req_data->ap);
 790                 g_free(req_data);
 791         }
 792
 793         __COMMON_FUNC_EXIT__;
 794         return ret;
 795 }
 796
 797 int wlan_manager_connect_with_password(wifi_manager_ap_h ap, const char *pass_phrase)
 798 {
 799         __COMMON_FUNC_ENTER__;
 800
 801         int ret;
 802
 803         if (ap == NULL)
 804                 return WLAN_MANAGER_ERR_INVALID_PARAM;
 805
 806
 807         ret = wifi_manager_ap_set_passphrase(ap, pass_phrase);
 808         if (ret != WIFI_MANAGER_ERROR_NONE) {
 809                 __COMMON_FUNC_EXIT__;
 810                 return ret;
 811         }
 812
 813         wlan_mgr_req_data_t *req_data = g_new0(wlan_mgr_req_data_t, 1);
 814         req_data->req_type = WLAN_MANAGER_REQ_TYPE_CONNECT;
 815         wifi_manager_ap_clone(&(req_data->ap), ap);
 816
 817         ret = wlan_connect(req_data->ap, wlan_manager_network_event_cb,
 818                         req_data, WPS_NONE, NULL);
 819         if (ret != WIFI_MANAGER_ERROR_NONE) {
 820                 ERROR_LOG(UG_NAME_REQ, "Connect failed. Error Reason [%d]", ret);
 821
 822                 wifi_manager_ap_destroy(req_data->ap);
 823                 g_free(req_data);
 824         }
 825
 826         __COMMON_FUNC_EXIT__;
 827         return ret;
 828 }
 829
 830 int wlan_manager_disconnect(wifi_manager_ap_h ap)
 831 {
 832         __COMMON_FUNC_ENTER__;
 833         int ret;
 834
 835         INFO_LOG(UG_NAME_REQ, "Request disconnection for ap [%p]", ap);
 836
 837         ret = wlan_disconnect(ap, wlan_manager_disconnect_cb, NULL);
 838         if (WIFI_MANAGER_ERROR_NONE != ret) {
 839                 ERROR_LOG(UG_NAME_REQ, "Disconnect failed. Error Reason [%d]", ret);
 840
 841                 __COMMON_FUNC_EXIT__;
 842                 return WLAN_MANAGER_ERR_UNKNOWN;
 843         }
 844
 845         __COMMON_FUNC_EXIT__;
 846         return WLAN_MANAGER_ERR_NONE;
 847 }
 848
 849 int wlan_manager_foreach_found_ap(wifi_manager_found_ap_cb callback, int *profiles_list_size)
 850 {
 851         __COMMON_FUNC_ENTER__;
 852
 853         return wifi_manager_foreach_found_ap(manager_object->wifi, callback, profiles_list_size);
 854
 855         __COMMON_FUNC_EXIT__;
 856 }
 857
 858 int wlan_manager_scan(void)
 859 {
 860         __COMMON_FUNC_ENTER__;
 861
 862         wlan_mgr_req_data_t *req_data = g_new0(wlan_mgr_req_data_t, 1);
 863         req_data->req_type = WLAN_MANAGER_REQ_TYPE_SCAN;
 864
 865         manager_object->b_scan_blocked = TRUE;
 866         int ret = wifi_manager_scan(manager_object->wifi, wlan_manager_network_event_cb, req_data);
 867         if (ret != WLAN_MANAGER_ERR_NONE) {
 868                 ERROR_LOG(UG_NAME_REQ, "Scan failed. Ret: %d", ret);
 869
 870                 g_free(req_data);
 871
 872                 __COMMON_FUNC_EXIT__;
 873                 return ret;
 874         }
 875
 876         /* Since the scan request was success,
 877          * lets reset the ui refresh
 878          */
 879         manager_object->b_ui_refresh = FALSE;
 880
 881         __COMMON_FUNC_EXIT__;
 882         return ret;
 883 }
 884
 885 int wlan_manager_scan_with_ssid(const char *ssid, void *user_data)
 886 {
 887         __COMMON_FUNC_ENTER__;
 888
 889         int ret = wifi_manager_scan_specific_ap(manager_object->wifi,
 890                         ssid, wlan_manager_specific_scan_finished_cb, user_data);
 891         if (ret != WIFI_MANAGER_ERROR_NONE) {
 892                 ERROR_LOG(UG_NAME_REQ, "Specific Scan failed. Ret: %d", ret);
 893                 __COMMON_FUNC_EXIT__;
 894                 return WLAN_MANAGER_ERR_OPERATION_FAILED;
 895         }
 896
 897         /* Since the scan request was success,
 898          * lets reset the ui refresh and scan update blocked flags.
 899          */
 900         manager_object->b_scan_blocked = FALSE;
 901         manager_object->b_ui_refresh = FALSE;
 902
 903         __COMMON_FUNC_EXIT__;
 904         return ret;
 905 }
 906
 907 void wlan_manager_scanned_profile_refresh(void)
 908 {
 909         __COMMON_FUNC_ENTER__;
 910
 911         if (FALSE == manager_object->b_scan_blocked)
 912                 manager_object->refresh_func();
 913         else
 914                 manager_object->b_ui_refresh = TRUE;
 915
 916         __COMMON_FUNC_EXIT__;
 917 }
 918
 919 STRENGTH_TYPES wlan_manager_get_signal_strength(int rssi)
 920 {
 921         /* Wi-Fi Signal Strength Display (dB / ConnMan normalized value)
 922          *
 923          * Excellent :  -63 ~           / 57 ~
 924          * Good:                -74 ~ -64       / 46 ~ 56
 925          * Weak:                -82 ~ -75       / 38 ~ 45
 926          * Very weak:           ~ -83   /    ~ 37
 927          */
 928         if (rssi >= -63)
 929                 return SIGNAL_STRENGTH_TYPE_EXCELLENT;
 930         else if (rssi >= -74)
 931                 return SIGNAL_STRENGTH_TYPE_GOOD;
 932         else if (rssi >= -82)
 933                 return SIGNAL_STRENGTH_TYPE_WEAK;
 934         else
 935                 return SIGNAL_STRENGTH_TYPE_VERY_WEAK;
 936
 937 }
 938
 939 static gboolean _refresh_ui(void *data)
 940 {
 941         manager_object->refresh_func();
 942
 943         manager_object->b_scan_blocked = FALSE;
 944         manager_object->b_ui_refresh = FALSE;
 945
 946         return FALSE;
 947 }
 948
 949 void wlan_manager_enable_scan_result_update(void)
 950 {
 951         __COMMON_FUNC_ENTER__;
 952
 953         if (manager_object == NULL)
 954                 return;
 955
 956         if (TRUE == manager_object->b_scan_blocked) {
 957                 if (TRUE == manager_object->b_ui_refresh) {
 958                         DEBUG_LOG(COMMON_NAME_LIB, "Refresh the UI with last scan update");
 959
 960                         /* Delayed rendering in order to get smooth effect of popup close */
 961                         common_util_managed_idle_add(_refresh_ui, NULL);
 962                 } else {
 963                         manager_object->b_scan_blocked = FALSE;
 964                 }
 965         }
 966
 967         __COMMON_FUNC_EXIT__;
 968 }
 969
 970 void wlan_manager_disable_scan_result_update(void)
 971 {
 972         __COMMON_FUNC_ENTER__;
 973
 974         if (manager_object == NULL)
 975                 return;
 976
 977         manager_object->b_scan_blocked = TRUE;
 978
 979         __COMMON_FUNC_EXIT__;
 980 }
 981
 982 int wlan_manager_get_connection_state(wifi_manager_connection_state_e *state)
 983 {
 984         __COMMON_FUNC_ENTER__;
 985
 986         return wifi_manager_get_connection_state(manager_object->wifi, state);
 987
 988         __COMMON_FUNC_EXIT__;
 989 }
 990
 991 gboolean wlan_manager_is_same_network(wifi_manager_ap_h ap1, wifi_manager_ap_h ap2)
 992 {
 993         gboolean is_same = FALSE;
 994         char *ap1_ssid, *ap2_ssid;
 995         wifi_manager_security_type_e ap1_sec, ap2_sec;
 996
 997         if (!ap1 || !ap2)
 998                 return FALSE;
 999
1000
1001         wifi_manager_ap_get_security_type(ap1, &ap1_sec);
1002         wifi_manager_ap_get_security_type(ap2, &ap2_sec);
1003
1004         if (ap1_sec != ap2_sec)
1005                 return is_same;
1006
1007
1008         wifi_manager_ap_get_essid(ap1, &ap1_ssid);
1009         wifi_manager_ap_get_essid(ap2, &ap2_ssid);
1010
1011         if (g_strcmp0(ap1_ssid, ap2_ssid) == 0)
1012                 is_same = TRUE;
1013
1014
1015         g_free(ap1_ssid);
1016         g_free(ap2_ssid);
1017
1018         return is_same;
1019 }
1020
1021 void wlan_validate_alt_connection(void)
1022 {
1023         wifi_manager_connection_state_e state = WIFI_MANAGER_CONNECTION_STATE_DISCONNECTED;
1024
1025
1026         int ret = wlan_manager_get_connection_state(&state);
1027         if (ret != WIFI_MANAGER_ERROR_NONE)
1028                 INFO_LOG(UG_NAME_ERR, "Failed to get wifi connection state [%d]", ret);
1029
1030
1031         switch (state) {
1032         case WIFI_MANAGER_CONNECTION_STATE_FAILURE:
1033         case WIFI_MANAGER_CONNECTION_STATE_CONNECTED:
1034         case WIFI_MANAGER_CONNECTION_STATE_DISCONNECTED:
1035                 wlan_connect_next(manager_object->wifi);
1036                 break;
1037
1038         case WIFI_MANAGER_CONNECTION_STATE_ASSOCIATION:
1039         case WIFI_MANAGER_CONNECTION_STATE_CONFIGURATION:
1040                 wlan_go_fast_next(manager_object->wifi);
1041                 break;
1042         default:
1043                 break;
1044         }
1045 }
1046
1047 int wlan_manager_set_autoscan_mode(wlan_manager_autoscan_mode_e mode)
1048 {
1049         int ret = wifi_manager_set_autoscan_mode(manager_object->wifi, mode);
1050         if (ret == WIFI_MANAGER_ERROR_NONE)
1051                 return WLAN_MANAGER_ERR_NONE;
1052         else
1053                 return WLAN_MANAGER_ERR_OPERATION_FAILED;
1054 }