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