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.1 (the "License");
   7 * you may not use this file except in compliance with the License.
   8 * You may obtain a copy of the License at
   9
  10 * http://www.tizenopensource.org/license
  11
  12 * Unless required by applicable law or agreed to in writing, software
  13 * distributed under the License is distributed on an "AS IS" BASIS,
  14 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  15 * See the License for the specific language governing permissions and
  16 * limitations under the License.
  17 *
  18 */
  19
  20 #include <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         case TETHERING_TYPE_BT:
  37                 _update_bt_item(ad, MH_STATE_NONE);
  38                 ad->is_bt_teth_enabling = false;
  39                 break;
  40         case TETHERING_TYPE_USB:
  41                 _update_usb_item(ad, MH_STATE_NONE);
  42                 ad->is_usb_teth_enabling = false;
  43                 break;
  44         default:
  45                 ERR("invalid type \n");
  46                 break;
  47         }
  48 }
  49 void _wifi_tethering_checkbox_popup_status_set(bool value)
  50 {
  51         is_wifi_tethering_checkbox_popup_active = value;
  52 }
  53
  54 bool _wifi_tethering_checkbox_popup_status_get(void)
  55 {
  56         return is_wifi_tethering_checkbox_popup_active;
  57 }
  58
  59 int _get_vconf_usb_state()
  60 {
  61         int value = VCONFKEY_SYSMAN_USB_DISCONNECTED;
  62
  63         if (vconf_get_int(VCONFKEY_SYSMAN_USB_STATUS, &value) < 0) {
  64                 ERR("vconf_get_int is failed\n");
  65                 return 0;
  66         }
  67         DBG("%s : %d\n", VCONFKEY_SYSMAN_USB_STATUS, value);
  68
  69         return value;
  70 }
  71
  72 void _update_tethering_item(mh_appdata_t * ad, mh_state_e state)
  73 {
  74         ERR("type : %d state : %d\n", ad->type, state);
  75         switch (ad->type) {
  76         case TETHERING_TYPE_WIFI:
  77                 _update_wifi_item(ad, state);
  78                 break;
  79         case TETHERING_TYPE_BT:
  80                 _update_bt_item(ad, state);
  81                 break;
  82         case TETHERING_TYPE_USB:
  83                 _update_usb_item(ad, state);
  84                 break;
  85         default:
  86                 break;
  87         }
  88 }
  89
  90 gboolean _ps_recheck_timeout_cb(gpointer data)
  91 {
  92         connection_cellular_state_e cellular_state = _get_cellular_state();
  93         mh_appdata_t *ad = (mh_appdata_t *)data;
  94         static int recheck_count = 0;
  95
  96         DBG("Re-Check cellular state (%d)\n", recheck_count);
  97
  98         if (cellular_state == CONNECTION_CELLULAR_STATE_FLIGHT_MODE) {
  99                 _update_tethering_item(ad, MH_STATE_NONE);
 100                 recheck_count = 0;
 101                 return FALSE;
 102         }
 103
 104         if (cellular_state == CONNECTION_CELLULAR_STATE_CONNECTED ||
 105                 cellular_state == CONNECTION_CELLULAR_STATE_AVAILABLE) {
 106                 if (ad->type == TETHERING_TYPE_WIFI) {
 107                         if (_create_wifi_hotspot_on_popup(ad) < 0) {
 108                                 ERR("__create_wifi_hotspot_on_popup fail\n");
 109                                 _update_tethering_item(ad, MH_STATE_NONE);
 110                                 recheck_count = 0;
 111                                 return FALSE;
 112                         }
 113                 _send_signal_qp(QP_SIGNAL_PROGRESS_ON);
 114                 } else if (ad->type == TETHERING_TYPE_BT && _create_bt_tethering_on_popup(ad) < 0) {
 115                                 ERR("_create_bt_tethering_on_popup fail\n");
 116                                 _update_tethering_item(ad, MH_STATE_NONE);
 117                                 recheck_count = 0;
 118                                 return FALSE;
 119                 } else if (ad->type == TETHERING_TYPE_USB && _create_usb_tethering_on_popup(ad) < 0) {
 120                                 ERR("__create_usb_hotspot_on_popup fail\n");
 121                                 _update_tethering_item(ad, MH_STATE_NONE);
 122                                 recheck_count = 0;
 123                                 return FALSE;
 124                 } else {
 125                         ERR("Unknown tethering type \n");
 126                         recheck_count = 0;
 127                         return FALSE;
 128                 }
 129         } else {
 130                 if (++recheck_count >= PS_RECHECK_COUNT_MAX) {
 131                         DBG("Cellular network is not connected : %d\n", cellular_state);
 132                         _update_tethering_item(ad, MH_STATE_NONE);
 133                         _prepare_popup(MH_POPUP_NETWORK_OUT_OF_RANGE, STR_NO_DATA_SERVICE);
 134                         _create_popup(ad);
 135                         recheck_count = 0;
 136                         return FALSE;
 137                 }
 138                 return TRUE;
 139         }
 140         recheck_count = 0;
 141         return FALSE;
 142 }
 143
 144 static bool __is_connected_wifi_net(mh_appdata_t *ad)
 145 {
 146         connection_wifi_state_e wifi_state = CONNECTION_WIFI_STATE_DEACTIVATED;
 147         int ret;
 148
 149         ret = connection_get_wifi_state(ad->conn_handle, &wifi_state);
 150         if (ret != CONNECTION_ERROR_NONE) {
 151                 ERR("connection_get_wifi_state() is failed : %d\n");
 152                 return false;
 153         }
 154
 155         if (wifi_state != CONNECTION_WIFI_STATE_CONNECTED) {
 156                 ERR("Wi-Fi network is not connected : %d\n", wifi_state);
 157                 return false;
 158         }
 159
 160         DBG("Wi-Fi network is connected\n");
 161         return true;
 162 }
 163
 164 static bool __is_connected_ethernet_net(mh_appdata_t *ad)
 165 {
 166         connection_ethernet_state_e ethernet_state = CONNECTION_ETHERNET_STATE_DEACTIVATED;
 167         int ret;
 168
 169         ret = connection_get_ethernet_state(ad->conn_handle, &ethernet_state);
 170         if (ret != CONNECTION_ERROR_NONE) {
 171                 ERR("connection_get_ethernet_state() is failed : %d\n");
 172                 return false;
 173         }
 174
 175         if (ethernet_state != CONNECTION_ETHERNET_STATE_CONNECTED) {
 176                 ERR("Ethernet network is not connected : %d\n", ethernet_state);
 177                 return false;
 178         }
 179
 180         DBG("Ethernet network is connected\n");
 181         return true;
 182 }
 183
 184 static int __is_preconditions_handled(mh_appdata_t *ad)
 185 {
 186         DBG("+\n");
 187
 188         connection_cellular_state_e cellular_state = CONNECTION_CELLULAR_STATE_OUT_OF_SERVICE;
 189         int dnet_state = 0;
 190
 191         /* check ethernet connection */
 192         if (__is_connected_ethernet_net(ad)) {
 193                 DBG("ethernet network is connected\n");
 194                 return 1;
 195         }
 196
 197         /*  check wifi connection */
 198         if (ad->type != TETHERING_TYPE_WIFI) {
 199                 if (__is_connected_wifi_net(ad)) {
 200                         DBG("wifi network is connected\n");
 201                         return 1;
 202                 }
 203         }
 204
 205         /* Check SIM state */
 206         if (_get_sim_state() != VCONFKEY_TELEPHONY_SIM_INSERTED) {
 207                 if (ad->type == TETHERING_TYPE_WIFI)
 208                         _prepare_popup(MH_POPUP_NO_SIM, STR_INSERT_SIM_TO_USE_TETH);
 209                 else
 210                         _prepare_popup(MH_POPUP_NO_SIM, STR_CONN_MOBILE_DATA_TO_USE_TETH);
 211
 212                 _create_popup(ad);
 213                 return -1;
 214         }
 215
 216         /* Check cellular state */
 217         cellular_state = _get_cellular_state();
 218         DBG("cellular state is :  %d \n", cellular_state);
 219         if (cellular_state == CONNECTION_CELLULAR_STATE_FLIGHT_MODE) {
 220                 _prepare_popup(MH_POPUP_FLIGHT_MODE, STR_DISABLE_FLIGHT_MODE_MSG);
 221                 _create_popup(ad);
 222                 ERR("Flight mode is ON\n");
 223                 return -1;
 224         } else {
 225                 if (vconf_get_bool(VCONFKEY_3G_ENABLE , &dnet_state) < 0) {
 226                         ERR("vconf_get_bool is failed\n");
 227                 } else if (dnet_state == 0) {
 228                         DBG("Data Network is not connected");
 229                         _prepare_popup(MH_POPUP_MOBILE_DATA_OFF, STR_NO_NET_CONN_MSG);
 230                         _create_popup(ad);
 231                         return 0;
 232                 }
 233                 if (cellular_state != CONNECTION_CELLULAR_STATE_CONNECTED &&
 234                         cellular_state != CONNECTION_CELLULAR_STATE_AVAILABLE) {
 235                         if (ad->ps_recheck_timer_id > 0) {
 236                                 g_source_remove(ad->ps_recheck_timer_id);
 237                                 ad->ps_recheck_timer_id = 0;
 238                                 if (ad->is_wifi_teth_enabling == true
 239                                                 && ad->type != TETHERING_TYPE_WIFI)
 240                                         _update_tethering_enabling_item(ad, TETHERING_TYPE_WIFI,
 241                                                                                                         MH_STATE_NONE);
 242                                 if (ad->is_bt_teth_enabling == true
 243                                                 && ad->type != TETHERING_TYPE_BT)
 244                                         _update_tethering_enabling_item(ad, TETHERING_TYPE_BT,
 245                                                                                                         MH_STATE_NONE);
 246                                 if (ad->is_usb_teth_enabling == true
 247                                                 && ad->type != TETHERING_TYPE_USB)
 248                                         _update_tethering_enabling_item(ad, TETHERING_TYPE_USB,
 249                                                                                                         MH_STATE_NONE);
 250                         }
 251                         ad->ps_recheck_timer_id = g_timeout_add(PS_RECHECK_INTERVAL,
 252                                                                                 _ps_recheck_timeout_cb, (void*)ad);
 253                         return 0;
 254                 }
 255         }
 256
 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_manager_is_activated(ad->wifi_handle, &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                 break;
 378
 379         case TETHERING_DISABLED_BY_LOW_BATTERY:
 380                 break;
 381
 382         default:
 383                 break;
 384         }
 385
 386         return;
 387 }
 388
 389 /* Tethering callbacks */
 390 void _enabled_cb(tethering_error_e result, tethering_type_e type, bool is_requested, void *user_data)
 391 {
 392         DBG("+\n");
 393         DBG("result : %d, type : %d, is_requested : %d\n", result, type, is_requested);
 394
 395         if (user_data == NULL) {
 396                 ERR("user_data is NULL\n");
 397                 return;
 398         }
 399
 400         mh_appdata_t *ad = (mh_appdata_t *)user_data;
 401
 402         if (!is_requested) {
 403                 if (ad->type == type && ad->popup) {
 404                         DBG("This tethering type is already enabled\n");
 405                         evas_object_del(ad->popup);
 406                         ad->popup = NULL;
 407                 }
 408                 _update_main_view(ad, type);
 409                 return;
 410         }
 411
 412         _update_main_view(ad, type);
 413
 414         return;
 415 }
 416
 417 void _disabled_cb(tethering_error_e result, tethering_type_e type, tethering_disabled_cause_e cause, void *user_data)
 418 {
 419         DBG("+\n");
 420         DBG("result : %d, type : %d, cause : %d\n", result, type, cause);
 421
 422         if (user_data == NULL) {
 423                 ERR("user_data is NULL\n");
 424                 return;
 425         }
 426
 427         mh_appdata_t *ad = (mh_appdata_t *)user_data;
 428
 429         if (cause != TETHERING_DISABLED_BY_REQUEST) {
 430                 if (ad->type == type && ad->popup) {
 431                         DBG("This tethering type is already disabled\n");
 432                         evas_object_del(ad->popup);
 433                         ad->popup = NULL;
 434                 }
 435                 __disable_tethering_by_ind(ad, cause);
 436                 _update_main_view(ad, type);
 437                 return;
 438         }
 439
 440         if (result != TETHERING_ERROR_NONE) {
 441                 _prepare_popup(MH_POPUP_TETH_ENABLING_FAILED, STR_UNABLE_TO_USE_TETH);
 442                 _create_popup(ad);
 443                 _update_main_view(ad, type);
 444                 return;
 445         }
 446
 447         if (ad->main.wifi_item && type == TETHERING_TYPE_WIFI && _get_vconf_prev_wifi_state() == true)
 448                 elm_object_item_disabled_set(ad->main.wifi_item, EINA_TRUE);
 449
 450         _update_main_view(ad, type);
 451
 452         return;
 453 }
 454
 455 void _connection_changed_cb(tethering_client_h client, bool is_opened, void *user_data)
 456 {
 457         DBG("+\n");
 458
 459         if (user_data == NULL) {
 460                 ERR("user_data is NULL\n");
 461                 return;
 462         }
 463
 464         mh_appdata_t *ad = (mh_appdata_t *)user_data;
 465         char *mac_addr = NULL;
 466
 467         if (is_opened) {
 468                 _append_list_client_handle(ad, client);
 469
 470 #ifdef TETHERING_DATA_USAGE_SUPPORT
 471                 if (ad->is_foreground && _get_list_clients_count(ad) == 1)
 472                         _start_update_data_packet_usage(ad);
 473 #endif
 474         } else {
 475                 tethering_client_get_mac_address(client, &mac_addr);
 476                 if (mac_addr) {
 477                         _delete_list_client_handle(ad, mac_addr);
 478                         free(mac_addr);
 479                 }
 480 #ifdef TETHERING_DATA_USAGE_SUPPORT
 481                 if (ad->is_foreground && _get_list_clients_count(ad) == 0)
 482                         _stop_update_data_packet_usage(ad);
 483 #endif
 484         }
 485
 486         ap_update_data_device(ad);
 487
 488         return;
 489 }
 490
 491 void _wifi_state_changed_cb(wifi_manager_device_state_e state, void *user_data)
 492 {
 493         if (user_data == NULL) {
 494                 ERR("user_data is NULL\n");
 495                 return;
 496         }
 497
 498         DBG("+\n");
 499
 500         mh_appdata_t *ad = (mh_appdata_t *)user_data;
 501         char *str = NULL;
 502         char *fmt = NULL;
 503         if (state == WIFI_MANAGER_DEVICE_STATE_ACTIVATED) {
 504                 if (ad->main.wifi_item && elm_object_item_disabled_get(ad->main.wifi_item))
 505                         elm_object_item_disabled_set(ad->main.wifi_item, EINA_FALSE);
 506                 _set_vconf_prev_wifi_state(false);
 507         } else if (state == WIFI_MANAGER_DEVICE_STATE_DEACTIVATED) {
 508                 _set_vconf_prev_wifi_state(true);
 509         }
 510
 511         if (ad->type == TETHERING_TYPE_WIFI && ad->popup && ad->popup_checkbox &&
 512                         _wifi_tethering_checkbox_popup_status_get()) {
 513                 evas_object_del(ad->popup_checkbox);
 514                 ad->popup_checkbox = NULL;
 515                 evas_object_del(ad->popup);
 516                 ad->popup = NULL;
 517                 if (state == WIFI_MANAGER_DEVICE_STATE_ACTIVATED)
 518                         fmt = STR_TETH_ON_DESC_1;
 519                 else
 520                         fmt = STR_TETH_ON_DESC_2;
 521
 522                 str = g_malloc0(MH_LABEL_LENGTH_MAX);
 523                 if (str == NULL) {
 524                         ERR("memory allocation is failed\n");
 525                         return;
 526                 }
 527                 snprintf(str, MH_LABEL_LENGTH_MAX, fmt, TETHERING_WIFI_MAX_CONNECTED_STA);
 528                 _prepare_popup(MH_POPUP_WIFI_ON_CHECKBOX, str);
 529                 g_free(str);
 530                 _create_popup(ad);
 531         }
 532         DBG("-\n");
 533 }
 534
 535 void _visibility_changed_cb(bool is_visible, void *user_data)
 536 {
 537         DBG("+\n");
 538
 539         if (user_data == NULL) {
 540                 ERR("user_data is NULL\n");
 541                 return;
 542         }
 543
 544         mh_appdata_t *ad = (mh_appdata_t *)user_data;
 545
 546         if (ad->setup.visibility == is_visible)
 547                 return;
 548
 549         ad->setup.visibility = is_visible;
 550         ad->setup.visibility_new = is_visible;
 551         if (ad->setup.hide_item)
 552                 elm_genlist_item_update(ad->setup.hide_item);
 553
 554         DBG("-\n");
 555
 556         return;
 557 }
 558
 559 void _security_type_changed_cb(tethering_wifi_security_type_e changed_type, void *user_data)
 560 {
 561         DBG("+\n");
 562
 563         if (user_data == NULL) {
 564                 ERR("user_data is NULL\n");
 565                 return;
 566         }
 567
 568         mh_appdata_t *ad = (mh_appdata_t *)user_data;
 569
 570         if (ad->setup.security_type == changed_type)
 571                 return;
 572
 573         ad->setup.security_type = changed_type;
 574         ad->setup.security_type_new = changed_type;
 575
 576         if (ad->setup.security_item)
 577                 elm_genlist_item_update(ad->setup.security_item);
 578
 579         DBG("-\n");
 580
 581         return;
 582 }
 583
 584 void _passphrase_changed_cb(void *user_data)
 585 {
 586         DBG("+\n");
 587
 588         if (user_data == NULL) {
 589                 ERR("user_data is NULL\n");
 590                 return;
 591         }
 592
 593         mh_appdata_t *ad = (mh_appdata_t *)user_data;
 594         char *passphrase = NULL;
 595         int ret;
 596
 597         ret = tethering_wifi_get_passphrase(ad->handle, &passphrase);
 598         if (ret != TETHERING_ERROR_NONE) {
 599                 ERR("tethering_wifi_get_passphrase failed ret = [0x%x]\n", ret);
 600                 return;
 601         }
 602
 603         if (!g_strcmp0(passphrase, ad->setup.wifi_passphrase))
 604                 goto DONE;
 605
 606         g_strlcpy(ad->setup.wifi_passphrase, passphrase,
 607                 sizeof(ad->setup.wifi_passphrase));
 608
 609         g_strlcpy(ad->setup.wifi_passphrase_new, passphrase,
 610                 sizeof(ad->setup.wifi_passphrase_new));
 611
 612         if (ad->setup.pw_item)
 613                 elm_genlist_item_update(ad->setup.pw_item);
 614
 615 DONE:
 616         g_free(passphrase);
 617         DBG("-\n");
 618         return;
 619 }
 620
 621 #ifdef TETHERING_DATA_USAGE_SUPPORT
 622 void _data_usage_cb(tethering_error_e result, unsigned long long received_data, unsigned long long sent_data, void *user_data)
 623 {
 624         if (user_data == NULL) {
 625                 ERR("user_data is NULL\n");
 626                 return;
 627         }
 628
 629         mh_appdata_t *ad = (mh_appdata_t *)user_data;
 630
 631         if (ad->data_statistics.pdp_total_sent != sent_data ||
 632                         ad->data_statistics.pdp_total_receive != received_data) {
 633                 ad->data_statistics.pdp_total_sent = sent_data;
 634                 ad->data_statistics.pdp_total_receive = received_data;
 635                 ap_update_data_packet_usage(ad);
 636         }
 637
 638         ad->data_statistics.is_updated = true;
 639
 640         return;
 641 }
 642 #endif
 643 /* End of Tethering callbacks */
 644
 645 int _handle_wifi_onoff_change(mh_appdata_t *ad)
 646 {
 647         __MOBILE_AP_FUNC_ENTER__;
 648
 649         int ret;
 650         int connected_wifi_clients = 0;
 651
 652         /* Turn off WiFi hotspot */
 653         if (ad->main.hotspot_mode & VCONFKEY_MOBILE_HOTSPOT_MODE_WIFI) {
 654                 if (_get_no_of_connected_device(ad, &connected_wifi_clients,
 655                                         TETHERING_TYPE_WIFI) == EINA_FALSE) {
 656                         ERR("Getting the number of connected device is failed\n");
 657                 }
 658                 if (connected_wifi_clients > 0) {
 659                         _prepare_popup(MH_POPUP_WIFI_OFF, STR_CLOSE_INTERNET_Q);
 660                         _create_popup(ad);
 661                 } else {
 662 #ifndef TIZEN_FEATURE_EMULATOR
 663                         ret = tethering_disable(ad->handle, TETHERING_TYPE_WIFI);
 664                         if (ret != TETHERING_ERROR_NONE) {
 665                                 ERR("wifi tethering off is failed : %d\n", ret);
 666                                 return -1;
 667                         }
 668 #endif
 669                         _send_signal_qp(QP_SIGNAL_PROGRESS_OFF);
 670                 }
 671                 return 0;
 672         }
 673
 674         /* Turn on WiFi hotspot */
 675         ret = __is_preconditions_handled(ad);
 676         if (ret < 0)
 677                 return -1;
 678         else if (ret == 0)
 679                 return 0;
 680
 681         if (_create_wifi_hotspot_on_popup(ad) < 0) {
 682                 ERR("__create_wifi_hotspot_on_popup fail\n");
 683                 return -1;
 684         }
 685
 686         __MOBILE_AP_FUNC_EXIT__;
 687
 688         return 0;
 689 }
 690
 691 int _handle_bt_onoff_change(mh_appdata_t *ad)
 692 {
 693         __MOBILE_AP_FUNC_ENTER__;
 694
 695         int ret;
 696
 697         /* Turn off Bluetooth tethering */
 698         if (ad->main.hotspot_mode & VCONFKEY_MOBILE_HOTSPOT_MODE_BT) {
 699 #ifndef TIZEN_FEATURE_EMULATOR
 700                 ret = tethering_disable(ad->handle, TETHERING_TYPE_BT);
 701                 if (ret) {
 702                         ERR("Error disable bt tethering [%d]\n", ret);
 703                         return -1;
 704                 }
 705 #endif
 706                 return 0;
 707         }
 708
 709         /* Turn on Bluetooth tethering */
 710         ret = __is_preconditions_handled(ad);
 711         if (ret < 0)
 712                 return -1;
 713         else if (ret == 0)
 714                 return 0;
 715
 716         if (_create_bt_tethering_on_popup(ad) < 0) {
 717                 ERR("_create_bt_tethering_on_popup fail\n");
 718                 return -1;
 719         }
 720
 721         __MOBILE_AP_FUNC_EXIT__;
 722
 723         return 0;
 724 }
 725
 726 int _handle_usb_onoff_change(mh_appdata_t *ad)
 727 {
 728         __MOBILE_AP_FUNC_ENTER__;
 729
 730         int ret;
 731
 732         /* Turn off USB tethering */
 733         if (ad->main.hotspot_mode & VCONFKEY_MOBILE_HOTSPOT_MODE_USB) {
 734 #ifndef TIZEN_FEATURE_EMULATOR
 735                 ret = tethering_disable(ad->handle, TETHERING_TYPE_USB);
 736                 if (ret) {
 737                         ERR("Error disable usb tethering : %d\n", ret);
 738                         return -1;
 739                 }
 740 #endif
 741                 return 0;
 742         }
 743
 744         /* Turn on USB tethering */
 745         ret = __is_preconditions_handled(ad);
 746         if (ret < 0)
 747                 return -1;
 748         else if (ret == 0)
 749                 return 0;
 750
 751         if (_create_usb_tethering_on_popup(ad) < 0) {
 752                 ERR("_create_usb_tethering_on_popup fail\n");
 753                 return -1;
 754         }
 755
 756         __MOBILE_AP_FUNC_EXIT__;
 757
 758         return 0;
 759 }
 760
 761 bool _is_wifi_direct_on(void)
 762 {
 763         int wifi_direct_state = 0;
 764         int ret;
 765
 766         ret = vconf_get_int(VCONFKEY_WIFI_DIRECT_STATE, &wifi_direct_state);
 767         if (ret < 0) {
 768                 ERR("vconf_get_int() is failed : %d\n", ret);
 769                 return false;
 770         }
 771
 772         return wifi_direct_state != 0 ? true : false;
 773 }