src/mh_func_onoff.c

   1 /*
   2 * ug-mobile-ap
   3 *
   4 * Copyright 2012-2013  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://floralicense.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 <stdlib.h>
  21 #include <wifi-direct.h>
  22
  23 #include "mh_func_onoff.h"
  24
  25 static bool __get_vconf_prev_wifi_state()
  26 {
  27         int value = 0;
  28
  29         if (vconf_get_bool(VCONF_MOBILE_AP_PREV_WIFI_STATUS, &value) < 0) {
  30                 ERR("vconf_get_bool is failed\n");
  31                 return false;
  32         }
  33
  34         DBG("%s : %d\n", VCONF_MOBILE_AP_PREV_WIFI_STATUS, value);
  35
  36         return value ? true : false;
  37 }
  38
  39 int _get_vconf_usb_state()
  40 {
  41         int value = VCONFKEY_SYSMAN_USB_DISCONNECTED;
  42
  43         if (vconf_get_int(VCONFKEY_SYSMAN_USB_STATUS, &value) < 0) {
  44                 ERR("vconf_get_int is failed\n");
  45                 return 0;
  46         }
  47
  48         DBG("%s : %d\n", VCONFKEY_SYSMAN_USB_STATUS, value);
  49
  50         return value;
  51 }
  52
  53 static bool __is_connected_wifi_net(mh_appdata_t *ad)
  54 {
  55         connection_wifi_state_e wifi_state = CONNECTION_WIFI_STATE_DEACTIVATED;
  56         int ret;
  57
  58         ret = connection_get_wifi_state(ad->conn_handle, &wifi_state);
  59         if (ret != CONNECTION_ERROR_NONE) {
  60                 ERR("connection_get_wifi_state() is failed : %d\n");
  61                 return false;
  62         }
  63
  64         if (wifi_state != CONNECTION_WIFI_STATE_CONNECTED) {
  65                 ERR("Wi-Fi network is not connected : %d\n", wifi_state);
  66                 return false;
  67         }
  68
  69         DBG("Wi-Fi network is connected\n");
  70         return true;
  71 }
  72
  73 static bool __is_connected_ethernet_net(mh_appdata_t *ad)
  74 {
  75         connection_ethernet_state_e ethernet_state = CONNECTION_ETHERNET_STATE_DEACTIVATED;
  76         int ret;
  77
  78         ret = connection_get_ethernet_state(ad->conn_handle, &ethernet_state);
  79         if (ret != CONNECTION_ERROR_NONE) {
  80                 ERR("connection_get_ethernet_state() is failed : %d\n");
  81                 return false;
  82         }
  83
  84         if (ethernet_state != CONNECTION_ETHERNET_STATE_CONNECTED) {
  85                 ERR("Ethernet network is not connected : %d\n", ethernet_state);
  86                 return false;
  87         }
  88
  89         DBG("Ethernet network is connected\n");
  90         return true;
  91 }
  92
  93 static bool __is_connected_cellular_net(mh_appdata_t *ad)
  94 {
  95         connection_cellular_state_e cellular_state = CONNECTION_CELLULAR_STATE_OUT_OF_SERVICE;
  96         sim_state_e sim_state = SIM_STATE_UNAVAILABLE;
  97         int ret;
  98
  99         /* Check SIM state */
 100         ret = sim_get_state(&sim_state);
 101         if (ret != SIM_ERROR_NONE) {
 102                 ERR("sim_get_state() is failed : %d\n", ret);
 103                 _prepare_popup(MH_POP_INFORMATION,
 104                                 _("IDS_MOBILEAP_POP_INSERT_SIM_CARD_AND_RESTART_DEVICE_TO_USE_TETHERING"));
 105                 _create_popup(ad);
 106                 return false;
 107         }
 108         DBG("SIM State : %d\n", sim_state);
 109         if (sim_state != SIM_STATE_AVAILABLE) {
 110                 _prepare_popup(MH_POP_INFORMATION,
 111                                 _("IDS_MOBILEAP_POP_INSERT_SIM_CARD_AND_RESTART_DEVICE_TO_USE_TETHERING"));
 112                 _create_popup(ad);
 113                 return false;
 114         }
 115
 116         ret = connection_get_cellular_state(ad->conn_handle, &cellular_state);
 117         if (ret != CONNECTION_ERROR_NONE) {
 118                 ERR("connection_get_cellular_state() is failed : %d\n");
 119                 return false;
 120         }
 121
 122         if (cellular_state == CONNECTION_CELLULAR_STATE_FLIGHT_MODE) {
 123                 _prepare_popup(MH_POP_INFORMATION_WO_BUTTON,
 124                                 _("IDS_MOBILEAP_POP_UNABLE_TO_USE_TETHERING_IN_FLIGHT_MODE_TO_USE_TETHERING_DISABLE_FLIGHT_MODE"));
 125                 _create_popup(ad);
 126                 ERR("Cellular network is not connected\n");
 127                 return false;
 128         } else if (cellular_state != CONNECTION_CELLULAR_STATE_CONNECTED &&
 129                         cellular_state != CONNECTION_CELLULAR_STATE_AVAILABLE) {
 130                 _prepare_popup(MH_POP_INFORMATION,
 131                                 _("IDS_MOBILEAP_POP_UNABLE_TO_USE_PACKET_DATA_SERVICE_OUT_OF_COVERAGE"));
 132                 _create_popup(ad);
 133                 ERR("Cellular network is not connected : %d\n", cellular_state);
 134                 return false;
 135         }
 136
 137         DBG("Cellular network is connected\n");
 138         return true;
 139 }
 140
 141 static int __create_wifi_hotspot_on_popup(mh_appdata_t *ad)
 142 {
 143         char *fmt;
 144         char *str;
 145         bool wifi_state = false;
 146
 147         wifi_is_activated(&wifi_state);
 148         if (wifi_state == true || _is_wifi_direct_on() == true)
 149                 fmt = _("IDS_ST_BODY_WI_FI_NETWORK_WILL_BE_DISCONNECTED_TETHERING_CONSUMES_MORE_BATTERY_POWER_AND_INCREASES_YOUR_DATA_USAGE_THE_MAXIMUM_NUMBER_OF_TETHERED_DEVICES_ALLOWED_IS_PD");
 150         else
 151                 fmt = _("IDS_ST_BODY_TETHERING_CONSUMES_MORE_BATTERY_POWER_AND_INCREASES_YOUR_DATA_USAGE_THE_MAXIMUM_NUMBER_OF_TETHERED_DEVICES_ALLOWED_IS_PD");
 152
 153         str = malloc(MH_LABEL_LENGTH_MAX);
 154         snprintf(str, MH_LABEL_LENGTH_MAX, fmt, TETHERING_WIFI_MAX_CONNECTED_STA);
 155         _prepare_popup(MH_POP_WIFI_ON_CONF, str);
 156         free(str);
 157
 158         _create_popup(ad);
 159
 160         return 0;
 161 }
 162
 163 static int __create_bt_tethering_on_popup(mh_appdata_t *ad)
 164 {
 165         char *str;
 166
 167         str = malloc(MH_LABEL_LENGTH_MAX);
 168         snprintf(str, MH_LABEL_LENGTH_MAX,
 169                         _("IDS_ST_BODY_TETHERING_CONSUMES_MORE_BATTERY_POWER_AND_INCREASES_YOUR_DATA_USAGE_THE_MAXIMUM_NUMBER_OF_TETHERED_DEVICES_ALLOWED_IS_PD"),
 170                         TETHERING_BT_MAX_CONNECTED_STA);
 171         _prepare_popup(MH_POP_BT_ON_CONF, str);
 172         free(str);
 173
 174         _create_popup(ad);
 175
 176         return 0;
 177 }
 178
 179 static int __create_usb_tethering_on_popup(mh_appdata_t *ad)
 180 {
 181         char *str;
 182
 183         str = _("IDS_MOBILEAP_POP_TETHERING_CONSUMES_MORE_BATTERY_POWER_AND_INCREASES_YOUR_DATA_USAGE");
 184         _prepare_popup(MH_POP_USB_ON_CONF, str);
 185         _create_popup(ad);
 186
 187         return 0;
 188 }
 189
 190 static void __disable_tethering_by_ind(mh_appdata_t *ad, tethering_disabled_cause_e cause)
 191 {
 192         if (ad == NULL) {
 193                 ERR("Param is NULL\n");
 194                 return;
 195         }
 196
 197         DBG("cause : %d\n", cause);
 198         switch (cause) {
 199         case TETHERING_DISABLED_BY_WIFI_ON:
 200                 DBG("TETHERING_DISABLED_IND by WIFI\n");
 201                 break;
 202
 203         case TETHERING_DISABLED_BY_BT_OFF:
 204                 DBG("TETHERING_DISABLED_BY_BT_DEACTIVATION\n");
 205                 break;
 206
 207         case TETHERING_DISABLED_BY_USB_DISCONNECTION:
 208                 DBG("TETHERING_DISABLED_IND by USB DISCONNECT\n");
 209                 break;
 210
 211         case TETHERING_DISABLED_BY_FLIGHT_MODE:
 212                 DBG("TETHERING_DISABLED_IND by FLIGHT_MODE\n");
 213                 break;
 214
 215         case TETHERING_DISABLED_BY_TIMEOUT:
 216                 DBG("TETHERING_DISABLED_BY_TIMEOUT\n");
 217                 break;
 218
 219         case TETHERING_DISABLED_BY_OTHERS:
 220                 DBG("TETHERING_DISABLED_IND by OTHERS\n");
 221                 break;
 222
 223         case TETHERING_DISABLED_BY_LOW_BATTERY:
 224                 DBG("TETHERING_DISABLED_IND by LOW_BATTERY\n");
 225                 break;
 226
 227         case TETHERING_DISABLED_BY_MDM_ON:
 228                 DBG("TETHERING_DISABLED_IND by MDM\n");
 229                 break;
 230
 231         default:
 232                 DBG("TETHERING_DISABLED_IND Default\n");
 233                 break;
 234         }
 235
 236         return;
 237 }
 238
 239 /* Wi-Fi Direct callback */
 240 static void _wifi_direct_state_cb(int error_code, wifi_direct_device_state_e state, void *user_data)
 241 {
 242         DBG("+\n");
 243
 244         if (user_data == NULL) {
 245                 ERR("The param is NULL\n");
 246                 return;
 247         }
 248
 249         mh_appdata_t *ad = (mh_appdata_t *)user_data;
 250         int ret = 0;
 251
 252         wifi_direct_unset_device_state_changed_cb();
 253         wifi_direct_deinitialize();
 254         DBG("-\n");
 255
 256         if (error_code != 0) {
 257                 ERR("wifi_direct_deactivate fail in cb : %d\n", error_code);
 258                 _update_main_view(ad);
 259                 return;
 260         }
 261
 262         if (state != WIFI_DIRECT_DEVICE_STATE_DEACTIVATED) {
 263                 ERR("Unknown state : %d\n", state);
 264                 return;
 265         }
 266
 267         ret = tethering_enable(ad->handle, TETHERING_TYPE_WIFI);
 268         if (ret != TETHERING_ERROR_NONE) {
 269                 ERR("wifi tethering on is failed : %d\n", ret);
 270                 _update_main_view(ad);
 271                 return;
 272         }
 273
 274         DBG("-\n");
 275         return;
 276 }
 277
 278 /* Wi-Fi callbacks */
 279 static void __wifi_activated_cb(wifi_error_e result, void *user_data)
 280 {
 281         __MOBILE_AP_FUNC_ENTER__;
 282
 283         if (user_data == NULL) {
 284                 ERR("The param is NULL\n");
 285                 return;
 286         }
 287
 288         mh_appdata_t *ad = (mh_appdata_t *)user_data;
 289         int ret = 0;
 290
 291         if (result != WIFI_ERROR_NONE) {
 292                 ERR("__wifi_activated_cb error : %d\n", result);
 293                 _update_main_view(ad);
 294                 return;
 295         }
 296
 297         DBG("Wi-Fi on is done\n");
 298
 299         ret = tethering_enable(ad->handle, TETHERING_TYPE_WIFI);
 300         if (ret != TETHERING_ERROR_NONE) {
 301                 ERR("wifi tethering on is failed : %d\n", ret);
 302                 return;
 303         }
 304         _update_main_view(ad);
 305
 306         __MOBILE_AP_FUNC_EXIT__;
 307         return;
 308 }
 309
 310 static void __wifi_deactivated_cb(wifi_error_e result, void *user_data)
 311 {
 312         __MOBILE_AP_FUNC_ENTER__;
 313
 314         if (user_data == NULL) {
 315                 ERR("The param is NULL\n");
 316                 return;
 317         }
 318
 319         mh_appdata_t *ad = (mh_appdata_t *)user_data;
 320         int ret;
 321
 322         if (result != WIFI_ERROR_NONE) {
 323                 ERR("__wifi_deactivated_cb error : %d\n", result);
 324                 _update_main_view(ad);
 325                 return;
 326         }
 327
 328         DBG("Wi-Fi is turned off\n");
 329
 330         ret = vconf_set_bool(VCONF_MOBILE_AP_PREV_WIFI_STATUS, 1);
 331         if (ret < 0)
 332                 ERR("vconf_set_bool() is failed : %d\n", ret);
 333
 334         ret = tethering_enable(ad->handle, TETHERING_TYPE_WIFI);
 335         if (ret != TETHERING_ERROR_NONE) {
 336                 ERR("wifi tethering on is failed : %d\n", ret);
 337                 _update_main_view(ad);
 338                 return;
 339         }
 340
 341         __MOBILE_AP_FUNC_EXIT__;
 342         return;
 343 }
 344
 345 /* Tethering callbacks */
 346 void _enabled_cb(tethering_error_e result, tethering_type_e type, bool is_requested, void *user_data)
 347 {
 348         if (user_data == NULL) {
 349                 ERR("user_data is NULL\n");
 350                 return;
 351         }
 352
 353         if (result == TETHERING_ERROR_NONE) {
 354                 int ret = vconf_set_int(
 355                                 VCONFKEY_MOBILE_HOTSPOT_WIFI_STATE,
 356                                 VCONFKEY_MOBILE_HOTSPOT_WIFI_ON);
 357                 if (ret < 0)
 358                         ERR("vconf_set_int() is failed : %d\n", ret);
 359         }
 360
 361         mh_appdata_t *ad = (mh_appdata_t *)user_data;
 362
 363         ad->main.need_recover_wifi_tethering = false;
 364
 365         if (!is_requested) {
 366                 if (NULL != ad->popup) {
 367                         evas_object_del(ad->popup);
 368                         ad->popup = NULL;
 369                 }
 370                 _update_main_view(ad);
 371
 372                 return;
 373         }
 374
 375         if (result != TETHERING_ERROR_NONE) {
 376                 _prepare_popup(MH_POP_INFORMATION,
 377                                 _("IDS_MOBILEAP_POP_UNABLE_TO_USE_TETHERING"));
 378                 _create_popup(ad);
 379         }
 380
 381         _update_main_view(ad);
 382
 383         return;
 384 }
 385
 386 void _disabled_cb(tethering_error_e result, tethering_type_e type, tethering_disabled_cause_e cause, void *user_data)
 387 {
 388         if (user_data == NULL) {
 389                 ERR("user_data is NULL\n");
 390                 return;
 391         }
 392
 393         if (result == TETHERING_ERROR_NONE) {
 394                 int ret = vconf_set_int(
 395                                 VCONFKEY_MOBILE_HOTSPOT_WIFI_STATE,
 396                                 VCONFKEY_MOBILE_HOTSPOT_WIFI_OFF);
 397                 if (ret < 0)
 398                         ERR("vconf_set_int() is failed : %d\n", ret);
 399         }
 400
 401         mh_appdata_t *ad = (mh_appdata_t *)user_data;
 402
 403         if (ad->main.need_recover_wifi_tethering == true) {
 404                 DBG("Wi-Fi tethering will be turned on again\n");
 405                 return;
 406         }
 407
 408         if (cause != TETHERING_DISABLED_BY_REQUEST) {
 409                 DBG("Tethering [%d] is disabled because of [%d]\n", type, cause);
 410                 if (NULL != ad->popup) {
 411                         evas_object_del(ad->popup);
 412                         ad->popup = NULL;
 413                 }
 414                 _update_main_view(ad);
 415                 __disable_tethering_by_ind(ad, cause);
 416                 return;
 417         }
 418
 419         if (result != TETHERING_ERROR_NONE) {
 420                 _prepare_popup(MH_POP_INFORMATION,
 421                                 _("IDS_MOBILEAP_POP_UNABLE_TO_USE_TETHERING"));
 422                 _create_popup(ad);
 423                 _update_main_view(ad);
 424                 return;
 425         }
 426
 427         DBG("Tethering [%d] is disabled by reqeust\n", type);
 428
 429         _update_main_view(ad);
 430
 431         return;
 432 }
 433
 434 void _connection_changed_cb(tethering_client_h client, bool is_opened, void *user_data)
 435 {
 436         if (user_data == NULL) {
 437                 ERR("user_data is NULL\n");
 438                 return;
 439         }
 440
 441         mh_appdata_t *ad = (mh_appdata_t *)user_data;
 442         char *name = NULL;
 443
 444         tethering_client_get_name(client, &name);
 445         DBG("Client %s is %s\n", name, is_opened ?  "connected" : "disconnected");
 446         if (name)
 447                 free(name);
 448
 449         ap_update_data_device(ad);
 450
 451         return;
 452 }
 453
 454 void _data_usage_cb(tethering_error_e result, unsigned long long received_data, unsigned long long sent_data, void *user_data)
 455 {
 456         if (user_data == NULL) {
 457                 ERR("user_data is NULL\n");
 458                 return;
 459         }
 460
 461         mh_appdata_t *ad = (mh_appdata_t *)user_data;
 462
 463         if (ad->data_statistics.pdp_total_sent != sent_data ||
 464                         ad->data_statistics.pdp_total_receive != received_data) {
 465                 ad->data_statistics.pdp_total_sent = sent_data;
 466                 ad->data_statistics.pdp_total_receive = received_data;
 467                 ap_update_data_packet_usage(ad);
 468         }
 469
 470         ad->data_statistics.is_updated = true;
 471
 472         return;
 473 }
 474 /* End of Tethering callbacks */
 475
 476 int _handle_wifi_onoff_change(mh_appdata_t *ad)
 477 {
 478         __MOBILE_AP_FUNC_ENTER__;
 479
 480         int ret;
 481         int connected_wifi_clients = 0;
 482
 483         /* Turn off WiFi hotspot */
 484         if (ad->main.hotspot_mode & VCONFKEY_MOBILE_HOTSPOT_MODE_WIFI) {
 485                 if (_get_no_of_connected_device(ad->handle, &connected_wifi_clients,
 486                                         TETHERING_TYPE_WIFI) == FALSE) {
 487                         ERR("Getting the number of connected device is failed\n");
 488                 }
 489                 if (connected_wifi_clients > 0) {
 490                         _prepare_popup(MH_POP_WIFI_OFF_CONF,
 491                                         _("IDS_MOBILEAP_POP_DISABLING_TETHERING_WILL_PREVENT_LINKED_DEVICES_FROM_ACCESSING_THE_INTERNET_CONTINUE_Q"));
 492                         _create_popup(ad);
 493                 } else {
 494                         ret = vconf_set_int(
 495                                         VCONFKEY_MOBILE_HOTSPOT_WIFI_STATE,
 496                                         VCONFKEY_MOBILE_HOTSPOT_WIFI_PENDING_OFF);
 497                         if (ret < 0)
 498                                 ERR("vconf_set_int() is failed : %d\n", ret);
 499
 500                         ret = tethering_disable(ad->handle, TETHERING_TYPE_WIFI);
 501                         if (ret != TETHERING_ERROR_NONE) {
 502                                 ERR("wifi tethering off is failed : %d\n", ret);
 503                                 return -1;
 504                         }
 505                 }
 506                 return 0;
 507         }
 508
 509         /* Turn on WiFi hotspot */
 510         if (!__is_connected_ethernet_net(ad) && !__is_connected_cellular_net(ad)) {
 511                 ERR("There is no connected network\n");
 512                 return -1;
 513         }
 514
 515         if (__create_wifi_hotspot_on_popup(ad) < 0) {
 516                 ERR("__create_wifi_hotspot_on_popup fail\n");
 517                 return -1;
 518         }
 519
 520         __MOBILE_AP_FUNC_EXIT__;
 521
 522         return 0;
 523 }
 524
 525 int _handle_bt_onoff_change(mh_appdata_t *ad)
 526 {
 527         __MOBILE_AP_FUNC_ENTER__;
 528
 529         int ret;
 530
 531         /* Turn off Bluetooth tethering */
 532         if (ad->main.hotspot_mode & VCONFKEY_MOBILE_HOTSPOT_MODE_BT) {
 533                 ret = tethering_disable(ad->handle, TETHERING_TYPE_BT);
 534                 if (ret) {
 535                         ERR("Error disable bt tethering [%d]\n", ret);
 536                         return -1;
 537                 }
 538                 return 0;
 539         }
 540
 541         /* Turn on Bluetooth tethering */
 542         if (!__is_connected_ethernet_net(ad) && !__is_connected_wifi_net(ad) &&
 543                         !__is_connected_cellular_net(ad)) {
 544                 ERR("There is no connected network\n");
 545                 return -1;
 546         }
 547
 548         if (__create_bt_tethering_on_popup(ad) < 0) {
 549                 ERR("__create_bt_tethering_on_popup fail\n");
 550                 return -1;
 551         }
 552
 553         __MOBILE_AP_FUNC_EXIT__;
 554
 555         return 0;
 556 }
 557
 558 int _handle_usb_onoff_change(mh_appdata_t *ad)
 559 {
 560         __MOBILE_AP_FUNC_ENTER__;
 561
 562         int ret;
 563
 564         /* Turn off USB tethering */
 565         if (ad->main.hotspot_mode & VCONFKEY_MOBILE_HOTSPOT_MODE_USB) {
 566                 ret = tethering_disable(ad->handle, TETHERING_TYPE_USB);
 567                 if (ret) {
 568                         DBG("Error disable usb tethering : %d\n", ret);
 569                         return -1;
 570                 }
 571                 return 0;
 572         }
 573
 574         /* Turn on USB tethering */
 575         if (!__is_connected_ethernet_net(ad) && !__is_connected_wifi_net(ad) &&
 576                         !__is_connected_cellular_net(ad)) {
 577                 ERR("There is no connected network\n");
 578                 return -1;
 579         }
 580
 581         if (__create_usb_tethering_on_popup(ad) < 0) {
 582                 ERR("__create_usb_tethering_on_popup fail\n");
 583                 return -1;
 584         }
 585
 586         __MOBILE_AP_FUNC_EXIT__;
 587
 588         return 0;
 589 }
 590
 591 int _turn_off_wifi(mh_appdata_t *ad)
 592 {
 593         int ret;
 594
 595         ret = wifi_deactivate(__wifi_deactivated_cb, (void *)ad);
 596         if (ret != WIFI_ERROR_NONE) {
 597                 ERR("wifi_deactivate() is failed : %d\n", ret);
 598                 return -1;
 599         }
 600
 601         return 0;
 602 }
 603
 604 int _turn_on_wifi(mh_appdata_t *ad)
 605 {
 606         int ret;
 607
 608         ret = wifi_activate(__wifi_activated_cb, (void *)ad);
 609         if (ret != WIFI_ERROR_NONE) {
 610                 ERR("wifi_activate() is failed : %d\n", ret);
 611                 return -1;
 612         }
 613
 614         return 0;
 615 }
 616
 617 bool _is_wifi_direct_on(void)
 618 {
 619         int wifi_direct_state = 0;
 620         int ret;
 621
 622         ret = vconf_get_int(VCONFKEY_WIFI_DIRECT_STATE, &wifi_direct_state);
 623         if (ret < 0) {
 624                 ERR("vconf_get_int() is failed : %d\n", ret);
 625                 return false;
 626         }
 627
 628         return wifi_direct_state != 0 ? true : false;
 629 }
 630
 631 int _turn_off_wifi_direct(mh_appdata_t *ad)
 632 {
 633         int ret;
 634
 635         ret = wifi_direct_initialize();
 636         if (ret < 0) {
 637                 ERR("wifi_direct_initialize() is failed : %d\n", ret);
 638                 return -1;
 639         }
 640
 641         ret = wifi_direct_set_device_state_changed_cb(_wifi_direct_state_cb, (void *)ad);
 642         if (ret < 0) {
 643                 ERR("wifi_direct_set_device_state_changed_cb() is failed : %d\n", ret);
 644                 ret = wifi_direct_deinitialize();
 645                 DBG("wifi_direct_deinitialize() ret : %d\n", ret);
 646                 return -1;
 647         }
 648
 649         ret = wifi_direct_deactivate();
 650         if (ret < 0) {
 651                 ERR("wifi_direct_deactivate() is failed : %d\n", ret);
 652                 ret = wifi_direct_unset_device_state_changed_cb();
 653                 DBG("wifi_direct_unset_device_state_changed_cb() ret : %d\n", ret);
 654                 ret = wifi_direct_deinitialize();
 655                 DBG("wifi_direct_deinitialize() ret : %d\n", ret);
 656                 return -1;
 657         }
 658
 659         return 0;
 660 }