sources/wearable/src/net/wifi_manager.c

   1 /*
   2  * Copyright (c) 2014 - 2015 Samsung Electronics Co., Ltd All Rights Reserved
   3  *
   4  * PROPRIETARY/CONFIDENTIAL
   5  *
   6  * This software is the confidential and proprietary information of
   7  * SAMSUNG ELECTRONICS (Confidential Information).
   8  * You shall not disclose such Confidential Information and shall
   9  * use it only in accordance with the terms of the license agreement
  10  * you entered into with SAMSUNG ELECTRONICS.  SAMSUNG make no
  11  * representations or warranties about the suitability
  12  * of the software, either express or implied, including but not
  13  * limited to the implied warranties of merchantability, fitness for a particular purpose, or non-
  14  * infringement. SAMSUNG shall not be liable for any damages suffered by licensee as
  15  * a result of using, modifying or distributing this software or its derivatives.
  16  */
  17
  18
  19 #include <dlog.h>
  20 #include <glib.h>
  21
  22 #include "util.h"
  23 #include "net/util/vconf_helper.h"
  24 #include "net/wifi_manager.h"
  25
  26 typedef enum {
  27         WIFI_MANAGER_CB_DEVICE_STATE_CHANGED,
  28         WIFI_MANAGER_CB_CONNECTION_STATE_CHANGED,
  29         WIFI_MANAGER_CB_BACKGROUND_SCAN
  30 } wifi_manager_cb_type;
  31
  32 struct _wifi_manager_object {
  33         GList *cb_data_list;
  34         GList *config_list;
  35 };
  36
  37 struct _wifi_ap_object {
  38         wifi_ap_h ap;
  39         gint rssi;
  40         bool wps_mode;
  41
  42         wifi_error_e last_connection_error;
  43         gboolean is_captiveportal;
  44 };
  45
  46 typedef struct _wifi_config_object {
  47         wifi_config_h handle;
  48         gchar *name;
  49         gchar *passphrase;
  50         wifi_security_type_e security_type;
  51         wifi_error_e last_error;
  52 } wifi_config_object;
  53
  54 typedef struct {
  55         wifi_manager_object *manager;
  56         wifi_ap_object *ap;
  57         wifi_manager_cb_type type;
  58         wifi_manager_generic_cb cb;
  59         wifi_manager_generic_state_changed_cb state_changed_cb;
  60         gpointer user_data;
  61 } wifi_manager_cb_data;
  62
  63 static wifi_manager_object *_last_initailized_wifi_manager;
  64
  65 static void            _update_wifi_config_list(wifi_manager_object *manager);
  66 static wifi_ap_object *_create_ap_object_by_ap_h(wifi_ap_h ap);
  67
  68 static void __wifi_common_cb(wifi_error_e error_code, gpointer user_data)
  69 {
  70         wifi_manager_cb_data *cb_data = (wifi_manager_cb_data *)user_data;
  71         WIFI_RET_IF_FAIL(cb_data);
  72
  73     WIFI_LOG_INFO("common cb");
  74
  75         if (cb_data->cb)
  76                 cb_data->cb(cb_data->manager, cb_data->ap, error_code, cb_data->user_data);
  77
  78         g_free(cb_data);
  79 }
  80
  81 static void __wifi_background_scan_cb(wifi_error_e error_code, gpointer user_data)
  82 {
  83         wifi_manager_cb_data *cb_data = (wifi_manager_cb_data *)user_data;
  84         WIFI_RET_IF_FAIL(cb_data != NULL);
  85
  86         if (cb_data->cb)
  87                 cb_data->cb(cb_data->manager, cb_data->ap, error_code, cb_data->user_data);
  88 }
  89
  90 static void __wifi_device_state_changed_cb(wifi_device_state_e state, void *user_data)
  91 {
  92         wifi_manager_cb_data *cb_data = (wifi_manager_cb_data *)user_data;
  93         WIFI_RET_IF_FAIL(cb_data);
  94
  95         if (state == WIFI_DEVICE_STATE_ACTIVATED) {
  96                 _update_wifi_config_list(cb_data->manager);
  97         }
  98
  99         if (cb_data->state_changed_cb)
 100                 cb_data->state_changed_cb(cb_data->manager,
 101                                           state,
 102                                           WIFI_CONNECTION_STATE_FAILURE, NULL,
 103                                           WIFI_RSSI_LEVEL_0, cb_data->user_data);
 104 }
 105
 106 static void __wifi_connection_state_changed_cb(wifi_connection_state_e state,
 107                                                wifi_ap_h ap, void *user_data)
 108 {
 109         wifi_manager_cb_data *cb_data = (wifi_manager_cb_data *)user_data;
 110         WIFI_RET_IF_FAIL(cb_data);
 111
 112         if (state == WIFI_CONNECTION_STATE_CONNECTED ||
 113             state == WIFI_CONNECTION_STATE_DISCONNECTED ||
 114             state == WIFI_CONNECTION_STATE_FAILURE) {
 115                 _update_wifi_config_list(cb_data->manager);
 116         }
 117
 118         if (cb_data->state_changed_cb) {
 119                 wifi_ap_object *ap_obj = _create_ap_object_by_ap_h(ap);
 120                 cb_data->state_changed_cb(cb_data->manager,
 121                                           WIFI_DEVICE_STATE_DEACTIVATED,
 122                                           state, ap_obj,
 123                                           WIFI_RSSI_LEVEL_0, cb_data->user_data);
 124                 wifi_manager_ap_destroy(ap_obj);
 125         }
 126 }
 127
 128 bool __wifi_config_list_cb(const wifi_config_h config, void *user_data)
 129 {
 130
 131     __WIFI_FUNC_ENTER__;
 132         wifi_manager_object *manager = user_data;
 133         wifi_config_object *config_obj;
 134         WIFI_RET_VAL_IF_FAIL(config != NULL, true);
 135         WIFI_RET_VAL_IF_FAIL(manager != NULL, true);
 136
 137         config_obj = g_new0(wifi_config_object, 1);
 138         WIFI_RET_VAL_IF_FAIL(config_obj != NULL, true);
 139
 140         wifi_config_clone(config, &(config_obj->handle));
 141         wifi_config_get_name(config, &(config_obj->name));
 142         wifi_config_get_security_type(config, &(config_obj->security_type));
 143         manager->config_list = g_list_append(manager->config_list, config_obj);
 144
 145     __WIFI_FUNC_EXIT__;
 146         return true;
 147 }
 148
 149 static void _wifi_config_destory(gpointer data)
 150 {
 151         wifi_config_object *config = data;
 152         if (config->handle) {
 153                 wifi_config_destroy(config->handle);
 154         }
 155         if (config->name) {
 156                 g_free(config->name);
 157         }
 158         if (config->passphrase) {
 159                 g_free(config->passphrase);
 160         }
 161         g_free(config);
 162 }
 163
 164 static void _clear_wifi_config_list(wifi_manager_object *manager)
 165 {
 166
 167     __WIFI_FUNC_ENTER__;
 168         WIFI_RET_IF_FAIL(manager != NULL);
 169         WIFI_RET_IF_FAIL(manager->config_list != NULL);
 170
 171         g_list_free_full(manager->config_list, _wifi_config_destory);
 172         manager->config_list = NULL;
 173
 174     __WIFI_FUNC_EXIT__;
 175 }
 176
 177 static void _update_wifi_config_list(wifi_manager_object *manager)
 178 {
 179         wifi_error_e err;
 180         WIFI_RET_IF_FAIL(manager);
 181
 182         __WIFI_FUNC_ENTER__;
 183
 184         if (manager->config_list) {
 185                 _clear_wifi_config_list(manager);
 186         }
 187
 188         err = wifi_config_foreach_configuration(__wifi_config_list_cb, manager);
 189         if (err != WIFI_ERROR_NONE) {
 190                 WIFI_LOG_ERR("wifi_config_foreach_configuration() is failed. error = %s",
 191                              wifi_error_to_string(err));
 192         }
 193
 194     __WIFI_FUNC_EXIT__;
 195 }
 196
 197 static wifi_config_object *_find_wifi_config_by_wifi_ap(wifi_manager_object *manager,
 198                                                         wifi_ap_object *ap)
 199 {
 200         GList *config_list;
 201         gchar *ssid;
 202         wifi_security_type_e sec_type;
 203         WIFI_RET_VAL_IF_FAIL(manager, NULL);
 204         WIFI_RET_VAL_IF_FAIL(ap, NULL);
 205
 206         ssid = wifi_manager_ap_get_ssid(ap);
 207         WIFI_RET_VAL_IF_FAIL(ssid, NULL);
 208         sec_type = wifi_manager_ap_get_security_type(ap);
 209
 210         config_list = manager->config_list;
 211         while (config_list) {
 212                 wifi_config_object *config = config_list->data;
 213                 if (!g_strcmp0(config->name, ssid) && (config->security_type == sec_type)) {
 214                         g_free(ssid);
 215                         return config;
 216                 }
 217                 config_list = config_list->next;
 218         }
 219         g_free(ssid);
 220         return NULL;
 221 }
 222
 223 static wifi_ap_object *_create_ap_object_by_ap_h(wifi_ap_h ap)
 224 {
 225         wifi_ap_object *ap_obj = g_new0(wifi_ap_object, 1);
 226         gboolean is_create_failed = FALSE;
 227         if (!ap_obj) {
 228                 return NULL;
 229         }
 230         if (WIFI_ERROR_NONE != wifi_ap_clone(&(ap_obj->ap), ap)) {
 231                 is_create_failed = TRUE;
 232         } else if (WIFI_ERROR_NONE != wifi_ap_get_rssi(ap, &(ap_obj->rssi))) {
 233                 is_create_failed = TRUE;
 234         } else if (WIFI_ERROR_NONE != wifi_ap_is_wps_supported(ap, &(ap_obj->wps_mode))) {
 235                 is_create_failed = TRUE;
 236         }
 237
 238         if (is_create_failed) {
 239                 wifi_manager_ap_destroy(ap_obj);
 240                 return NULL;
 241         }
 242         ap_obj->last_connection_error = WIFI_ERROR_NONE;
 243         ap_obj->is_captiveportal = FALSE;
 244         return ap_obj;
 245 }
 246
 247 gint wifi_manager_default_compare_ap(gconstpointer a, gconstpointer b)
 248 {
 249         wifi_ap_object *ap_obj1 = (wifi_ap_object *)a;
 250         wifi_ap_object *ap_obj2 = (wifi_ap_object *)b;
 251         wifi_connection_state_e state1 = WIFI_CONNECTION_STATE_DISCONNECTED;
 252         wifi_connection_state_e state2 = WIFI_CONNECTION_STATE_DISCONNECTED;
 253         bool favorite1 = false;
 254         bool favorite2 = false;
 255
 256         wifi_ap_get_connection_state(ap_obj1->ap, &state1);
 257         wifi_ap_get_connection_state(ap_obj2->ap, &state2);
 258         if (state1 != state2) {
 259                 if (state1 == WIFI_CONNECTION_STATE_CONNECTED)
 260                         return -1;
 261                 if (state2 == WIFI_CONNECTION_STATE_CONNECTED)
 262                         return 1;
 263
 264                 if (state1 == WIFI_CONNECTION_STATE_CONFIGURATION)
 265                         return -1;
 266                 if (state2 == WIFI_CONNECTION_STATE_CONFIGURATION)
 267                         return 1;
 268
 269                 if (state1 == WIFI_CONNECTION_STATE_ASSOCIATION)
 270                         return -1;
 271                 if (state2 == WIFI_CONNECTION_STATE_ASSOCIATION)
 272                         return 1;
 273         }
 274
 275         favorite1 = wifi_manager_ap_is_favorite(
 276                 _last_initailized_wifi_manager, ap_obj1);
 277         favorite2 = wifi_manager_ap_is_favorite(
 278                 _last_initailized_wifi_manager, ap_obj2);
 279         if (favorite1 != favorite2) {
 280                 if (favorite1)
 281                         return -1;
 282                 if (favorite2)
 283                         return 1;
 284         }
 285
 286         /* Alphabetical order */
 287         /*
 288         return strcasecmp((const char *) wifi_device1->ssid,
 289                         (const char *) wifi_device2->ssid);
 290         */
 291         /* RSSI preferred */
 292         return((ap_obj1->rssi >= ap_obj2->rssi) ? -1 : 1);
 293 }
 294
 295 #ifdef TIZEN_TELEPHONY_ENABLE
 296 static bool __update_ap_list_foreach(wifi_ap_h ap, void *user_data)
 297 {
 298         GList **ap_list = user_data;
 299         wifi_ap_object *ap_obj = NULL;
 300         WIFI_RET_VAL_IF_FAIL(ap_list, true);
 301
 302         ap_obj = _create_ap_object_by_ap_h(ap);
 303         WIFI_RET_VAL_IF_FAIL(ap_obj, true);
 304
 305         *ap_list = g_list_insert_sorted(*ap_list, ap_obj, wifi_manager_default_compare_ap);
 306         return true;
 307 }
 308 #else
 309 // Find AP list except EAP type when WC1-S Bluetooth model(No SIM).
 310 static bool __update_ap_list_foreach(wifi_ap_h ap, void *user_data)
 311 {
 312         GList **ap_list = user_data;
 313         wifi_security_type_e sec_type = WIFI_SECURITY_TYPE_NONE;
 314         wifi_error_e err;
 315         wifi_ap_object *ap_obj = NULL;
 316         WIFI_RET_VAL_IF_FAIL(ap_list != NULL, true);
 317
 318         err = wifi_ap_get_security_type(ap, &sec_type);
 319         WIFI_RET_VAL_IF_FAIL(err == WIFI_ERROR_NONE, true);
 320         if (sec_type == WIFI_SECURITY_TYPE_EAP) {
 321                 WIFI_LOG_INFO("EAP type AP skip(No SIM model).");
 322                 return true;
 323         }
 324
 325         ap_obj = _create_ap_object_by_ap_h(ap);
 326         WIFI_RET_VAL_IF_FAIL(ap_obj != NULL, true);
 327
 328         *ap_list = g_list_insert_sorted(*ap_list, ap_obj, wifi_manager_default_compare_ap);
 329         return true;
 330 }
 331 #endif
 332
 333 static void _delete_cb_data_by_type(wifi_manager_object *manager, wifi_manager_cb_type type)
 334 {
 335         GList *cb_data_list = manager->cb_data_list;
 336         while (cb_data_list) {
 337                 GList *next = cb_data_list->next;
 338                 wifi_manager_cb_data *cb_data = cb_data_list->data;
 339                 if (cb_data->type == type) {
 340                         manager->cb_data_list =
 341                                 g_list_delete_link(manager->cb_data_list, cb_data_list);
 342                         g_free(cb_data);
 343                 }
 344                 cb_data_list = next;
 345         }
 346 }
 347
 348 static gchar *_ap_get_proxy_address(wifi_ap_object *ap_obj)
 349 {
 350         gchar *proxy_address = NULL;
 351         wifi_error_e err;
 352         WIFI_RET_VAL_IF_FAIL(ap_obj != NULL, NULL);
 353
 354         err = wifi_ap_get_proxy_address(ap_obj->ap,
 355                                         WIFI_ADDRESS_FAMILY_IPV4, &proxy_address);
 356         if (err != WIFI_ERROR_NONE) {
 357                 WIFI_LOG_ERR("wifi_ap_get_proxy_address() is failed. error = %s",
 358                              wifi_error_to_string(err));
 359                 if (proxy_address) {
 360                         g_free(proxy_address);
 361                 }
 362                 return NULL;
 363         }
 364         if (!proxy_address || strlen(proxy_address) == 0) {
 365                 WIFI_LOG_INFO("proxy_address is NULL.");
 366                 if (proxy_address) {
 367                         g_free(proxy_address);
 368                 }
 369                 return NULL;
 370         }
 371         return proxy_address;
 372 }
 373
 374 /*
 375  * Wi-Fi Manager API
 376  */
 377 wifi_manager_object *wifi_manager_new()
 378 {
 379         return g_new0(wifi_manager_object, 1);
 380 }
 381
 382 void wifi_manager_free(wifi_manager_object *manager)
 383 {
 384         if (manager)
 385                 g_free(manager);
 386 }
 387
 388 wifi_error_e wifi_manager_init(wifi_manager_object *manager)
 389 {
 390         wifi_error_e err;
 391         bool is_activate;
 392         WIFI_RET_VAL_IF_FAIL(manager, WIFI_ERROR_INVALID_PARAMETER);
 393
 394         err = wifi_initialize();
 395         if (err != WIFI_ERROR_NONE) {
 396                 return err;
 397         }
 398         err = wifi_manager_is_activated(manager, &is_activate);
 399         if (err == WIFI_ERROR_NONE) {
 400                 if (is_activate) {
 401                         _update_wifi_config_list(manager);
 402                 }
 403         } else {
 404                 WIFI_LOG_ERR("wifi_manager_is_activated() is failed. error = %s",
 405                              wifi_error_to_string(err));
 406         }
 407         _last_initailized_wifi_manager = manager;
 408         return err;
 409 }
 410
 411 wifi_error_e wifi_manager_deinit(wifi_manager_object *manager)
 412 {
 413         WIFI_RET_VAL_IF_FAIL(manager, WIFI_ERROR_INVALID_PARAMETER);
 414
 415         _clear_wifi_config_list(manager);
 416         if (manager->cb_data_list) {
 417                 GList *cb_data_list = manager->cb_data_list;
 418                 while (cb_data_list) {
 419                         wifi_manager_cb_data *cb_data = cb_data_list->data;
 420                         if (cb_data->type == WIFI_MANAGER_CB_DEVICE_STATE_CHANGED) {
 421                                 wifi_unset_device_state_changed_cb();
 422                         } else if (cb_data->type == WIFI_MANAGER_CB_CONNECTION_STATE_CHANGED) {
 423                                 wifi_unset_connection_state_changed_cb();
 424                         } else if (cb_data->type == WIFI_MANAGER_CB_BACKGROUND_SCAN) {
 425                                 wifi_unset_background_scan_cb();
 426                         }
 427
 428                         cb_data_list = cb_data_list->next;
 429                 }
 430                 g_list_free_full(manager->cb_data_list, g_free);
 431         }
 432         return wifi_deinitialize();
 433 }
 434
 435 wifi_manager_object *wifi_manager_new_with_init(wifi_error_e *error)
 436 {
 437         wifi_manager_object *manager = wifi_manager_new();
 438         *error = WIFI_ERROR_NONE;
 439         if (manager) {
 440                 *error = wifi_manager_init(manager);
 441                 if (*error != WIFI_ERROR_NONE) {
 442                         wifi_manager_free(manager);
 443                 }
 444         } else
 445                 *error = WIFI_ERROR_OUT_OF_MEMORY;
 446         return manager;
 447 }
 448
 449 wifi_error_e wifi_manager_free_with_deinit(wifi_manager_object *manager)
 450 {
 451         wifi_error_e error = wifi_manager_deinit(manager);
 452         wifi_manager_free(manager);
 453         return error;
 454 }
 455
 456 wifi_error_e wifi_manager_get_csccode(wifi_manager_object *manager, wifi_manager_csccode *code)
 457 {
 458         WIFI_RET_VAL_IF_FAIL(manager != NULL, WIFI_ERROR_INVALID_PARAMETER);
 459         WIFI_RET_VAL_IF_FAIL(code != NULL, WIFI_ERROR_INVALID_PARAMETER);
 460
 461         *code = WIFI_MANAGER_CSC_UNKNOWN;
 462 #ifdef TIZEN_TELEPHONY_ENABLE
 463         if (vconf_is_skt()) {
 464                 *code = WIFI_MANAGER_CSC_SKT;
 465         }
 466 #endif
 467         return WIFI_ERROR_NONE;
 468 }
 469
 470 wifi_error_e wifi_manager_scan(wifi_manager_object *manager,
 471                                wifi_manager_generic_cb callback, gpointer user_data)
 472 {
 473         wifi_manager_cb_data *cb_data = NULL;
 474         WIFI_RET_VAL_IF_FAIL(manager != NULL, WIFI_ERROR_INVALID_PARAMETER);
 475
 476         cb_data = g_new0(wifi_manager_cb_data, 1);
 477         if (cb_data) {
 478                 cb_data->manager = manager;
 479                 cb_data->cb = callback;
 480                 cb_data->user_data = user_data;
 481
 482                 WIFI_LOG_INFO("Wi-Fi Scan start.");
 483                 return wifi_scan(__wifi_common_cb, cb_data);
 484         }
 485         return WIFI_ERROR_OUT_OF_MEMORY;
 486 }
 487
 488 wifi_error_e wifi_manager_get_found_ap_list(wifi_manager_object *manager,
 489                                             GList **ap_list)
 490 {
 491         wifi_error_e error = WIFI_ERROR_INVALID_PARAMETER;
 492         WIFI_RET_VAL_IF_FAIL(manager, WIFI_ERROR_INVALID_PARAMETER);
 493
 494         error = wifi_foreach_found_aps(__update_ap_list_foreach, ap_list);
 495         if (error != WIFI_ERROR_NONE) {
 496                 if (*ap_list) {
 497                         g_list_free(*ap_list);
 498                         *ap_list = NULL;
 499                 }
 500         }
 501         return error;
 502 }
 503
 504 wifi_error_e wifi_manager_activate(wifi_manager_object *manager,
 505                                    wifi_manager_generic_cb callback, gpointer user_data)
 506 {
 507         wifi_manager_cb_data *cb_data = NULL;
 508         WIFI_RET_VAL_IF_FAIL(manager, WIFI_ERROR_INVALID_PARAMETER);
 509
 510     WIFI_LOG_ERR("+");
 511
 512         cb_data = g_new0(wifi_manager_cb_data, 1);
 513         if (cb_data) {
 514                 cb_data->manager = manager;
 515                 cb_data->cb = callback;
 516                 cb_data->user_data = user_data;
 517                 return wifi_activate(__wifi_common_cb, cb_data);
 518         }
 519         return WIFI_ERROR_OUT_OF_MEMORY;
 520 }
 521
 522 wifi_error_e wifi_manager_deactivate(wifi_manager_object *manager,
 523                     wifi_manager_generic_cb callback, gpointer user_data)
 524 {
 525         wifi_manager_cb_data *cb_data = NULL;
 526         WIFI_RET_VAL_IF_FAIL(manager, WIFI_ERROR_INVALID_PARAMETER);
 527
 528     WIFI_LOG_ERR("+");
 529
 530         cb_data = g_new0(wifi_manager_cb_data, 1);
 531         if (cb_data) {
 532                 cb_data->manager = manager;
 533                 cb_data->cb = callback;
 534                 cb_data->user_data = user_data;
 535                 return wifi_deactivate(__wifi_common_cb, cb_data);
 536         }
 537         return WIFI_ERROR_OUT_OF_MEMORY;
 538 }
 539
 540 wifi_error_e wifi_manager_is_activated(wifi_manager_object *manager, bool *activated)
 541 {
 542         WIFI_RET_VAL_IF_FAIL(manager, WIFI_ERROR_INVALID_PARAMETER);
 543         return wifi_is_activated(activated);
 544 }
 545
 546 wifi_error_e wifi_manager_set_device_state_changed_cb(wifi_manager_object *manager,
 547                                                       wifi_manager_generic_state_changed_cb callback, void *user_data)
 548 {
 549         wifi_manager_cb_data *cb_data = NULL;
 550         wifi_error_e err = WIFI_ERROR_INVALID_PARAMETER;
 551         WIFI_RET_VAL_IF_FAIL(manager, WIFI_ERROR_INVALID_PARAMETER);
 552
 553         cb_data = g_new0(wifi_manager_cb_data, 1);
 554         WIFI_RET_VAL_IF_FAIL(cb_data, WIFI_ERROR_OUT_OF_MEMORY);
 555
 556         cb_data->manager = manager;
 557         cb_data->type = WIFI_MANAGER_CB_DEVICE_STATE_CHANGED;
 558         cb_data->state_changed_cb = callback;
 559         cb_data->user_data = user_data;
 560         err = wifi_set_device_state_changed_cb(
 561                 __wifi_device_state_changed_cb, cb_data);
 562         if (err == WIFI_ERROR_NONE)
 563                 manager->cb_data_list = g_list_append(manager->cb_data_list, cb_data);
 564         return err;
 565 }
 566
 567 wifi_error_e wifi_manager_unset_device_state_changed_cb(wifi_manager_object *manager)
 568 {
 569         wifi_error_e err = WIFI_ERROR_INVALID_PARAMETER;
 570         WIFI_RET_VAL_IF_FAIL(manager, WIFI_ERROR_INVALID_PARAMETER);
 571
 572         err = wifi_unset_device_state_changed_cb();
 573         _delete_cb_data_by_type(manager, WIFI_MANAGER_CB_DEVICE_STATE_CHANGED);
 574         return err;
 575 }
 576
 577 wifi_error_e wifi_manager_set_background_scan_cb(wifi_manager_object *manager,
 578                                                  wifi_manager_generic_cb callback, void *user_data)
 579 {
 580         wifi_manager_cb_data *cb_data = NULL;
 581         wifi_error_e err = WIFI_ERROR_INVALID_PARAMETER;
 582         WIFI_RET_VAL_IF_FAIL(manager != NULL, WIFI_ERROR_INVALID_PARAMETER);
 583
 584         cb_data = g_new0(wifi_manager_cb_data, 1);
 585         WIFI_RET_VAL_IF_FAIL(cb_data != NULL, WIFI_ERROR_OUT_OF_MEMORY);
 586
 587         cb_data->manager = manager;
 588         cb_data->type = WIFI_MANAGER_CB_BACKGROUND_SCAN;
 589         cb_data->cb = callback;
 590         cb_data->user_data = user_data;
 591         err = wifi_set_background_scan_cb(__wifi_background_scan_cb, cb_data);
 592         if (err == WIFI_ERROR_NONE)
 593                 manager->cb_data_list = g_list_append(manager->cb_data_list, cb_data);
 594         return err;
 595 }
 596
 597 wifi_error_e wifi_manager_unset_background_scan_cb(wifi_manager_object *manager)
 598 {
 599         wifi_error_e err = WIFI_ERROR_INVALID_PARAMETER;
 600         WIFI_RET_VAL_IF_FAIL(manager, WIFI_ERROR_INVALID_PARAMETER);
 601
 602         err = wifi_unset_background_scan_cb();
 603         _delete_cb_data_by_type(manager, WIFI_MANAGER_CB_BACKGROUND_SCAN);
 604         return err;
 605 }
 606
 607 wifi_error_e wifi_manager_set_connection_state_changed_cb(wifi_manager_object *manager,
 608                                                           wifi_manager_generic_state_changed_cb callback, void *user_data)
 609 {
 610         wifi_manager_cb_data *cb_data = NULL;
 611         wifi_error_e err = WIFI_ERROR_INVALID_PARAMETER;
 612         WIFI_RET_VAL_IF_FAIL(manager, WIFI_ERROR_INVALID_PARAMETER);
 613
 614         cb_data = g_new0(wifi_manager_cb_data, 1);
 615         WIFI_RET_VAL_IF_FAIL(cb_data, WIFI_ERROR_OUT_OF_MEMORY);
 616
 617         cb_data->manager = manager;
 618         cb_data->type = WIFI_MANAGER_CB_CONNECTION_STATE_CHANGED;
 619         cb_data->state_changed_cb = callback;
 620         cb_data->user_data = user_data;
 621         err = wifi_set_connection_state_changed_cb(
 622                 __wifi_connection_state_changed_cb, cb_data);
 623         if (err == WIFI_ERROR_NONE)
 624                 manager->cb_data_list = g_list_append(manager->cb_data_list, cb_data);
 625         return err;
 626 }
 627
 628 wifi_error_e wifi_manager_unset_connection_state_changed_cb(wifi_manager_object *manager)
 629 {
 630         wifi_error_e err = WIFI_ERROR_INVALID_PARAMETER;
 631         WIFI_RET_VAL_IF_FAIL(manager, WIFI_ERROR_INVALID_PARAMETER);
 632
 633         err = wifi_unset_connection_state_changed_cb();
 634         _delete_cb_data_by_type(manager, WIFI_MANAGER_CB_CONNECTION_STATE_CHANGED);
 635         return err;
 636 }
 637
 638 wifi_error_e wifi_manager_get_connection_state(wifi_manager_object *manager,
 639                                                wifi_connection_state_e *connection_state)
 640 {
 641         WIFI_RET_VAL_IF_FAIL(manager, WIFI_ERROR_INVALID_PARAMETER);
 642         return wifi_get_connection_state(connection_state);
 643 }
 644
 645 wifi_error_e wifi_manager_connect(wifi_manager_object *manager,
 646                                   wifi_ap_object *ap, wifi_manager_generic_cb callback, gpointer user_data)
 647 {
 648         wifi_manager_cb_data *cb_data = NULL;
 649         WIFI_RET_VAL_IF_FAIL(manager, WIFI_ERROR_INVALID_PARAMETER);
 650         WIFI_RET_VAL_IF_FAIL(ap, WIFI_ERROR_INVALID_PARAMETER);
 651
 652         cb_data = g_new0(wifi_manager_cb_data, 1);
 653         if (cb_data) {
 654                 cb_data->manager = manager;
 655                 cb_data->ap = ap;
 656                 cb_data->cb = callback;
 657                 cb_data->user_data = user_data;
 658                 return wifi_connect(ap->ap, __wifi_common_cb, cb_data);
 659         }
 660         return WIFI_ERROR_OUT_OF_MEMORY;
 661 }
 662
 663 wifi_error_e wifi_manager_connect_by_wps_pbc(wifi_manager_object *manager,
 664                                              wifi_ap_object *ap, wifi_manager_generic_cb callback, gpointer user_data)
 665 {
 666         wifi_manager_cb_data *cb_data = NULL;
 667         WIFI_RET_VAL_IF_FAIL(manager, WIFI_ERROR_INVALID_PARAMETER);
 668         WIFI_RET_VAL_IF_FAIL(ap, WIFI_ERROR_INVALID_PARAMETER);
 669
 670         cb_data = g_new0(wifi_manager_cb_data, 1);
 671         if (cb_data) {
 672                 cb_data->manager = manager;
 673                 cb_data->ap = ap;
 674                 cb_data->cb = callback;
 675                 cb_data->user_data = user_data;
 676                 return wifi_connect_by_wps_pbc(ap->ap, __wifi_common_cb, cb_data);
 677         }
 678         return WIFI_ERROR_OUT_OF_MEMORY;
 679 }
 680
 681 wifi_error_e wifi_manager_connect_by_wps_pin(wifi_manager_object *manager,
 682                                              wifi_ap_object *ap, const gchar *pin,
 683                                              wifi_manager_generic_cb callback, gpointer user_data)
 684 {
 685         wifi_manager_cb_data *cb_data = NULL;
 686         WIFI_RET_VAL_IF_FAIL(manager, WIFI_ERROR_INVALID_PARAMETER);
 687         WIFI_RET_VAL_IF_FAIL(ap, WIFI_ERROR_INVALID_PARAMETER);
 688
 689         cb_data = g_new0(wifi_manager_cb_data, 1);
 690         if (cb_data) {
 691                 cb_data->manager = manager;
 692                 cb_data->ap = ap;
 693                 cb_data->cb = callback;
 694                 cb_data->user_data = user_data;
 695                 return wifi_connect_by_wps_pin(ap->ap, pin, __wifi_common_cb, cb_data);
 696         }
 697         return WIFI_ERROR_OUT_OF_MEMORY;
 698 }
 699
 700 wifi_error_e wifi_manager_disconnect(wifi_manager_object *manager,
 701                                      wifi_ap_object *ap, wifi_manager_generic_cb callback, gpointer user_data)
 702 {
 703         wifi_manager_cb_data *cb_data = NULL;
 704         WIFI_RET_VAL_IF_FAIL(manager, WIFI_ERROR_INVALID_PARAMETER);
 705         WIFI_RET_VAL_IF_FAIL(ap, WIFI_ERROR_INVALID_PARAMETER);
 706
 707         cb_data = g_new0(wifi_manager_cb_data, 1);
 708         if (cb_data) {
 709                 cb_data->manager = manager;
 710                 cb_data->ap = ap;
 711                 cb_data->cb = callback;
 712                 cb_data->user_data = user_data;
 713                 return wifi_disconnect(ap->ap, __wifi_common_cb, cb_data);
 714         }
 715         return WIFI_ERROR_OUT_OF_MEMORY;
 716 }
 717
 718 wifi_error_e wifi_manager_get_connected_ap(wifi_manager_object *manager,
 719                                            wifi_ap_object **ap)
 720 {
 721         wifi_ap_h ap_h = NULL;
 722         wifi_error_e err = WIFI_ERROR_INVALID_PARAMETER;
 723         WIFI_RET_VAL_IF_FAIL(manager, WIFI_ERROR_INVALID_PARAMETER);
 724
 725         err = wifi_get_connected_ap(&ap_h);
 726         if (err != WIFI_ERROR_NONE) {
 727                 if (ap_h) {
 728                         wifi_ap_destroy(ap_h);
 729                 }
 730                 return err;
 731         }
 732         *ap = _create_ap_object_by_ap_h(ap_h);
 733         wifi_ap_destroy(ap_h);
 734         if (!(*ap))
 735                 return WIFI_ERROR_OUT_OF_MEMORY;
 736         return WIFI_ERROR_NONE;
 737 }
 738
 739 /*
 740  * Wi-Fi AP API
 741  */
 742 wifi_ap_object *wifi_manager_ap_clone(wifi_ap_object *ap_obj)
 743 {
 744         WIFI_RET_VAL_IF_FAIL(ap_obj != NULL, NULL);
 745
 746         return _create_ap_object_by_ap_h(ap_obj->ap);
 747 }
 748
 749 void wifi_manager_ap_destroy(wifi_ap_object *ap_obj)
 750 {
 751         WIFI_RET_IF_FAIL(ap_obj != NULL);
 752
 753         wifi_ap_destroy(ap_obj->ap);
 754         g_free(ap_obj);
 755 }
 756
 757 gboolean wifi_manager_ap_is_equals(wifi_ap_object *ap_obj1, wifi_ap_object *ap_obj2)
 758 {
 759         gchar *ssid1, *ssid2;
 760         wifi_security_type_e sec_type1, sec_type2;
 761         gboolean is_equals = FALSE;
 762         WIFI_RET_VAL_IF_FAIL(ap_obj1 != NULL, FALSE);
 763         WIFI_RET_VAL_IF_FAIL(ap_obj2 != NULL, FALSE);
 764
 765         ssid1 = wifi_manager_ap_get_ssid(ap_obj1);
 766         ssid2 = wifi_manager_ap_get_ssid(ap_obj2);
 767
 768         sec_type1 = wifi_manager_ap_get_security_type(ap_obj1);
 769         sec_type2 = wifi_manager_ap_get_security_type(ap_obj2);
 770
 771         is_equals = (!g_strcmp0(ssid1, ssid2)) && (sec_type1 == sec_type2);
 772
 773         g_free(ssid1);
 774         g_free(ssid2);
 775
 776         return is_equals;
 777 }
 778
 779 void wifi_manager_ap_refresh(wifi_ap_object *ap_obj)
 780 {
 781         WIFI_RET_IF_FAIL(ap_obj);
 782
 783         wifi_error_e err = wifi_ap_refresh(ap_obj->ap);
 784         if (err != WIFI_ERROR_NONE) {
 785                 WIFI_LOG_ERR("wifi_ap_refresh() is failed. error = %s",
 786                              wifi_error_to_string(err));
 787         }
 788 }
 789
 790 wifi_ap_h wifi_manager_ap_get_ap_h(wifi_ap_object *ap_obj)
 791 {
 792         WIFI_RET_VAL_IF_FAIL(ap_obj, NULL);
 793
 794         return ap_obj->ap;
 795 }
 796
 797 wifi_error_e wifi_manager_ap_get_last_connection_error(wifi_manager_object *manager,
 798                                                        wifi_ap_object *ap_obj)
 799 {
 800         WIFI_RET_VAL_IF_FAIL(manager, WIFI_ERROR_INVALID_PARAMETER);
 801         WIFI_RET_VAL_IF_FAIL(ap_obj, WIFI_ERROR_INVALID_PARAMETER);
 802
 803         if (wifi_manager_ap_is_favorite(manager, ap_obj)) {
 804                 wifi_config_object *config = _find_wifi_config_by_wifi_ap(manager, ap_obj);
 805                 if (config) {
 806                         // Favorite ap's last connection error
 807                         return config->last_error;
 808                 }
 809         }
 810         // Connection failed ap's last connection error
 811         return ap_obj->last_connection_error;
 812 }
 813
 814 void wifi_manager_ap_set_last_connection_error(wifi_ap_object *ap_obj, wifi_error_e error)
 815 {
 816         WIFI_RET_IF_FAIL(ap_obj);
 817
 818         ap_obj->last_connection_error = error;
 819 }
 820
 821 gboolean wifi_manager_ap_is_captiveportal(wifi_manager_object *manager, wifi_ap_object *ap_obj)
 822 {
 823         WIFI_RET_VAL_IF_FAIL(manager != NULL, FALSE);
 824         WIFI_RET_VAL_IF_FAIL(ap_obj != NULL, FALSE);
 825
 826         return ap_obj->is_captiveportal;
 827 }
 828
 829 void wifi_manager_ap_set_captiveportal(wifi_ap_object *ap_obj, gboolean is_captiveportal)
 830 {
 831         WIFI_RET_IF_FAIL(ap_obj != NULL);
 832
 833         ap_obj->is_captiveportal = is_captiveportal;
 834 }
 835
 836 wifi_error_e wifi_manager_ap_forget(wifi_ap_object *ap_obj)
 837 {
 838         wifi_error_e err;
 839         WIFI_RET_VAL_IF_FAIL(ap_obj != NULL, WIFI_ERROR_INVALID_PARAMETER);
 840
 841         err = wifi_forget_ap(ap_obj->ap);
 842         if (err != WIFI_ERROR_NONE) {
 843                 WIFI_LOG_ERR("wifi_forget_ap() is failed. error = %s",
 844                              wifi_error_to_string(err));
 845         }
 846         return err;
 847 }
 848
 849 gchar *wifi_manager_ap_get_ssid(wifi_ap_object *ap_obj)
 850 {
 851         gchar *ssid = NULL;
 852         WIFI_RET_VAL_IF_FAIL(ap_obj, NULL);
 853
 854         wifi_error_e err = wifi_ap_get_essid(ap_obj->ap, &ssid);
 855         if (err != WIFI_ERROR_NONE) {
 856                 WIFI_LOG_ERR("wifi_ap_get_essid() is failed. error = %s",
 857                              wifi_error_to_string(err));
 858                 if (ssid) {
 859                         g_free(ssid);
 860                 }
 861                 return NULL;
 862         }
 863         return ssid;
 864 }
 865
 866 gint wifi_manager_ap_get_rssi(wifi_ap_object *ap_obj)
 867 {
 868         WIFI_RET_VAL_IF_FAIL(ap_obj, 0);
 869
 870         return ap_obj->rssi;
 871 }
 872
 873 wifi_manager_ap_signal_strength wifi_manager_ap_get_signal_strength(wifi_ap_object *ap_obj)
 874 {
 875         WIFI_RET_VAL_IF_FAIL(ap_obj, WIFI_MANAGER_SIGNAL_STRENGTH_NULL);
 876
 877         /* Wi-Fi Signal Strength Display (dB / ConnMan normalized value)
 878          *
 879          * Excellent : -63 ~     / 57 ~
 880          * Good:       -74 ~ -64 / 46 ~ 56
 881          * Weak:       -82 ~ -75 / 38 ~ 45
 882          * Very weak:      ~ -83 /    ~ 37
 883          */
 884         if (ap_obj->rssi >= -63)
 885                 return WIFI_MANAGER_SIGNAL_STRENGTH_EXCELLENT;
 886         else if (ap_obj->rssi >= -74)
 887                 return WIFI_MANAGER_SIGNAL_STRENGTH_GOOD;
 888         else if (ap_obj->rssi >= -82)
 889                 return WIFI_MANAGER_SIGNAL_STRENGTH_WEAK;
 890         else if (ap_obj->rssi >= -92)
 891                 return WIFI_MANAGER_SIGNAL_STRENGTH_VERY_WEAK;
 892         else
 893                 return WIFI_MANAGER_SIGNAL_STRENGTH_NULL;
 894 }
 895
 896 gint wifi_manager_ap_get_max_speed(wifi_ap_object *ap_obj)
 897 {
 898         gint max_speed = 0;
 899         WIFI_RET_VAL_IF_FAIL(ap_obj, 0);
 900
 901         wifi_error_e err = wifi_ap_get_max_speed(ap_obj->ap, &max_speed);
 902         if (err != WIFI_ERROR_NONE) {
 903                 WIFI_LOG_ERR("wifi_ap_get_max_speed() is failed. error = %s",
 904                              wifi_error_to_string(err));
 905                 return 0;
 906         }
 907         return max_speed;
 908 }
 909
 910 void wifi_manager_ap_set_password(wifi_ap_object *ap_obj, const gchar *password)
 911 {
 912         wifi_error_e err;
 913         WIFI_RET_IF_FAIL(ap_obj);
 914
 915         err = wifi_ap_set_passphrase(ap_obj->ap, password);
 916         if (err != WIFI_ERROR_NONE) {
 917                 WIFI_LOG_ERR("wifi_ap_set_passphrase() is failed. error = %s",
 918                              wifi_error_to_string(err));
 919         }
 920 }
 921
 922 wifi_eap_type_e wifi_manager_ap_get_eap_type(wifi_ap_object *ap_obj)
 923 {
 924         wifi_eap_type_e eap_type = WIFI_EAP_TYPE_AKA;
 925         wifi_error_e err;
 926         WIFI_RET_VAL_IF_FAIL(ap_obj, eap_type);
 927
 928         err = wifi_ap_get_eap_type(ap_obj->ap, &eap_type);
 929         if (err != WIFI_ERROR_NONE) {
 930                 WIFI_LOG_ERR("wifi_ap_get_eap_type() is failed. error = %s",
 931                              wifi_error_to_string(err));
 932         }
 933         return eap_type;
 934 }
 935
 936 void wifi_manager_ap_set_eap_type(wifi_ap_object *ap_obj, wifi_eap_type_e type)
 937 {
 938         wifi_error_e err;
 939         WIFI_RET_IF_FAIL(ap_obj);
 940
 941         err = wifi_ap_set_eap_type(ap_obj->ap, type);
 942         if (err != WIFI_ERROR_NONE) {
 943                 WIFI_LOG_ERR("wifi_ap_set_eap_type() is failed. error = %s",
 944                              wifi_error_to_string(err));
 945         }
 946 }
 947
 948 wifi_security_type_e wifi_manager_ap_get_security_type(wifi_ap_object *ap_obj)
 949 {
 950         wifi_security_type_e sec_type = WIFI_SECURITY_TYPE_NONE;
 951         wifi_error_e err;
 952         WIFI_RET_VAL_IF_FAIL(ap_obj, sec_type);
 953
 954         err = wifi_ap_get_security_type(ap_obj->ap, &sec_type);
 955         if (err != WIFI_ERROR_NONE) {
 956                 WIFI_LOG_ERR("wifi_ap_get_security_type() is failed. error = %s",
 957                              wifi_error_to_string(err));
 958         }
 959         return sec_type;
 960 }
 961
 962 gchar *wifi_manager_ap_get_security_type_text(wifi_ap_object *ap_obj)
 963 {
 964         switch (wifi_manager_ap_get_security_type(ap_obj)) {
 965         case WIFI_SECURITY_TYPE_NONE:
 966                 return g_strdup(STR_OPEN);
 967
 968         case WIFI_SECURITY_TYPE_WEP:
 969         case WIFI_SECURITY_TYPE_WPA_PSK:
 970         case WIFI_SECURITY_TYPE_WPA2_PSK:
 971                 return g_strdup(STR_SECURED);
 972
 973         case WIFI_SECURITY_TYPE_EAP:
 974                 return g_strdup(STR_SECURED_EAP);
 975
 976 #if defined TIZEN_WLAN_CHINA_WAPI
 977         case WIFI_SECURITY_TYPE_WAPI_PSK:
 978                 return g_strdup(STR_WAPI_PSK);
 979
 980         case WIFI_SECURITY_TYPE_WAPI_CERT:
 981                 return g_strdup(STR_WAPI_CERT);
 982 #endif
 983         default:
 984                 return g_strdup("");
 985         }
 986 }
 987
 988 wifi_connection_state_e wifi_manager_ap_get_connection_state(wifi_ap_object *ap_obj)
 989 {
 990         wifi_connection_state_e conn_state = WIFI_CONNECTION_STATE_FAILURE;
 991         wifi_error_e err;
 992         WIFI_RET_VAL_IF_FAIL(ap_obj, WIFI_CONNECTION_STATE_FAILURE);
 993         err = wifi_ap_get_connection_state(ap_obj->ap, &conn_state);
 994         if (err != WIFI_ERROR_NONE) {
 995                 WIFI_LOG_ERR("wifi_ap_get_connection_state() is failed. error = %s",
 996                              wifi_error_to_string(err));
 997         }
 998         return conn_state;
 999 }
