src/ui.c

   1 /*
   2  *  pwlock
   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://floralicense.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 <appcore-efl.h>
  21 #include <Ecore_X.h>
  22 #include <ui-gadget.h>
  23 #include <vconf.h>
  24 #include <ail.h>
  25 #include <appsvc.h>
  26 #include <system_info.h>
  27
  28 #include "pwlock.h"
  29 #include "util.h"
  30 #include "tapi.h"
  31 #include "ui.h"
  32 #include "langs.h"
  33 #include "ui-callback.h"
  34
  35 static Elm_Gen_Item_Class itc_label1, itc_entry1, itc_label2, itc_entry2;
  36 static void _ug_layout_cb(ui_gadget_h ug, enum ug_mode mode, void *priv);
  37 static void _ug_destroy_cb(ui_gadget_h ug, void *priv);
  38 static Evas_Object *_create_bg(Evas_Object * win);
  39 static void _destroy_previous_ugs(void *data);
  40 static void _focused_cb(void *data, Evas_Object * obj, void *event_info);
  41 static void _unfocused_cb(void *data, Evas_Object * obj, void *event_info);
  42 static void _eraser_clicked_cb(void *data, Evas_Object * obj,
  43                                const char *emission, const char *source);
  44 static Evas_Object *_create_editfield(Evas_Object * parent, Eina_Bool focus);
  45 static Evas_Object *_editfield_entry_get(Evas_Object * parent);
  46 static Evas_Object *_create_toolbar_btn(Evas_Object *parent);
  47
  48 static int _ug_destroy = 0;
  49
  50 static int _header_idx[] = {
  51         _UI_PIN, IDS_IDLE_HEADER_PIN_LOCK,
  52         _UI_PUK, IDS_IDLE_HEADER_PUK_LOCK,
  53         _UI_PUK_PIN, IDS_IDLE_HEADER_PUK_LOCK,
  54         _UI_PUK_CNF, IDS_IDLE_HEADER_PUK_LOCK,
  55         _UI_BLOCK, IDS_IDLE_HEADER_SIM_BLOCKED,
  56         _UI_SIM_LOCK, IDS_IDLE_HEADER_SIM_LOCK,
  57         _UI_NETWORK_LOCK_NCK, IDS_IDLE_HEADER_NETWORK_LOCK,
  58         _UI_NETWORK_LOCK_NSCK, IDS_IDLE_HEADER_NETWORK_LOCK,
  59         _UI_NETWORK_LOCK_SPCK, IDS_IDLE_HEADER_NETWORK_LOCK,
  60         _UI_NETWORK_LOCK_CCK, IDS_IDLE_HEADER_NETWORK_LOCK,
  61         _UI_FINISH, IDS_STU_POP_SETUP_COMPLETE,
  62 };
  63
  64 static int _tit_idx[] = {
  65         _UI_PIN, STR_E_PIN, IDS_IDLE_BODY_ENTER_PIN,
  66         _UI_PUK, STR_E_PUK, IDS_IDLE_BODY_ENTER_PUK,
  67         _UI_PUK_PIN, STR_E_NEW, IDS_IDLE_BODY_ENTER_NEW_PIN,
  68         _UI_PUK_CNF, STR_R_PIN, IDS_IDLE_BODY_ENTER_PIN,
  69         _UI_BLOCK, STR_BLOCK,
  70         IDS_IDLE_BODY_SIM_CARD_NOT_AVAILABLE_CONTACT_YOUR_SERVICE_PROVIDER,
  71         _UI_SIM_LOCK, STR_SIM_LOCK, IDS_COM_BODY_ENTER_PASSWORD,
  72         _UI_NETWORK_LOCK_NCK, STR_NETWORK_LOCK_NCK,
  73         IDS_IDLE_BODY_NETWORK_PERSONALISATION_ON_ENTER_CONTROL_KEY,
  74         _UI_NETWORK_LOCK_NSCK, STR_NETWORK_LOCK_NSCK,
  75         IDS_IDLE_BODY_NETWORK_SUBSET_PERSONALISATION_ON_ENTER_CONTROL_KEY,
  76         _UI_NETWORK_LOCK_SPCK, STR_NETWORK_LOCK_SPCK,
  77         IDS_IDLE_BODY_SERVICE_PROVIDER_PERSONALISATION_ON_ENTER_CONTROL_KEY,
  78         _UI_NETWORK_LOCK_CCK, STR_NETWORK_LOCK_CCK,
  79         IDS_IDLE_BODY_CORPORATE_PERSONALISATION_ON_ENTER_CONTROL_KEY,
  80         _UI_LANG, STR_LANG, IDS_IDLE_HEADER_DISPLAY_LANGUAGE,
  81 };
  82
  83 static char *_get_header(int ui_type)
  84 {
  85         int i;
  86         char *r = "";
  87
  88         for (i = 0; i < sizeof(_header_idx) / sizeof(_header_idx[0]); i = i + 2) {
  89                 if (ui_type == _header_idx[i]) {
  90                         r = pwlock_get_string(_header_idx[i + 1]);
  91                         break;
  92                 }
  93         }
  94
  95         return r;
  96 }
  97
  98 static char *_get_tip(int ui_type)
  99 {
 100         int i;
 101         char *r = "";
 102         if (sizeof(_tit_idx[0]) != 0) {
 103                 for (i = 0; i < sizeof(_tit_idx) / sizeof(_tit_idx[0]);
 104                      i = i + 3) {
 105                         if (ui_type == _tit_idx[i]) {
 106                                 r = pwlock_get_string(_tit_idx[i + 2]);
 107                                 break;
 108                         }
 109                 }
 110         }
 111
 112         return r;
 113 }
 114
 115 static Eina_Bool pwlock_back_cb(void *data, Elm_Object_Item *it)
 116 {
 117         _DBG("back key is touched");
 118
 119         elm_object_item_del(it);
 120
 121         return EINA_FALSE;
 122 }
 123
 124 static Evas_Object *_create_bg(Evas_Object * win)
 125 {                               /* nbeat */
 126         Evas_Object *bg = elm_bg_add(win);
 127         evas_object_size_hint_weight_set(bg, EVAS_HINT_EXPAND,
 128                                          EVAS_HINT_EXPAND);
 129         evas_object_color_set(bg, 0, 0, 0, 255);
 130         elm_win_resize_object_add(win, bg);
 131         evas_object_show(bg);
 132         return bg;
 133 }
 134
 135 static Evas_Object *_create_conformant(Evas_Object * parent)
 136 {
 137         Evas_Object *conform;
 138         conform = elm_conformant_add(parent);
 139         evas_object_size_hint_weight_set(conform, EVAS_HINT_EXPAND,
 140                                          EVAS_HINT_EXPAND);
 141         elm_win_resize_object_add(parent, conform);
 142         elm_win_indicator_mode_set(parent, ELM_WIN_INDICATOR_SHOW);
 143         evas_object_show(conform);
 144
 145         return conform;
 146 }
 147
 148 static Evas_Object *_create_layout(struct appdata *ad)
 149 {
 150         Evas_Object *ly;
 151
 152         ly = elm_layout_add(ad->elm_conform);
 153         if (!ly) {
 154                 _ERR("UI layout add error");
 155                 return NULL;
 156         }
 157
 158         /* Apply the nbeat layout style */
 159         elm_layout_theme_set(ly, "layout", "application", "default");
 160
 161         evas_object_size_hint_weight_set(ly, EVAS_HINT_EXPAND,
 162                                          EVAS_HINT_EXPAND);
 163         evas_object_show(ly);
 164
 165         return ly;
 166 }
 167
 168 static Evas_Object *_create_toolbar_btn(Evas_Object *parent)
 169 {
 170         Evas_Object *toolbar = elm_toolbar_add(parent);
 171
 172         if (!toolbar)
 173                 return NULL;
 174
 175         elm_object_style_set(toolbar, "default");
 176         elm_toolbar_shrink_mode_set(toolbar, ELM_TOOLBAR_SHRINK_EXPAND);
 177         elm_toolbar_transverse_expanded_set(toolbar, EINA_TRUE);
 178
 179         return toolbar;
 180 }
 181
 182 Evas_Object *pwlock_add_layout_from_edj(Evas_Object *parent, const char *file,
 183                 const char *group) {
 184         Evas_Object *layout = NULL;
 185         Eina_Bool ret = EINA_FALSE;
 186
 187         if (parent == NULL) {
 188                 _ERR("parent is NULL");
 189                 return NULL;
 190         }
 191
 192         layout = elm_layout_add(parent);
 193         if (layout == NULL) {
 194                 _ERR("layout is NULL");
 195                 return NULL;
 196         }
 197
 198         ret = elm_layout_file_set(layout, file, group);
 199         _DBG("File:%s, Group:%s", file, group);
 200         if (ret != EINA_TRUE) {
 201                 _DBG("Error loading File:%s, Group:%s", file, group);
 202                 evas_object_del(layout);
 203                 return NULL;
 204         }
 205         evas_object_size_hint_weight_set(layout, EVAS_HINT_EXPAND,
 206                         EVAS_HINT_EXPAND);
 207         evas_object_show(layout);
 208
 209         return layout;
 210 }
 211
 212 static void init_ui(struct appdata *ad)
 213 {
 214         if (!ad->elm_bg)
 215                 ad->elm_bg = _create_bg(ad->win);
 216
 217         if (!ad->elm_conform)
 218                 ad->elm_conform = _create_conformant(ad->win);
 219
 220         if (!ad->layout_main) {
 221                 ad->layout_main = _create_layout(ad);
 222                 if (!ad->layout_main)
 223                         return;
 224                 elm_object_content_set(ad->elm_conform, ad->layout_main);
 225         }
 226
 227         if (!ad->elm_navigation_frame) {
 228                 ad->elm_navigation_frame = elm_naviframe_add(ad->layout_main);
 229                 if (!ad->elm_navigation_frame) {
 230                         _ERR("UI navi add error");
 231                         return;
 232                 }
 233
 234                 elm_object_part_content_set(ad->layout_main, "elm.swallow.content", ad->elm_navigation_frame);
 235                 evas_object_show(ad->elm_navigation_frame);
 236         }
 237 }
 238
 239 void show_msg(struct appdata *ad, int strid)
 240 {
 241         int max = 0;
 242         char *msg = NULL;
 243         char *str = NULL;
 244
 245         if (ad->msg) {
 246                 free(ad->msg);
 247                 ad->msg = NULL;
 248         }
 249         if (strid == IDS_IDLE_BODY_PD_TO_PD_DIGITS_REQUIRED) {
 250
 251                 max = PWLOCK_PIN_PASSWORD_MAX_LENGTH;
 252                 str = pwlock_get_string(IDS_IDLE_BODY_PD_TO_PD_DIGITS_REQUIRED);
 253                 Eina_Strbuf *temp_str_buf = eina_strbuf_new();
 254                 eina_strbuf_append_printf(temp_str_buf,
 255                                           str, PWLOCK_PASSWORD_MIN_LENGTH, max);
 256                 msg = eina_strbuf_string_steal(temp_str_buf);
 257                 eina_strbuf_free(temp_str_buf);
 258         } else {
 259                 msg = pwlock_get_string(strid);
 260         }
 261         if (msg == NULL || msg[0] == '\0')
 262                 return;
 263
 264         ad->msg = strdup(msg);
 265
 266         if (!ad->layout_contents)
 267                 return;
 268         remove_waiting_popup(ad);
 269         show_popup(ad, msg, EINA_TRUE);
 270 }
 271
 272 static inline const char *_entry_get(Evas_Object * e)
 273 {
 274         const char *s = NULL;
 275
 276         if (e)
 277                 s = elm_entry_entry_get(_editfield_entry_get(e));
 278
 279         return s;
 280 }
 281
 282 static void _set_str(char **s, const char *str)
 283 {
 284         if (s == NULL)
 285                 return;
 286
 287         if (*s)
 288                 free(*s);
 289
 290         if (str && str[0] != '\0')
 291                 *s = strdup(str);
 292         else
 293                 *s = NULL;
 294 }
 295
 296 static void do_UI_PUK_CNF(struct appdata *ad)
 297 {
 298         const char *s = NULL;
 299
 300         _DBG("%s", __func__);
 301         s = _entry_get(ad->layout_entry);
 302
 303         if (s && ad->pin_str && !strcmp(ad->pin_str, s)) {
 304                 do_state(ad);
 305                 return;
 306         }
 307
 308         _set_str(&ad->pin_str, NULL);
 309         show_msg(ad, IDS_IDLE_BODY_INCORRECT_PIN_TRY_AGAIN);
 310
 311         /* FIXME popup should be top display, so load main should be called after show msg.. */
 312         load_main(ad, _UI_PUK_PIN);
 313 }
 314
 315 static int _check_input_string(int view_type, const char *entry_str)
 316 {
 317
 318         int lenstr = 0;
 319         _DBG("_check_input_string: %s", entry_str);
 320
 321         if (entry_str == NULL)
 322                 return IDS_IDLE_BODY_PASSWORD_EMPTY;
 323
 324         lenstr = strlen(entry_str);
 325         int max_len = 0;
 326         max_len = PWLOCK_PIN_PASSWORD_MAX_LENGTH;
 327         _DBG("_check_input_string length: %d,max_len=%d,PWLOCK_PASSWORD_MIN_LENGTH=%d", lenstr, max_len, PWLOCK_PASSWORD_MIN_LENGTH);
 328
 329         if (lenstr < PWLOCK_PASSWORD_MIN_LENGTH || lenstr > max_len) {
 330                 return IDS_IDLE_BODY_PD_TO_PD_DIGITS_REQUIRED;
 331         }
 332         return 0;               /* means fit for the rule */
 333 }
 334
 335 static void response_cb(void *data, Evas_Object * obj, void *event_info)
 336 {
 337         struct appdata *ad;
 338         ad = (struct appdata *)data;
 339
 340         _DBG("response callback=%d\n", (int)event_info);
 341
 342         if (((int)event_info != 5) && (obj != NULL)) {
 343                 evas_object_del(obj);
 344         }
 345         /* clear_entry(ad); */
 346 }
 347
 348 static void _block_clicked_cb(void *data, Evas_Object * obj, void *event_info)
 349 {
 350         if (obj) {
 351                 evas_object_del(obj);
 352                 obj = NULL;
 353         }
 354 }
 355
 356 void _show_popup(void *data, char *msg_str)
 357 {
 358         Evas_Object *popup;
 359         Evas_Object *button;
 360         struct appdata *ad;
 361         ad = (struct appdata *)data;
 362         Ecore_X_Window x_win;
 363
 364         ecore_imf_context_input_panel_hide(elm_entry_imf_context_get
 365                                            (_editfield_entry_get
 366                                             (ad->layout_entry)));
 367         popup = elm_popup_add(ad->win);
 368         evas_object_size_hint_weight_set(popup, EVAS_HINT_EXPAND,
 369                                          EVAS_HINT_EXPAND);
 370
 371         /* FIXME  */
 372         x_win = elm_win_xwindow_get(ad->win);
 373         ecore_x_netwm_window_type_set(x_win, ECORE_X_WINDOW_TYPE_DIALOG);
 374
 375         evas_object_smart_callback_add(popup, "block,clicked",
 376                                        _block_clicked_cb, NULL);
 377
 378         elm_popup_timeout_set(popup, 3);
 379         elm_object_text_set(popup, msg_str);
 380         elm_object_part_text_set(popup, "title", "Information");
 381
 382         button = elm_button_add(popup);
 383         elm_object_text_set(button, pwlock_get_string(IDS_COM_SK_OK));
 384         elm_object_part_content_set(popup, "button1", button);
 385         evas_object_smart_callback_add(button, "clicked", response_cb, popup);
 386
 387         evas_object_show(popup);
 388 }
 389
 390 static void _imf_context_input_panel_hide(void *data)
 391 {
 392         struct appdata *ad = data;
 393         Ecore_IMF_Context *imf_context = NULL;
 394         Ecore_IMF_Context *imf_context_second = NULL;
 395         imf_context =
 396             elm_entry_imf_context_get(_editfield_entry_get(ad->layout_entry));
 397         if (imf_context)
 398                 ecore_imf_context_input_panel_hide(imf_context);
 399
 400         imf_context_second =
 401             elm_entry_imf_context_get(_editfield_entry_get
 402                                       (ad->layout_second_entry));
 403         if (imf_context_second)
 404                 ecore_imf_context_input_panel_hide(imf_context_second);
 405 }
 406
 407 static void _done_button_changed(void *data, Evas_Object * obj, void *e)
 408 {
 409         struct appdata *ad = data;
 410         const char* entry_str = NULL;
 411         int length = 0;
 412
 413         entry_str =elm_entry_entry_get(_editfield_entry_get(ad->layout_entry));
 414
 415         if (entry_str) {
 416                 length = strlen(entry_str);
 417         }
 418
 419         if (length == 0) {
 420                 elm_object_disabled_set(ad->elm_button_done, EINA_TRUE);
 421         } else {
 422                 elm_object_disabled_set(ad->elm_button_done, EINA_FALSE);
 423         }
 424         if (elm_object_focus_get(ad->layout_entry)) {
 425                 if (elm_entry_is_empty(_editfield_entry_get(ad->layout_entry))) {
 426                         elm_object_signal_emit(ad->layout_entry,
 427                                                "elm,state,eraser,hide", "elm");
 428                 } else {
 429                         elm_object_signal_emit(ad->layout_entry,
 430                                                "elm,state,eraser,show", "elm");
 431                 }
 432         }
 433 }
 434
 435 static void _done_cb(void *data, Evas_Object * obj, void *e)
 436 {
 437         struct appdata *ad = data;
 438         int ret = -1;
 439         ad->lock_view_loaded = 1;
 440         _DBG("Done clicked ui_type: %d", ad->ui_type);
 441         _imf_context_input_panel_hide(ad);
 442
 443         switch (ad->ui_type) {
 444         case _UI_PIN:
 445         case _UI_SIM_LOCK:
 446                 show_waiting_popup(ad,
 447                                    pwlock_get_string
 448                                    (IDS_IDLE_POP_CHECKING_SIM_CARD_ING));
 449                 _set_str(&ad->entry_str, _entry_get(ad->layout_entry));
 450                 _DBG("entry string: [%s]", ad->entry_str);
 451                 ret = _check_input_string(ad->ui_type, ad->entry_str);
 452                 if (ret == 0) {
 453                         do_state(ad);
 454                 } else {
 455                         remove_waiting_popup(ad);
 456                         show_msg(ad, ret);
 457                         clear_entry(ad);
 458                 }
 459                 break;
 460         case _UI_PUK:
 461                 _set_str(&ad->entry_str, _entry_get(ad->layout_entry));
 462                 _DBG("entry string: [%s]", ad->entry_str);
 463                 ret = _check_input_string(ad->ui_type, ad->entry_str);
 464                 if (ret == 0) {
 465                         /* load_main(ad, _UI_PUK_PIN); */
 466                         pwlock_destroy(ad);
 467                         show_puk_pin(ad);
 468                 } else {
 469                         remove_waiting_popup(ad);
 470                         show_msg(ad, ret);
 471                         clear_entry(ad);
 472                 }
 473                 break;
 474         case _UI_PUK_PIN:
 475                 show_waiting_popup(ad,
 476                                    pwlock_get_string
 477                                    (IDS_IDLE_POP_CHECKING_SIM_CARD_ING));
 478                 _set_str(&ad->pin_str, _entry_get(ad->layout_entry));
 479                 _DBG("entry string: [%s]", ad->pin_str);
 480                 ret = _check_input_string(ad->ui_type, ad->pin_str);
 481                 if (ret == 0) {
 482                         const char *layout_entry = _entry_get(ad->layout_entry);
 483                         const char *layout_second_entry = _entry_get(ad->layout_second_entry);
 484                         if (layout_entry && layout_second_entry &&
 485                                         0 == strcmp(layout_entry, layout_second_entry)) {
 486                                 do_UI_PUK_CNF(ad);
 487                         } else {
 488                                 remove_waiting_popup(ad);
 489                                 show_msg(ad, IDS_IDLE_POP_PASSWORDS_NOT_MATCH);
 490                                 clear_entry(ad);
 491                         }
 492                 } else {
 493                         remove_waiting_popup(ad);
 494                         show_msg(ad, ret);
 495                         clear_entry(ad);
 496                 }
 497                 break;
 498         case _UI_PUK_CNF:
 499                 show_waiting_popup(ad,
 500                                    pwlock_get_string
 501                                    (IDS_IDLE_POP_CHECKING_SIM_CARD_ING));
 502                 ret =
 503                     _check_input_string(ad->ui_type,
 504                                         _entry_get(ad->layout_entry));
 505                 if (ret == 0) {
 506                         do_UI_PUK_CNF(ad);
 507                 } else {
 508                         remove_waiting_popup(ad);
 509                         show_msg(ad, ret);
 510                         clear_entry(ad);
 511                 }
 512                 break;
 513         case _UI_NETWORK_LOCK_NCK:
 514         case _UI_NETWORK_LOCK_NSCK:
 515         case _UI_NETWORK_LOCK_SPCK:
 516         case _UI_NETWORK_LOCK_CCK:
 517                 _set_str(&ad->entry_str, _entry_get(ad->layout_entry));
 518                 _DBG("entry string: [%s]", ad->entry_str);
 519                 ret = _check_input_string(ad->ui_type, ad->entry_str);
 520                 if (ret == 0) {
 521                         do_state(ad);
 522                 } else {
 523                         remove_waiting_popup(ad);
 524                         clear_entry(ad);
 525                         show_msg(ad, ret);
 526                 }
 527                 break;
 528         }
 529         _DBG("Exit _done_cb");
 530 }
 531
 532 static void _dial_cb(void *data, Evas_Object * obj, void *e)
 533 {
 534         _DBG("%s,%d", __func__, __LINE__);
 535         struct appdata *ad = data;
 536
 537         if (!ad) {
 538                 return;
 539         }
 540
 541         service_h service;
 542         service_create(&service);
 543
 544         if (!service) {
 545                 return;
 546         }
 547
 548         set_win_prop(ad, ECORE_X_WINDOW_TYPE_NORMAL);
 549
 550 // To-Do : In here, we have to set an appropriate parameter for emergency call mode.
 551 //         However, current ref. dialer app control does not support emergency mode,
 552 //         so, we have to wait till dialer app control support emergency call mode.
 553
 554         service_set_operation(service,SERVICE_OPERATION_DIAL);
 555         service_send_launch_request(service, NULL, NULL);
 556
 557         service_destroy(service);
 558 }
 559
 560 static void _pp_rsp_ok_cb(void *data, Evas_Object * e, void *ei)
 561 {
 562         int i = (int)ei;
 563         struct appdata *ad = (struct appdata *)data;
 564
 565         _DBG("popup rsp: %d\n", i);
 566
 567         if (NULL == ad) {
 568                 return;
 569         }
 570
 571         if (ad->popup) {
 572                 evas_object_del(ad->popup);
 573                 ad->popup = NULL;
 574         }
 575
 576         ad->cancel_setup = 1;
 577         if (ad->current_ug) {
 578                 ug_destroy(ad->current_ug);
 579                 ad->state = _ST_EXIT;
 580                 do_state(ad);
 581         }
 582
 583         if (ad->sim_status == SIM_REQ_LOCK || ad->sim_status == SIM_REQ_NCK
 584             || ad->sim_status == SIM_REQ_NSCK || ad->sim_status == SIM_REQ_SPCK
 585             || ad->sim_status == SIM_REQ_CCK) {
 586                 if (ad->pin_changed == 1) {
 587                         show_sim_lock(ad);
 588                         ad->pin_changed = 0;
 589                 }
 590         }
 591         if (ad->ui_type == _UI_LANG || ad->ui_type == _UI_TIME) {       /* for IMF show problems */
 592                 return;
 593         }
 594         if (ad->layout_entry) {
 595                 evas_object_show(_editfield_entry_get(ad->layout_entry));
 596                 elm_object_focus_set(_editfield_entry_get(ad->layout_entry),
 597                                      EINA_TRUE);
 598         }
 599         if (ad->msg) {
 600                 free(ad->msg);
 601                 ad->msg = NULL;
 602         }
 603 }
 604
 605 static void _pp_rsp_cancel_cb(void *data, Evas_Object * e, void *ei)
 606 {
 607         int i = (int)ei;
 608         struct appdata *ad = (struct appdata *)data;
 609
 610         _DBG("popup rsp: %d\n", i);
 611
 612         if (NULL == ad) {
 613                 return;
 614         }
 615
 616         if (ad->popup) {
 617                 evas_object_del(ad->popup);
 618                 ad->popup = NULL;
 619         }
 620
 621         ad->cancel_setup = 0;
 622         if (ad->sim_status == SIM_REQ_LOCK || ad->sim_status == SIM_REQ_NCK
 623             || ad->sim_status == SIM_REQ_NSCK || ad->sim_status == SIM_REQ_SPCK
 624             || ad->sim_status == SIM_REQ_CCK) {
 625                 if (ad->pin_changed == 1) {
 626                         show_sim_lock(ad);
 627                         ad->pin_changed = 0;
 628                 }
 629         }
 630         if (ad->ui_type == _UI_LANG || ad->ui_type == _UI_TIME) {       /* for IMF show problems */
 631                 return;
 632         }
 633         if (ad->layout_entry) {
 634                 evas_object_show(_editfield_entry_get(ad->layout_entry));
 635                 elm_object_focus_set(_editfield_entry_get(ad->layout_entry),
 636                                      EINA_TRUE);
 637         }
 638         if (ad->msg) {
 639                 free(ad->msg);
 640                 ad->msg = NULL;
 641         }
 642 }
 643
 644 static void _destroy_previous_ugs(void *data)
 645 {
 646         struct appdata *ad = (struct appdata *)data;
 647         if (!ad) {
 648                 return;
 649         }
 650
 651         _DBG("%s,%d", __func__, __LINE__);
 652
 653         switch (ad->ui_type) {
 654         case _UI_LANG:
 655                 break;
 656         default:
 657                 if (ad->language_ug) {
 658                         ug_destroy(ad->language_ug);
 659                         ad->language_ug = NULL;
 660                 }
 661                 break;
 662         }
 663
 664         _DBG("%s,%d", __func__, __LINE__);
 665
 666         /* when last UG or SIM changed with fisrt UG, destroy the view
 667         if (((ad->sim_changed == 1) && (ad->ui_type == _UI_LANG))
 668             || (ad->ui_type == _UI_TIME)) {
 669                 _DBG("%s,%d", __func__, __LINE__);
 670                 pwlock_destroy(ad);
 671         }
 672         */
 673 }
 674
 675 static void _focused_cb(void *data, Evas_Object * obj, void *event_info)
 676 {
 677         if (!elm_entry_is_empty(obj)) {
 678                 elm_object_signal_emit(data, "elm,state,eraser,show", "elm");
 679         }
 680         elm_object_signal_emit(data, "elm,state,guidetext,hide", "elm");
 681 }
 682
 683 static void _unfocused_cb(void *data, Evas_Object * obj, void *event_info)
 684 {
 685         if (elm_entry_is_empty(obj)) {
 686                 elm_object_signal_emit(data, "elm,state,guidetext,show", "elm");
 687         }
 688         elm_object_signal_emit(data, "elm,state,eraser,hide", "elm");
 689 }
 690
 691 static void _eraser_clicked_cb(void *data, Evas_Object * obj,
 692                                const char *emission, const char *source)
 693 {
 694         elm_entry_entry_set(data, "");
 695 }
 696
 697 static Evas_Object *_create_editfield(Evas_Object * parent, Eina_Bool focus)
 698 {
 699         Evas_Object *layout = NULL;
 700         Evas_Object *entry = NULL;
 701         static Elm_Entry_Filter_Limit_Size limit_filter_data;
 702
 703         limit_filter_data.max_char_count = PWLOCK_PIN_PASSWORD_MAX_LENGTH;
 704         limit_filter_data.max_byte_count = 0;
 705
 706         layout = elm_layout_add(parent);
 707         elm_layout_theme_set(layout, "layout", "editfield", "default");
 708
 709         entry = elm_entry_add(parent);
 710         elm_entry_scrollable_set(entry, EINA_TRUE);
 711         elm_entry_single_line_set(entry, EINA_TRUE);
 712         elm_entry_password_set(entry, EINA_TRUE);
 713         elm_entry_input_panel_layout_set(entry,
 714                                          ELM_INPUT_PANEL_LAYOUT_NUMBERONLY);
 715         elm_entry_markup_filter_append(entry, elm_entry_filter_limit_size,
 716                                        &limit_filter_data);
 717         evas_object_show(entry);
 718         evas_object_smart_callback_add(entry, "focused", _focused_cb, layout);
 719         evas_object_smart_callback_add(entry, "unfocused", _unfocused_cb,
 720                                        layout);
 721
 722         elm_object_part_content_set(layout, "elm.swallow.content", entry);
 723         elm_object_part_text_set(layout, "elm.guidetext", "");
 724         elm_object_signal_callback_add(layout, "elm,eraser,clicked", "elm",
 725                                        _eraser_clicked_cb, entry);
 726         elm_object_focus_set(entry, focus);
 727
 728         return layout;
 729 }
 730
 731 static Evas_Object *_editfield_entry_get(Evas_Object * parent)
 732 {
 733         Evas_Object *entry = NULL;
 734
 735         entry = elm_object_part_content_get(parent, "elm.swallow.content");
 736
 737         return entry;
 738 }
 739
 740 static void _entry_changed_cb(void *data, Evas_Object * obj, void *event_info)
 741 {
 742         if (elm_object_focus_get(data)) {
 743                 if (elm_entry_is_empty(obj)) {
 744                         elm_object_signal_emit(data, "elm,state,eraser,hide",
 745                                                "elm");
 746                 } else {
 747                         elm_object_signal_emit(data, "elm,state,eraser,show",
 748                                                "elm");
 749                 }
 750         }
 751 }
 752
 753 static char *_gl_label_get_title1(void *data, Evas_Object * obj,
 754                                   const char *part)
 755 {
 756         struct appdata *ad = (struct appdata *)data;
 757         char buf[512] = {0, };
 758         char buf2[256] = {0, };
 759
 760         if (!ad || !part) {
 761                 return NULL;
 762         }
 763         if (!strcmp(part, "elm.text")) {
 764                 _DBG("retry_cnt = %d", ad->retry_cnt);
 765                 if (ad->retry_cnt == 1) {
 766                         snprintf(buf, sizeof(buf), "%s (%s)", _get_tip(ad->ui_type),
 767                                                              pwlock_get_string(IDS_IDLE_BODY_1_ATTEMPT_LEFT));
 768                 } else if (ad->retry_cnt > 1) {
 769                         snprintf(buf2, sizeof(buf2), pwlock_get_string(IDS_IDLE_BODY_PD_ATTEMPTS_LEFT), ad->retry_cnt);
 770                         snprintf(buf, sizeof(buf), "%s (%s)", _get_tip(ad->ui_type), buf2);
 771
 772                 } else {
 773                         snprintf(buf, sizeof(buf), "%s", _get_tip(ad->ui_type));
 774                 }
 775
 776                 return strdup(buf);
 777         }
 778         return NULL;
 779 }
 780
 781 static Evas_Object *_gl_icon_get1(void *data, Evas_Object * obj,
 782                                   const char *part)
 783 {
 784         Evas_Object *layout = NULL;
 785
 786         struct appdata *ad = (struct appdata *)data;
 787
 788         if (!ad || !part) {
 789                 return NULL;
 790         }
 791
 792         if (!strcmp(part, "elm.icon")) {
 793                 layout = _create_editfield(obj, EINA_TRUE);
 794                 evas_object_smart_callback_add(_editfield_entry_get(layout),
 795                                                "changed", _done_button_changed,
 796                                                ad);
 797
 798                 ad->layout_entry = layout;
 799
 800                 return layout;
 801
 802         }
 803         return NULL;
 804 }
 805
 806 static char *_gl_label_get_title2(void *data, Evas_Object * obj,
 807                                   const char *part)
 808 {
 809         struct appdata *ad = (struct appdata *)data;
 810         char buf[50] = { 0, };
 811
 812         if (!ad || !part) {
 813                 return NULL;
 814         }
 815         if (!strcmp(part, "elm.text")) {
 816                 snprintf(buf, sizeof(buf), "%s", _get_tip(ad->ui_type + 1));
 817                 return strdup(buf);
 818         }
 819         return NULL;
 820 }
 821
 822 static Evas_Object *_gl_icon_get2(void *data, Evas_Object * obj,
 823                                   const char *part)
 824 {
 825         Evas_Object *layout = NULL;
 826
 827         struct appdata *ad = (struct appdata *)data;
 828
 829         if (!ad || !part) {
 830                 return NULL;
 831         }
 832         if (!strcmp(part, "elm.icon")) {
 833                 layout = _create_editfield(obj, EINA_FALSE);
 834                 evas_object_smart_callback_add(_editfield_entry_get(layout),
 835                                                "changed", _entry_changed_cb,
 836                                                layout);
 837
 838                 ad->layout_second_entry = layout;
 839
 840                 return layout;
 841
 842         }
 843         return NULL;
 844 }
 845
 846 static void _list_set_styles()
 847 {
 848         itc_label1.item_style = "dialogue/title";
 849         itc_label1.func.text_get = _gl_label_get_title1;
 850         itc_label1.func.content_get = NULL;
 851         itc_label1.func.state_get = NULL;
 852         itc_label1.func.del = NULL;
 853
 854         itc_entry1.item_style = "dialogue/1icon";
 855         itc_entry1.func.text_get = NULL;
 856         itc_entry1.func.content_get = _gl_icon_get1;
 857         itc_entry1.func.state_get = NULL;
 858         itc_entry1.func.del = NULL;
 859
 860         itc_label2.item_style = "dialogue/title";
 861         itc_label2.func.text_get = _gl_label_get_title2;
 862         itc_label2.func.content_get = NULL;
 863         itc_label2.func.state_get = NULL;
 864         itc_label2.func.del = NULL;
 865
 866         itc_entry2.item_style = "dialogue/1icon";
 867         itc_entry2.func.text_get = NULL;
 868         itc_entry2.func.content_get = _gl_icon_get2;
 869         itc_entry2.func.state_get = NULL;
 870         itc_entry2.func.del = NULL;
 871 }
 872
 873 void load_main(struct appdata *ad, int ui_type)
 874 {
 875         Evas_Object *bt_done = NULL;
 876         Evas_Object *bt_dial = NULL;
 877         Evas_Object *genlist = NULL;
 878         Elm_Object_Item *genlist_item = NULL;
 879
 880         _DBG("%s", __func__);
 881
 882         set_win_prop(ad, ECORE_X_WINDOW_TYPE_NOTIFICATION);
 883
 884         ad->ui_type = ui_type;
 885
 886         ad->layout_contents = pwlock_add_layout_from_edj(ad->elm_navigation_frame, EDJFILE, "pwlock-lock-ui");
 887
 888         genlist = elm_genlist_add(ad->layout_contents);
 889         elm_object_part_content_set(ad->layout_contents, "swl/genlist", genlist);
 890         _list_set_styles();
 891
 892
 893         if (_UI_PUK_PIN == ui_type) {
 894                 ad->retry_cnt = 0;
 895         }
 896
 897         genlist_item =
 898             elm_genlist_item_append(genlist, &itc_label1, (void *)ad, NULL,
 899                                     ELM_GENLIST_ITEM_NONE, NULL, NULL);
 900         elm_genlist_item_select_mode_set(genlist_item, ELM_OBJECT_SELECT_MODE_NONE);
 901
 902         genlist_item =
 903             elm_genlist_item_append(genlist, &itc_entry1, (void *)ad, NULL,
 904                                     ELM_GENLIST_ITEM_NONE, NULL, NULL);
 905         elm_genlist_item_select_mode_set(genlist_item, ELM_OBJECT_SELECT_MODE_DISPLAY_ONLY);
 906
 907         if (_UI_PUK_PIN == ui_type) {
 908                 genlist_item =
 909                     elm_genlist_item_append(genlist, &itc_label2, (void *)ad,
 910                                             NULL, ELM_GENLIST_ITEM_NONE, NULL,
 911                                             NULL);
 912                 elm_genlist_item_select_mode_set(genlist_item, ELM_OBJECT_SELECT_MODE_NONE);
 913
 914                 genlist_item =
 915                     elm_genlist_item_append(genlist, &itc_entry2, (void *)ad,
 916                                             NULL, ELM_GENLIST_ITEM_NONE, NULL,
 917                                             NULL);
 918                 elm_genlist_item_select_mode_set(genlist_item, ELM_OBJECT_SELECT_MODE_DISPLAY_ONLY);
 919         }
 920
 921         _DBG("load_main ad->ui_type = %d", ad->ui_type);
 922
 923 #if 0   // This code is temporarily disabled since  dialer app control does not provide emergency call mode
 924         bt_dial = elm_button_add(ad->elm_navigation_frame);
 925         //elm_object_style_set(bt_dial, "naviframe/title/default");
 926         evas_object_size_hint_weight_set(bt_dial, EVAS_HINT_EXPAND,
 927                                          EVAS_HINT_EXPAND);
 928         evas_object_size_hint_align_set(bt_dial, EVAS_HINT_FILL, 0.5);
 929
 930         elm_object_text_set(bt_dial, pwlock_get_string(IDS_IDLE_BUTTON_DIALER));
 931         evas_object_smart_callback_add(bt_dial, "clicked", _dial_cb, ad);
 932         ad->elm_button_dial = bt_dial;
 933         evas_object_show(bt_dial);
 934 #endif
 935
 936         bt_done = elm_button_add(ad->elm_navigation_frame);
 937         //elm_object_style_set(bt_done, "naviframe/title/default");
 938         evas_object_size_hint_weight_set(bt_done, EVAS_HINT_EXPAND,
 939                                          EVAS_HINT_EXPAND);
 940         evas_object_size_hint_align_set(bt_done, EVAS_HINT_FILL, 0.5);
 941
 942         elm_object_text_set(bt_done, pwlock_get_string(IDS_COM_SK_DONE));
 943         evas_object_smart_callback_add(bt_done, "clicked", _done_cb, ad);
 944         ad->elm_button_done = bt_done;
 945         evas_object_show(bt_done);
 946
 947         elm_object_disabled_set(bt_done, EINA_TRUE);
 948
 949         elm_naviframe_item_pop(ad->elm_navigation_frame);
 950         elm_naviframe_item_push(ad->elm_navigation_frame, _get_header(ui_type), NULL,
 951                         NULL, ad->layout_contents, NULL);
 952
 953 #if 0   // This code is temporarily disabled since  dialer app control does not provide emergency call mode
 954         elm_object_part_content_set(ad->layout_contents, "button.select.emergency", bt_dial);
 955 #endif
 956         elm_object_part_content_set(ad->layout_contents, "button.select.done", bt_done);
 957
 958         ad->ui_type = ui_type;
 959         remove_waiting_popup(ad);
 960 }
 961
 962 void show_pin(struct appdata *ad)
 963 {
 964         _DBG("%s", __func__);
 965
 966         if (!ad->elm_navigation_frame)
 967                 init_ui(ad);
 968
 969         load_main(ad, _UI_PIN);
 970
 971         evas_object_show(ad->win);
 972 }
 973
 974 void show_puk(struct appdata *ad)
 975 {
 976         _DBG("%s", __func__);
 977
 978         if (!ad->elm_navigation_frame)
 979                 init_ui(ad);
 980
 981         load_main(ad, _UI_PUK);
 982
 983         evas_object_show(ad->win);
 984 }
 985
 986 void show_puk_pin(struct appdata *ad)
 987 {
 988         _DBG("%s", __func__);
 989
 990         if (!ad->elm_navigation_frame)
 991                 init_ui(ad);
 992
 993         load_main(ad, _UI_PUK_PIN);
 994
 995         evas_object_show(ad->win);
 996 }
 997
 998 void show_sim_lock(struct appdata *ad)
 999 {
1000         _DBG("%s", __func__);
1001
1002         int st = ad->sim_status;
1003         if (!ad->elm_navigation_frame) {
1004                 init_ui(ad);
1005         }
1006         switch (st) {
1007         case SIM_REQ_LOCK:
1008                 load_main(ad, _UI_SIM_LOCK);
1009                 break;
1010         case SIM_REQ_NCK:
1011                 load_main(ad, _UI_NETWORK_LOCK_NCK);
1012                 break;
1013         case SIM_REQ_NSCK:
1014                 load_main(ad, _UI_NETWORK_LOCK_NSCK);
1015                 break;
1016         case SIM_REQ_SPCK:
1017                 load_main(ad, _UI_NETWORK_LOCK_SPCK);
1018                 break;
1019         case SIM_REQ_CCK:
1020                 load_main(ad, _UI_NETWORK_LOCK_CCK);
1021                 break;
1022         default:
1023                 load_main(ad, _UI_SIM_LOCK);
1024                 break;
1025         }
1026
1027         evas_object_show(ad->win);
1028 }
1029
1030 void show_block(struct appdata *ad)
1031 {
1032         Evas_Object *ly = NULL;
1033         Evas_Object *bt_dial = NULL;
1034         Evas_Object *el = NULL;
1035         Elm_Object_Item *navi_it = NULL;
1036         char buf[1024] = { 0, };
1037
1038         _DBG("%s", __func__);
1039
1040         set_win_prop(ad, ECORE_X_WINDOW_TYPE_NOTIFICATION);
1041
1042         if (!ad->elm_navigation_frame)
1043                 init_ui(ad);
1044
1045         ly = elm_layout_add(ad->elm_navigation_frame);
1046         elm_layout_theme_set(ly, "layout", "application", "noindicator");
1047         /*Create content field */
1048         el = elm_label_add(ad->elm_navigation_frame);
1049         elm_label_line_wrap_set(el, ELM_WRAP_WORD);
1050
1051         snprintf(buf, sizeof(buf), "%s%s%s",
1052                  "<br><font_size=32 font=SLP:style=Regular color=#7c7c7c align=center>",
1053                  pwlock_get_string
1054                  (IDS_IDLE_BODY_SIM_CARD_NOT_AVAILABLE_CONTACT_YOUR_SERVICE_PROVIDER),
1055                  "</>");
1056         elm_object_text_set(el, buf);
1057
1058         elm_object_part_content_set(ly, "elm.swallow.content", el);
1059         evas_object_show(el);
1060
1061         bt_dial = elm_button_add(ad->elm_navigation_frame);
1062         elm_object_text_set(bt_dial, pwlock_get_string(IDS_IDLE_BUTTON_DIALER));
1063         evas_object_smart_callback_add(bt_dial, "clicked", _dial_cb, ad);
1064         evas_object_show(bt_dial);
1065
1066         ad->layout_contents = ly;
1067         navi_it = elm_naviframe_item_push(ad->elm_navigation_frame, _get_header(_UI_BLOCK),
1068                                 NULL, NULL, ad->layout_contents, NULL);
1069
1070         elm_object_item_part_content_set(navi_it, "title_right_btn", bt_dial);
1071         ad->ui_type = _UI_BLOCK;
1072         evas_object_show(ad->win);
1073         remove_waiting_popup(ad);
1074 }
1075
1076 void pwlock_destroy(struct appdata *ad)
1077 {
1078         _DBG("%s", __func__);
1079
1080         remove_waiting_popup(ad);
1081         if (!ad->elm_navigation_frame)
1082                 return;
1083         _DBG("%s %d", __func__, __LINE__);
1084
1085         elm_naviframe_item_pop(ad->elm_navigation_frame);
1086
1087         if (ad->layout_contents) {
1088                 evas_object_del(ad->layout_contents);
1089                 ad->layout_contents = NULL;
1090         }
1091         if (ad->layout_entry) {
1092                 evas_object_del(ad->layout_entry);
1093                 ad->layout_entry = NULL;
1094         }
1095         if (ad->layout_second_entry) {
1096                 evas_object_del(ad->layout_second_entry);
1097                 ad->layout_second_entry = NULL;
1098         }
1099
1100         /* FIXME we should check window hide for fast boot */
1101         /* evas_object_hide(ad->win); */
1102         _DBG("%s %d %p", __func__, __LINE__, ad->elm_navigation_frame);
1103 }
1104
1105 void clear_entry(struct appdata *ad)
1106 {
1107         if (ad->layout_entry) {
1108                 elm_object_part_text_set(ad->layout_entry, "elm.guidetext", "");
1109                 elm_entry_entry_set(_editfield_entry_get(ad->layout_entry), "");
1110         }
1111         if (ad->layout_second_entry) {
1112                 elm_object_part_text_set(ad->layout_second_entry,
1113                                          "elm.guidetext", "");
1114                 elm_entry_entry_set(_editfield_entry_get
1115                                     (ad->layout_second_entry), "");
1116         }
1117 }
1118
1119 static void _ug_layout_cb(ui_gadget_h ug, enum ug_mode mode, void *priv)
1120 {
1121         struct appdata *ad = (struct appdata *)priv;
1122         Evas_Object *base;
1123         _DBG("%s begin", __func__);
1124         if (!ug || !priv)
1125                 return;
1126
1127         base = (Evas_Object *) ug_get_layout(ug);
1128         if (!base) {
1129                 _DBG("base layout null!\n");
1130                 return;
1131         }
1132
1133         _DBG("%s,%d", __func__, __LINE__);
1134         switch (mode) {
1135         case UG_MODE_FULLVIEW:
1136                 evas_object_size_hint_weight_set(base, EVAS_HINT_EXPAND,
1137                                                  EVAS_HINT_EXPAND);
1138                 //elm_win_resize_object_add(ug_get_window(), base);
1139                 //ug_disable_effect(ug);
1140
1141                 evas_object_show(base);
1142                 break;
1143         default:
1144                 break;
1145         }
1146         if (_UI_LANG == ad->ui_type) {
1147                 ad->language_settings_loaded = 1;
1148         }
1149         //_destroy_previous_ugs(ad);
1150         _DBG("%s end", __func__);
1151
1152 }
1153
1154 static void _ug_result_cb(ui_gadget_h ug, service_h service, void *priv)
1155 {
1156         _DBG("function=%s", __func__);
1157         struct appdata *ad = NULL;
1158
1159         if (!ug || !priv || !service) {
1160                 return;
1161         }
1162         char *retv = NULL;
1163         ad = (struct appdata *)priv;
1164         _DBG("ad->state=%d", ad->state);
1165
1166         switch (ad->state) {
1167         case _ST_LANG:
1168                 {
1169                         service_get_extra_data(service, "updateType", &retv);
1170                         if (retv)
1171                                 _DBG("_ST_LANG updateType = %s", retv);
1172                         service_get_extra_data(service, "ON_OFF_TEXT", &retv);
1173                         if (retv)
1174                                 _DBG("_ST_LANG ON_OFF_TEXT = %s", retv);
1175                         service_get_extra_data(service, "result", &retv);
1176                         if (retv)
1177                                 _DBG("_ST_LANG language result = %s", retv);
1178                         char *path = (char *)vconf_get_str(VCONFKEY_LANGSET);
1179                         if (path) {
1180                                 int r;
1181                                 _DBG("VCONFKEY_LANGSET value = %s", path);
1182                                 setenv("LANG", path, 1);
1183                                 setenv("LC_MESSAGES", path, 1);
1184                                 r = setlocale(LC_ALL, "");
1185                                 if (r == NULL) {
1186                                         r = setlocale(LC_ALL, path);
1187                                 }
1188                                 bindtextdomain(PACKAGE, LOCALEDIR);
1189                                 textdomain(PACKAGE);
1190                                 free(path);
1191                                 path = NULL;
1192                         }
1193                 }
1194                 break;
1195         default:
1196                 break;
1197         }
1198
1199         if (!retv) {            /* avoid to click ug quickly */
1200                 _DBG("retv = %s", retv);
1201                 _ug_destroy = 1;
1202         }
1203 }
1204
1205 static void _ug_destroy_cb(ui_gadget_h ug, void *priv)
1206 {
1207         _DBG("%s, %d begin", __func__, __LINE__);
1208         struct appdata *ad = NULL;
1209         if (1 == _ug_destroy) {
1210                 _ug_destroy = 0;
1211                 return;
1212         }
1213         if (priv) {
1214                 ad = (struct appdata *)priv;
1215         }
1216         if (ad == NULL)
1217                 return;
1218
1219         if (ug) {
1220                 ug_destroy(ug);
1221                 ug = NULL;
1222         }
1223
1224         _DBG("%s, %d ad->state: %d", __func__, __LINE__, ad->state);
1225         switch (ad->state) {
1226         case _ST_LANG:
1227         case _ST_TIME:
1228                 {
1229                         ad->state = _ST_GREETING;
1230                         //show_waiting_popup(ad, NULL);
1231                         do_state(ad);
1232                 }
1233                 break;
1234         default:
1235                 {
1236                         if (ad->win)
1237                                 evas_object_show(ad->win);
1238                 }
1239                 break;
1240         }
1241 }
1242
1243 static void _menu_greeting_button_lang_cb(void *data, Evas_Object * obj, void *e) {
1244         _DBG("%s,%d", __func__, __LINE__);
1245         struct appdata *ad = data;
1246
1247         if (!ad)
1248                 return;
1249
1250         ad->state = _ST_LANG;
1251         show_lang(ad);
1252         /* TODO: */
1253 }
1254
1255 static void _menu_greeting_button_dt_cb(void *data, Evas_Object * obj, void *e) {
1256         _DBG("%s,%d", __func__, __LINE__);
1257         struct appdata *ad = data;
1258
1259         if (!ad)
1260                 return;
1261
1262         ad->state = _ST_TIME;
1263         show_time(ad);
1264         /* TODO: */
1265 }
1266
1267 static void _nosim_retry_cb(void *data, Evas_Object * obj, void *event_info) {
1268         _DBG("%s,%d", __func__, __LINE__);
1269         struct appdata *ad = data;
1270
1271         if (!ad)
1272                 return;
1273
1274         do_state_directly(_ST_SIM, ad);
1275 }
1276
1277 int show_greeting(struct appdata *ad) {
1278         _DBG("%s,%d", __func__, __LINE__);
1279
1280         char *model_name = NULL;
1281
1282         Evas_Object *navi = NULL;
1283         Elm_Object_Item *navi_it = NULL;
1284         Evas_Object *contents = NULL;
1285         Evas_Object *button = NULL;
1286         Evas_Object *dt_btn = NULL;
1287         Evas_Object *toolbar = NULL;
1288
1289         int ret_val;
1290
1291         if (!ad)
1292                 return 0;
1293
1294         set_win_prop(ad, ECORE_X_WINDOW_TYPE_NOTIFICATION);
1295
1296         ad->ui_type = _UI_GREETING;
1297
1298         pwlock_destroy(ad);
1299
1300         init_ui(ad);
1301         navi = ad->elm_navigation_frame;
1302
1303         contents = pwlock_add_layout_from_edj(navi, EDJFILE, "pwlock-menu-lang");
1304
1305         elm_theme_extension_add(NULL, EDJFILE);
1306
1307         ret_val = system_info_get_value_string(SYSTEM_INFO_KEY_PLATFORM_NAME, &model_name);
1308         if (ret_val != SYSTEM_INFO_ERROR_NONE) {
1309                 _ERR("system_info_get_value_string return error : %d", ret_val);
1310         } else {
1311                 _DBG("SYSTEM_INFO_KEY_PLATFORM_NAME = %s\n", model_name);
1312         }
1313
1314         elm_object_part_text_set(contents, "text.greeting.1", pwlock_get_string(IDS_SCM_BODY_WELCOME_E));
1315         if (model_name != NULL) {
1316                 _DBG("Device Name = %s\n", model_name);
1317                 //elm_object_part_text_set(contents, "text.greeting.1", pwlock_get_string(IDS_IDLE_BODY_GREETING_WELCOME));
1318                 elm_object_part_text_set(contents, "text.greeting.2", model_name);
1319         }
1320
1321         PWLOCK_MEMFREE(model_name);
1322
1323         elm_object_part_text_set(contents, "text.help",
1324                         pwlock_get_string(IDS_STU_BODY_SELECT_LANGUAGE));
1325
1326         button = elm_button_add(navi);
1327         //elm_object_style_set(button, "pwlock/lang_btn");
1328         elm_object_part_content_set(contents, "button.select.lang", button);
1329
1330         elm_object_text_set(button, pwlock_get_lang_title());
1331         evas_object_smart_callback_add(button, "clicked", _menu_greeting_button_lang_cb, ad);
1332
1333         elm_object_part_text_set(contents, "text.dt", "Set date and time");
1334
1335         dt_btn = elm_button_add(navi);
1336         //elm_object_style_set(dt_btn, "pwlock/lang_btn");
1337         elm_object_part_content_set(contents, "button.select.dt", dt_btn);
1338
1339         elm_object_text_set(dt_btn, "Date and time");
1340         evas_object_smart_callback_add(dt_btn, "clicked", _menu_greeting_button_dt_cb, ad);
1341
1342         toolbar = _create_toolbar_btn(navi);
1343         elm_toolbar_item_append(toolbar, NULL, pwlock_get_string(IDS_ST_SK_EMERGENCY_CALL), _dial_cb, ad);
1344         elm_toolbar_item_append(toolbar, NULL, pwlock_get_string(IDS_COM_SK_START), pwlock_greeting_next_cb, ad);
1345
1346         navi_it = elm_naviframe_item_push(navi, NULL, NULL, NULL, contents, NULL);
1347
1348         elm_object_item_part_content_set(navi_it, "toolbar", toolbar);
1349
1350         elm_naviframe_item_title_visible_set(navi_it, EINA_FALSE);
1351         elm_naviframe_item_pop_cb_set(navi_it, pwlock_back_cb, ad);
1352
1353         evas_object_show(ad->win);
1354         _destroy_previous_ugs(ad);
1355
1356         return 1;
1357 }
1358
1359 int show_connection(struct appdata *ad) {
1360         _DBG("%s", __func__);
1361         ad->ui_type = _UI_CONNECTION;
1362         ui_gadget_h ug;
1363         service_h service;
1364
1365         //if (ad->connection_ug) {
1366         //      evas_object_show(ad->wifi_ug_layout);
1367         //      return 1;
1368         //}
1369
1370         if (ad->wifi_ug_loaded) {
1371                 return 1;
1372         } else {
1373                 ad->wifi_ug_loaded = 1;
1374         }
1375
1376         UG_INIT_EFL(ad->win, UG_OPT_INDICATOR_ENABLE);
1377         struct ug_cbs *cbs = (struct ug_cbs *)calloc(1, sizeof(struct ug_cbs));
1378
1379         service_create(&service);
1380
1381         if (cbs == NULL) {
1382                 service_destroy(service);       /* prevent */
1383                 return 0;
1384         }
1385         cbs->layout_cb  = pwlock_ug_connection_layout_cb;
1386         cbs->result_cb  = pwlock_ug_connection_result_cb;
1387         cbs->destroy_cb = pwlock_ug_connection_destroy_cb;
1388         cbs->priv = (void *)ad;
1389         if (!service) {
1390                 service_destroy(service);
1391                 free(cbs);      /*  memory leak */
1392                 return 0;
1393         }
1394         service_add_extra_data(service, "caller", "pwlock");
1395         service_add_extra_data(service, "lbutton", pwlock_get_string(IDS_COM_BODY_PREVIOUS));
1396         service_add_extra_data(service, "rbutton_next", pwlock_get_string(IDS_COM_SK_NEXT));
1397         service_add_extra_data(service, "rbutton_skip", pwlock_get_string(IDS_COM_SK_SKIP));
1398
1399         ug = ug_create(NULL, "wifi-efl-UG", UG_MODE_FULLVIEW, service, cbs);
1400         service_destroy(service);
1401         free(cbs);
1402         if (!ug) {
1403                 _DBG("Get connection ug failed.");
1404                 ad->wifi_ug_loaded = 0;
1405                 if (ad->btn_evt_state == BUTTON_STATE_PREV_CLICKED)
1406                         ad->state = _ST_GREETING;
1407                 else
1408                         ad->state = _ST_FINISH;
1409                 do_state(ad);
1410                 return 0;
1411         }
1412         set_win_prop(ad, ECORE_X_WINDOW_TYPE_NOTIFICATION);
1413         ad->current_ug = ad->connection_ug = ug;
1414         evas_object_show(ad->win);
1415         _destroy_previous_ugs(ad);
1416         return 1;
1417 }
1418
1419 int show_tutorial(struct appdata *ad) {
1420         _DBG("%s,%d", __func__, __LINE__);
1421         Evas_Object *navi = NULL;
1422         Evas_Object *prev_btn = NULL;
1423         Evas_Object *next_btn = NULL;
1424         Elm_Object_Item *navi_it = NULL;
1425
1426         if (!ad)
1427                 return 0;
1428
1429         set_win_prop(ad, ECORE_X_WINDOW_TYPE_NOTIFICATION);
1430
1431         ad->ui_type = _UI_TUTORIAL;
1432
1433         pwlock_destroy(ad);
1434
1435         init_ui(ad);
1436         navi = ad->elm_navigation_frame;
1437
1438         prev_btn = _create_toolbar_btn(navi);
1439         next_btn = _create_toolbar_btn(navi);
1440
1441         navi_it =
1442             elm_naviframe_item_push(navi, (const char *)_("TUTORIAL"),
1443                                     NULL, NULL, NULL, NULL);
1444
1445         elm_object_item_part_content_set(navi_it, "toolbar_button1", prev_btn);
1446         elm_object_item_part_content_set(navi_it, "toolbar_button2", next_btn);
1447
1448         evas_object_show(ad->win);
1449         _destroy_previous_ugs(ad);
1450
1451         return 1;
1452 }
1453
1454 int show_lang(struct appdata *ad)
1455 {
1456         _DBG("%s", __func__);
1457         ad->ui_type = _UI_LANG;
1458         ui_gadget_h ug;
1459         service_h service;
1460
1461         set_win_prop(ad, ECORE_X_WINDOW_TYPE_NOTIFICATION);
1462
1463         UG_INIT_EFL(ad->win, UG_OPT_INDICATOR_ENABLE);
1464         struct ug_cbs *cbs = (struct ug_cbs *)calloc(1, sizeof(struct ug_cbs));
1465
1466         service_create(&service);
1467
1468         if (cbs == NULL) {
1469                 service_destroy(service);       /* prevent */
1470                 return 0;
1471         }
1472         cbs->layout_cb = _ug_layout_cb;
1473         cbs->result_cb = _ug_result_cb;
1474         cbs->destroy_cb = _ug_destroy_cb;
1475         cbs->priv = (void *)ad;
1476         if (!service) {
1477                 service_destroy(service);
1478                 free(cbs);      /*  memory leak */
1479                 return 0;
1480         }
1481         service_add_extra_data(service, "caller", "pwlock");
1482         service_add_extra_data(service, "viewtype", "language");
1483
1484         ug = ug_create(NULL, "setting-phone-efl", UG_MODE_FULLVIEW, service, cbs);
1485         service_destroy(service);
1486         free(cbs);
1487         if (!ug) {
1488                 _DBG("Get phone ug failed.");
1489                 ad->state = _ST_GREETING;
1490                 do_state(ad);
1491                 return 0;
1492         }
1493         ad->current_ug = ad->language_ug = ug;
1494         evas_object_show(ad->win);
1495         return 1;
1496 }
1497
1498 int show_nosim(struct appdata *ad)
1499 {
1500         _DBG("%s,%d", __func__, __LINE__);
1501         Evas_Object *layout = NULL;
1502         Evas_Object *navi = NULL;
1503         Evas_Object *button = NULL;
1504         Evas_Object *toolbar = NULL;
1505         Elm_Object_Item *navi_it = NULL;
1506
1507         if (!ad)
1508                 return 0;
1509
1510         set_win_prop(ad, ECORE_X_WINDOW_TYPE_NOTIFICATION);
1511
1512         ad->ui_type = _UI_NOSIM;
1513
1514         pwlock_destroy(ad);
1515
1516         init_ui(ad);
1517         navi = ad->elm_navigation_frame;
1518
1519         layout = pwlock_add_layout_from_edj(navi, EDJFILE, "pwlock-nosim-ui");
1520
1521         elm_object_part_text_set(layout, "text.help", pwlock_get_string(IDS_STU_BODY_HOW_TO_INSERT_SIM_CARD_HELP_MSG));
1522
1523         button = elm_button_add(layout);
1524         elm_object_text_set(button, pwlock_get_string(IDS_ST_BUTTON_TRY_AGAIN_ABB));
1525         evas_object_smart_callback_add(button, "clicked", _nosim_retry_cb, ad);
1526         elm_object_part_content_set(layout, "button.select.retry", button);
1527
1528         toolbar = _create_toolbar_btn(navi);
1529         elm_toolbar_item_append(toolbar, NULL, pwlock_get_string(IDS_COM_BODY_PREVIOUS), pwlock_nosim_prev_cb, ad);
1530         elm_toolbar_item_append(toolbar, NULL, pwlock_get_string(IDS_COM_SK_SKIP), pwlock_nosim_skip_cb, ad);
1531
1532         navi_it =
1533             elm_naviframe_item_push(navi, (const char *)_(pwlock_get_string(IDS_COM_BODY_NO_SIM_CARD_IN_DEVICE)),
1534                                     NULL, NULL, layout, NULL);
1535
1536         elm_object_item_part_content_set(navi_it, "toolbar", toolbar);
1537
1538         elm_naviframe_item_pop_cb_set(navi_it, pwlock_back_cb, ad);
1539
1540         evas_object_show(ad->win);
1541         _destroy_previous_ugs(ad);
1542
1543         return 1;
1544 }
1545
1546 int show_time(struct appdata *ad)
1547 {
1548         _DBG("%s,%d", __func__, __LINE__);
1549         if (!ad)
1550                 return 0;
1551         ad->ui_type = _UI_TIME;
1552         ui_gadget_h ug;
1553
1554         set_win_prop(ad, ECORE_X_WINDOW_TYPE_NOTIFICATION);
1555
1556         ad->date_and_time_settings_loaded = 1;
1557         service_h service;
1558         UG_INIT_EFL(ad->win, UG_OPT_INDICATOR_ENABLE);
1559         struct ug_cbs *cbs = (struct ug_cbs *)calloc(1, sizeof(struct ug_cbs));
1560
1561         service_create(&service);
1562
1563         if (cbs == NULL) {
1564                 service_destroy(service);       /* prevent */
1565                 return 0;
1566         }
1567         cbs->layout_cb = _ug_layout_cb;
1568         cbs->result_cb = _ug_result_cb;
1569         cbs->destroy_cb = _ug_destroy_cb;
1570         cbs->priv = (void *)ad;
1571         if (!service) {
1572                 service_destroy(service);
1573                 free(cbs);      /*  memory leak */
1574                 return 0;
1575         }
1576         service_add_extra_data(service, "caller", "pwlock");
1577         //service_add_extra_data(service, "lbutton", pwlock_get_string(IDS_COM_BODY_PREVIOUS));
1578         //service_add_extra_data(service, "rbutton", pwlock_get_string(IDS_COM_SK_NEXT));
1579
1580         ug = ug_create(NULL, "setting-time-efl", UG_MODE_FULLVIEW, service, cbs);
1581         service_destroy(service);
1582         free(cbs);
1583         if (!ug) {
1584                 _DBG("?????Get time ug failed.");
1585                 ad->state = _ST_GREETING;
1586                 do_state(ad);
1587                 return 0;
1588         }
1589         ad->current_ug = ad->date_ug = ug;
1590         evas_object_show(ad->win);
1591         _destroy_previous_ugs(ad);
1592         return 1;
1593 }
1594
1595 int show_finish(struct appdata *ad) {
1596         _DBG("%s,%d", __func__, __LINE__);
1597
1598         Evas_Object *navi = NULL;
1599         Evas_Object *toolbar = NULL;
1600         Elm_Object_Item *navi_it = NULL;
1601         Evas_Object *contents = NULL;
1602         Evas_Object *label = NULL;
1603         Eina_Strbuf *finish_text;
1604
1605         if (!ad)
1606                 return 0;
1607
1608         set_win_prop(ad, ECORE_X_WINDOW_TYPE_NOTIFICATION);
1609
1610         ad->ui_type = _UI_FINISH;
1611
1612         pwlock_destroy(ad);
1613
1614         init_ui(ad);
1615         navi = ad->elm_navigation_frame;
1616
1617         contents = pwlock_add_layout_from_edj(navi, EDJFILE, "pwlock-finish");
1618
1619         finish_text = eina_strbuf_new();
1620
1621         label = elm_label_add(contents);
1622         elm_label_line_wrap_set(label, ELM_WRAP_WORD);
1623         evas_object_size_hint_weight_set(label, EVAS_HINT_EXPAND, 0.0);
1624         evas_object_size_hint_align_set(label, EVAS_HINT_FILL, EVAS_HINT_FILL);
1625
1626         if (finish_text != NULL && eina_strbuf_append_printf(finish_text,
1627                         "<font size=32 color=#d7d7d7 align=center><br> %s </font>",
1628                         pwlock_get_string(IDS_STU_BODY_DEVICE_IS_SET_UP_AND_READY_TO_USE)) == EINA_TRUE) {
1629                 elm_object_text_set(label, eina_strbuf_string_get(finish_text));
1630         }
1631
1632         if (finish_text != NULL) {
1633                 eina_strbuf_free(finish_text);
1634         }
1635
1636         elm_object_part_content_set(contents, "swl/label", label);
1637
1638         toolbar = _create_toolbar_btn(navi);
1639         elm_toolbar_item_append(toolbar, NULL, pwlock_get_string(IDS_COM_BODY_PREVIOUS), pwlock_finish_prev_cb, ad);
1640         elm_toolbar_item_append(toolbar, NULL, pwlock_get_string(IDS_ST_BODY_INSTALTAB_FINISH), pwlock_finish_cb, ad);
1641
1642         navi_it = elm_naviframe_item_push(navi, _get_header(ad->ui_type), NULL, NULL, contents, NULL);
1643
1644         elm_object_item_part_content_set(navi_it, "toolbar", toolbar);
1645
1646         elm_naviframe_item_pop_cb_set(navi_it, pwlock_back_cb, ad);
1647
1648         evas_object_show(ad->win);
1649         _destroy_previous_ugs(ad);
1650
1651         return 1;
1652 }
1653
1654 #if 0
1655 int show_dialer(struct appdata *ad)
1656 {
1657         _DBG("%s,%d", __func__, __LINE__);
1658         if (!ad)
1659                 return 0;
1660         ad->ui_type = _UI_DIALER;
1661
1662         service_h service;
1663         service_create(&service);
1664         UG_INIT_EFL(ad->win, UG_OPT_INDICATOR_ENABLE);
1665         struct ug_cbs *cbs = (struct ug_cbs *)calloc(1, sizeof(struct ug_cbs));
1666         if (cbs == NULL) {
1667                 service_destroy(service);       /* prevent */
1668                 return 0;
1669         }
1670         cbs->layout_cb = _ug_layout_cb;
1671         cbs->result_cb = NULL;
1672         cbs->destroy_cb = _ug_destroy_cb;
1673         cbs->priv = (void *)ad;
1674
1675         if (!service) {
1676                 service_destroy(service);
1677                 free(cbs);      /*  memory leak */
1678                 return 0;
1679         }
1680
1681         service_add_extra_data(service, "emergency_dialer", "emergency");
1682         ad->dialer_ug = ug_create(NULL, "dialer-efl", UG_MODE_FULLVIEW, service, cbs);
1683         service_destroy(service);
1684         free(cbs);
1685         if (!ad->dialer_ug) {
1686                 _DBG("dialer ug failed\n");
1687                 return 0;
1688         }
1689         ad->current_ug = ad->dialer_ug;
1690         evas_object_show(ad->win);
1691         return 1;
1692 }
1693 #endif
1694
1695 void show_popup(struct appdata *ad, const char *mesg, Eina_Bool mode)
1696 {
1697         if (!ad) {
1698                 return;
1699         }
1700         Evas_Object *pp;
1701         Evas_Object *button1;
1702         Evas_Object *button2;
1703         ad->previous_ui_type = ad->ui_type;
1704
1705         if (ad->popup) {
1706                 evas_object_del(ad->popup);
1707                 ad->popup = NULL;
1708         }
1709         ecore_imf_context_input_panel_hide(elm_entry_imf_context_get
1710                                            (_editfield_entry_get
1711                                             (ad->layout_entry)));
1712         pp = elm_popup_add(ad->win);
1713         ad->popup = pp;
1714         evas_object_size_hint_weight_set(pp, EVAS_HINT_EXPAND,
1715                                          EVAS_HINT_EXPAND);
1716         elm_object_text_set(pp, mesg);
1717         if (EINA_TRUE == mode) {
1718                 elm_popup_timeout_set(pp, 3);
1719         } else {
1720                 button1 = elm_button_add(pp);
1721                 elm_object_text_set(button1, pwlock_get_string(IDS_COM_SK_OK));
1722                 elm_object_part_content_set(pp, "button1", button1);
1723                 evas_object_smart_callback_add(button1, "clicked", _pp_rsp_ok_cb,
1724                                                ad);
1725
1726                 button2 = elm_button_add(pp);
1727                 elm_object_text_set(button2, pwlock_get_string(IDS_COM_SK_CANCEL));
1728                 elm_object_part_content_set(pp, "button2", button2);
1729                 evas_object_smart_callback_add(button2, "clicked", _pp_rsp_cancel_cb,
1730                                                ad);
1731         }
1732         remove_waiting_popup(ad);
1733         evas_object_show(pp);
1734 }
1735
1736 void show_waiting_popup(struct appdata *ad, const char *msg_str)
1737 {
1738         if (!ad) {
1739                 return;
1740         }
1741
1742         _DBG("%s", __func__);
1743
1744         Evas_Object *popup = NULL;
1745         Evas_Object *progressbar = NULL;
1746         Evas_Object *box = NULL;
1747         Evas_Object *label = NULL;
1748
1749         Eina_Strbuf *popup_str;
1750
1751         remove_waiting_popup(ad);
1752
1753         popup = elm_popup_add(ad->win);
1754         ad->waiting_popup = popup;
1755         box = elm_box_add(popup);
1756         if (msg_str != NULL) {
1757                 popup_str = eina_strbuf_new();
1758                 label = elm_label_add(popup);
1759                 elm_label_line_wrap_set(label, EINA_TRUE);
1760                 if (popup_str != NULL && eina_strbuf_append_printf(popup_str,
1761                         "<font color=#ffffff>%s</font>", msg_str) == EINA_TRUE) {
1762                         elm_object_text_set(label, eina_strbuf_string_get(popup_str));
1763                 }
1764                 evas_object_size_hint_weight_set(label, EVAS_HINT_EXPAND,
1765                                                  EVAS_HINT_EXPAND);
1766                 evas_object_size_hint_align_set(label, EVAS_HINT_FILL,
1767                                                 EVAS_HINT_FILL);
1768                 evas_object_show(label);
1769                 elm_box_pack_end(box, label);
1770
1771                 if (popup_str != NULL) {
1772                         eina_strbuf_free(popup_str);
1773                 }
1774         }
1775
1776         progressbar = elm_progressbar_add(popup);
1777         elm_object_style_set(progressbar, "pending_list");
1778         elm_progressbar_pulse(progressbar, EINA_TRUE);
1779         evas_object_size_hint_align_set(progressbar, EVAS_HINT_FILL,
1780                                         EVAS_HINT_FILL);
1781         evas_object_size_hint_weight_set(progressbar, EVAS_HINT_EXPAND,
1782                                          EVAS_HINT_EXPAND);
1783         elm_progressbar_pulse(progressbar, EINA_TRUE);
1784         evas_object_show(progressbar);
1785         elm_box_pack_end(box, progressbar);
1786         evas_object_show(box);
1787         elm_object_content_set(popup, box);
1788         evas_object_show(popup);
1789
1790         evas_object_show(ad->win);
1791 }
1792
1793 void remove_waiting_popup(struct appdata *ad)
1794 {
1795         _DBG("%s", __func__);
1796         if (!ad) {
1797                 return;
1798         }
1799         if (ad->waiting_popup) {
1800                 _DBG("delete waiting popup");
1801                 evas_object_del(ad->waiting_popup);
1802                 ad->waiting_popup = NULL;
1803         }
1804 }
1805
1806 Eina_Bool show_puk_do(void *data)
1807 {
1808         _DBG("%s, %d begin", __func__, __LINE__);
1809         struct appdata *ad = (struct appdata *)data;
1810
1811         show_puk(ad);
1812         ad->state = _ST_SIM_PUKCNF;
1813
1814         return ECORE_CALLBACK_CANCEL;
1815 }
1816
1817 void update_pw_entry(struct appdata *ad, char *input_data)
1818 {
1819         _DBG("%s", __func__);
1820
1821         if (input_data == NULL)
1822                 return;
1823         elm_entry_entry_set(_editfield_entry_get(ad->layout_entry), input_data);
1824         elm_entry_cursor_end_set(_editfield_entry_get(ad->layout_entry));
1825         _done_cb(ad, NULL, NULL);
1826 }