src/mh_func_onoff.c

   1 /*
   2 * ug-mobile-ap
   3 *
   4 * Copyright 2012  Samsung Electronics Co., Ltd
   5
   6 * Licensed under the Flora License, Version 1.0 (the "License");
   7 * you may not use this file except in compliance with the License.
   8 * You may obtain a copy of the License at
   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 <stdlib.h>
  21 #include <glib.h>
  22
  23 #include "mh_func_onoff.h"
  24 #include "mh_popup.h"
  25 #include "mh_string.h"
  26
  27 static bool is_wifi_tethering_checkbox_popup_active = false;
  28
  29 void _update_tethering_enabling_item(mh_appdata_t *ad, tethering_type_e type, mh_state_e state)
  30 {
  31         switch(type) {
  32         case TETHERING_TYPE_WIFI:
  33                 _update_wifi_item(ad, MH_STATE_NONE);
  34                 ad->is_wifi_teth_enabling = false;
  35                 break;
  36
  37         case TETHERING_TYPE_BT:
  38                 _update_bt_item(ad, MH_STATE_NONE);
  39                 ad->is_bt_teth_enabling = false;
  40                 break;
  41
  42         case TETHERING_TYPE_USB:
  43                 _update_usb_item(ad, MH_STATE_NONE);
  44                 ad->is_usb_teth_enabling = false;
  45                 break;
  46
  47         default :
  48                 ERR("invalid type \n");
  49                 break;
  50         }
  51 }
  52 void _wifi_tethering_checkbox_popup_status_set(bool value)
  53 {
  54         is_wifi_tethering_checkbox_popup_active = value;
  55 }
  56
  57 bool _wifi_tethering_checkbox_popup_status_get(void)
  58 {
  59         return is_wifi_tethering_checkbox_popup_active;
  60 }
  61
  62 int _get_vconf_usb_state()
  63 {
  64         int value = VCONFKEY_SYSMAN_USB_DISCONNECTED;
  65
  66         if (vconf_get_int(VCONFKEY_SYSMAN_USB_STATUS, &value) < 0) {
  67                 ERR("vconf_get_int is failed\n");
  68                 return 0;
  69         }
  70         DBG("%s : %d\n", VCONFKEY_SYSMAN_USB_STATUS, value);
  71
  72         return value;
  73 }
  74
  75 void _update_tethering_item(mh_appdata_t * ad, mh_state_e state)
  76 {
  77         ERR("type : %d state : %d\n", ad->type, state);
  78         switch(ad->type)        {
  79                 case TETHERING_TYPE_WIFI:
  80                         _update_wifi_item(ad, state);
  81                         break;
  82                 case TETHERING_TYPE_BT:
  83                         _update_bt_item(ad, state);
  84                         break;
  85                 case TETHERING_TYPE_USB:
  86                         _update_usb_item(ad, state);
  87                         break;
  88                 default:
  89                         break;
  90         }
  91 }
  92
  93 gboolean _ps_recheck_timeout_cb(gpointer data)
  94 {
  95         connection_cellular_state_e cellular_state = _get_cellular_state();
  96         mh_appdata_t *ad = (mh_appdata_t *)data;
  97         static int recheck_count = 0;
  98
  99         DBG("Re-Check cellular state (%d)\n", recheck_count);
 100
 101         if(cellular_state == CONNECTION_CELLULAR_STATE_FLIGHT_MODE) {
 102                 _update_tethering_item(ad, MH_STATE_NONE);
 103                 recheck_count = 0;
 104                 return FALSE;
 105         }
 106
 107         if (cellular_state == CONNECTION_CELLULAR_STATE_CONNECTED ||
 108                 cellular_state == CONNECTION_CELLULAR_STATE_AVAILABLE) {
 109                 if (ad->type == TETHERING_TYPE_WIFI) {
 110                         if (_create_wifi_hotspot_on_popup(ad) < 0) {
 111                                 ERR("__create_wifi_hotspot_on_popup fail\n");
 112                                 _update_tethering_item(ad, MH_STATE_NONE);
 113                                 recheck_count = 0;
 114                                 return FALSE;
 115                         }
 116                 _send_signal_qp(QP_SIGNAL_PROGRESS_ON);
 117                 } else if (ad->type == TETHERING_TYPE_BT && _create_bt_tethering_on_popup(ad) < 0) {
 118                                 ERR("_create_bt_tethering_on_popup fail\n");
 119                                 _update_tethering_item(ad, MH_STATE_NONE);
 120                                 recheck_count = 0;
 121                                 return FALSE;
 122                 } else if (ad->type == TETHERING_TYPE_USB && _create_usb_tethering_on_popup(ad) < 0) {
 123                                 ERR("__create_usb_hotspot_on_popup fail\n");
 124                                 _update_tethering_item(ad, MH_STATE_NONE);
 125                                 recheck_count = 0;
 126                                 return FALSE;
 127                 } else {
 128                         ERR("Unknown tethering type \n");
 129                         recheck_count = 0;
 130                         return FALSE;
 131                 }
 132         } else {
 133                 if(++recheck_count >= PS_RECHECK_COUNT_MAX) {
 134                         DBG("Cellular network is not connected : %d\n", cellular_state);
 135                         _update_tethering_item(ad, MH_STATE_NONE);
 136                         _prepare_popup(MH_POPUP_NETWORK_OUT_OF_RANGE, STR_NO_DATA_SERVICE);
 137                         _create_popup(ad);
 138                         recheck_count = 0;
 139                         return FALSE;
 140                 }
 141                 return TRUE;
 142         }
 143         recheck_count = 0;
 144         return FALSE;
 145 }
 146
 147 static bool __is_connected_wifi_net(mh_appdata_t *ad)
 148 {
 149         connection_wifi_state_e wifi_state = CONNECTION_WIFI_STATE_DEACTIVATED;
 150         int ret;
 151
 152         ret = connection_get_wifi_state(ad->conn_handle, &wifi_state);
 153         if (ret != CONNECTION_ERROR_NONE) {
 154                 ERR("connection_get_wifi_state() is failed : %d\n");
 155                 return false;
 156         }
 157
 158         if (wifi_state != CONNECTION_WIFI_STATE_CONNECTED) {
 159                 ERR("Wi-Fi network is not connected : %d\n", wifi_state);
 160                 return false;
 161         }
 162
 163         DBG("Wi-Fi network is connected\n");
 164         return true;
 165 }
 166
 167 static bool __is_connected_ethernet_net(mh_appdata_t *ad)
 168 {
 169         connection_ethernet_state_e ethernet_state = CONNECTION_ETHERNET_STATE_DEACTIVATED;
 170         int ret;
 171
 172         ret = connection_get_ethernet_state(ad->conn_handle, &ethernet_state);
 173         if (ret != CONNECTION_ERROR_NONE) {
 174                 ERR("connection_get_ethernet_state() is failed : %d\n");
 175                 return false;
 176         }
 177
 178         if (ethernet_state != CONNECTION_ETHERNET_STATE_CONNECTED) {
 179                 ERR("Ethernet network is not connected : %d\n", ethernet_state);
 180                 return false;
 181         }
 182
 183         DBG("Ethernet network is connected\n");
 184         return true;
 185 }
 186
 187 static int __is_preconditions_handled(mh_appdata_t *ad)
 188 {
 189         DBG("+\n");
 190
 191         connection_cellular_state_e cellular_state = CONNECTION_CELLULAR_STATE_OUT_OF_SERVICE;
 192         int dnet_state = 0;
 193
 194         /* check ethernet connection */
 195         if (__is_connected_ethernet_net(ad)) {
 196                 DBG("ethernet network is connected\n");
 197                 return 1;
 198         }
 199
 200         /*  check wifi connection */
 201         if (ad->type != TETHERING_TYPE_WIFI) {
 202                 if (__is_connected_wifi_net(ad)) {
 203                         DBG("wifi network is connected\n");
 204                         return 1;
 205                 }
 206         }
 207
 208         /* Check SIM state */
 209         if (_get_sim_state() != VCONFKEY_TELEPHONY_SIM_INSERTED) {
 210                 if(ad->type == TETHERING_TYPE_WIFI)
 211                         _prepare_popup(MH_POPUP_NO_SIM, STR_INSERT_SIM_TO_USE_TETH);
 212                 else
 213                         _prepare_popup(MH_POPUP_NO_SIM, STR_CONN_MOBILE_DATA_TO_USE_TETH);
 214
 215                 _create_popup(ad);
 216                 return -1;
 217         }
 218
 219         /* Check cellular state */
 220         cellular_state = _get_cellular_state();
 221         DBG("cellular state is :  %d \n", cellular_state);
 222         if (cellular_state == CONNECTION_CELLULAR_STATE_FLIGHT_MODE) {
 223                 _prepare_popup(MH_POPUP_FLIGHT_MODE, STR_DISABLE_FLIGHT_MODE_MSG);
 224                 _create_popup(ad);
 225                 ERR("Flight mode is ON\n");
 226                 return -1;
 227         } else {
 228                 if (vconf_get_bool(VCONFKEY_3G_ENABLE , &dnet_state) < 0) {
 229                         ERR("vconf_get_bool is failed\n");
 230                 } else if(dnet_state == 0) {
 231                         DBG("Data Network is not connected");
 232                         _prepare_popup(MH_POPUP_MOBILE_DATA_OFF, STR_NO_NET_CONN_MSG);
 233                         _create_popup(ad);
 234                         return 0;
 235                 }
 236                 if (cellular_state != CONNECTION_CELLULAR_STATE_CONNECTED &&
 237                         cellular_state != CONNECTION_CELLULAR_STATE_AVAILABLE) {
 238                         if(ad->ps_recheck_timer_id > 0) {
 239                                 g_source_remove(ad->ps_recheck_timer_id);
 240                                 ad->ps_recheck_timer_id = 0;
 241                                 if (ad->is_wifi_teth_enabling == true && ad->type != TETHERING_TYPE_WIFI) {
 242                                         _update_tethering_enabling_item(ad, TETHERING_TYPE_WIFI, MH_STATE_NONE);
 243                                 }
 244                                 if (ad->is_bt_teth_enabling == true && ad->type != TETHERING_TYPE_BT) {
 245                                         _update_tethering_enabling_item(ad, TETHERING_TYPE_BT, MH_STATE_NONE);
 246                                 }
 247                                 if (ad->is_usb_teth_enabling == true && ad->type != TETHERING_TYPE_USB) {
 248                                         _update_tethering_enabling_item(ad, TETHERING_TYPE_USB, MH_STATE_NONE);
 249                                 }
 250                         }
 251                         ad->ps_recheck_timer_id = g_timeout_add(PS_RECHECK_INTERVAL, _ps_recheck_timeout_cb, (void*)ad);
 252                         return 0;
 253                 }
 254         }
 255
 256         DBG("Cellular network is connected\n");
 257         DBG("-\n");
 258         return 1;
 259 }
 260
 261 int _create_wifi_hotspot_on_popup(mh_appdata_t *ad)
 262 {
 263         char *fmt = NULL;
 264         char *str = NULL;
 265         bool wifi_state = false;
 266         int value = 0;
 267
 268         wifi_is_activated(&wifi_state);
 269         _set_vconf_prev_wifi_state(wifi_state);
 270         value = _get_checkbox_status(TETHERING_TYPE_WIFI);
 271         if (0 == value) {
 272                 if (wifi_state == true || _is_wifi_direct_on() == true) {
 273                         fmt = STR_TETH_ON_DESC_1;
 274                 } else {
 275                         fmt = STR_TETH_ON_DESC_2;
 276                 }
 277                 str = g_malloc0(MH_LABEL_LENGTH_MAX);
 278                 if (str == NULL) {
 279                         ERR("memory allocation is failed\n");
 280                         return -1;
 281                 }
 282                 snprintf(str, MH_LABEL_LENGTH_MAX, fmt, TETHERING_WIFI_MAX_CONNECTED_STA);
 283                 _wifi_tethering_checkbox_popup_status_set(true);
 284                 _prepare_popup(MH_POPUP_WIFI_ON_CHECKBOX, str);
 285                 g_free(str);
 286                 _create_popup(ad);
 287         } else {
 288                 _prepare_popup_type(MH_POPUP_WIFI_ON_CHECKBOX);
 289                 _teth_on(ad);
 290         }
 291         return 0;
 292 }
 293
 294 int _create_bt_tethering_on_popup(mh_appdata_t *ad)
 295 {
 296         char *fmt = STR_TETH_ON_DESC_2;
 297         char *str = NULL;
 298         int value = 0;
 299         value = _get_checkbox_status(TETHERING_TYPE_BT);
 300         if (0 == value) {
 301                 str = g_malloc0(MH_LABEL_LENGTH_MAX);
 302                 if (str == NULL) {
 303                         ERR("memory allocation is failed\n");
 304                         return -1;
 305                 }
 306                 snprintf(str, MH_LABEL_LENGTH_MAX, fmt,
 307                                 TETHERING_BT_MAX_CONNECTED_STA);
 308                 _prepare_popup(MH_POPUP_BT_ON_CHECKBOX, str);
 309                 g_free(str);
 310                 _create_popup(ad);
 311         } else {
 312                 _prepare_popup_type(MH_POPUP_BT_ON_CHECKBOX);
 313                 _teth_on(ad);
 314         }
 315         return 0;
 316 }
 317
 318 int _create_usb_tethering_on_popup(mh_appdata_t *ad)
 319 {
 320         int value = 0;
 321         char *str = NULL;
 322         value = _get_checkbox_status(TETHERING_TYPE_USB);
 323         DBG("%s : %d\n", VCONF_MOBILE_AP_USB_POPUP_CHECKBOX_STATUS, value);
 324         if (0 == value) {
 325                 str = g_malloc0(MH_LABEL_LENGTH_MAX);
 326                 if (str == NULL) {
 327                         ERR("memory allocation is failed\n");
 328                         return -1;
 329                 }
 330                 snprintf(str, MH_LABEL_LENGTH_MAX, "%s",
 331                                 STR_TETH_ON_DESC_3);
 332                 _prepare_popup(MH_POPUP_USB_ON_CHECKBOX, str);
 333                 g_free(str);
 334                 _create_popup(ad);
 335         } else {
 336                 _prepare_popup_type(MH_POPUP_USB_ON_CHECKBOX);
 337                 _teth_on(ad);
 338         }
 339         return 0;
 340 }
 341
 342 static void __disable_tethering_by_ind(mh_appdata_t *ad, tethering_disabled_cause_e cause)
 343 {
 344         if (ad == NULL) {
 345                 ERR("Param is NULL\n");
 346                 return;
 347         }
 348
 349         DBG("cause : %d\n", cause);
 350         switch (cause) {
 351         case TETHERING_DISABLED_BY_WIFI_ON:
 352                 break;
 353
 354         case TETHERING_DISABLED_BY_BT_OFF:
 355                 break;
 356
 357         case TETHERING_DISABLED_BY_USB_DISCONNECTION:
 358                 if (ad->is_bt_teth_enabling && ad->main.bt_item) {
 359                         _update_bt_item(ad, MH_STATE_NONE);
 360                         ad->is_bt_teth_enabling = false;
 361                 }
 362                 if (ad->is_wifi_teth_enabling && ad->main.wifi_item) {
 363                         _update_wifi_item(ad, MH_STATE_NONE);
 364                         ad->is_wifi_teth_enabling = false;
 365                 }
 366                 break;
 367
 368         case TETHERING_DISABLED_BY_FLIGHT_MODE:
 369                 break;
 370
 371         case TETHERING_DISABLED_BY_TIMEOUT:
 372                 break;
 373
 374         case TETHERING_DISABLED_BY_OTHERS:
 375                 if (ad->main.wifi_item && _get_vconf_prev_wifi_state() == true) {
 376                         elm_object_item_disabled_set(ad->main.wifi_item, EINA_TRUE);
 377                 }
 378                 break;
 379
 380         case TETHERING_DISABLED_BY_LOW_BATTERY:
 381                 break;
 382
 383         default:
 384                 break;
 385         }
 386
 387         return;
 388 }
 389
 390 /* Wi-Fi callbacks */
 391 static void __wifi_activated_cb(wifi_error_e result, void *user_data)
 392 {
 393         DBG("+\n");
 394
 395         return;
 396 }
 397
 398 /* Tethering callbacks */
 399 void _enabled_cb(tethering_error_e result, tethering_type_e type, bool is_requested, void *user_data)
 400 {
 401         DBG("+\n");
 402         DBG("result : %d, type : %d, is_requested : %d\n", result, type, is_requested);
 403
 404         if (user_data == NULL) {
 405                 ERR("user_data is NULL\n");
 406                 return;
 407         }
 408
 409         mh_appdata_t *ad = (mh_appdata_t *)user_data;
 410
 411         if (!is_requested) {
 412                 if (ad->type == type && ad->popup) {
 413                         DBG("This tethering type is already enabled\n");
 414                         evas_object_del(ad->popup);
 415                         ad->popup = NULL;
 416                 }
 417                 _update_main_view(ad, type);
 418                 if (type == TETHERING_TYPE_RESERVED) {
 419                         DBG("MobileAP is turned on\n");
 420                         _prepare_popup(MH_POPUP_WIFI_AP_OFF, STR_WIFI_AP_CONTROLLED_ANOTHER_APP);
 421                         _create_popup(ad);
 422                 }
 423                 return;
 424         }
 425
 426         if (result != TETHERING_ERROR_NONE) {
 427         }
 428         _update_main_view(ad, type);
 429
 430         return;
 431 }
 432
 433 void _disabled_cb(tethering_error_e result, tethering_type_e type, tethering_disabled_cause_e cause, void *user_data)
 434 {
 435         DBG("+\n");
 436         DBG("result : %d, type : %d, cause : %d\n", result, type, cause);
 437
 438         if (user_data == NULL) {
 439                 ERR("user_data is NULL\n");
 440                 return;
 441         }
 442
 443         mh_appdata_t *ad = (mh_appdata_t *)user_data;
 444
 445         if (cause != TETHERING_DISABLED_BY_REQUEST) {
 446                 if (ad->type == type && ad->popup) {
 447                         DBG("This tethering type is already disabled\n");
 448                         evas_object_del(ad->popup);
 449                         ad->popup = NULL;
 450                 }
 451                 __disable_tethering_by_ind(ad, cause);
 452                 _update_main_view(ad, type);
 453                 return;
 454         }
 455
 456         if (result != TETHERING_ERROR_NONE) {
 457                 _prepare_popup(MH_POPUP_TETH_ENABLING_FAILED, STR_UNABLE_TO_USE_TETH);
 458                 _create_popup(ad);
 459                 _update_main_view(ad, type);
 460                 return;
 461         }
 462
 463         if (ad->main.wifi_item && type == TETHERING_TYPE_WIFI && _get_vconf_prev_wifi_state() == true) {
 464                 elm_object_item_disabled_set(ad->main.wifi_item, EINA_TRUE);
 465         }
 466
 467         _update_main_view(ad, type);
 468
 469         return;
 470 }
 471
 472 void _connection_changed_cb(tethering_client_h client, bool is_opened, void *user_data)
 473 {
 474         DBG("+\n");
 475
 476         if (user_data == NULL) {
 477                 ERR("user_data is NULL\n");
 478                 return;
 479         }
 480
 481         mh_appdata_t *ad = (mh_appdata_t *)user_data;
 482         char *mac_addr = NULL;
 483
 484         if (is_opened) {
 485                 _append_list_client_handle(ad, client);
 486
 487 #ifdef TETHERING_DATA_USAGE_SUPPORT
 488                 if (ad->is_foreground && _get_list_clients_count(ad) == 1) {
 489                         _start_update_data_packet_usage(ad);
 490                 }
 491 #endif
 492         } else {
 493                 tethering_client_get_mac_address(client, &mac_addr);
 494                 if (mac_addr) {
 495                         _delete_list_client_handle(ad, mac_addr);
 496                         free(mac_addr);
 497                 }
 498 #ifdef TETHERING_DATA_USAGE_SUPPORT
 499                 if (ad->is_foreground && _get_list_clients_count(ad) == 0)
 500                         _stop_update_data_packet_usage(ad);
 501 #endif
 502         }
 503
 504         ap_update_data_device(ad);
 505
 506         return;
 507 }
 508
 509 void _wifi_state_changed_cb(wifi_device_state_e state, void *user_data)
 510 {
 511         if (user_data == NULL) {
 512                 ERR("user_data is NULL\n");
 513                 return;
 514         }
 515
 516         DBG("+\n");
 517
 518         mh_appdata_t *ad= (mh_appdata_t *)user_data;
 519         char *str = NULL;
 520         char *fmt = NULL;
 521         if (state == WIFI_DEVICE_STATE_ACTIVATED) {
 522                 if (ad->main.wifi_item && elm_object_item_disabled_get(ad->main.wifi_item))
 523                         elm_object_item_disabled_set(ad->main.wifi_item, EINA_FALSE);
 524                 _set_vconf_prev_wifi_state(false);
 525         } else if (state == WIFI_DEVICE_STATE_DEACTIVATED){
 526                 _set_vconf_prev_wifi_state(true);
 527         }
 528
 529         if (ad->type == TETHERING_TYPE_WIFI && ad->popup && ad->popup_checkbox &&
 530                         _wifi_tethering_checkbox_popup_status_get()) {
 531                 evas_object_del(ad->popup_checkbox);
 532                 ad->popup_checkbox = NULL;
 533                 evas_object_del(ad->popup);
 534                 ad->popup = NULL;
 535                 if (state == WIFI_DEVICE_STATE_ACTIVATED) {
 536                         fmt = STR_TETH_ON_DESC_1;
 537                 } else {
 538                         fmt = STR_TETH_ON_DESC_2;
 539                 }
 540                 str = g_malloc0(MH_LABEL_LENGTH_MAX);
 541                 if (str == NULL) {
 542                         ERR("memory allocation is failed\n");
 543                         return;
 544                 }
 545                 snprintf(str, MH_LABEL_LENGTH_MAX, fmt, TETHERING_WIFI_MAX_CONNECTED_STA);
 546                 _prepare_popup(MH_POPUP_WIFI_ON_CHECKBOX, str);
 547                 g_free(str);
 548                 _create_popup(ad);
 549         }
 550         DBG("-\n");
 551 }
 552
 553 void _visibility_changed_cb(bool is_visible, void *user_data)
 554 {
 555         DBG("+\n");
 556
 557         if (user_data == NULL) {
 558                 ERR("user_data is NULL\n");
 559                 return;
 560         }
 561
 562         mh_appdata_t *ad = (mh_appdata_t *)user_data;
 563
 564         if (ad->setup.visibility == is_visible)
 565                 return;
 566
 567         ad->setup.visibility = is_visible;
 568         ad->setup.visibility_new = is_visible;
 569         if (ad->setup.hide_item)
 570                 elm_genlist_item_update(ad->setup.hide_item);
 571
 572         DBG("-\n");
 573
 574         return;
 575 }
 576
 577 void _security_type_changed_cb(tethering_wifi_security_type_e changed_type, void *user_data)
 578 {
 579         DBG("+\n");
 580
 581         if (user_data == NULL) {
 582                 ERR("user_data is NULL\n");
 583                 return;
 584         }
 585
 586         mh_appdata_t *ad = (mh_appdata_t *)user_data;
 587
 588         if (ad->setup.security_type == changed_type)
 589                 return;
 590
 591         ad->setup.security_type = changed_type;
 592         ad->setup.security_type_new = changed_type;
 593
 594         if (ad->setup.security_item)
 595                 elm_genlist_item_update(ad->setup.security_item);
 596
 597         DBG("-\n");
 598
 599         return;
 600 }
 601
 602 void _passphrase_changed_cb(void *user_data)
 603 {
 604         DBG("+\n");
 605
 606         if (user_data == NULL) {
 607                 ERR("user_data is NULL\n");
 608                 return;
 609         }
 610
 611         mh_appdata_t *ad = (mh_appdata_t *)user_data;
 612         char *passphrase = NULL;
 613         int ret;
 614
 615         ret = tethering_wifi_get_passphrase(ad->handle, &passphrase);
 616         if (ret != TETHERING_ERROR_NONE) {
 617                 ERR("tethering_wifi_get_passphrase failed ret = [0x%x]\n", ret);
 618                 return;
 619         }
 620
 621         if (!g_strcmp0(passphrase, ad->setup.wifi_passphrase)) {
 622                 goto DONE;
 623         }
 624
 625         g_strlcpy(ad->setup.wifi_passphrase, passphrase,
 626                 sizeof(ad->setup.wifi_passphrase));
 627
 628         g_strlcpy(ad->setup.wifi_passphrase_new, passphrase,
 629                 sizeof(ad->setup.wifi_passphrase_new));
 630
 631         if (ad->setup.pw_item)
 632                 elm_genlist_item_update(ad->setup.pw_item);
 633
 634 DONE:
 635         g_free(passphrase);
 636         DBG("-\n");
 637         return;
 638 }
 639
 640 #ifdef TETHERING_DATA_USAGE_SUPPORT
 641 void _data_usage_cb(tethering_error_e result, unsigned long long received_data, unsigned long long sent_data, void *user_data)
 642 {
 643         if (user_data == NULL) {
 644                 ERR("user_data is NULL\n");
 645                 return;
 646         }
 647
 648         mh_appdata_t *ad = (mh_appdata_t *)user_data;
 649
 650         if (ad->data_statistics.pdp_total_sent != sent_data ||
 651                         ad->data_statistics.pdp_total_receive != received_data) {
 652                 ad->data_statistics.pdp_total_sent = sent_data;
 653                 ad->data_statistics.pdp_total_receive = received_data;
 654                 ap_update_data_packet_usage(ad);
 655         }
 656
 657         ad->data_statistics.is_updated = true;
 658
 659         return;
 660 }
 661 #endif
 662 /* End of Tethering callbacks */
 663
 664 int _handle_wifi_onoff_change(mh_appdata_t *ad)
 665 {
 666         __MOBILE_AP_FUNC_ENTER__;
 667
 668         int ret;
 669         int connected_wifi_clients = 0;
 670
 671         /* Turn off WiFi hotspot */
 672         if (ad->main.hotspot_mode & VCONFKEY_MOBILE_HOTSPOT_MODE_WIFI) {
 673                 if (_get_no_of_connected_device(ad, &connected_wifi_clients,
 674                                         TETHERING_TYPE_WIFI) == EINA_FALSE) {
 675                         ERR("Getting the number of connected device is failed\n");
 676                 }
 677                 if (connected_wifi_clients > 0) {
 678                         _prepare_popup(MH_POPUP_WIFI_OFF, STR_CLOSE_INTERNET_Q);
 679                         _create_popup(ad);
 680                 } else {
 681                         ret = tethering_disable(ad->handle, TETHERING_TYPE_WIFI);
 682                         if (ret != TETHERING_ERROR_NONE) {
 683                                 ERR("wifi tethering off is failed : %d\n", ret);
 684                                 return -1;
 685                         }
 686                         _send_signal_qp(QP_SIGNAL_PROGRESS_OFF);
 687                 }
 688                 return 0;
 689         }
 690
 691         /* Turn on WiFi hotspot */
 692         ret = __is_preconditions_handled(ad);
 693         if (ret < 0)
 694                 return -1;
 695         else if (ret == 0)
 696                 return 0;
 697
 698         if (_create_wifi_hotspot_on_popup(ad) < 0) {
 699                 ERR("__create_wifi_hotspot_on_popup fail\n");
 700                 return -1;
 701         }
 702
 703         __MOBILE_AP_FUNC_EXIT__;
 704
 705         return 0;
 706 }
 707
 708 int _handle_bt_onoff_change(mh_appdata_t *ad)
 709 {
 710         __MOBILE_AP_FUNC_ENTER__;
 711
 712         int ret;
 713
 714         /* Turn off Bluetooth tethering */
 715         if (ad->main.hotspot_mode & VCONFKEY_MOBILE_HOTSPOT_MODE_BT) {
 716                 ret = tethering_disable(ad->handle, TETHERING_TYPE_BT);
 717                 if (ret) {
 718                         ERR("Error disable bt tethering [%d]\n", ret);
 719                         return -1;
 720                 }
 721                 return 0;
 722         }
 723
 724         /* Turn on Bluetooth tethering */
 725         ret = __is_preconditions_handled(ad);
 726         if (ret < 0)
 727                 return -1;
 728         else if (ret == 0)
 729                 return 0;
 730
 731         if (_create_bt_tethering_on_popup(ad) < 0) {
 732                 ERR("_create_bt_tethering_on_popup fail\n");
 733                 return -1;
 734         }
 735
 736         __MOBILE_AP_FUNC_EXIT__;
 737
 738         return 0;
 739 }
 740
 741 int _handle_usb_onoff_change(mh_appdata_t *ad)
 742 {
 743         __MOBILE_AP_FUNC_ENTER__;
 744
 745         int ret;
 746
 747         /* Turn off USB tethering */
 748         if (ad->main.hotspot_mode & VCONFKEY_MOBILE_HOTSPOT_MODE_USB) {
 749                 ret = tethering_disable(ad->handle, TETHERING_TYPE_USB);
 750                 if (ret) {
 751                         ERR("Error disable usb tethering : %d\n", ret);
 752                         return -1;
 753                 }
 754                 return 0;
 755         }
 756
 757         /* Turn on USB tethering */
 758         ret = __is_preconditions_handled(ad);
 759         if (ret < 0)
 760                 return -1;
 761         else if (ret == 0)
 762                 return 0;
 763
 764         if (_create_usb_tethering_on_popup(ad) < 0) {
 765                 ERR("_create_usb_tethering_on_popup fail\n");
 766                 return -1;
 767         }
 768
 769         __MOBILE_AP_FUNC_EXIT__;
 770
 771         return 0;
 772 }
 773
 774 int _turn_on_wifi(void)
 775 {
 776         int ret;
 777
 778         ret = wifi_activate(__wifi_activated_cb, NULL);
 779         if (ret != WIFI_ERROR_NONE) {
 780                 ERR("wifi_activate() is failed : %d\n", ret);
 781                 return -1;
 782         }
 783
 784         return 0;
 785 }
 786
 787 bool _is_wifi_direct_on(void)
 788 {
 789         int wifi_direct_state = 0;
 790         int ret;
 791
 792         ret = vconf_get_int(VCONFKEY_WIFI_DIRECT_STATE, &wifi_direct_state);
 793         if (ret < 0) {
 794                 ERR("vconf_get_int() is failed : %d\n", ret);
 795                 return false;
 796         }
 797
 798         return wifi_direct_state != 0 ? true : false;
 799 }