1000
1001 gchar *wifi_manager_ap_get_ip_address(wifi_ap_object *ap_obj)
1002 {
1003         gchar *ip_address = NULL;
1004         WIFI_RET_VAL_IF_FAIL(ap_obj, NULL);
1005
1006         wifi_error_e err = wifi_ap_get_ip_address(ap_obj->ap,
1007                                                   WIFI_ADDRESS_FAMILY_IPV4, &ip_address);
1008         if (err != WIFI_ERROR_NONE) {
1009                 WIFI_LOG_ERR("wifi_ap_get_ip_address() is failed. error = %s",
1010                              wifi_error_to_string(err));
1011                 if (ip_address) {
1012                         g_free(ip_address);
1013                 }
1014                 return NULL;
1015         }
1016         return ip_address;
1017 }
1018
1019 void wifi_manager_ap_set_ip_address(wifi_ap_object *ap_obj, const gchar *ip_address)
1020 {
1021         wifi_error_e err;
1022         WIFI_RET_IF_FAIL(ap_obj);
1023
1024         err = wifi_ap_set_ip_address(ap_obj->ap, WIFI_ADDRESS_FAMILY_IPV4, ip_address);
1025         if (err != WIFI_ERROR_NONE) {
1026                 WIFI_LOG_ERR("wifi_ap_set_ip_address() is failed. error = %s",
1027                              wifi_error_to_string(err));
1028         }
1029 }
1030
1031 gchar *wifi_manager_ap_get_gateway_address(wifi_ap_object *ap_obj)
1032 {
1033         gchar *gateway = NULL;
1034         WIFI_RET_VAL_IF_FAIL(ap_obj, NULL);
1035
1036         wifi_error_e err = wifi_ap_get_gateway_address(ap_obj->ap,
1037                                                        WIFI_ADDRESS_FAMILY_IPV4, &gateway);
1038         if (err != WIFI_ERROR_NONE) {
1039                 WIFI_LOG_ERR("wifi_ap_get_gateway_address() is failed. error = %s",
1040                              wifi_error_to_string(err));
1041                 if (gateway) {
1042                         g_free(gateway);
1043                 }
1044                 return NULL;
1045         }
1046         return gateway;
1047 }
1048
1049 void wifi_manager_ap_set_gateway_address(wifi_ap_object *ap_obj, const gchar *gateway_address)
1050 {
1051         wifi_error_e err;
1052         WIFI_RET_IF_FAIL(ap_obj);
1053
1054         err = wifi_ap_set_gateway_address(ap_obj->ap, WIFI_ADDRESS_FAMILY_IPV4, gateway_address);
1055         if (err != WIFI_ERROR_NONE) {
1056                 WIFI_LOG_ERR("wifi_ap_set_gateway_address() is failed. error = %s",
1057                              wifi_error_to_string(err));
1058         }
1059 }
1060
1061 gchar *wifi_manager_ap_get_subnet_mask(wifi_ap_object *ap_obj)
1062 {
1063         gchar *subnet_mask = NULL;
1064         WIFI_RET_VAL_IF_FAIL(ap_obj, NULL);
1065
1066         wifi_error_e err = wifi_ap_get_subnet_mask(ap_obj->ap,
1067                                                    WIFI_ADDRESS_FAMILY_IPV4, &subnet_mask);
1068         if (err != WIFI_ERROR_NONE) {
1069                 WIFI_LOG_ERR("wifi_ap_get_subnet_mask() is failed. error = %s",
1070                              wifi_error_to_string(err));
1071                 if (subnet_mask) {
1072                         g_free(subnet_mask);
1073                 }
1074                 return NULL;
1075         }
1076         return subnet_mask;
1077 }
1078
1079 void wifi_manager_ap_set_subnet_mask(wifi_ap_object *ap_obj, const gchar *subnet_mask)
1080 {
1081         wifi_error_e err;
1082         WIFI_RET_IF_FAIL(ap_obj);
1083
1084         err = wifi_ap_set_subnet_mask(ap_obj->ap, WIFI_ADDRESS_FAMILY_IPV4, subnet_mask);
1085         if (err != WIFI_ERROR_NONE) {
1086                 WIFI_LOG_ERR("wifi_ap_set_subnet_mask() is failed. error = %s",
1087                              wifi_error_to_string(err));
1088         }
1089 }
1090
1091 gchar *wifi_manager_ap_get_dns_address(wifi_ap_object *ap_obj, gint order)
1092 {
1093         gchar *dns_address = NULL;
1094         WIFI_RET_VAL_IF_FAIL(ap_obj, NULL);
1095
1096         wifi_error_e err = wifi_ap_get_dns_address(ap_obj->ap,
1097                                                    order, WIFI_ADDRESS_FAMILY_IPV4, &dns_address);
1098         if (err != WIFI_ERROR_NONE) {
1099                 WIFI_LOG_ERR("wifi_ap_get_dns_address() is failed. error = %s",
1100                              wifi_error_to_string(err));
1101                 if (dns_address) {
1102                         g_free(dns_address);
1103                 }
1104                 return NULL;
1105         }
1106         return dns_address;
1107 }
1108
1109 void wifi_manager_ap_set_dns_address(wifi_ap_object *ap_obj, const gchar *dns_address, gint order)
1110 {
1111         wifi_error_e err;
1112         WIFI_RET_IF_FAIL(ap_obj);
1113
1114         err = wifi_ap_set_dns_address(ap_obj->ap, order, WIFI_ADDRESS_FAMILY_IPV4, dns_address);
1115         if (err != WIFI_ERROR_NONE) {
1116                 WIFI_LOG_ERR("wifi_ap_set_dns_address() is failed. error = %s",
1117                              wifi_error_to_string(err));
1118         }
1119 }
1120
1121 wifi_ip_config_type_e wifi_manager_ap_get_ip_config(wifi_ap_object *ap_obj)
1122 {
1123         wifi_ip_config_type_e config_type = WIFI_IP_CONFIG_TYPE_NONE;
1124         wifi_error_e err;
1125         WIFI_RET_VAL_IF_FAIL(ap_obj, WIFI_IP_CONFIG_TYPE_NONE);
1126
1127         err = wifi_ap_get_ip_config_type(ap_obj->ap,
1128                                          WIFI_ADDRESS_FAMILY_IPV4, &config_type);
1129         if (err != WIFI_ERROR_NONE) {
1130                 WIFI_LOG_ERR("wifi_ap_get_ip_config_type() is failed. error = %s",
1131                              wifi_error_to_string(err));
1132         }
1133         return config_type;
1134 }
1135
1136 void wifi_manager_ap_set_ip_config(wifi_ap_object *ap_obj, wifi_ip_config_type_e config_type)
1137 {
1138         wifi_error_e err;
1139         WIFI_RET_IF_FAIL(ap_obj);
1140         err = wifi_ap_set_ip_config_type(ap_obj->ap,
1141                                          WIFI_ADDRESS_FAMILY_IPV4, config_type);
1142         if (err != WIFI_ERROR_NONE) {
1143                 WIFI_LOG_ERR("wifi_ap_set_ip_config_type() is failed. error = %s",
1144                              wifi_error_to_string(err));
1145         }
1146 }
1147
1148 bool wifi_manager_ap_is_ip_config_static(wifi_ap_object *ap_obj)
1149 {
1150         return wifi_manager_ap_get_ip_config(ap_obj) == WIFI_IP_CONFIG_TYPE_STATIC;
1151 }
1152
1153 void wifi_manager_ap_set_ip_config_static(wifi_ap_object *ap_obj)
1154 {
1155         wifi_manager_ap_set_ip_config(ap_obj, WIFI_IP_CONFIG_TYPE_STATIC);
1156 }
1157
1158 wifi_proxy_type_e wifi_manager_ap_get_proxy_type(wifi_ap_object *ap_obj)
1159 {
1160         wifi_proxy_type_e proxy_type = WIFI_PROXY_TYPE_AUTO;
1161         wifi_error_e err;
1162         WIFI_RET_VAL_IF_FAIL(ap_obj, WIFI_PROXY_TYPE_AUTO);
1163
1164         err = wifi_ap_get_proxy_type(ap_obj->ap, &proxy_type);
1165         if (err != WIFI_ERROR_NONE) {
1166                 WIFI_LOG_ERR("wifi_ap_get_proxy_type() is failed. error = %s",
1167                              wifi_error_to_string(err));
1168         }
1169         return proxy_type;
1170 }
1171
1172 void wifi_manager_ap_set_proxy_type(wifi_ap_object *ap_obj, wifi_proxy_type_e proxy_type)
1173 {
1174         wifi_error_e err;
1175         WIFI_RET_IF_FAIL(ap_obj);
1176
1177         err = wifi_ap_set_proxy_type(ap_obj->ap, proxy_type);
1178         if (err != WIFI_ERROR_NONE) {
1179                 WIFI_LOG_ERR("wifi_ap_set_proxy_type() is failed. error = %s",
1180                              wifi_error_to_string(err));
1181         }
1182 }
1183
1184 bool wifi_manager_ap_is_proxy_manual(wifi_ap_object *ap_obj)
1185 {
1186         return wifi_manager_ap_get_proxy_type(ap_obj) == WIFI_PROXY_TYPE_MANUAL;
1187 }
1188
1189 void wifi_manager_ap_set_proxy_manual(wifi_ap_object *ap_obj)
1190 {
1191         wifi_manager_ap_set_proxy_type(ap_obj, WIFI_PROXY_TYPE_MANUAL);
1192 }
1193
1194 gchar *wifi_manager_ap_get_proxy_address(wifi_ap_object *ap_obj)
1195 {
1196         gchar *proxy_address = NULL;
1197         char *saveptr = NULL;
1198         WIFI_RET_VAL_IF_FAIL(ap_obj != NULL, NULL);
1199
1200         proxy_address = _ap_get_proxy_address(ap_obj);
1201         if (proxy_address == NULL) {
1202                 WIFI_LOG_INFO("Proxy address is NULL.");
1203                 return NULL;
1204         }
1205
1206         return g_strdup(strtok_r(proxy_address, ":", &saveptr));
1207 }
1208
1209 gchar *wifi_manager_ap_get_proxy_port(wifi_ap_object *ap_obj)
1210 {
1211         gchar *proxy_address = NULL;
1212         char *saveptr = NULL;
1213         WIFI_RET_VAL_IF_FAIL(ap_obj != NULL, NULL);
1214
1215         proxy_address = _ap_get_proxy_address(ap_obj);
1216         if (proxy_address == NULL) {
1217                 WIFI_LOG_INFO("Proxy address is NULL.");
1218                 return NULL;
1219         }
1220
1221         strtok_r(proxy_address, ":", &saveptr);
1222         return g_strdup(strtok(NULL, ":"));
1223 }
1224
1225 void wifi_manager_ap_set_proxy_address(wifi_ap_object *ap_obj, const gchar *proxy_address)
1226 {
1227         wifi_error_e err;
1228         WIFI_RET_IF_FAIL(ap_obj);
1229
1230         err = wifi_ap_set_proxy_address(ap_obj->ap, WIFI_ADDRESS_FAMILY_IPV4, proxy_address);
1231         if (err != WIFI_ERROR_NONE) {
1232                 WIFI_LOG_ERR("wifi_ap_set_proxy_type() is failed. error = %s",
1233                              wifi_error_to_string(err));
1234         }
1235 }
1236
1237 bool wifi_manager_ap_is_wps_mode(wifi_ap_object *ap_obj)
1238 {
1239         return ap_obj->wps_mode;
1240 }
1241
1242 bool wifi_manager_ap_is_favorite(wifi_manager_object *manager, wifi_ap_object *ap_obj)
1243 {
1244         bool is_favorite = false;
1245         wifi_error_e err;
1246         WIFI_RET_VAL_IF_FAIL(ap_obj != NULL, false);
1247
1248         err = wifi_ap_is_favorite(ap_obj->ap, &is_favorite);
1249         if (err != WIFI_ERROR_NONE) {
1250                 WIFI_LOG_ERR("wifi_ap_is_favorite() is failed. error = %d", err);
1251         }
1252         return is_favorite;
1253 }
1254
1255 gboolean wifi_manager_ap_has_configuration(wifi_manager_object *manager,
1256                                            wifi_ap_object *ap_obj)
1257 {
1258         WIFI_RET_VAL_IF_FAIL(manager != NULL, FALSE);
1259         WIFI_RET_VAL_IF_FAIL(ap_obj != NULL, FALSE);
1260
1261         if (_find_wifi_config_by_wifi_ap(manager, ap_obj) == NULL) {
1262                 WIFI_LOG_INFO("AP config profile not found.");
1263                 return FALSE;
1264         }
1265         WIFI_LOG_INFO("AP has config profile.");
1266         return TRUE;
1267 }
1268
1269 wifi_error_e wifi_manager_ap_remove_configuration(wifi_manager_object *manager,
1270                                                   wifi_ap_object *ap_obj)
1271 {
1272         wifi_config_object *config;
1273         wifi_error_e error = WIFI_ERROR_NONE;
1274         WIFI_RET_VAL_IF_FAIL(manager != NULL, WIFI_ERROR_INVALID_PARAMETER);
1275         WIFI_RET_VAL_IF_FAIL(ap_obj != NULL, WIFI_ERROR_INVALID_PARAMETER);
1276
1277         config = _find_wifi_config_by_wifi_ap(manager, ap_obj);
1278         WIFI_RET_VAL_IF_FAIL(config != NULL, WIFI_ERROR_INVALID_OPERATION);
1279
1280         _update_wifi_config_list(manager);
1281         return error;
1282 }
1283
1284 wifi_error_e wifi_manager_update_wifi_config_list(wifi_manager_object *manager)
1285 {
1286         wifi_error_e error = WIFI_ERROR_NONE;
1287
1288         WIFI_RET_VAL_IF_FAIL(manager != NULL, WIFI_ERROR_INVALID_PARAMETER);
1289
1290         _update_wifi_config_list(manager);
1291
1292         return error;
1293 }
1294
1295 /*
1296  * Wearable connection API (weconn feature)
1297  */
1298
1299 gboolean wifi_manager_set_wifi_use(wifi_manager_object *manager, gboolean is_wifi_use)
1300 {
1301         WIFI_RET_VAL_IF_FAIL(manager, FALSE);
1302         return vconf_set_wifi_use(is_wifi_use ? 1 : 0);
1303 }
1304
1305 gboolean wifi_manager_is_wifi_use(wifi_manager_object *manager)
1306 {
1307         WIFI_RET_VAL_IF_FAIL(manager, FALSE);
1308         return vconf_is_wifi_use();
1309 }
1310
1311 gboolean wifi_manager_set_wifi_use_changed_cb(wifi_manager_object *manager,
1312                                               vconf_callback_fn callback, void *data)
1313 {
1314         WIFI_RET_VAL_IF_FAIL(manager, FALSE);
1315     WIFI_LOG_INFO("VCONF_WIFI_USE - notify wifi key changed");
1316         return vconf_notify_wifi_key_changed(callback, data);
1317 }