src/mh_popup.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 <efl_extension.h>
  21 #include <app_control_internal.h>
  22 #include <bundle.h>
  23 #include <bundle_internal.h>
  24 #include <aul.h>
  25
  26 #include "mh_common_utility.h"
  27 #include "mobile_hotspot.h"
  28 #include "mh_popup.h"
  29 #include "mh_string.h"
  30
  31 #define MAX_BUF_SIZE    (256u)
  32 #define NETPOPUP                "net.netpopup"
  33 #define NETWORK_SETTING_APP     "org.tizen.setting-network"
  34
  35 static mh_popup_type_e popup_type = MH_POPUP_NONE;
  36 static Evas_Object *popup_content = NULL;
  37 static char *popup_string = NULL;
  38
  39 static void __launch_network_app(void)
  40 {
  41         int ret = APP_CONTROL_ERROR_NONE;
  42         app_control_h app_control;
  43
  44         ret = app_control_create(&app_control);
  45         if (ret != APP_CONTROL_ERROR_NONE) {
  46                 ERR("app_control_create failed");
  47                 return;
  48         }
  49         app_control_set_operation(app_control, APP_CONTROL_OPERATION_DEFAULT);
  50         app_control_set_launch_mode(app_control, APP_CONTROL_LAUNCH_MODE_GROUP);
  51         app_control_set_app_id(app_control, NETWORK_SETTING_APP);
  52
  53         ret = app_control_send_launch_request(app_control, NULL, NULL);
  54         if (ret == APP_CONTROL_ERROR_NONE)
  55                 DBG("Launch network ug successful");
  56         else
  57                 ERR("Fail to launch network ug");
  58
  59         app_control_destroy(app_control);
  60 }
  61
  62 static void __handle_popup_resp(void *data, bool response)
  63 {
  64         __MOBILE_AP_FUNC_ENTER__;
  65
  66         if (data == NULL) {
  67                 ERR("The param is NULL\n");
  68                 return;
  69         }
  70
  71         mh_appdata_t *ad = (mh_appdata_t *)data;
  72         int ret = 0;
  73         Eina_Bool state = 0;
  74
  75         if (ad->popup_checkbox) {
  76                 state = elm_check_state_get(ad->popup_checkbox);
  77                 evas_object_del(ad->popup_checkbox);
  78                 ad->popup_checkbox = NULL;
  79                 DBG("Checkbox status is = %d\n", state);
  80         }
  81         if (ad->popup) {
  82                 evas_object_del(ad->popup);
  83                 ad->popup = NULL;
  84         }
  85
  86         if (response == true) {
  87                 switch (popup_type) {
  88                 case MH_POPUP_WIFI_ON_CHECKBOX:
  89                         if (state)
  90                                 _set_checkbox_status(TETHERING_TYPE_WIFI, 1);
  91
  92                         ad->is_wifi_teth_enabling = false;
  93                         ret = tethering_enable(ad->handle, TETHERING_TYPE_WIFI);
  94                         if (ret != TETHERING_ERROR_NONE) {
  95                                 ERR("wifi tethering on is failed : %d\n", ret);
  96                                 _update_wifi_item(ad, MH_STATE_NONE);
  97                         }
  98                         _wifi_tethering_checkbox_popup_status_set(false);
  99                         _send_signal_qp(QP_SIGNAL_PROGRESS_ON);
 100                         break;
 101
 102                 case MH_POPUP_BT_ON_CHECKBOX:
 103                         if (state)
 104                                 _set_checkbox_status(TETHERING_TYPE_BT, 1);
 105
 106                         ad->is_bt_teth_enabling = false;
 107                         ret = tethering_enable(ad->handle, TETHERING_TYPE_BT);
 108                         if (ret != TETHERING_ERROR_NONE) {
 109                                 ERR("Error enable bt tethering : %d\n", ret);
 110                                 _update_bt_item(ad, MH_STATE_NONE);
 111                         }
 112                         break;
 113
 114                 case MH_POPUP_USB_ON_CHECKBOX:
 115                         if (state)
 116                                 _set_checkbox_status(TETHERING_TYPE_USB, 1);
 117
 118                         if (_get_vconf_usb_state() == VCONFKEY_SYSMAN_USB_DISCONNECTED) {
 119                                 _update_tethering_item(ad, MH_STATE_NONE);
 120                                 break;
 121                         }
 122                         ad->is_usb_teth_enabling = false;
 123                         ret = tethering_enable(ad->handle, TETHERING_TYPE_USB);
 124                         if (ret != TETHERING_ERROR_NONE) {
 125                                 ERR("Error enable usb tethering : %d\n", ret);
 126                                 _update_usb_item(ad, MH_STATE_NONE);
 127                         }
 128                         break;
 129
 130                 case MH_POPUP_WIFI_OFF:
 131                         ret = tethering_disable(ad->handle, TETHERING_TYPE_WIFI);
 132                         if (ret != TETHERING_ERROR_NONE) {
 133                                 ERR("wifi tethering off is failed : %d\n", ret);
 134                                 _update_wifi_item(ad, MH_STATE_NONE);
 135                         }
 136                         _send_signal_qp(QP_SIGNAL_PROGRESS_OFF);
 137                         break;
 138
 139                 case MH_POPUP_MOBILE_DATA_OFF:
 140                         __launch_network_app();
 141                         _update_tethering_enabling_item(ad, ad->type, MH_STATE_NONE);
 142                         break;
 143
 144                 default:
 145                         ERR("Unknown popup_type : %d\n", popup_type);
 146                         break;
 147                 }
 148         } else {
 149                 switch (popup_type) {
 150                 case MH_POPUP_WIFI_ON_CHECKBOX:
 151                         _update_tethering_enabling_item(ad, TETHERING_TYPE_WIFI, MH_STATE_NONE);
 152                         _send_signal_qp(QP_SIGNAL_PROGRESS_RESET);
 153                         _wifi_tethering_checkbox_popup_status_set(false);
 154                         break;
 155
 156                 case MH_POPUP_BT_ON_CHECKBOX:
 157                         _update_tethering_enabling_item(ad, TETHERING_TYPE_BT, MH_STATE_NONE);
 158                         break;
 159
 160                 case MH_POPUP_USB_ON_CHECKBOX:
 161                         _update_tethering_enabling_item(ad, TETHERING_TYPE_USB, MH_STATE_NONE);
 162                         break;
 163
 164                 case MH_POPUP_WIFI_AP_OFF:
 165                         if (ad->setup.genlist)
 166                                 elm_naviframe_item_pop(ad->naviframe);
 167                         elm_naviframe_item_pop(ad->naviframe);
 168                         break;
 169
 170                 case MH_POPUP_WIFI_OFF:
 171                         _update_tethering_enabling_item(ad, TETHERING_TYPE_WIFI, MH_STATE_NONE);
 172                         _send_signal_qp(QP_SIGNAL_PROGRESS_RESET);
 173                         break;
 174
 175                 case MH_POPUP_MOBILE_DATA_OFF:
 176                         _update_tethering_enabling_item(ad, ad->type, MH_STATE_NONE);
 177                         break;
 178                 default:
 179                         ERR("Unknown popup_type : %d\n", popup_type);
 180                         break;
 181                 }
 182         }
 183
 184         __MOBILE_AP_FUNC_EXIT__;
 185 }
 186
 187 #ifdef TIZEN_FEATURE_EMULATOR
 188 static void __handle_emul_popup_resp(void *data, bool response)
 189 {
 190         __MOBILE_AP_FUNC_ENTER__;
 191
 192         if (data == NULL) {
 193                 ERR("The param is NULL\n");
 194                 return;
 195         }
 196
 197         mh_appdata_t *ad = (mh_appdata_t *)data;
 198         Eina_Bool state = 0;
 199
 200         if (ad->popup_checkbox) {
 201                 state = elm_check_state_get(ad->popup_checkbox);
 202                 evas_object_del(ad->popup_checkbox);
 203                 ad->popup_checkbox = NULL;
 204                 DBG("Checkbox status is = %d\n", state);
 205         }
 206         if (ad->popup) {
 207                 evas_object_del(ad->popup);
 208                 ad->popup = NULL;
 209         }
 210
 211         if (response == true) {
 212                 switch (popup_type) {
 213                 case MH_POPUP_WIFI_ON_CHECKBOX:
 214                         if (state)
 215                                 _set_checkbox_status(TETHERING_TYPE_WIFI, 1);
 216                         ad->is_wifi_teth_enabling = false;
 217                         break;
 218
 219                 case MH_POPUP_BT_ON_CHECKBOX:
 220                         if (state)
 221                                 _set_checkbox_status(TETHERING_TYPE_BT, 1);
 222                         ad->is_bt_teth_enabling = false;
 223                         break;
 224
 225                 default:
 226                         ERR("Unknown popup_type : %d\n", popup_type);
 227                         break;
 228                 }
 229         } else {
 230                 switch (popup_type) {
 231                 case MH_POPUP_WIFI_ON_CHECKBOX:
 232                         _update_tethering_enabling_item(ad, TETHERING_TYPE_WIFI, MH_STATE_NONE);
 233                         _wifi_tethering_checkbox_popup_status_set(false);
 234                         break;
 235
 236                 case MH_POPUP_BT_ON_CHECKBOX:
 237                         _update_tethering_enabling_item(ad, TETHERING_TYPE_BT, MH_STATE_NONE);
 238                         break;
 239
 240                 default:
 241                         ERR("Unknown popup_type : %d\n", popup_type);
 242                         break;
 243                 }
 244         }
 245
 246         __MOBILE_AP_FUNC_EXIT__;
 247 }
 248 #endif
 249
 250 void _teth_on(mh_appdata_t *ad)
 251 {
 252 #ifndef TIZEN_FEATURE_EMULATOR
 253         __handle_popup_resp(ad, true);
 254 #else
 255         __handle_emul_popup_resp(ad, true);
 256 #endif
 257 }
 258
 259 static void __popup_yes_btn_clicked_cb(void *data, Evas_Object *obj, void *event_info)
 260 {
 261         if (data == NULL || obj == NULL) {
 262                 ERR("The param is NULL\n");
 263                 return;
 264         }
 265
 266 #ifndef TIZEN_FEATURE_EMULATOR
 267         __handle_popup_resp(data, true);
 268 #else
 269         mh_appdata_t *ad = (mh_appdata_t *)data;
 270
 271         __handle_emul_popup_resp(data, true);
 272         _update_emul_main_view(ad, _get_selected_type(), _get_selected_state());
 273 #endif
 274 }
 275
 276 static void __popup_no_btn_clicked_cb(void *data, Evas_Object *obj, void *event_info)
 277 {
 278         if (data == NULL || obj == NULL) {
 279                 ERR("The param is NULL\n");
 280                 return;
 281         }
 282
 283 #ifndef TIZEN_FEATURE_EMULATOR
 284         __handle_popup_resp(data, false);
 285 #else
 286         __handle_emul_popup_resp(data, false);
 287 #endif
 288 }
 289
 290 static void __popup_no_btn_mouse_event_cb(void *data, Evas *evas, Evas_Object *obj, void *event_info)
 291 {
 292         if (data == NULL || obj == NULL) {
 293                 ERR("The param is NULL\n");
 294                 return;
 295         }
 296
 297         Evas_Event_Mouse_Up *ev = event_info;
 298
 299         if (ev->button == 3)
 300 #ifndef TIZEN_FEATURE_EMULATOR
 301                 __handle_popup_resp(data, false);
 302 #else
 303                 __handle_emul_popup_resp(data, false);
 304 #endif
 305 }
 306
 307 static void __popup_block_clicked_cb(void *data, Evas_Object *obj, void *event_info)
 308 {
 309         if (obj == NULL) {
 310                 ERR("The param is NULL\n");
 311                 return;
 312         }
 313
 314         elm_popup_dismiss(obj);
 315 }
 316
 317 static void __popup_hide_finished_cb(void *data, Evas_Object *obj, void *event_info)
 318 {
 319         if (data == NULL) {
 320                 ERR("The param is NULL\n");
 321                 return;
 322         }
 323
 324 #ifndef TIZEN_FEAUTRE_EMULATOR
 325         __handle_popup_resp(data, false);
 326 #else
 327         __handle_emul_popup_resp(data, false);
 328 #endif
 329 }
 330
 331 void _prepare_popup_with_content(int type, Evas_Object *obj)
 332 {
 333         __MOBILE_AP_FUNC_ENTER__;
 334
 335         if (obj == NULL) {
 336                 ERR("param is NULL\n");
 337                 return;
 338         }
 339
 340         popup_type = type;
 341
 342         if (popup_content)
 343                 evas_object_del(popup_content);
 344         popup_content = obj;
 345
 346         if (popup_string) {
 347                 free(popup_string);
 348                 popup_string = NULL;
 349         }
 350
 351         __MOBILE_AP_FUNC_EXIT__;
 352 }
 353
 354 void _prepare_popup(int type, const char *str)
 355 {
 356         __MOBILE_AP_FUNC_ENTER__;
 357
 358         if (str == NULL) {
 359                 ERR("param is NULL\n");
 360                 return;
 361         }
 362         popup_type = type;
 363
 364         popup_content = NULL;
 365
 366         if (popup_string)
 367                 free(popup_string);
 368
 369         popup_string = strndup(str, MH_LABEL_LENGTH_MAX);
 370         if (popup_string == NULL)
 371                 ERR("strndup is failed\n");
 372
 373         __MOBILE_AP_FUNC_EXIT__;
 374 }
 375
 376 void _prepare_popup_type(int type)
 377 {
 378         popup_type = type;
 379 }
 380
 381 static void __language_changed_cb(void *data, Evas_Object *obj, void *event_info)
 382 {
 383         __MOBILE_AP_FUNC_ENTER__;
 384
 385         mh_appdata_t *ad = (mh_appdata_t *)data;
 386         Evas_Object *label = NULL;
 387         bool wifi_state = false;
 388         char *fmt = NULL;
 389         char str[MH_LABEL_LENGTH_MAX];
 390
 391         if (ad->type < TETHERING_TYPE_USB || ad->type > TETHERING_TYPE_BT) {
 392                 ERR("Invalid Tethering type\n");
 393                 return;
 394         }
 395
 396         switch (ad->type) {
 397         case TETHERING_TYPE_WIFI:
 398                 wifi_is_activated(&wifi_state);
 399                 _set_vconf_prev_wifi_state(wifi_state);
 400                 if (wifi_state == true || _is_wifi_direct_on() == true)
 401                         fmt = STR_TETH_ON_DESC_1;
 402                 else
 403                         fmt = STR_TETH_ON_DESC_2;
 404
 405                 snprintf(str, MH_LABEL_LENGTH_MAX, fmt, TETHERING_WIFI_MAX_CONNECTED_STA);
 406                 break;
 407
 408         case TETHERING_TYPE_BT:
 409                 fmt = STR_TETH_ON_DESC_2;
 410                 snprintf(str, MH_LABEL_LENGTH_MAX, fmt, TETHERING_BT_MAX_CONNECTED_STA);
 411                 break;
 412
 413         case TETHERING_TYPE_USB:
 414                 snprintf(str, MH_LABEL_LENGTH_MAX, STR_TETH_ON_DESC_3);
 415                 break;
 416         default:
 417                 break;
 418         }
 419
 420         label = elm_label_add(ad->main.check_popup_ly);
 421         elm_object_style_set(label, "popup/default");
 422         elm_label_line_wrap_set(label, ELM_WRAP_MIXED);
 423         elm_object_text_set(label, str);
 424         evas_object_size_hint_weight_set(label, EVAS_HINT_EXPAND, 0.0);
 425         evas_object_size_hint_align_set(label, EVAS_HINT_FILL, EVAS_HINT_FILL);
 426         evas_object_show(label);
 427         elm_object_part_content_set(ad->main.check_popup_ly, "elm.swallow.content", label);
 428
 429         __MOBILE_AP_FUNC_EXIT__;
 430 }
 431
 432 static void __popup_with_checkbox(mh_appdata_t *ad)
 433 {
 434         __MOBILE_AP_FUNC_ENTER__;
 435
 436         Evas_Object *popup = NULL;
 437         Evas_Object *yes_button = NULL;
 438         Evas_Object *cancel_button = NULL;
 439         Evas_Object *layout = NULL;
 440         Evas_Object *label = NULL;
 441         Evas_Object *check = NULL;
 442
 443         popup = elm_popup_add(ad->win);
 444         elm_popup_align_set(popup, ELM_NOTIFY_ALIGN_FILL, 1.0);
 445         evas_object_size_hint_weight_set(popup, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
 446         ad->popup = popup;
 447         switch (ad->type) {
 448         case TETHERING_TYPE_WIFI:
 449                 elm_object_domain_translatable_part_text_set(popup, "title,text", PACKAGE,
 450                                 "IDS_MOBILEAP_MBODY_WI_FI_TETHERING");
 451                 break;
 452         case TETHERING_TYPE_BT:
 453                 elm_object_domain_translatable_part_text_set(popup, "title,text", PACKAGE,
 454                                 "IDS_MOBILEAP_BODY_BLUETOOTH_TETHERING");
 455                 break;
 456         case TETHERING_TYPE_USB:
 457                 elm_object_domain_translatable_part_text_set(popup, "title,text", PACKAGE,
 458                                 "IDS_MOBILEAP_MBODY_USB_TETHERING");
 459                 break;
 460         default:
 461                 break;
 462         }
 463
 464         /* layout */
 465         layout = elm_layout_add(popup);
 466         elm_layout_file_set(layout, FILE_PATH_OF_EDC, "popup_checkview_layout");
 467         evas_object_size_hint_weight_set(layout, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
 468         evas_object_size_hint_align_set(layout, EVAS_HINT_FILL, 1.0);
 469         ad->main.check_popup_ly = layout;
 470
 471         /* check */
 472         check = elm_check_add(popup);
 473         elm_object_style_set(check, "popup");
 474         elm_object_domain_translatable_text_set(check, PACKAGE, STR_NO_SHOW_AGAIN);
 475         evas_object_size_hint_align_set(check, EVAS_HINT_FILL, EVAS_HINT_FILL);
 476         evas_object_size_hint_weight_set(check, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
 477         elm_object_part_content_set(layout, "elm.swallow.end", check);
 478         ad->popup_checkbox = check;
 479
 480         /* label */
 481         label = elm_label_add(layout);
 482         elm_object_style_set(label, "popup/default");
 483         elm_label_line_wrap_set(label, ELM_WRAP_MIXED);
 484         elm_object_text_set(label, popup_string);
 485         evas_object_size_hint_weight_set(label, EVAS_HINT_EXPAND, 0.0);
 486         evas_object_size_hint_align_set(label, EVAS_HINT_FILL, EVAS_HINT_FILL);
 487         evas_object_show(label);
 488         elm_object_part_content_set(layout, "elm.swallow.content", label);
 489
 490         cancel_button = _create_button(popup,  "IDS_BR_SK_CANCEL",
 491                                 "button1", __popup_no_btn_clicked_cb, ad);
 492         yes_button = _create_button(popup, "IDS_ST_BUTTON_ENABLE_M_USE",
 493                                 "button2", __popup_yes_btn_clicked_cb, ad);
 494
 495         evas_object_smart_callback_add(popup, "language,changed", __language_changed_cb, ad);
 496
 497         eext_object_event_callback_add(popup, EEXT_CALLBACK_BACK,
 498                         __popup_no_btn_clicked_cb, (void *)ad);
 499
 500         evas_object_event_callback_add(popup, EVAS_CALLBACK_MOUSE_UP,
 501                         __popup_no_btn_mouse_event_cb, (void *)ad);
 502         evas_object_smart_callback_add(popup, "block,clicked",
 503                         __popup_block_clicked_cb, NULL);
 504         evas_object_smart_callback_add(popup, "dismissed",
 505                         __popup_hide_finished_cb, ad);
 506
 507
 508         if (check && yes_button) {
 509                 elm_object_focus_next_object_set(check, yes_button, ELM_FOCUS_PREVIOUS);
 510                 elm_object_focus_next_object_set(yes_button, check, ELM_FOCUS_NEXT);
 511                 if (cancel_button) {
 512                         elm_object_focus_next_object_set(cancel_button, check, ELM_FOCUS_PREVIOUS);
 513                         elm_object_focus_next_object_set(check , cancel_button, ELM_FOCUS_NEXT);
 514                 }
 515         }
 516
 517         elm_object_content_set(popup, layout);
 518         evas_object_show(popup);
 519         ad->popup = popup;
 520
 521         __MOBILE_AP_FUNC_EXIT__;
 522 }
 523
 524 Eina_Bool _create_popup(mh_appdata_t *ad)
 525 {
 526         __MOBILE_AP_FUNC_ENTER__;
 527
 528         Evas_Object *popup = NULL;
 529         Evas_Object *cancel_button = NULL;
 530         Evas_Object *yes_button = NULL;
 531
 532         if (ad == NULL) {
 533                 ERR("The param is NULL\n");
 534                 if (popup_string) {
 535                         free(popup_string);
 536                         popup_string = NULL;
 537                 }
 538                 popup_content = NULL;
 539
 540                 return EINA_FALSE;
 541         }
 542
 543         if (ad->popup != NULL) {
 544                 evas_object_del(ad->popup);
 545                 ad->popup = NULL;
 546         }
 547         ad->popup_checkbox = NULL;
 548         DBG("popup type : %d", popup_type);
 549
 550         switch (popup_type) {
 551         case MH_POPUP_WIFI_ON_CHECKBOX:
 552         case MH_POPUP_BT_ON_CHECKBOX:
 553         case MH_POPUP_USB_ON_CHECKBOX:
 554                 __popup_with_checkbox(ad);
 555                 break;
 556
 557         case MH_POPUP_WIFI_OFF:
 558                 popup = elm_popup_add(ad->win);
 559                 elm_popup_align_set(popup, ELM_NOTIFY_ALIGN_FILL, 1.0);
 560                 ad->popup = popup;
 561
 562                 elm_object_domain_translatable_part_text_set(popup, "title,text", PACKAGE,
 563                                 "IDS_MOBILEAP_MBODY_WI_FI_TETHERING");
 564
 565                 evas_object_size_hint_weight_set(popup,
 566                                 EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
 567
 568                 if (popup_content == NULL)
 569                         elm_object_domain_translatable_text_set(popup, PACKAGE, popup_string);
 570                 else
 571                         elm_object_content_set(popup, popup_content);
 572
 573                 cancel_button = _create_button(popup, STR_CANCEL,
 574                                 "button1", __popup_no_btn_clicked_cb, ad);
 575                 yes_button = _create_button(popup, STR_TURN_OFF,
 576                                 "button2", __popup_yes_btn_clicked_cb, ad);
 577
 578                 eext_object_event_callback_add(popup, EEXT_CALLBACK_BACK,
 579                                 __popup_no_btn_clicked_cb, (void *)ad);
 580                 evas_object_event_callback_add(popup, EVAS_CALLBACK_MOUSE_UP,
 581                                 __popup_no_btn_mouse_event_cb, (void *)ad);
 582                 evas_object_smart_callback_add(popup, "block,clicked",
 583                                 __popup_block_clicked_cb, NULL);
 584                 evas_object_smart_callback_add(popup, "dismissed",
 585                                 __popup_hide_finished_cb, ad);
 586
 587                 evas_object_show(popup);
 588                 break;
 589
 590         case MH_POPUP_TETH_ENABLING_FAILED:
 591         case MH_POPUP_NO_SIM:
 592         case MH_POPUP_FLIGHT_MODE:
 593         case MH_POPUP_NETWORK_OUT_OF_RANGE:
 594                 popup = elm_popup_add(ad->win);
 595                 elm_popup_align_set(popup, ELM_NOTIFY_ALIGN_FILL, 1.0);
 596                 ad->popup = popup;
 597                 evas_object_size_hint_weight_set(popup, EVAS_HINT_EXPAND,
 598                                 EVAS_HINT_EXPAND);
 599
 600                 if (popup_content == NULL)
 601                         elm_object_domain_translatable_text_set(popup, PACKAGE, popup_string);
 602                 else
 603                         elm_object_content_set(popup, popup_content);
 604                 elm_object_domain_translatable_part_text_set(popup, "title,text", PACKAGE,
 605                                 STR_NO_NET_CONN);
 606                 cancel_button = _create_button(popup,  STR_CANCEL,
 607                                 "button1", __popup_no_btn_clicked_cb, ad);
 608
 609                 eext_object_event_callback_add(popup, EEXT_CALLBACK_BACK,
 610                                 __popup_no_btn_clicked_cb, (void *)ad);
 611                 evas_object_event_callback_add(popup, EVAS_CALLBACK_MOUSE_UP,
 612                                 __popup_no_btn_mouse_event_cb, (void *)ad);
 613                 evas_object_smart_callback_add(popup, "block,clicked",
 614                                 __popup_block_clicked_cb, NULL);
 615                 evas_object_smart_callback_add(popup, "dismissed",
 616                                 __popup_hide_finished_cb, ad);
 617
 618                 evas_object_show(popup);
 619                 break;
 620
 621         case MH_POPUP_MOBILE_DATA_OFF:
 622                 popup = elm_popup_add(ad->win);
 623                 elm_popup_align_set(popup, ELM_NOTIFY_ALIGN_FILL, 1.0);
 624                 ad->popup = popup;
 625                 evas_object_size_hint_weight_set(popup, EVAS_HINT_EXPAND,
 626                                 EVAS_HINT_EXPAND);
 627
 628                 if (popup_content == NULL)
 629                         elm_object_domain_translatable_text_set(popup, PACKAGE, popup_string);
 630                 else
 631                         elm_object_content_set(popup, popup_content);
 632                 elm_object_domain_translatable_part_text_set(popup, "title,text", PACKAGE,
 633                                 STR_NO_NET_CONN);
 634                 cancel_button = _create_button(popup,  STR_CANCEL,
 635                                 "button1", __popup_no_btn_clicked_cb, ad);
 636                 yes_button = _create_button(popup, STR_SETTING,
 637                                 "button2", __popup_yes_btn_clicked_cb, ad);
 638
 639                 eext_object_event_callback_add(popup, EEXT_CALLBACK_BACK,
 640                                 __popup_no_btn_clicked_cb, (void *)ad);
 641                 evas_object_event_callback_add(popup, EVAS_CALLBACK_MOUSE_UP,
 642                                 __popup_no_btn_mouse_event_cb, (void *)ad);
 643                 evas_object_smart_callback_add(popup, "block,clicked",
 644                                 __popup_block_clicked_cb, NULL);
 645                 evas_object_smart_callback_add(popup, "dismissed",
 646                                 __popup_hide_finished_cb, ad);
 647
 648                 evas_object_show(popup);
 649                 break;
 650
 651         case MH_POPUP_WIFI_AP_OFF:
 652                 popup = elm_popup_add(ad->win);
 653                 elm_popup_align_set(popup, ELM_NOTIFY_ALIGN_FILL, 1.0);
 654                 ad->popup = popup;
 655                 evas_object_size_hint_weight_set(popup,
 656                                 EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
 657
 658                 elm_object_domain_translatable_part_text_set(popup, "title,text", PACKAGE,
 659                                 STR_TETH);
 660                 if (popup_content == NULL)
 661                         elm_object_domain_translatable_text_set(popup, PACKAGE, popup_string);
 662                 else
 663                         elm_object_content_set(popup, popup_content);
 664
 665                 cancel_button = _create_button(popup,  STR_CANCEL,
 666                                 "button1", __popup_no_btn_clicked_cb, ad);
 667                 yes_button = _create_button(popup, STR_ENABLE,
 668                                 "button2", __popup_yes_btn_clicked_cb, ad);
 669
 670                 eext_object_event_callback_add(popup, EEXT_CALLBACK_BACK,
 671                                 __popup_no_btn_clicked_cb, (void *)ad);
 672                 evas_object_event_callback_add(popup, EVAS_CALLBACK_MOUSE_UP,
 673                                 __popup_no_btn_mouse_event_cb, (void *)ad);
 674
 675                 evas_object_show(popup);
 676                 break;
 677
 678         default:
 679                 ERR("Unknown popup_type : %d\n", popup_type);
 680                 break;
 681         }
 682
 683         if (cancel_button && yes_button) {
 684                 elm_object_focus_next_object_set(cancel_button, yes_button, ELM_FOCUS_PREVIOUS);
 685                 elm_object_focus_next_object_set(yes_button, cancel_button, ELM_FOCUS_NEXT);
 686         }
 687
 688         if (popup_string) {
 689                 free(popup_string);
 690                 popup_string = NULL;
 691         }
 692         popup_content = NULL;
 693
 694         __MOBILE_AP_FUNC_EXIT__;
 695
 696         return EINA_TRUE;
 697 }
 698
 699 void _destroy_popup(mh_appdata_t *ad)
 700 {
 701         __MOBILE_AP_FUNC_ENTER__;
 702
 703         if (ad == NULL) {
 704                 ERR("ad is null\n");
 705                 return;
 706         }
 707
 708         if (ad->popup) {
 709                 evas_object_del(ad->popup);
 710                 ad->popup = NULL;
 711         }
 712         ad->popup_checkbox = NULL;
 713
 714         if (popup_string) {
 715                 free(popup_string);
 716                 popup_string = NULL;
 717         }
 718         popup_content = NULL;
 719         popup_type = MH_POPUP_NONE;
 720
 721         __MOBILE_AP_FUNC_EXIT__;
 722
 723         return;
 724 }
 725
 726 void _create_security_restriction_noti(tethering_type_e type)
 727 {
 728         bundle *b = NULL;
 729         char restricted_type[MAX_BUF_SIZE] = {0, };
 730         int ret;
 731
 732         switch (type) {
 733         case TETHERING_TYPE_WIFI:
 734                 g_strlcpy(restricted_type, "wifi tethering", MAX_BUF_SIZE - 1);
 735                 break;
 736         case TETHERING_TYPE_USB:
 737                 g_strlcpy(restricted_type, "usb tethering", MAX_BUF_SIZE - 1);
 738                 break;
 739         case TETHERING_TYPE_BT:
 740                 g_strlcpy(restricted_type, "bt tethering", MAX_BUF_SIZE - 1);
 741                 break;
 742         default:
 743                 ERR("Invalid type.\n");
 744                 return;
 745         }
 746         b = bundle_create();
 747
 748         bundle_add(b, "_SYSPOPUP_TYPE_", "toast_popup");
 749         bundle_add(b, "_SYSPOPUP_CONTENT_", "security restriction");
 750         bundle_add(b, "_RESTRICTED_TYPE_", restricted_type);
 751
 752         DBG("Launch security restriction alert network popup");
 753         ret = aul_launch_app(NETPOPUP, b);
 754         if (ret < 0)
 755                 ERR("Fail to launch syspopup");
 756
 757         bundle_free(b);
 758         return;
 759 }