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