src/mh_view_main.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 <time.h>
  21 #include <limits.h>
  22 #include <efl_extension.h>
  23 #include <dpm/restriction.h>
  24
  25 #include "mh_view_main.h"
  26 #include "mh_common_utility.h"
  27 #include "mh_popup.h"
  28 #include "mh_string.h"
  29
  30 static void __ctx_move_more_ctxpopup(Evas_Object *ctx, mh_appdata_t *ad);
  31 static void __ctx_delete_more_ctxpopup_cb(void *data, Evas *e, Evas_Object *obj,
  32                                           void *event_info);
  33 static void __create_ctxpopup_more_button(void *data, Evas_Object *obj,
  34                                           void *event_info);
  35
  36 static Eina_Bool rotate_flag = EINA_FALSE;
  37
  38 void _genlist_update_device_item(mh_appdata_t *ad);
  39 mh_appdata_t *g_ad = NULL;
  40 #define UPDATE_INTERVAL 1
  41
  42 #ifdef TIZEN_FEATURE_EMULATOR
  43 static tethering_type_e updated_type = TETHERING_TYPE_ALL;
  44 static tethering_type_e selected_type = TETHERING_TYPE_ALL;
  45 static Eina_Bool selected_state = EINA_FALSE;
  46
  47 tethering_type_e _get_updated_type(void)
  48 {
  49         return updated_type;
  50 }
  51
  52 tethering_type_e _get_selected_type(void)
  53 {
  54         return selected_type;
  55 }
  56
  57 Eina_Bool _get_selected_state(void)
  58 {
  59         return selected_state;
  60 }
  61 #endif
  62
  63 void _list_connected_dev(mh_appdata_t *ap)
  64 {
  65         __MOBILE_AP_FUNC_ENTER__;
  66
  67         if (ap == NULL) {
  68                 ERR("data is NULL\n");
  69                 return;
  70         }
  71
  72         _add_connected_clients(ap);
  73         __MOBILE_AP_FUNC_EXIT__;
  74 }
  75
  76 static bool _connected_clients_cb(tethering_client_h client, void *user_data)
  77 {
  78         __MOBILE_AP_FUNC_ENTER__;
  79
  80         if (user_data == NULL) {
  81                 ERR("user_data is NULL\n");
  82                 return true;
  83         }
  84
  85         mh_appdata_t *ad = (mh_appdata_t *)user_data;
  86
  87         _append_list_client_handle(ad, client);
  88
  89         __MOBILE_AP_FUNC_EXIT__;
  90         return true;
  91 }
  92
  93 void ap_update_data_device(mh_appdata_t *ad)
  94 {
  95         __MOBILE_AP_FUNC_ENTER__;
  96
  97         if (ad == NULL) {
  98                 ERR("Invalid param\n");
  99                 return;
 100         }
 101
 102         _genlist_update_device_item(ad);
 103
 104         __MOBILE_AP_FUNC_EXIT__;
 105 }
 106
 107 #ifdef TETHERING_DATA_USAGE_SUPPORT
 108 Eina_Bool ap_update_data_packet_usage(mh_appdata_t *ad)
 109 {
 110         if (ad == NULL) {
 111                 ERR("Invalid param\n");
 112                 return EINA_FALSE;
 113         }
 114
 115         if (ad->main.usage_item)
 116                 elm_genlist_item_update(ad->main.usage_item);
 117
 118         return EINA_TRUE;
 119 }
 120
 121 Eina_Bool ap_get_data_statistics(void *data)
 122 {
 123         if (!data) {
 124                 ERR("The param is NULL\n");
 125                 return ECORE_CALLBACK_CANCEL;
 126         }
 127         mh_appdata_t *ad = (mh_appdata_t *)data;
 128
 129         if (ad->main.hotspot_mode == VCONFKEY_MOBILE_HOTSPOT_MODE_NONE) {
 130                 ad->update_statistics_handle = NULL;
 131                 return ECORE_CALLBACK_CANCEL;
 132         }
 133
 134         /* If previous data is not updated, new data is not required */
 135         if (ad->data_statistics.is_updated == false)
 136                 return ECORE_CALLBACK_RENEW;
 137
 138         /* Because previous data is updated, new data is required.
 139            It will be returned asynchronously. */
 140         tethering_get_data_usage(ad->handle, _data_usage_cb, (void *)ad);
 141         ad->data_statistics.is_updated = false;
 142
 143         return ECORE_CALLBACK_RENEW;
 144 }
 145 #endif
 146
 147 Eina_Bool ap_update_device_conn_time(void * data)
 148 {
 149         if (!data) {
 150                 ERR("The param is NULL\n");
 151                 return ECORE_CALLBACK_CANCEL;
 152         }
 153         mh_appdata_t *ad = (mh_appdata_t *)data;
 154         int count = 0;
 155
 156 #ifdef TIZEN_FEATURE_EMULATOR
 157         if (ad->main.hotspot_mode == VCONFKEY_MOBILE_HOTSPOT_MODE_NONE) {
 158                 _stop_update_device_conn_time(ad);
 159                 return ECORE_CALLBACK_CANCEL;
 160         }
 161
 162         if (ad->main.hotspot_mode & VCONFKEY_MOBILE_HOTSPOT_MODE_WIFI) {
 163                 updated_type = TETHERING_TYPE_WIFI;
 164                 elm_genlist_item_fields_update(ad->main.emul_station_items[TETHERING_TYPE_WIFI],
 165                                         "elm.text.sub", ELM_GENLIST_ITEM_FIELD_TEXT);
 166         }
 167
 168         if (ad->main.hotspot_mode & VCONFKEY_MOBILE_HOTSPOT_MODE_BT) {
 169                 updated_type = TETHERING_TYPE_BT;
 170                 elm_genlist_item_fields_update(ad->main.emul_station_items[TETHERING_TYPE_BT],
 171                                         "elm.text.sub", ELM_GENLIST_ITEM_FIELD_TEXT);
 172         }
 173
 174         if (ad->main.hotspot_mode & VCONFKEY_MOBILE_HOTSPOT_MODE_USB) {
 175                 updated_type = TETHERING_TYPE_USB;
 176                 elm_genlist_item_fields_update(ad->main.emul_station_items[TETHERING_TYPE_USB],
 177                                         "elm.text.sub", ELM_GENLIST_ITEM_FIELD_TEXT);
 178         }
 179
 180         updated_type = TETHERING_TYPE_ALL;
 181
 182         return ECORE_CALLBACK_RENEW;
 183 #endif
 184
 185         if (ad->main.hotspot_mode == VCONFKEY_MOBILE_HOTSPOT_MODE_NONE) {
 186                 _stop_update_device_conn_time(ad);
 187                 __MOBILE_AP_FUNC_EXIT__;
 188                 return ECORE_CALLBACK_CANCEL;
 189         }
 190
 191         while (count < ad->main.no_of_clients) {
 192                 if (ad->main.station_items[count])
 193                         elm_genlist_item_fields_update(ad->main.station_items[count++],
 194                                         "elm.text.sub", ELM_GENLIST_ITEM_FIELD_TEXT);
 195         }
 196         return ECORE_CALLBACK_RENEW;
 197 }
 198
 199 void _start_update_device_conn_time(mh_appdata_t *ad)
 200 {
 201         __MOBILE_AP_FUNC_ENTER__;
 202
 203         if (ad == NULL) {
 204                 ERR("Invalid param\n");
 205                 __MOBILE_AP_FUNC_EXIT__;
 206                 return;
 207         }
 208
 209         if (ad->update_conn_time_handle)
 210                 _stop_update_device_conn_time(ad);
 211
 212         ad->update_conn_time_handle = ecore_timer_add(UPDATE_INTERVAL,
 213                         ap_update_device_conn_time, (void *)ad);
 214
 215         __MOBILE_AP_FUNC_EXIT__;
 216 }
 217
 218 void _stop_update_device_conn_time(mh_appdata_t *ad)
 219 {
 220         __MOBILE_AP_FUNC_ENTER__;
 221
 222         if (ad == NULL) {
 223                 ERR("Invalid param\n");
 224                 return;
 225         }
 226
 227         if (ad->update_conn_time_handle) {
 228                 ecore_timer_del(ad->update_conn_time_handle);
 229                 ad->update_conn_time_handle = NULL;
 230         }
 231         __MOBILE_AP_FUNC_EXIT__;
 232 }
 233
 234 #ifdef TETHERING_DATA_USAGE_SUPPORT
 235 void _start_update_data_packet_usage(mh_appdata_t *ad)
 236 {
 237         __MOBILE_AP_FUNC_ENTER__;
 238
 239         if (ad == NULL) {
 240                 ERR("Invalid param\n");
 241                 return;
 242         }
 243
 244         if (ad->update_statistics_handle)
 245                 _stop_update_data_packet_usage(ad);
 246
 247         ad->data_statistics.is_updated = false;
 248         tethering_get_data_usage(ad->handle, _data_usage_cb, (void *)ad);
 249         ad->update_statistics_handle = ecore_timer_add(MH_UPDATE_INTERVAL,
 250                         ap_get_data_statistics, (void *)ad);
 251
 252         __MOBILE_AP_FUNC_EXIT__;
 253         return;
 254 }
 255
 256 void _stop_update_data_packet_usage(mh_appdata_t *ad)
 257 {
 258         __MOBILE_AP_FUNC_ENTER__;
 259
 260         if (ad == NULL) {
 261                 ERR("Invalid param\n");
 262                 return;
 263         }
 264
 265         if (ad->update_statistics_handle) {
 266                 ecore_timer_del(ad->update_statistics_handle);
 267                 ad->data_statistics.is_updated = false;
 268                 ad->update_statistics_handle = NULL;
 269         }
 270
 271         __MOBILE_AP_FUNC_EXIT__;
 272         return;
 273 }
 274 #endif
 275
 276 static void __read_setting(mh_appdata_t *ad)
 277 {
 278         __MOBILE_AP_FUNC_ENTER__;
 279
 280         if (ad == NULL) {
 281                 ERR("Invalid param\n");
 282                 return;
 283         }
 284
 285         int ret = 0;
 286         char *ssid = NULL;
 287         char *passphrase = NULL;
 288         bool visibility;
 289         tethering_wifi_security_type_e type;
 290
 291         ad->main.hotspot_mode = _get_vconf_hotspot_mode();
 292
 293 #ifdef TETHERING_DATA_USAGE_SUPPORT
 294         ad->data_statistics.pdp_total_sent = 0;
 295         ad->data_statistics.pdp_total_receive = 0;
 296         if (ad->main.hotspot_mode != VCONFKEY_MOBILE_HOTSPOT_MODE_NONE)
 297                 tethering_get_data_usage(ad->handle, _data_usage_cb, (void *)ad);
 298 #endif
 299
 300         ret = tethering_wifi_get_ssid(ad->handle, &ssid);
 301         if (ret != TETHERING_ERROR_NONE || ssid == NULL) {
 302                 ERR("tethering_wifi_get_ssid is failed : %d\n", ret);
 303                 return;
 304         }
 305         g_strlcpy(ad->setup.device_name, ssid, sizeof(ad->setup.device_name));
 306         free(ssid);
 307
 308         ret = tethering_wifi_get_passphrase(ad->handle, &passphrase);
 309         if (ret != TETHERING_ERROR_NONE || passphrase == NULL) {
 310                 ERR("tethering_wifi_get_passphrase is failed : %d\n", ret);
 311                 return;
 312         }
 313
 314         g_strlcpy(ad->setup.wifi_passphrase, passphrase,
 315                         sizeof(ad->setup.wifi_passphrase));
 316         g_strlcpy(ad->setup.wifi_passphrase_new, passphrase,
 317                         sizeof(ad->setup.wifi_passphrase_new));
 318         free(passphrase);
 319
 320         ret = tethering_wifi_get_ssid_visibility(ad->handle, &visibility);
 321         if (ret != TETHERING_ERROR_NONE)
 322                 ERR("tethering_wifi_get_ssid_visibility is failed\n");
 323
 324         ad->setup.visibility = visibility;
 325         ad->setup.visibility_new = visibility;
 326
 327         ret = tethering_wifi_get_security_type(ad->handle, &type);
 328         if (ret != TETHERING_ERROR_NONE)
 329                 ERR("tethering_wifi_get_security_type is failed\n");
 330
 331         ad->setup.security_type = type;
 332         ad->setup.security_type_new = type;
 333
 334         __MOBILE_AP_FUNC_EXIT__;
 335 }
 336
 337 void _update_wifi_item(mh_appdata_t *ad, int wifi_state)
 338 {
 339         __MOBILE_AP_FUNC_ENTER__;
 340
 341         if (ad->main.wifi_state == wifi_state)
 342                 return;
 343
 344         if (ad->main.wifi_state == MH_STATE_PROCESS) {
 345                 ad->main.wifi_state = MH_STATE_NONE;
 346                 elm_genlist_item_select_mode_set(ad->main.wifi_item, ELM_OBJECT_SELECT_MODE_DEFAULT);
 347         } else if (ad->main.wifi_state == MH_STATE_NONE) {
 348                 ad->main.wifi_state = MH_STATE_PROCESS;
 349                 elm_genlist_item_select_mode_set(ad->main.wifi_item, ELM_OBJECT_SELECT_MODE_DISPLAY_ONLY);
 350         }
 351
 352         if (ad->main.wifi_item)
 353                 elm_genlist_item_update(ad->main.wifi_item);
 354
 355         if (ad->main.setup_item)
 356                 elm_object_item_signal_emit(ad->main.setup_item, "elm,state,bottom", "");
 357
 358         __MOBILE_AP_FUNC_EXIT__;
 359
 360         return;
 361 }
 362
 363 void _update_bt_item(mh_appdata_t *ad, int bt_state)
 364 {
 365         __MOBILE_AP_FUNC_ENTER__;
 366
 367         if (ad->main.bt_state == bt_state)
 368                 return;
 369
 370         if (ad->main.bt_state == MH_STATE_PROCESS) {
 371                 ad->main.bt_state = MH_STATE_NONE;
 372                 elm_genlist_item_select_mode_set(ad->main.bt_item, ELM_OBJECT_SELECT_MODE_DEFAULT);
 373         } else if (ad->main.bt_state == MH_STATE_NONE) {
 374                 ad->main.bt_state = MH_STATE_PROCESS;
 375                 elm_genlist_item_select_mode_set(ad->main.bt_item, ELM_OBJECT_SELECT_MODE_DISPLAY_ONLY);
 376         }
 377
 378         if (ad->main.bt_item)
 379                 elm_genlist_item_update(ad->main.bt_item);
 380
 381         __MOBILE_AP_FUNC_EXIT__;
 382
 383         return;
 384 }
 385
 386 void _update_usb_item(mh_appdata_t *ad, int usb_state)
 387 {
 388         __MOBILE_AP_FUNC_ENTER__;
 389
 390         if (ad->main.usb_state == usb_state)
 391                 return;
 392
 393         if (ad->main.usb_state == MH_STATE_PROCESS) {
 394                 ad->main.usb_state = MH_STATE_NONE;
 395                 elm_genlist_item_select_mode_set(ad->main.usb_item, ELM_OBJECT_SELECT_MODE_DEFAULT);
 396         } else if (ad->main.usb_state == MH_STATE_NONE) {
 397                 ad->main.usb_state = MH_STATE_PROCESS;
 398                 elm_genlist_item_select_mode_set(ad->main.usb_item, ELM_OBJECT_SELECT_MODE_DISPLAY_ONLY);
 399         }
 400
 401         elm_genlist_item_update(ad->main.usb_item);
 402
 403         __MOBILE_AP_FUNC_EXIT__;
 404
 405         return;
 406 }
 407
 408 void _genlist_update_device_item(mh_appdata_t *ad)
 409 {
 410         __MOBILE_AP_FUNC_ENTER__;
 411
 412         if (ad == NULL) {
 413                 ERR("Invalid param\n");
 414                 return;
 415         }
 416         unsigned int no_of_dev = 0;
 417         no_of_dev = _get_list_clients_count(ad);
 418         Elm_Object_Item *item = NULL;
 419
 420         if (no_of_dev == 0) {
 421                 if (ad->main.device_item) {
 422                         elm_object_item_del(ad->main.device_item);
 423                         ad->main.device_item = NULL;
 424                         _update_conn_clients(ad);
 425                 }
 426         } else {
 427                 if (ad->main.device_item) {
 428                 _update_conn_clients(ad);
 429                 } else {
 430                         item = elm_genlist_item_append(ad->main.genlist,
 431                                         ad->main.device_itc, ad, NULL,
 432                                         ELM_GENLIST_ITEM_NONE, NULL, NULL);
 433                         elm_genlist_item_select_mode_set(item, ELM_OBJECT_SELECT_MODE_DISPLAY_ONLY);
 434                         ad->main.device_item = item;
 435                         _list_connected_dev(ad);
 436                         }
 437                 }
 438
 439
 440         __MOBILE_AP_FUNC_EXIT__;
 441         return;
 442 }
 443
 444 void _update_main_view(mh_appdata_t *ad, tethering_type_e type)
 445 {
 446         __MOBILE_AP_FUNC_ENTER__;
 447
 448         if (ad == NULL) {
 449                 ERR("Invalid param\n");
 450                 return;
 451         }
 452
 453         int state = VCONFKEY_MOBILE_HOTSPOT_MODE_NONE;
 454         Eina_Bool wifi_state = EINA_FALSE;
 455         Eina_Bool bt_state = EINA_FALSE;
 456         Eina_Bool usb_state = EINA_FALSE;
 457         Eina_Bool wifi_ap_state = EINA_FALSE;
 458         Elm_Object_Item *item = NULL;
 459         Evas_Object *obj;
 460         int no_of_dev = 0;
 461
 462         ad->main.hotspot_mode = _get_vconf_hotspot_mode();
 463         state = ad->main.hotspot_mode;
 464
 465         wifi_state = (Eina_Bool)(state & VCONFKEY_MOBILE_HOTSPOT_MODE_WIFI);
 466         bt_state = (Eina_Bool)(state & VCONFKEY_MOBILE_HOTSPOT_MODE_BT);
 467         usb_state = (Eina_Bool)(state & VCONFKEY_MOBILE_HOTSPOT_MODE_USB);
 468         wifi_ap_state = (Eina_Bool)(state & VCONFKEY_MOBILE_HOTSPOT_MODE_WIFI_AP);
 469
 470         if (wifi_ap_state) {
 471                 if (ad->main.wifi_item)
 472                         elm_object_item_disabled_set(ad->main.wifi_item, EINA_TRUE);
 473                 if (ad->main.setup_item)
 474                         elm_object_item_disabled_set(ad->main.setup_item, EINA_TRUE);
 475                 if (ad->main.bt_item)
 476                         elm_object_item_disabled_set(ad->main.bt_item, EINA_TRUE);
 477                 if (ad->main.usb_item)
 478                         elm_object_item_disabled_set(ad->main.usb_item, EINA_TRUE);
 479         } else {
 480                 if (ad->main.setup_item)
 481                         elm_object_item_disabled_set(ad->main.setup_item, EINA_FALSE);
 482                 if (ad->main.bt_item)
 483                         elm_object_item_disabled_set(ad->main.bt_item, EINA_FALSE);
 484                 if (_get_vconf_usb_state() == VCONFKEY_SYSMAN_USB_DISCONNECTED) {
 485                         if (ad->main.usb_item)
 486                                 elm_object_item_disabled_set(ad->main.usb_item, EINA_TRUE);
 487                 } else {
 488                         if (ad->main.usb_item)
 489                                 elm_object_item_disabled_set(ad->main.usb_item, EINA_FALSE);
 490                 }
 491         }
 492
 493         if (wifi_state || bt_state || usb_state) {
 494 #ifdef TETHERING_DATA_USAGE_SUPPORT
 495                 if (ad->main.usage_item == NULL) {
 496                         item = elm_genlist_item_insert_before(ad->main.genlist,
 497                                         ad->main.usage_itc, ad, NULL,
 498                                         ad->main.sp_item[0],
 499                                         ELM_GENLIST_ITEM_NONE, NULL, NULL);
 500                         elm_genlist_item_select_mode_set(item,
 501                                         ELM_OBJECT_SELECT_MODE_DISPLAY_ONLY);
 502                         ad->main.usage_item = item;
 503                 }
 504 #endif
 505
 506                 no_of_dev = _get_list_clients_count(ad);
 507                 if (ad->main.device_item == NULL) {
 508                         if (no_of_dev != 0) {
 509                                 item = elm_genlist_item_append(ad->main.genlist,
 510                                                 ad->main.device_itc, ad, NULL,
 511                                                 ELM_GENLIST_ITEM_NONE, NULL, NULL);
 512                                 elm_genlist_item_select_mode_set(item, ELM_OBJECT_SELECT_MODE_DEFAULT);
 513                         _list_connected_dev(ad);
 514                         _update_conn_clients(ad);
 515                         }
 516                         ad->main.device_item = item;
 517                 }
 518         } else {
 519                 if (ad->main.device_item) {
 520                         elm_object_item_del(ad->main.device_item);
 521                         ad->main.device_item = NULL;
 522                 }
 523 #ifdef TETHERING_DATA_USAGE_SUPPORT
 524                 if (ad->main.usage_item) {
 525                         elm_object_item_del(ad->main.usage_item);
 526                         ad->main.usage_item = NULL;
 527                 }
 528 #endif
 529         }
 530
 531         if (wifi_state) {
 532                 if (ad->main.help_item) {
 533                         elm_genlist_item_update(ad->main.help_item);
 534                 } else {
 535                         item = elm_genlist_item_insert_after(ad->main.genlist,
 536                                         ad->main.help_itc, ad, NULL,
 537                                         ad->main.wifi_item,
 538                                         ELM_GENLIST_ITEM_NONE, NULL,
 539                                         NULL);
 540                         if (item == NULL) {
 541                                 ERR("elm_genlist_item_insert_after NULL\n");
 542                         } else {
 543                                 elm_genlist_item_select_mode_set(item,
 544                                                 ELM_OBJECT_SELECT_MODE_DISPLAY_ONLY);
 545                                 ad->main.help_item = item;
 546                         }
 547                 }
 548         } else {
 549                 if (ad->main.help_item) {
 550                         elm_object_item_del(ad->main.help_item);
 551                         ad->main.help_item = NULL;
 552                 }
 553         }
 554
 555         switch (type) {
 556         case TETHERING_TYPE_WIFI:
 557                 /* Update Wi-Fi tethering on / off button */
 558                 if (ad->main.wifi_state != MH_STATE_NONE) {
 559                         _update_wifi_item(ad, MH_STATE_NONE);
 560                 } else {
 561                         obj = elm_object_item_part_content_get(ad->main.wifi_item, "elm.swallow.end");
 562                         if (obj != NULL)
 563                                 elm_check_state_set(obj, wifi_state);
 564
 565                         if (ad->main.wifi_item)
 566                                 elm_genlist_item_update(ad->main.wifi_item);
 567                 }
 568                 break;
 569
 570         case TETHERING_TYPE_BT:
 571                 /* Update BT tethering on / off button */
 572                 if (ad->main.bt_state != MH_STATE_NONE) {
 573                         _update_bt_item(ad, MH_STATE_NONE);
 574                 } else {
 575                         obj = elm_object_item_part_content_get(ad->main.bt_item, "elm.swallow.end");
 576                         if (obj != NULL)
 577                                 elm_check_state_set(obj, bt_state);
 578
 579                         if (ad->main.bt_item)
 580                                 elm_genlist_item_update(ad->main.bt_item);
 581                 }
 582                 break;
 583
 584         case TETHERING_TYPE_USB:
 585                 /* Update USB tethering on / off button */
 586                 if (ad->main.usb_state != MH_STATE_NONE) {
 587                         _update_usb_item(ad, MH_STATE_NONE);
 588                 } else {
 589                         obj = elm_object_item_part_content_get(ad->main.usb_item, "elm.swallow.end");
 590                         if (obj != NULL)
 591                                 elm_check_state_set(obj, usb_state);
 592
 593                         if (ad->main.usb_item)
 594                                 elm_genlist_item_update(ad->main.usb_item);
 595                 }
 596                 break;
 597
 598         default:
 599                 DBG("Unknown tethering type : %d\n", type);
 600                 break;
 601         }
 602
 603         __MOBILE_AP_FUNC_EXIT__;
 604
 605         return;
 606 }
 607
 608 #ifdef TIZEN_FEATURE_EMULATOR
 609 void _update_emul_main_view(mh_appdata_t *ad, tethering_type_e type, Eina_Bool state)
 610 {
 611         __MOBILE_AP_FUNC_ENTER__;
 612
 613         if (ad == NULL) {
 614                 ERR("Invalid param\n");
 615                 return;
 616         }
 617
 618         Elm_Object_Item *item = NULL;
 619
 620         switch (type) {
 621         case TETHERING_TYPE_WIFI:
 622                 /* Update Wi-Fi tethering on / off button */
 623                 _update_wifi_item(ad, MH_STATE_NONE);
 624                 if (state) {
 625                         ad->main.hotspot_mode |= VCONFKEY_MOBILE_HOTSPOT_MODE_WIFI;
 626                         if (ad->main.help_item) {
 627                                 elm_genlist_item_update(ad->main.help_item);
 628                         } else {
 629                                 item = elm_genlist_item_insert_after(ad->main.genlist,
 630                                                 ad->main.help_itc, ad, NULL,
 631                                                 ad->main.wifi_item,
 632                                                 ELM_GENLIST_ITEM_NONE, NULL,
 633                                                 NULL);
 634                                 if (item == NULL) {
 635                                         ERR("elm_genlist_item_insert_after NULL\n");
 636                                 } else {
 637                                         elm_genlist_item_select_mode_set(item,
 638                                                         ELM_OBJECT_SELECT_MODE_DISPLAY_ONLY);
 639                                         ad->main.help_item = item;
 640                                 }
 641                         }
 642                 } else {
 643                         ad->main.hotspot_mode ^= VCONFKEY_MOBILE_HOTSPOT_MODE_WIFI;
 644                         if (ad->main.help_item) {
 645                                 elm_object_item_del(ad->main.help_item);
 646                                 ad->main.help_item = NULL;
 647                         }
 648                 }
 649
 650                 if (ad->main.wifi_item)
 651                         elm_genlist_item_update(ad->main.wifi_item);
 652                 break;
 653
 654         case TETHERING_TYPE_BT:
 655                 /* Update BT tethering on / off button */
 656                 _update_bt_item(ad, MH_STATE_NONE);
 657                 if (state)
 658                         ad->main.hotspot_mode |= VCONFKEY_MOBILE_HOTSPOT_MODE_BT;
 659                 else
 660                         ad->main.hotspot_mode ^= VCONFKEY_MOBILE_HOTSPOT_MODE_BT;
 661
 662                 if (ad->main.bt_item)
 663                         elm_genlist_item_update(ad->main.bt_item);
 664                 break;
 665
 666         case TETHERING_TYPE_USB:
 667                 /* Update USB tethering on / off button */
 668                 _update_usb_item(ad, MH_STATE_NONE);
 669                 if (state)
 670                         ad->main.hotspot_mode |= VCONFKEY_MOBILE_HOTSPOT_MODE_USB;
 671                 else
 672                         ad->main.hotspot_mode ^= VCONFKEY_MOBILE_HOTSPOT_MODE_USB;
 673
 674                 if (ad->main.usb_item)
 675                         elm_genlist_item_update(ad->main.usb_item);
 676                 break;
 677
 678         default:
 679                 DBG("Unknown tethering type : %d\n", type);
 680                 break;
 681         }
 682
 683         if (ad->main.hotspot_mode && ad->main.device_item == NULL) {
 684                 item = elm_genlist_item_append(ad->main.genlist,
 685                                 ad->main.device_itc, ad, NULL,
 686                                 ELM_GENLIST_ITEM_NONE, NULL, NULL);
 687                 elm_genlist_item_select_mode_set(item, ELM_OBJECT_SELECT_MODE_DEFAULT);
 688                 ad->main.device_item = item;
 689         } else if (ad->main.hotspot_mode == 0 && ad->main.device_item) {
 690                         elm_object_item_del(ad->main.device_item);
 691                         ad->main.device_item = NULL;
 692         }
 693
 694         __update_emul_clients_genlist(ad);
 695
 696         __MOBILE_AP_FUNC_EXIT__;
 697         return;
 698 }
 699 #endif
 700
 701 static int __is_allowed(tethering_type_e type)
 702 {
 703         int state = 0;
 704         device_policy_manager_h dpm = NULL;
 705
 706         dpm = dpm_manager_create();
 707         if (dpm == NULL) {
 708                 ERR("Failed to create device policy manager!!");
 709                 return 0;
 710         }
 711
 712         switch (type) {
 713         case TETHERING_TYPE_WIFI:
 714                 dpm_restriction_get_wifi_hotspot_state(dpm, &state);
 715                 break;
 716         case TETHERING_TYPE_USB:
 717                 dpm_restriction_get_usb_tethering_state(dpm, &state);
 718                 break;
 719         case TETHERING_TYPE_BT:
 720                 dpm_restriction_get_bluetooth_tethering_state(dpm, &state);
 721                 break;
 722         default:
 723                 break;
 724         }
 725
 726         dpm_manager_destroy(dpm);
 727
 728         return state;
 729 }
 730
 731 static void __wifi_onoff_changed_cb(void *data, Evas_Object *obj,
 732                                                         void *event_info)
 733 {
 734         __MOBILE_AP_FUNC_ENTER__;
 735
 736         if (!__is_allowed(TETHERING_TYPE_WIFI)) {
 737                 ERR("Wi-Fi tethering is restricted!!");
 738                 elm_check_state_set(obj, EINA_FALSE);
 739                 _create_security_restriction_noti(TETHERING_TYPE_WIFI);
 740                 return;
 741         }
 742
 743         if (data == NULL) {
 744                 ERR("The param is NULL\n");
 745                 return;
 746         }
 747
 748         mh_appdata_t *ad = (mh_appdata_t *)data;
 749
 750         _update_wifi_item(ad, MH_STATE_PROCESS);
 751         ad->type = TETHERING_TYPE_WIFI;
 752         ad->is_wifi_teth_enabling = true;
 753
 754 #ifdef TIZEN_FEATURE_EMULATOR
 755         selected_type = TETHERING_TYPE_WIFI;
 756         selected_state = (ad->main.hotspot_mode & VCONFKEY_MOBILE_HOTSPOT_MODE_WIFI) ? EINA_FALSE : EINA_TRUE;
 757         DBG("type [%d] state[%d]", selected_type, selected_state);
 758 #endif
 759
 760         if (_handle_wifi_onoff_change(ad) != 0) {
 761                 ERR("_handle_wifi_onoff_change is failed\n");
 762                 _update_wifi_item(ad, MH_STATE_NONE);
 763                 ad->is_wifi_teth_enabling = false;
 764         }
 765
 766 #ifdef TIZEN_FEATURE_EMULATOR
 767         if (_get_checkbox_status(selected_type) || !selected_state)
 768                 _update_emul_main_view(ad, selected_type, selected_state);
 769 #endif
 770
 771         __MOBILE_AP_FUNC_EXIT__;
 772
 773         return;
 774 }
 775
 776 static void __select_wifi_item(void *data, Evas_Object *obj, void *event_info)
 777 {
 778         __MOBILE_AP_FUNC_ENTER__;
 779
 780         Evas_Object *content;
 781         Elm_Object_Item *item = (Elm_Object_Item *)event_info;
 782
 783         if (data == NULL) {
 784                 ERR("The param is NULL\n");
 785                 return;
 786         }
 787
 788         elm_genlist_item_selected_set(item, EINA_FALSE);
 789
 790         content = elm_object_item_part_content_get(item, "elm.icon");
 791         __wifi_onoff_changed_cb(data, content, NULL);
 792
 793         __MOBILE_AP_FUNC_EXIT__;
 794
 795         return;
 796 }
 797
 798 static void __bt_onoff_changed_cb(void *data, Evas_Object *obj, void *event_info)
 799 {
 800         __MOBILE_AP_FUNC_ENTER__;
 801
 802         if (!__is_allowed(TETHERING_TYPE_BT)) {
 803                 ERR("BT tethering is restricted!!");
 804                 elm_check_state_set(obj, EINA_FALSE);
 805                 _create_security_restriction_noti(TETHERING_TYPE_BT);
 806                 return;
 807         }
 808
 809         if (data == NULL) {
 810                 ERR("The param is NULL\n");
 811                 return;
 812         }
 813
 814         mh_appdata_t *ad = (mh_appdata_t *)data;
 815
 816         _update_bt_item(ad, MH_STATE_PROCESS);
 817         ad->type = TETHERING_TYPE_BT;
 818         ad->is_bt_teth_enabling = true;
 819
 820 #ifdef TIZEN_FEATURE_EMULATOR
 821         selected_type = TETHERING_TYPE_BT;
 822         selected_state = (ad->main.hotspot_mode & VCONFKEY_MOBILE_HOTSPOT_MODE_BT) ? EINA_FALSE : EINA_TRUE;
 823         DBG("type [%d] state[%d]", selected_type, selected_state);
 824 #endif
 825
 826         if (_handle_bt_onoff_change(ad) != 0) {
 827                 ERR("_handle_bt_onoff_change is failed\n");
 828                 _update_bt_item(ad, MH_STATE_NONE);
 829                 ad->is_bt_teth_enabling = false;
 830         }
 831
 832 #ifdef TIZEN_FEATURE_EMULATOR
 833         if (_get_checkbox_status(selected_type) || !selected_state)
 834                 _update_emul_main_view(ad, selected_type, selected_state);
 835 #endif
 836
 837         __MOBILE_AP_FUNC_EXIT__;
 838
 839         return;
 840 }
 841
 842 static void __select_bt_item(void *data, Evas_Object *obj, void *event_info)
 843 {
 844         __MOBILE_AP_FUNC_ENTER__;
 845
 846         Evas_Object *content;
 847         Elm_Object_Item *item = (Elm_Object_Item *)event_info;
 848
 849         if (data == NULL) {
 850                 ERR("The param is NULL\n");
 851                 return;
 852         }
 853
 854         elm_genlist_item_selected_set(item, EINA_FALSE);
 855
 856         content = elm_object_item_part_content_get(item, "elm.icon");
 857         __bt_onoff_changed_cb(data, content, NULL);
 858
 859         __MOBILE_AP_FUNC_EXIT__;
 860
 861         return;
 862 }
 863
 864 static void __usb_onoff_changed_cb(void *data, Evas_Object *obj, void *event_info)
 865 {
 866         __MOBILE_AP_FUNC_ENTER__;
 867
 868         if (!__is_allowed(TETHERING_TYPE_USB)) {
 869                 ERR("USB tethering is restricted!!");
 870                 elm_check_state_set(obj, EINA_FALSE);
 871                 _create_security_restriction_noti(TETHERING_TYPE_USB);
 872                 return;
 873         }
 874
 875         if (data == NULL) {
 876                 ERR("The param is NULL\n");
 877                 return;
 878         }
 879
 880         mh_appdata_t *ad = (mh_appdata_t *)data;
 881         _update_usb_item(ad, MH_STATE_PROCESS);
 882         ad->type = TETHERING_TYPE_USB;
 883         ad->is_usb_teth_enabling = true;
 884
 885 #ifdef TIZEN_FEATURE_EMULATOR
 886         selected_type = TETHERING_TYPE_USB;
 887         selected_state = (ad->main.hotspot_mode & VCONFKEY_MOBILE_HOTSPOT_MODE_USB) ? EINA_FALSE : EINA_TRUE;
 888 #endif
 889
 890         if (_handle_usb_onoff_change(ad) != 0) {
 891                 ERR("_handle_usb_onoff_change is failed\n");
 892                 _update_usb_item(ad, MH_STATE_NONE);
 893                 ad->is_usb_teth_enabling = false;
 894         }
 895
 896 #ifdef TIZEN_FEATURE_EMULATOR
 897         if (_get_checkbox_status(selected_type) || !selected_state)
 898                 _update_emul_main_view(ad, selected_type, selected_state);
 899 #endif
 900
 901         __MOBILE_AP_FUNC_EXIT__;
 902
 903         return;
 904 }
 905
 906 static void __select_usb_item(void *data, Evas_Object *obj, void *event_info)
 907 {
 908         __MOBILE_AP_FUNC_ENTER__;
 909
 910         Evas_Object *content;
 911         Elm_Object_Item *item = (Elm_Object_Item *)event_info;
 912
 913         if (data == NULL) {
 914                 ERR("The param is NULL\n");
 915                 return;
 916         }
 917
 918         elm_genlist_item_selected_set(item, EINA_FALSE);
 919
 920         content = elm_object_item_part_content_get(item, "elm.icon");
 921         __usb_onoff_changed_cb(data, content, NULL);
 922
 923         __MOBILE_AP_FUNC_EXIT__;
 924
 925         return;
 926 }
 927
 928 static void  __back_btn_cb(void *data, Elm_Object_Item *navi_item)
 929 {
 930         INFO("+\n");
 931
 932         if (data == NULL) {
 933                 ERR("The param is NULL\n");
 934                 return;
 935         }
 936
 937         mh_appdata_t *ad = (mh_appdata_t*)data;
 938
 939         _release_list_client_handle(ad);
 940         _main_callback_del(ad);
 941
 942         ug_destroy_me(((mh_ugdata_t *)ad->gadget)->ug);
 943
 944         INFO("-\n");
 945         return;
 946 }
 947
 948 static char *__get_wifi_label(void *data, Evas_Object *obj, const char *part)
 949 {
 950         if (!strcmp("elm.text", part))
 951                 return strdup(STR_MOBILE_HOTSPOT);
 952
 953         return NULL;
 954 }
 955
 956 static Evas_Object *__get_wifi_icon(void *data, Evas_Object *obj,
 957                 const char *part)
 958 {
 959         mh_appdata_t *ad = (mh_appdata_t*)data;
 960         Evas_Object *btn = NULL;
 961
 962         if (data == NULL) {
 963                 ERR("The param is NULL\n");
 964                 return NULL;
 965         }
 966
 967         if (!strcmp("elm.swallow.end", part)) {
 968                 if (ad->main.wifi_state == MH_STATE_PROCESS) {
 969                         btn = _create_progressbar(obj, "process_medium");
 970                 } else {
 971                         btn = elm_check_add(obj);
 972                         elm_object_style_set(btn, "on&off");
 973
 974                         evas_object_propagate_events_set(btn, EINA_FALSE);
 975                         evas_object_size_hint_align_set(btn, EVAS_HINT_FILL, EVAS_HINT_FILL);
 976                         evas_object_size_hint_weight_set(btn, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
 977                         elm_check_state_set(btn, ad->main.hotspot_mode &
 978                                 VCONFKEY_MOBILE_HOTSPOT_MODE_WIFI ? EINA_TRUE : EINA_FALSE);
 979
 980                         evas_object_smart_callback_add(btn, "changed", __wifi_onoff_changed_cb, ad);
 981                         evas_object_show(btn);
 982                 }
 983         }
 984
 985         return btn;
 986 }
 987
 988 static char *__get_bt_label(void *data, Evas_Object *obj, const char *part)
 989 {
 990         if (!strcmp("elm.text", part))
 991                 return strdup(STR_BLUETOOTH_TETH);
 992
 993         return NULL;
 994 }
 995
 996 static Evas_Object *__get_bt_icon(void *data, Evas_Object *obj, const char *part)
 997 {
 998         mh_appdata_t *ad = (mh_appdata_t *)data;
 999         Evas_Object *btn = NULL;
1000
1001         if (data == NULL) {
1002                 ERR("The param is NULL\n");
1003                 return NULL;
1004         }
1005
1006         if (!strcmp("elm.swallow.end", part)) {
1007                 if (ad->main.bt_state == MH_STATE_PROCESS) {
1008                         btn = _create_progressbar(obj, "process_medium");
1009                 } else {
1010                         btn = elm_check_add(obj);
1011                         if (btn == NULL) {
1012                                 ERR("btn is NULL\n");
1013                                 return NULL;
1014                         }
1015                         elm_object_style_set(btn, "on&off");
1016                         evas_object_pass_events_set(btn, EINA_TRUE);
1017                         evas_object_propagate_events_set(btn, EINA_FALSE);
1018                         elm_check_state_set(btn, ad->main.hotspot_mode &
1019                                 VCONFKEY_MOBILE_HOTSPOT_MODE_BT ? EINA_TRUE : EINA_FALSE);
1020                         evas_object_show(btn);
1021                         evas_object_smart_callback_add(btn, "changed", __bt_onoff_changed_cb, ad);
1022                 }
1023         }
1024
1025         return btn;
1026 }
1027
1028 static char *__get_usb_label(void *data, Evas_Object *obj, const char *part)
1029 {
1030         if (!strcmp("elm.text", part))
1031                 return strdup(STR_USB_TETH);
1032
1033         return NULL;
1034 }
1035
1036 static Evas_Object *__get_usb_icon(void *data, Evas_Object *obj,
1037                                                         const char *part)
1038 {
1039         mh_appdata_t *ad = (mh_appdata_t *)data;
1040         Evas_Object *btn = NULL;
1041
1042         if (data == NULL) {
1043                 ERR("The param is NULL\n");
1044                 return NULL;
1045         }
1046
1047         if (!strcmp("elm.swallow.end", part)) {
1048                 if (ad->main.usb_state == MH_STATE_PROCESS) {
1049                         btn = _create_progressbar(obj, "process_medium");
1050                 } else {
1051                         btn = elm_check_add(obj);
1052                         if (btn == NULL) {
1053                                 ERR("btn is NULL\n");
1054                                 return NULL;
1055                         }
1056                         elm_object_style_set(btn, "on&off");
1057                         evas_object_pass_events_set(btn, EINA_TRUE);
1058                         evas_object_propagate_events_set(btn, EINA_FALSE);
1059                         elm_check_state_set(btn, ad->main.hotspot_mode &
1060                                 VCONFKEY_MOBILE_HOTSPOT_MODE_USB ? EINA_TRUE : EINA_FALSE);
1061                         evas_object_show(btn);
1062                         evas_object_smart_callback_add(btn, "changed", __usb_onoff_changed_cb, ad);
1063                 }
1064         }
1065
1066         return btn;
1067 }
1068
1069 static char *__get_help_label(void *data, Evas_Object *obj, const char *part)
1070 {
1071         mh_appdata_t *ad = (mh_appdata_t *)data;
1072         char buf[MH_LABEL_LENGTH_MAX] = {0, };
1073         char device_name[MH_LABEL_LENGTH_MAX] = {0, };
1074         char passphrase[MH_LABEL_LENGTH_MAX] = {0, };
1075         char security_type[MH_LABEL_LENGTH_MAX] = {0, };
1076         char *fmt = STR_SECURITY_TYPE_PS;
1077         char *hidden = "";
1078         char *ptr = NULL;
1079         char *device_name_utf = NULL;
1080         int wifi_state = VCONFKEY_MOBILE_HOTSPOT_MODE_NONE;
1081
1082         if (data == NULL) {
1083                 ERR("The param is NULL\n");
1084                 return NULL;
1085         }
1086
1087         if (!strcmp("elm.text.multiline", part)) {
1088                 device_name_utf = vconf_get_str(VCONFKEY_SETAPPL_DEVICE_NAME_STR);
1089                 if (device_name_utf == NULL) {
1090                         ERR("vconf_get_str failed \n");
1091                         return NULL;
1092                 }
1093
1094                 ptr = elm_entry_utf8_to_markup(device_name_utf);
1095                 if (ptr == NULL) {
1096                         g_free(device_name_utf);
1097                         ERR("elm_entry_utf8_to_markup is failed\n");
1098                         return NULL;
1099                 }
1100
1101                 g_strlcpy(ad->setup.device_name, ptr,
1102                                 sizeof(ad->setup.device_name));
1103                 g_strlcpy(device_name, ptr, MH_LABEL_LENGTH_MAX);
1104                 g_free(device_name_utf);
1105                 g_free(ptr);
1106                 ptr = NULL;
1107
1108                 if (ad->setup.security_type != TETHERING_WIFI_SECURITY_TYPE_NONE) {
1109                         ptr = elm_entry_utf8_to_markup(ad->setup.wifi_passphrase);
1110                         if (ptr == NULL) {
1111                                 ERR("elm_entry_utf8_to_markup is failed\n");
1112                                 return NULL;
1113                         }
1114                         g_strlcpy(passphrase, ptr, MH_LABEL_LENGTH_MAX);
1115                         g_free(ptr);
1116
1117                         snprintf(security_type, sizeof(security_type),
1118                                         fmt, "WPA2 PSK");
1119                 }
1120
1121                 wifi_state = ad->main.hotspot_mode & VCONFKEY_MOBILE_HOTSPOT_MODE_WIFI;
1122
1123                 if (wifi_state && ad->setup.visibility == false)
1124                         hidden = STR_MOBILE_HOTSPOT_IS_HIDDEN;
1125
1126                 if (wifi_state && ad->setup.security_type != TETHERING_WIFI_SECURITY_TYPE_NONE) {
1127                         snprintf(buf, MH_LABEL_LENGTH_MAX,
1128                                         "<font_size=30>"
1129                                         "%s: %s<br>"
1130                                         "%s: %s<br>"
1131                                         "%s<br>"
1132                                         "%s%s"
1133                                         "%s"
1134                                         "</font_size>",
1135                                         STR_DEV_NAME,
1136                                         device_name,
1137                                         STR_PASSWORD,
1138                                         passphrase,
1139                                         security_type,
1140                                         STR_ENTER_THE_PASSWORD_ON_THE_OTHER_DEVICE,
1141                                         hidden[0] != '\0' ? "<br>" : "",
1142                                         hidden);
1143                 } else {
1144                         snprintf(buf, MH_LABEL_LENGTH_MAX,
1145                                         "<font_size=30>"
1146                                         "%s: %s%s"
1147                                         "%s"
1148                                         "</font_size>",
1149                                         STR_DEV_NAME,
1150                                         device_name,
1151                                         hidden[0] != '\0' ? "<br>" : "",
1152                                         hidden);
1153                 }
1154
1155                 return strdup(buf);
1156         }
1157
1158         return NULL;
1159 }
1160
1161 static char *__get_device_label(void *data, Evas_Object *obj,
1162                                                         const char *part)
1163 {
1164         char buf[MH_LABEL_LENGTH_MAX] = {0, };
1165
1166         if (data == NULL) {
1167                 ERR("The param is NULL\n");
1168                 return NULL;
1169         }
1170
1171         if (!strcmp("elm.text", part)) {
1172                 snprintf(buf, MH_LABEL_LENGTH_MAX, "<font_size=30>%s</font_size>", STR_CONNECTED_DEV);
1173                 return strdup(buf);
1174         }
1175
1176         return NULL;
1177 }
1178
1179 #ifdef TETHERING_DATA_USAGE_SUPPORT
1180 static char *__get_usage_label(void *data, Evas_Object *obj, const char *part)
1181 {
1182         mh_appdata_t *ad = (mh_appdata_t*)data;
1183         unsigned long long total = 0;
1184         unsigned long long sent = 0;
1185         unsigned long long received = 0;
1186         char *fmt_str;
1187         char buf[MH_LABEL_LENGTH_MAX] = {0, };
1188         char label[MH_LABEL_LENGTH_MAX] = {0, };
1189
1190         if (data == NULL) {
1191                 ERR("The param is NULL\n");
1192                 return NULL;
1193         }
1194
1195         if (!strcmp("elm.text", part)) {
1196                 g_strlcpy(label, STR_DATA_USAGE, sizeof(label));
1197                 return strdup(label);
1198         } else if (!strcmp("elm.text.multiline", part)) {
1199                 sent = ad->data_statistics.pdp_total_sent;
1200                 received = ad->data_statistics.pdp_total_receive;
1201
1202                 if (sent >= MH_MB || received >= MH_MB) {
1203                         sent /= MH_MB;
1204                         received /= MH_MB;
1205
1206                         total = sent + received;
1207                         fmt_str = STR_MB;
1208                 } else if (sent + received >= MH_MB) {
1209                         total = (sent + received) / MH_MB;
1210                         fmt_str = STR_MB;
1211                 } else if (sent >= MH_KB || received >= MH_KB) {
1212                         sent /= MH_KB;
1213                         received /= MH_KB;
1214
1215                         total = sent + received;
1216                         fmt_str = STR_KB;
1217                 } else if (sent + received >= MH_KB) {
1218                         total = (sent + received) / MH_KB;
1219                         fmt_str = STR_KB;
1220                 } else {
1221                         total = sent + received;
1222                         fmt_str = STR_BYTE;
1223                 }
1224
1225                 if (total > INT_MAX) {
1226                         ERR("data usage overflow\n");
1227                         total = 0;
1228                 }
1229                 snprintf(label, MH_LABEL_LENGTH_MAX, fmt_str, (int)total);
1230                 return strdup(label);
1231         }
1232
1233         return NULL;
1234 }
1235 #endif
1236
1237 static void __set_genlist_itc(mh_appdata_t *ad)
1238 {
1239         /* On, Off view's item class for genlist */
1240         ad->main.wifi_itc = elm_genlist_item_class_new();
1241         if (ad->main.wifi_itc == NULL) {
1242                 ERR("elm_genlist_item_class_new failed\n");
1243                 return;
1244         }
1245
1246         ad->main.wifi_itc->item_style = MH_GENLIST_1LINE_TEXT_ICON_STYLE;
1247         ad->main.wifi_itc->func.text_get = __get_wifi_label;
1248         ad->main.wifi_itc->func.content_get =  __get_wifi_icon;
1249         ad->main.wifi_itc->func.state_get = NULL;
1250         ad->main.wifi_itc->func.del = NULL;
1251
1252         /* End of On, Off view's item class for genlist */
1253
1254         /* Off view's item class for genlist */
1255         ad->main.bt_itc = elm_genlist_item_class_new();
1256         if (ad->main.bt_itc == NULL) {
1257                 ERR("elm_genlist_item_class_new failed\n");
1258                 return;
1259         }
1260
1261         ad->main.bt_itc->item_style = MH_GENLIST_1LINE_TEXT_ICON_STYLE;
1262         ad->main.bt_itc->func.text_get = __get_bt_label;
1263         ad->main.bt_itc->func.content_get = __get_bt_icon;
1264         ad->main.bt_itc->func.state_get = NULL;
1265         ad->main.bt_itc->func.del = NULL;
1266
1267         ad->main.usb_itc = elm_genlist_item_class_new();
1268         if (ad->main.usb_itc == NULL) {
1269                 ERR("elm_genlist_item_class_new failed\n");
1270                 return;
1271         }
1272
1273         ad->main.usb_itc->item_style = MH_GENLIST_1LINE_TEXT_ICON_STYLE;
1274         ad->main.usb_itc->func.text_get = __get_usb_label;
1275         ad->main.usb_itc->func.content_get = __get_usb_icon;
1276         ad->main.usb_itc->func.state_get = NULL;
1277         ad->main.usb_itc->func.del = NULL;
1278
1279         ad->main.help_itc = elm_genlist_item_class_new();
1280         if (ad->main.help_itc == NULL) {
1281                 ERR("elm_genlist_item_class_new failed\n");
1282                 return;
1283         }
1284
1285         ad->main.help_itc->item_style = MH_GENLIST_MULTILINE_TEXT_STYLE;
1286         ad->main.help_itc->func.text_get = __get_help_label;
1287         ad->main.help_itc->func.content_get = NULL;
1288         ad->main.help_itc->func.state_get = NULL;
1289         ad->main.help_itc->func.del = NULL;
1290
1291         /* End of Off view's item class for genlist */
1292
1293
1294         ad->main.device_itc = elm_genlist_item_class_new();
1295         if (ad->main.device_itc == NULL) {
1296                 ERR("elm_genlist_item_class_new failed\n");
1297                 return;
1298         }
1299
1300         ad->main.device_itc->item_style = MH_GENLIST_GROUP_INDEX_STYLE;
1301         ad->main.device_itc->func.text_get = __get_device_label;
1302         ad->main.device_itc->func.content_get = NULL;
1303         ad->main.device_itc->func.state_get = NULL;
1304         ad->main.device_itc->func.del = NULL;
1305
1306 #ifdef TETHERING_DATA_USAGE_SUPPORT
1307         ad->main.usage_itc = elm_genlist_item_class_new();
1308         if (ad->main.usage_itc == NULL) {
1309                 ERR("elm_genlist_item_class_new failed\n");
1310                 return;
1311         }
1312
1313         ad->main.usage_itc->item_style = MH_GENLIST_MULTILINE_TEXT_STYLE;
1314         ad->main.usage_itc->func.text_get = __get_usage_label;
1315         ad->main.usage_itc->func.content_get = NULL;
1316         ad->main.usage_itc->func.state_get = NULL;
1317         ad->main.usage_itc->func.del = NULL;
1318 #endif
1319         /* End of On view's item class for genlist */
1320         return;
1321 }
1322
1323 static void __gl_realized(void *data, Evas_Object *obj, void *event_info)
1324 {
1325         if (data == NULL || event_info == NULL) {
1326                 ERR("Invalid param\n");
1327                 return;
1328         }
1329
1330         mh_appdata_t *ad = (mh_appdata_t *)data;
1331         Elm_Object_Item *item = (Elm_Object_Item *)event_info;
1332         Evas_Object *ao;
1333         Evas_Object *btn;
1334         char str[MH_LABEL_LENGTH_MAX] = {0, };
1335         int i = 0;
1336
1337         if (item == ad->main.wifi_item || item == ad->main.bt_item || item == ad->main.usb_item) {
1338                 ao = elm_object_item_access_object_get(item);
1339                 btn = elm_object_item_part_content_get(item, "on&off");
1340                 snprintf(str, sizeof(str), "%s, %s", "On/off button",
1341                                 (elm_check_state_get(btn) ? "On" : "Off"));
1342                 elm_access_info_set(ao, ELM_ACCESS_CONTEXT_INFO, str);
1343
1344                 if (item == ad->main.wifi_item || item == ad->main.bt_item) {
1345                         DBG("Wi-Fi or BT item : %p\n", item);
1346                         elm_object_item_signal_emit(item, "elm,state,top", "");
1347                 } else if (item == ad->main.usb_item) {
1348                         DBG("USB item\n");
1349                         elm_object_item_signal_emit(item, "elm,state,bottom", "");
1350                 }
1351         } else if (item == ad->main.setup_item) {
1352                 DBG("setup_item\n");
1353                 ao = elm_object_item_access_object_get(item);
1354                 elm_access_info_set(ao, ELM_ACCESS_CONTEXT_INFO, "Item");
1355
1356                 elm_object_item_signal_emit(item, "elm,state,bottom", "");
1357         } else if (item == ad->main.device_item) {
1358                 DBG("device_item\n");
1359                 ao = elm_object_item_access_object_get(item);
1360                 snprintf(str, sizeof(str), "%s, %s", "Expandable list",
1361                                 "Double tap to open list");
1362                 elm_access_info_set(ao, ELM_ACCESS_CONTEXT_INFO, str);
1363
1364                 elm_object_item_signal_emit(item, "elm,state,top", "");
1365         } else if (ad->main.device_item != NULL &&
1366                         ad->main.device_item == elm_genlist_item_parent_get(item)) {
1367                 DBG("device_item's child\n");
1368                 elm_object_item_signal_emit(item, "elm,state,center", "");
1369         } else {
1370                 for (i = 0; i < 4; i++) {
1371                         if (item == ad->main.sp_item[i])
1372                                 elm_object_item_access_unregister(item);
1373                 }
1374         }
1375 #ifdef TETHERING_DATA_USAGE_SUPPORT
1376         if (item == ad->main.usage_item) {
1377                         DBG("usage_item\n");
1378                         elm_object_item_signal_emit(item, "elm,state,bottom", "");
1379         }
1380 #endif
1381         return;
1382 }
1383
1384 static void __create_inner_contents(mh_appdata_t *ad)
1385 {
1386         __MOBILE_AP_FUNC_ENTER__;
1387
1388         Elm_Object_Item *item = NULL;
1389         int no_of_dev = 0;
1390
1391         __read_setting(ad);
1392         ad->main.genlist = elm_genlist_add(ad->naviframe);
1393         elm_genlist_mode_set(ad->main.genlist, ELM_LIST_COMPRESS);
1394         evas_object_smart_callback_add(ad->main.genlist, "realized", __gl_realized, ad);
1395
1396         __set_genlist_itc(ad);
1397
1398         item = elm_genlist_item_append(ad->main.genlist, ad->main.wifi_itc,
1399                         ad, NULL, ELM_GENLIST_ITEM_NONE,
1400                         __select_wifi_item, ad);
1401         ad->main.wifi_item = item;
1402
1403         if (ad->main.hotspot_mode & VCONFKEY_MOBILE_HOTSPOT_MODE_WIFI) {
1404                 item = elm_genlist_item_append(ad->main.genlist, ad->main.help_itc,
1405                                 ad, NULL, ELM_GENLIST_ITEM_NONE,
1406                                 NULL, NULL);
1407                 elm_genlist_item_select_mode_set(item, ELM_OBJECT_SELECT_MODE_DISPLAY_ONLY);
1408                 ad->main.help_item = item;
1409         }
1410
1411         item = elm_genlist_item_append(ad->main.genlist, ad->main.bt_itc,
1412                         ad, NULL, ELM_GENLIST_ITEM_NONE,
1413                         __select_bt_item, ad);
1414         ad->main.bt_item = item;
1415
1416         item = elm_genlist_item_append(ad->main.genlist, ad->main.usb_itc,
1417                         ad, NULL, ELM_GENLIST_ITEM_NONE,
1418                         __select_usb_item, ad);
1419         ad->main.usb_item = item;
1420         if (_get_vconf_usb_state() == VCONFKEY_SYSMAN_USB_DISCONNECTED) {
1421                 if (ad->main.usb_item)
1422                         elm_object_item_disabled_set(ad->main.usb_item, EINA_TRUE);
1423         } else {
1424                 if (ad->main.usb_item)
1425                         elm_object_item_disabled_set(ad->main.usb_item, EINA_FALSE);
1426         }
1427         if (ad->main.hotspot_mode & (VCONFKEY_MOBILE_HOTSPOT_MODE_WIFI |
1428                                 VCONFKEY_MOBILE_HOTSPOT_MODE_USB |
1429                                 VCONFKEY_MOBILE_HOTSPOT_MODE_BT)) {
1430 #ifdef TETHERING_DATA_USAGE_SUPPORT
1431                 item = elm_genlist_item_append(ad->main.genlist, ad->main.usage_itc,
1432                                 ad, NULL, ELM_GENLIST_ITEM_NONE, NULL, NULL);
1433                 elm_genlist_item_select_mode_set(item,
1434                                 ELM_OBJECT_SELECT_MODE_DISPLAY_ONLY);
1435                 ad->main.usage_item = item;
1436 #endif
1437                 /* Insert "Connected devices" item */
1438                 tethering_foreach_connected_clients(ad->handle, TETHERING_TYPE_ALL,
1439                                 _connected_clients_cb, (void *)ad);
1440
1441                 no_of_dev = _get_list_clients_count(ad);
1442                 if (no_of_dev != 0) {
1443                         item = elm_genlist_item_append(ad->main.genlist,
1444                                                 ad->main.device_itc, ad, NULL,
1445                                                 ELM_GENLIST_ITEM_NONE, NULL, NULL);
1446                         elm_genlist_item_select_mode_set(item, ELM_OBJECT_SELECT_MODE_DISPLAY_ONLY);
1447                         _list_connected_dev(ad);
1448                         _update_conn_clients(ad);
1449                 }
1450                 ad->main.device_item = item;
1451         }
1452
1453         if (ad->main.hotspot_mode & VCONFKEY_MOBILE_HOTSPOT_MODE_WIFI_AP) {
1454                 if (ad->main.wifi_item)
1455                         elm_object_item_disabled_set(ad->main.wifi_item, EINA_TRUE);
1456                 if (ad->main.setup_item)
1457                         elm_object_item_disabled_set(ad->main.setup_item, EINA_TRUE);
1458                 if (ad->main.bt_item)
1459                         elm_object_item_disabled_set(ad->main.bt_item, EINA_TRUE);
1460                 if (ad->main.usb_item)
1461                         elm_object_item_disabled_set(ad->main.usb_item, EINA_TRUE);
1462         }
1463
1464         __MOBILE_AP_FUNC_EXIT__;
1465         return;
1466 }
1467
1468 void _main_free_genlist_itc(mh_appdata_t *ad)
1469 {
1470         __MOBILE_AP_FUNC_ENTER__;
1471
1472         if (ad == NULL)
1473                 return;
1474
1475         mh_main_view_t *mv = &ad->main;
1476
1477 #ifdef TETHERING_DATA_USAGE_SUPPORT
1478         _free_genlist_itc(&mv->usage_itc);
1479 #endif
1480         _free_genlist_itc(&mv->device_itc);
1481         _free_genlist_itc(&mv->device0_itc);
1482         _free_genlist_itc(&mv->help_itc);
1483         _free_genlist_itc(&mv->usb_itc);
1484         _free_genlist_itc(&mv->bt_itc);
1485         _free_genlist_itc(&mv->setup_itc);
1486         _free_genlist_itc(&mv->wifi_itc);
1487         __MOBILE_AP_FUNC_EXIT__;
1488         return;
1489 }
1490
1491 void _main_callback_del(mh_appdata_t *ad)
1492 {
1493         __MOBILE_AP_FUNC_ENTER__;
1494
1495         if (ad == NULL) {
1496                 ERR("ad is NULL\n");
1497                 return;
1498         }
1499
1500         Evas_Object *obj;
1501
1502         obj = elm_object_item_part_content_get(ad->main.wifi_item, "elm.swallow.end");
1503         if (obj != NULL)
1504                 evas_object_smart_callback_del(obj, "changed", __wifi_onoff_changed_cb);
1505
1506         obj = elm_object_item_part_content_get(ad->main.bt_item, "elm.swallow.end");
1507         if (obj != NULL)
1508                 evas_object_smart_callback_del(obj, "changed", __bt_onoff_changed_cb);
1509
1510         obj = elm_object_item_part_content_get(ad->main.usb_item, "elm.swallow.end");
1511         if (obj != NULL)
1512                 evas_object_smart_callback_del(obj, "changed", __usb_onoff_changed_cb);
1513
1514         evas_object_smart_callback_del(ad->main.genlist, "realized", __gl_realized);
1515
1516         __MOBILE_AP_FUNC_EXIT__;
1517 }
1518
1519 void _ctxpopup_more_button_callback_add(mh_appdata_t *ad)
1520 {
1521         eext_object_event_callback_add(ad->naviframe, EEXT_CALLBACK_MORE,
1522                         __create_ctxpopup_more_button, ad);
1523 }
1524
1525 void _ctxpopup_more_button_callback_del(mh_appdata_t *ad)
1526 {
1527         eext_object_event_callback_del(ad->naviframe, EEXT_CALLBACK_MORE,
1528                         __create_ctxpopup_more_button);
1529 }
1530
1531 static void __ctx_move_more_ctxpopup(Evas_Object *ctx, mh_appdata_t *ad)
1532 {
1533         Evas_Coord w;
1534         Evas_Coord h;
1535         int pos = -1;
1536         __MOBILE_AP_FUNC_ENTER__;
1537
1538         elm_win_screen_size_get(ad->win, NULL, NULL, &w, &h);
1539         pos = elm_win_rotation_get(ad->win);
1540
1541         switch (pos) {
1542         case 0:
1543         case 180:
1544                 evas_object_move(ctx, w/2, h);
1545                 break;
1546         case 90:
1547                 evas_object_move(ctx, h/2, w);
1548                 break;
1549         case 270:
1550                 evas_object_move(ctx, h/2, w);
1551                 break;
1552         }
1553         __MOBILE_AP_FUNC_EXIT__;
1554 }
1555
1556 static void __rotate_more_ctxpopup_cb(void *data, Evas_Object *obj, void *event_info)
1557 {
1558         __MOBILE_AP_FUNC_ENTER__;
1559
1560         mh_appdata_t *ad = (mh_appdata_t *)data;
1561         Evas_Object *ctx = ad->ctxpopup;
1562
1563         __ctx_move_more_ctxpopup(ctx, ad);
1564         evas_object_show(ctx);
1565
1566         __MOBILE_AP_FUNC_EXIT__;
1567 }
1568
1569 static void __dismissed_more_ctxpopup_cb(void *data, Evas_Object *obj, void *event)
1570 {
1571         __MOBILE_AP_FUNC_ENTER__;
1572
1573         mh_appdata_t *ad = (mh_appdata_t *)data;
1574         Evas_Object *ctx = ad->ctxpopup;
1575
1576         if (!rotate_flag) {
1577                 evas_object_del(ctx);
1578                 ctx = NULL;
1579         } else {
1580                 __ctx_move_more_ctxpopup(ctx, ad);
1581                 evas_object_show(ctx);
1582                 rotate_flag = EINA_FALSE;
1583         }
1584         __MOBILE_AP_FUNC_EXIT__;
1585 }
1586
1587 static void __ctx_delete_more_ctxpopup_cb(void *data, Evas *e, Evas_Object *obj,
1588                 void *event_info)
1589 {
1590         Evas_Object *navi = (Evas_Object *)data;
1591         Evas_Object *ctx = obj;
1592
1593         if (navi == NULL) {
1594                 ERR("data is null\n");
1595                 return;
1596         }
1597         __MOBILE_AP_FUNC_ENTER__;
1598
1599         evas_object_smart_callback_del(ctx, "dismissed",
1600                         __dismissed_more_ctxpopup_cb);
1601         evas_object_smart_callback_del(elm_object_top_widget_get(ctx),
1602                         "rotation,changed", __rotate_more_ctxpopup_cb);
1603         evas_object_event_callback_del_full(ctx, EVAS_CALLBACK_DEL,
1604                         __ctx_delete_more_ctxpopup_cb, navi);
1605         __MOBILE_AP_FUNC_EXIT__;
1606 }
1607
1608 static void __gl_configure_wifi_tethering(void *data, Evas_Object *obj, void *event_info)
1609 {
1610         __MOBILE_AP_FUNC_ENTER__;
1611
1612         if (data == NULL) {
1613                 ERR("The param is NULL\n");
1614                 return;
1615         }
1616         mh_appdata_t *ad = (mh_appdata_t *)data;
1617
1618         evas_object_del(ad->ctxpopup);
1619         ad->ctxpopup = NULL;
1620
1621         elm_genlist_item_selected_set((Elm_Object_Item *)event_info, EINA_FALSE);
1622         _ctxpopup_more_button_callback_del(ad);
1623         mh_draw_wifi_setup_view(ad);
1624
1625         __MOBILE_AP_FUNC_EXIT__;
1626
1627         return;
1628 }
1629
1630 static void __create_ctxpopup_more_button(void *data, Evas_Object *obj,
1631                 void *event_info)
1632 {
1633         mh_appdata_t *ad = (mh_appdata_t *)data;
1634         Evas_Object *ctxpopup = NULL;
1635
1636         if (ad == NULL) {
1637                 ERR("ad is null\n");
1638                 return;
1639         }
1640         __MOBILE_AP_FUNC_ENTER__;
1641
1642         ctxpopup = elm_ctxpopup_add(ad->win);
1643         elm_ctxpopup_auto_hide_disabled_set(ctxpopup, EINA_TRUE);
1644
1645         eext_object_event_callback_add(ctxpopup, EEXT_CALLBACK_BACK,
1646                         eext_ctxpopup_back_cb, ad);
1647         eext_object_event_callback_add(ctxpopup, EEXT_CALLBACK_MORE,
1648                         eext_ctxpopup_back_cb, ad);
1649         elm_object_style_set(ctxpopup, "more/default");
1650         evas_object_smart_callback_add(ctxpopup, "dismissed",
1651                         __dismissed_more_ctxpopup_cb, ad);
1652         evas_object_smart_callback_add(elm_object_top_widget_get(ctxpopup), "rotation,changed",
1653                         __rotate_more_ctxpopup_cb, ad);
1654         evas_object_event_callback_add(ctxpopup, EVAS_CALLBACK_DEL,
1655                         __ctx_delete_more_ctxpopup_cb, ad->naviframe);
1656
1657         elm_ctxpopup_direction_priority_set(ctxpopup, ELM_CTXPOPUP_DIRECTION_UP,
1658                         ELM_CTXPOPUP_DIRECTION_DOWN,
1659                         ELM_CTXPOPUP_DIRECTION_UNKNOWN,
1660                         ELM_CTXPOPUP_DIRECTION_UNKNOWN);
1661
1662         __ctx_move_more_ctxpopup(ctxpopup, ad);
1663         elm_ctxpopup_item_append(ctxpopup, STR_CONFIGURE_MOBILE_HOTSPOT,
1664                         NULL, __gl_configure_wifi_tethering, ad);
1665
1666         evas_object_show(ctxpopup);
1667
1668         ad->ctxpopup = ctxpopup;
1669
1670         __MOBILE_AP_FUNC_EXIT__;
1671 }
1672
1673
1674 void _main_draw_contents(mh_appdata_t *ad)
1675 {
1676         INFO("+\n");
1677
1678         Elm_Object_Item *navi_item;
1679
1680         __create_inner_contents(ad);
1681
1682         ad->main.back_btn = elm_button_add(ad->naviframe);
1683         if (ad->main.back_btn == NULL) {
1684                 ERR("elm_button_add is failed\n");
1685                 if (ad->main.genlist) {
1686                         evas_object_del(ad->main.genlist);
1687                         ad->main.genlist = NULL;
1688                 }
1689                 return;
1690         }
1691         elm_object_style_set(ad->main.back_btn, "naviframe/back_btn/default");
1692
1693         eext_object_event_callback_add(ad->naviframe, EEXT_CALLBACK_BACK,
1694                         eext_naviframe_back_cb, NULL);
1695         _ctxpopup_more_button_callback_add(ad);
1696         evas_object_smart_callback_add(ad->main.back_btn, "clicked", (Evas_Smart_Cb)__back_btn_cb, (void *)ad);
1697         elm_object_focus_allow_set(ad->main.back_btn, EINA_FALSE);
1698
1699         navi_item = elm_naviframe_item_push(ad->naviframe, IDS_TETH,
1700                                 ad->main.back_btn, NULL, ad->main.genlist, NULL);
1701         elm_object_item_domain_text_translatable_set(navi_item, PKGNAME, EINA_TRUE);
1702
1703         elm_naviframe_item_pop_cb_set(navi_item, (Elm_Naviframe_Item_Pop_Cb)__back_btn_cb, (void *)ad);
1704         ad->navi_item = navi_item;
1705         g_ad = ad;
1706         INFO("-\n");
1707         return;
1708 }