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                 return;
 419         }
 420
 421         if (result != TETHERING_ERROR_NONE) {
 422         }
 423         _update_main_view(ad, type);
 424
 425         return;
 426 }
 427
 428 void _disabled_cb(tethering_error_e result, tethering_type_e type, tethering_disabled_cause_e cause, void *user_data)
 429 {
 430         DBG("+\n");
 431         DBG("result : %d, type : %d, cause : %d\n", result, type, cause);
 432
 433         if (user_data == NULL) {
 434                 ERR("user_data is NULL\n");
 435                 return;
 436         }
 437
 438         mh_appdata_t *ad = (mh_appdata_t *)user_data;
 439
 440         if (cause != TETHERING_DISABLED_BY_REQUEST) {
 441                 if (ad->type == type && ad->popup) {
 442                         DBG("This tethering type is already disabled\n");
 443                         evas_object_del(ad->popup);
 444                         ad->popup = NULL;
 445                 }
 446                 __disable_tethering_by_ind(ad, cause);
 447                 _update_main_view(ad, type);
 448                 return;
 449         }
 450
 451         if (result != TETHERING_ERROR_NONE) {
 452                 _prepare_popup(MH_POPUP_TETH_ENABLING_FAILED, STR_UNABLE_TO_USE_TETH);
 453                 _create_popup(ad);
 454                 _update_main_view(ad, type);
 455                 return;
 456         }
 457
 458         if (ad->main.wifi_item && type == TETHERING_TYPE_WIFI && _get_vconf_prev_wifi_state() == true) {
 459                 elm_object_item_disabled_set(ad->main.wifi_item, EINA_TRUE);
 460         }
 461
 462         _update_main_view(ad, type);
 463
 464         return;
 465 }
 466
 467 void _connection_changed_cb(tethering_client_h client, bool is_opened, void *user_data)
 468 {
 469         DBG("+\n");
 470
 471         if (user_data == NULL) {
 472                 ERR("user_data is NULL\n");
 473                 return;
 474         }
 475
 476         mh_appdata_t *ad = (mh_appdata_t *)user_data;
 477         char *mac_addr = NULL;
 478
 479         if (is_opened) {
 480                 _append_list_client_handle(ad, client);
 481
 482 #ifdef TETHERING_DATA_USAGE_SUPPORT
 483                 if (ad->is_foreground && _get_list_clients_count(ad) == 1) {
 484                         _start_update_data_packet_usage(ad);
 485                 }
 486 #endif
 487         } else {
 488                 tethering_client_get_mac_address(client, &mac_addr);
 489                 if (mac_addr) {
 490                         _delete_list_client_handle(ad, mac_addr);
 491                         free(mac_addr);
 492                 }
 493 #ifdef TETHERING_DATA_USAGE_SUPPORT
 494                 if (ad->is_foreground && _get_list_clients_count(ad) == 0)
 495                         _stop_update_data_packet_usage(ad);
 496 #endif
 497         }
 498
 499         ap_update_data_device(ad);
 500
 501         return;
 502 }
 503
 504 void _wifi_state_changed_cb(wifi_device_state_e state, void *user_data)
 505 {
 506         if (user_data == NULL) {
 507                 ERR("user_data is NULL\n");
 508                 return;
 509         }
 510
 511         DBG("+\n");
 512
 513         mh_appdata_t *ad= (mh_appdata_t *)user_data;
 514         char *str = NULL;
 515         char *fmt = NULL;
 516         if (state == WIFI_DEVICE_STATE_ACTIVATED) {
 517                 if (ad->main.wifi_item && elm_object_item_disabled_get(ad->main.wifi_item))
 518                         elm_object_item_disabled_set(ad->main.wifi_item, EINA_FALSE);
 519                 _set_vconf_prev_wifi_state(false);
 520         } else if (state == WIFI_DEVICE_STATE_DEACTIVATED){
 521                 _set_vconf_prev_wifi_state(true);
 522         }
 523
 524         if (ad->type == TETHERING_TYPE_WIFI && ad->popup && ad->popup_checkbox &&
 525                         _wifi_tethering_checkbox_popup_status_get()) {
 526                 evas_object_del(ad->popup_checkbox);
 527                 ad->popup_checkbox = NULL;
 528                 evas_object_del(ad->popup);
 529                 ad->popup = NULL;
 530                 if (state == WIFI_DEVICE_STATE_ACTIVATED) {
 531                         fmt = STR_TETH_ON_DESC_1;
 532                 } else {
 533                         fmt = STR_TETH_ON_DESC_2;
 534                 }
 535                 str = g_malloc0(MH_LABEL_LENGTH_MAX);
 536                 if (str == NULL) {
 537                         ERR("memory allocation is failed\n");
 538                         return;
 539                 }
 540                 snprintf(str, MH_LABEL_LENGTH_MAX, fmt, TETHERING_WIFI_MAX_CONNECTED_STA);
 541                 _prepare_popup(MH_POPUP_WIFI_ON_CHECKBOX, str);
 542                 g_free(str);
 543                 _create_popup(ad);
 544         }
 545         DBG("-\n");
 546 }
 547
 548 void _visibility_changed_cb(bool is_visible, void *user_data)
 549 {
 550         DBG("+\n");
 551
 552         if (user_data == NULL) {
 553                 ERR("user_data is NULL\n");
 554                 return;
 555         }
 556
 557         mh_appdata_t *ad = (mh_appdata_t *)user_data;
 558
 559         if (ad->setup.visibility == is_visible)
 560                 return;
 561
 562         ad->setup.visibility = is_visible;
 563         ad->setup.visibility_new = is_visible;
 564         if (ad->setup.hide_item)
 565                 elm_genlist_item_update(ad->setup.hide_item);
 566
 567         DBG("-\n");
 568
 569         return;
 570 }
 571
 572 void _security_type_changed_cb(tethering_wifi_security_type_e changed_type, void *user_data)
 573 {
 574         DBG("+\n");
 575
 576         if (user_data == NULL) {
 577                 ERR("user_data is NULL\n");
 578                 return;
 579         }
 580
 581         mh_appdata_t *ad = (mh_appdata_t *)user_data;
 582
 583         if (ad->setup.security_type == changed_type)
 584                 return;
 585
 586         ad->setup.security_type = changed_type;
 587         ad->setup.security_type_new = changed_type;
 588
 589         if (ad->setup.security_item)
 590                 elm_genlist_item_update(ad->setup.security_item);
 591
 592         DBG("-\n");
 593
 594         return;
 595 }
 596
 597 void _passphrase_changed_cb(void *user_data)
 598 {
 599         DBG("+\n");
 600
 601         if (user_data == NULL) {
 602                 ERR("user_data is NULL\n");
 603                 return;
 604         }
 605
 606         mh_appdata_t *ad = (mh_appdata_t *)user_data;
 607         char *passphrase = NULL;
 608         int ret;
 609
 610         ret = tethering_wifi_get_passphrase(ad->handle, &passphrase);
 611         if (ret != TETHERING_ERROR_NONE) {
 612                 ERR("tethering_wifi_get_passphrase failed ret = [0x%x]\n", ret);
 613                 return;
 614         }
 615
 616         if (!g_strcmp0(passphrase, ad->setup.wifi_passphrase)) {
 617                 goto DONE;
 618         }
 619
 620         g_strlcpy(ad->setup.wifi_passphrase, passphrase,
 621                 sizeof(ad->setup.wifi_passphrase));
 622
 623         g_strlcpy(ad->setup.wifi_passphrase_new, passphrase,
 624                 sizeof(ad->setup.wifi_passphrase_new));
 625
 626         if (ad->setup.pw_item)
 627                 elm_genlist_item_update(ad->setup.pw_item);
 628
 629 DONE:
 630         g_free(passphrase);
 631         DBG("-\n");
 632         return;
 633 }
 634
 635 #ifdef TETHERING_DATA_USAGE_SUPPORT
 636 void _data_usage_cb(tethering_error_e result, unsigned long long received_data, unsigned long long sent_data, void *user_data)
 637 {
 638         if (user_data == NULL) {
 639                 ERR("user_data is NULL\n");
 640                 return;
 641         }
 642
 643         mh_appdata_t *ad = (mh_appdata_t *)user_data;
 644
 645         if (ad->data_statistics.pdp_total_sent != sent_data ||
 646                         ad->data_statistics.pdp_total_receive != received_data) {
 647                 ad->data_statistics.pdp_total_sent = sent_data;
 648                 ad->data_statistics.pdp_total_receive = received_data;
 649                 ap_update_data_packet_usage(ad);
 650         }
 651
 652         ad->data_statistics.is_updated = true;
 653
 654         return;
 655 }
 656 #endif
 657 /* End of Tethering callbacks */
 658
 659 int _handle_wifi_onoff_change(mh_appdata_t *ad)
 660 {
 661         __MOBILE_AP_FUNC_ENTER__;
 662
 663         int ret;
 664         int connected_wifi_clients = 0;
 665
 666         /* Turn off WiFi hotspot */
 667         if (ad->main.hotspot_mode & VCONFKEY_MOBILE_HOTSPOT_MODE_WIFI) {
 668                 if (_get_no_of_connected_device(ad, &connected_wifi_clients,
 669                                         TETHERING_TYPE_WIFI) == EINA_FALSE) {
 670                         ERR("Getting the number of connected device is failed\n");
 671                 }
 672                 if (connected_wifi_clients > 0) {
 673                         _prepare_popup(MH_POPUP_WIFI_OFF, STR_CLOSE_INTERNET_Q);
 674                         _create_popup(ad);
 675                 } else {
 676                         ret = tethering_disable(ad->handle, TETHERING_TYPE_WIFI);
 677                         if (ret != TETHERING_ERROR_NONE) {
 678                                 ERR("wifi tethering off is failed : %d\n", ret);
 679                                 return -1;
 680                         }
 681                         _send_signal_qp(QP_SIGNAL_PROGRESS_OFF);
 682                 }
 683                 return 0;
 684         }
 685
 686         /* Turn on WiFi hotspot */
 687         ret = __is_preconditions_handled(ad);
 688         if (ret < 0)
 689                 return -1;
 690         else if (ret == 0)
 691                 return 0;
 692
 693         if (_create_wifi_hotspot_on_popup(ad) < 0) {
 694                 ERR("__create_wifi_hotspot_on_popup fail\n");
 695                 return -1;
 696         }
 697
 698         __MOBILE_AP_FUNC_EXIT__;
 699
 700         return 0;
 701 }
 702
 703 int _handle_bt_onoff_change(mh_appdata_t *ad)
 704 {
 705         __MOBILE_AP_FUNC_ENTER__;
 706
 707         int ret;
 708
 709         /* Turn off Bluetooth tethering */
 710         if (ad->main.hotspot_mode & VCONFKEY_MOBILE_HOTSPOT_MODE_BT) {
 711                 ret = tethering_disable(ad->handle, TETHERING_TYPE_BT);
 712                 if (ret) {
 713                         ERR("Error disable bt tethering [%d]\n", ret);
 714                         return -1;
 715                 }
 716                 return 0;
 717         }
 718
 719         /* Turn on Bluetooth tethering */
 720         ret = __is_preconditions_handled(ad);
 721         if (ret < 0)
 722                 return -1;
 723         else if (ret == 0)
 724                 return 0;
 725
 726         if (_create_bt_tethering_on_popup(ad) < 0) {
 727                 ERR("_create_bt_tethering_on_popup fail\n");
 728                 return -1;
 729         }
 730
 731         __MOBILE_AP_FUNC_EXIT__;
 732
 733         return 0;
 734 }
 735
 736 int _handle_usb_onoff_change(mh_appdata_t *ad)
 737 {
 738         __MOBILE_AP_FUNC_ENTER__;
 739
 740         int ret;
 741
 742         /* Turn off USB tethering */
 743         if (ad->main.hotspot_mode & VCONFKEY_MOBILE_HOTSPOT_MODE_USB) {
 744                 ret = tethering_disable(ad->handle, TETHERING_TYPE_USB);
 745                 if (ret) {
 746                         ERR("Error disable usb tethering : %d\n", ret);
 747                         return -1;
 748                 }
 749                 return 0;
 750         }
 751
 752         /* Turn on USB tethering */
 753         ret = __is_preconditions_handled(ad);
 754         if (ret < 0)
 755                 return -1;
 756         else if (ret == 0)
 757                 return 0;
 758
 759         if (_create_usb_tethering_on_popup(ad) < 0) {
 760                 ERR("_create_usb_tethering_on_popup fail\n");
 761                 return -1;
 762         }
 763
 764         __MOBILE_AP_FUNC_EXIT__;
 765
 766         return 0;
 767 }
 768
 769 int _turn_on_wifi(void)
 770 {
 771         int ret;
 772
 773         ret = wifi_activate(__wifi_activated_cb, NULL);
 774         if (ret != WIFI_ERROR_NONE) {
 775                 ERR("wifi_activate() is failed : %d\n", ret);
 776                 return -1;
 777         }
 778
 779         return 0;
 780 }
 781
 782 bool _is_wifi_direct_on(void)
 783 {
 784         int wifi_direct_state = 0;
 785         int ret;
 786
 787         ret = vconf_get_int(VCONFKEY_WIFI_DIRECT_STATE, &wifi_direct_state);
 788         if (ret < 0) {
 789                 ERR("vconf_get_int() is failed : %d\n", ret);
 790                 return false;
 791         }
 792
 793         return wifi_direct_state != 0 ? true : false;
 794 }