src/util.c

   1 /*
   2  * Copyright 2012  Samsung Electronics Co., Ltd
   3  *
   4  * Licensed under the Flora License, Version 1.1 (the License);
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  *  http://floralicense.org/license/
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an AS IS BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16
  17 #include <Ecore_X.h>
  18 #include <Elementary.h>
  19 #include <utilX.h>
  20 #include <vconf.h>
  21 #include <vconf-keys.h>
  22 #include <ail.h>
  23 #include <ui-gadget.h>
  24 #include <heynoti.h>
  25
  26 #include "util.h"
  27 #include "sim-state.h"
  28 #include "info.h"
  29 #include "bg.h"
  30 #include "noti.h"
  31
  32 #define DEFAULT_BG_PATH     "/opt/share/settings/Wallpapers/Home_default.jpg"
  33 #define SYSTEM_RESUME       "system_wakeup"
  34
  35 static Evas_Coord pos_down_y = 0;
  36
  37 void _set_win_property(Evas_Object * win)
  38 {
  39         Ecore_X_Window xwin;
  40
  41         if (win == NULL) {
  42                 LOGD("[Error:%s] Invalid argument: win is NULL", __func__);
  43                 return;
  44         }
  45         xwin = elm_win_xwindow_get(win);
  46         if (xwin == 0) {
  47                 LOGD("[Error:%s] Cannot get xwindow", __func__);
  48                 return;
  49         }
  50
  51         ecore_x_netwm_window_type_set(xwin, ECORE_X_WINDOW_TYPE_NOTIFICATION);
  52
  53         utilx_set_system_notification_level(ecore_x_display_get(), xwin, UTILX_NOTIFICATION_LEVEL_NORMAL);
  54
  55         utilx_set_window_opaque_state(ecore_x_display_get(), xwin, UTILX_OPAQUE_STATE_ON);
  56 }
  57
  58 Evas_Object *_add_layout(Evas_Object *parent, const char *file, const char *group)
  59 {
  60         if (parent == NULL)
  61                 return NULL;
  62
  63         Evas_Object *ly;
  64         int r;
  65
  66         ly = elm_layout_add(parent);
  67         if (ly == NULL)
  68                 return NULL;
  69
  70         r = elm_layout_file_set(ly, file, group);
  71         if (!r) {
  72                 evas_object_del(ly);
  73                 return NULL;
  74         }
  75         evas_object_size_hint_weight_set(ly, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
  76
  77         evas_object_show(ly);
  78
  79         return ly;
  80 }
  81
  82 Evas_Object *_make_top_layout(struct appdata *ad)
  83 {
  84         if (ad == NULL)
  85                 return NULL;
  86
  87         Evas_Object *eo = NULL;
  88         Evas_Object *conform = NULL;
  89
  90         conform = elm_conformant_add(ad->win);
  91         if(conform == NULL) {
  92                 return NULL;
  93         }
  94
  95 #if 0
  96         elm_object_style_set(conform, "indicator_overlap");
  97 #else
  98         elm_object_signal_emit(conform, "elm,state,virtualkeypad,disable", "");
  99         elm_object_signal_emit(conform, "elm,state,indicator,overlap", "");
 100         elm_object_signal_emit(conform, "elm,state,clipboard,disable", "");
 101 #endif
 102
 103         eo = _add_layout(conform, EDJEFILE, "lock-main");
 104         if (eo == NULL)
 105                 return NULL;
 106
 107         evas_object_size_hint_weight_set(conform, EVAS_HINT_EXPAND,
 108                                                  EVAS_HINT_EXPAND);
 109         elm_win_resize_object_add(ad->win, conform);
 110         elm_object_content_set(conform, eo);
 111         evas_object_show(conform);
 112         evas_object_resize(eo, ad->win_w, ad->win_h);
 113
 114         return eo;
 115 }
 116
 117 Evas_Object *_make_slider(Evas_Object *parent)
 118 {
 119         Evas_Object *layout = NULL;
 120
 121         if (parent == NULL) {
 122                 LOCK_SCREEN_TRACE_DBG("The parent of slider is null");
 123                 return NULL;
 124         }
 125
 126         layout = _add_layout(parent, EDJEFILE, "lock-slider");
 127         if (layout == NULL) {
 128                 return NULL;
 129         }
 130
 131         return layout;
 132 }
 133
 134 Evas_Object *_get_bg_image(Evas_Object *parent)
 135 {
 136         Evas_Object *bg = NULL;
 137         char *file = NULL;
 138         Eina_Bool ret = EINA_FALSE;
 139
 140         if (parent == NULL)
 141                 return NULL;
 142
 143         if ((file = vconf_get_str(VCONFKEY_IDLE_LOCK_BGSET)) ==  NULL) {
 144                 file = vconf_get_str(VCONFKEY_BGSET);
 145         }
 146
 147         bg = elm_icon_add(parent);
 148         if (bg == NULL)
 149                 return NULL;
 150         elm_icon_aspect_fixed_set(bg, EINA_FALSE);
 151
 152         if (file) {
 153                 ret = elm_icon_file_set(bg, file, NULL);
 154                 if (ret == EINA_FALSE) {
 155                         elm_icon_file_set(bg, DEFAULT_BG_PATH, NULL);
 156                 }
 157                 free(file);
 158         } else {
 159                 elm_icon_file_set(bg, DEFAULT_BG_PATH, NULL);
 160         }
 161         return bg;
 162 }
 163
 164 void lockscreen_info_show(struct appdata *ad)
 165 {
 166         if(ad == NULL){
 167                 return;
 168         }
 169
 170         edje_object_signal_emit(_EDJ(ad->ly_main), "show,text.area", "text.area");
 171         edje_object_signal_emit(_EDJ(ad->ly_main), "show,sw.noti", "sw.noti");
 172         edje_object_signal_emit(_EDJ(ad->ly_main), "show,sim.state", "sim.state");
 173         edje_object_signal_emit(_EDJ(ad->ly_main), "show,rect.info", "rect.info");
 174         if(ad->slider != NULL) {
 175                 evas_object_show(ad->slider);
 176         }
 177 }
 178
 179 void lockscreen_info_hide(struct appdata *ad)
 180 {
 181         if(ad == NULL){
 182                 return;
 183         }
 184
 185         edje_object_signal_emit(_EDJ(ad->ly_main), "hide,text.area", "text.area");
 186         edje_object_signal_emit(_EDJ(ad->ly_main), "hide,sw.noti", "sw.noti");
 187         edje_object_signal_emit(_EDJ(ad->ly_main), "hide,sim.state", "sim.state");
 188         edje_object_signal_emit(_EDJ(ad->ly_main), "hide,rect.info", "rect.info");
 189         if(ad->slider != NULL) {
 190                 evas_object_hide(ad->slider);
 191         }
 192 }
 193
 194 static void _app_exit(void *data, Evas_Object *obj, const char *emission, const char *source)
 195 {
 196         struct appdata *ad = data;
 197         _app_terminate(ad);
 198 }
 199
 200 static int _init_heynoti(void *data)
 201 {
 202         struct appdata *ad = data;
 203         if (ad == NULL) {
 204                 return EXIT_FAILURE;
 205         }
 206         int fd = -1, ret = -1;
 207         LOCK_SCREEN_TRACE_DBG("[ == %s == ]", __func__);
 208
 209         fd = heynoti_init();
 210         if (fd == -1) {
 211                 LOCK_SCREEN_TRACE_DBG("Heynoti init error\n");
 212                 return EXIT_FAILURE;
 213         }
 214
 215         ret = heynoti_subscribe(fd, SYSTEM_RESUME, update_time, ad);
 216         if (ret == -1) {
 217                 LOCK_SCREEN_TRACE_DBG("[Error] heynoti_subscribe : system_wakeup\n");
 218                 return EXIT_FAILURE;
 219         }
 220
 221         ret = heynoti_attach_handler(fd);
 222         if (ret == -1) {
 223                 LOCK_SCREEN_TRACE_DBG("[Error] heynoti_attach_handler failed.\n");
 224                 return EXIT_FAILURE;
 225         }
 226
 227         ad->heynoti_fd = fd;
 228
 229         return EXIT_SUCCESS;
 230 }
 231
 232 static void _fini_heynoti(void *data)
 233 {
 234         struct appdata *ad = data;
 235         if (ad == NULL) {
 236                 return;
 237         }
 238         LOCK_SCREEN_TRACE_DBG("[ == %s == ]", __func__);
 239         heynoti_unsubscribe(ad->heynoti_fd, SYSTEM_RESUME, update_time);
 240         heynoti_close(ad->heynoti_fd);
 241         ad->heynoti_fd = 0;
 242 }
 243
 244 static int _get_vconf_screenreader(void)
 245 {
 246         int is_screenreader = -1;
 247         if(vconf_get_bool(VCONFKEY_SETAPPL_ACCESSIBILITY_TTS, &is_screenreader) < 0) {
 248                 return -1;
 249         }
 250         return is_screenreader;
 251 }
 252
 253 static void _pm_state_cb(keynode_t * node, void *data)
 254 {
 255         LOCK_SCREEN_TRACE_DBG("_pm_state_cb");
 256
 257         struct appdata *ad = data;
 258         int val = -1;
 259
 260         if (vconf_get_int(VCONFKEY_PM_STATE, &val) < 0) {
 261                 LOCK_SCREEN_TRACE_ERR("Cannot get VCONFKEY_PM_STATE");
 262                 return;
 263         }
 264
 265         if (val == VCONFKEY_PM_STATE_NORMAL) {
 266                 LOCK_SCREEN_TRACE_DBG("LCD on");
 267                 update_time(ad);
 268                 if(_get_vconf_screenreader() && ad->ao_bg) {
 269                         elm_access_highlight_set(ad->ao_bg);
 270                 }
 271         } else {
 272                 init_slider_touch_variables(ad);
 273         }
 274 }
 275
 276 static Eina_Bool _mouse_cb(void *data, Evas_Object *obj, void *action_info)
 277 {
 278         struct appdata *ad = data;
 279         if (!ad) return EINA_FALSE;
 280
 281         Elm_Access_Action_Info *a;
 282         a = (Elm_Access_Action_Info *) action_info;
 283         if (!a) return EINA_FALSE;
 284         LOCK_SCREEN_TRACE_DBG("event : %d, read x: %d, y: %d\n", a->mouse_type, a->x, a->y);
 285
 286         static Eina_Bool bDrag = EINA_FALSE;
 287         static int event = 0;
 288         static int origin_x = -1;
 289         static int origin_y = -1;
 290
 291         int step_width = 0;
 292         int step_number = 0;
 293         int alpha = 0;
 294
 295         event = a->mouse_type;
 296         if(event == 0) {
 297                 origin_x = a->x;
 298                 origin_y = a->y;
 299                 bDrag = EINA_TRUE;
 300
 301                 edje_object_signal_emit(_EDJ(ad->slider), "press",
 302                                 "lock.image.l");
 303                 edje_object_signal_emit(_EDJ(ad->slider), "press02",
 304                                 "lock.image.r");
 305         } else if(event == 1) {
 306                 if(bDrag == EINA_FALSE) {
 307                         return EINA_FALSE;
 308                 }
 309                 if(abs(a->y - origin_y) > _X(80)){
 310                         bDrag = EINA_FALSE;
 311                 } else {
 312                         step_width = _X(360)/14;
 313                         step_number = abs(a->x - origin_x) / step_width;
 314                         alpha = 255 - (2.55 * step_number *3);
 315
 316                         if (step_number < 1) {
 317                                 edje_object_signal_emit(_EDJ(ad->slider), "press02",
 318                                                 "lock.image.r");
 319                         } else if (step_number < 2) {
 320                                 edje_object_signal_emit(_EDJ(ad->slider), "press03",
 321                                                 "lock.image.r");
 322                         } else if (step_number < 3) {
 323                                 edje_object_signal_emit(_EDJ(ad->slider), "press04",
 324                                                 "lock.image.r");
 325                         } else if (step_number < 4) {
 326                                 edje_object_signal_emit(_EDJ(ad->slider), "press05",
 327                                                 "lock.image.r");
 328                         } else if (step_number < 5) {
 329                                 edje_object_signal_emit(_EDJ(ad->slider), "press06",
 330                                                 "lock.image.r");
 331                         } else if (step_number < 6) {
 332                                 edje_object_signal_emit(_EDJ(ad->slider), "press07",
 333                                                 "lock.image.r");
 334                         } else if (step_number < 7) {
 335                                 edje_object_signal_emit(_EDJ(ad->slider), "press08",
 336                                                 "lock.image.r");
 337                         } else if (step_number < 8) {
 338                                 edje_object_signal_emit(_EDJ(ad->slider), "press09",
 339                                                 "lock.image.r");
 340                         } else if (step_number < 9) {
 341                                 edje_object_signal_emit(_EDJ(ad->slider), "press10",
 342                                                 "lock.image.r");
 343                         } else if (step_number < 10) {
 344                                 edje_object_signal_emit(_EDJ(ad->slider), "press11",
 345                                                 "lock.image.r");
 346                         } else if (step_number < 11) {
 347                                 edje_object_signal_emit(_EDJ(ad->slider), "press12",
 348                                                 "lock.image.r");
 349                         } else if (step_number < 12) {
 350                                 edje_object_signal_emit(_EDJ(ad->slider), "press13",
 351                                                 "lock.image.r");
 352                         } else if (step_number < 13) {
 353                                 edje_object_signal_emit(_EDJ(ad->slider), "press14",
 354                                                 "lock.image.r");
 355                         } else {
 356                                 edje_object_signal_emit(_EDJ(ad->slider), "press15",
 357                                                 "lock.image.r");
 358                         }
 359                         evas_object_color_set(ad->ly_main, alpha, alpha, alpha, alpha);
 360                 }
 361         } else if(event == 2) {
 362                 edje_object_signal_emit(_EDJ(ad->slider), "release", "lock.image.l");
 363                 edje_object_signal_emit(_EDJ(ad->slider), "release", "lock.image.r");
 364                 evas_object_color_set(ad->ly_main, 255, 255, 255, 255);
 365                 ad->bDrag = 0;
 366
 367                 if(bDrag == EINA_TRUE && abs(a->x - origin_x) > _X(360)) {
 368
 369                         if(ad->slider) {
 370                                 evas_object_del(ad->slider);
 371                                 ad->slider = NULL;
 372                         }
 373                         LOCK_SCREEN_TRACE_DBG("unlock the lock-screen");
 374                         elm_win_indicator_mode_set(ad->win, ELM_WIN_INDICATOR_HIDE);
 375                         elm_object_signal_emit(ad->ly_main, "transit,clipper", "clipper");
 376                         vconf_set_int(VCONFKEY_IDLE_LOCK_STATE, VCONFKEY_IDLE_UNLOCK);
 377                 }
 378                 bDrag = EINA_FALSE;
 379         }
 380         return EINA_TRUE;
 381 }
 382
 383 static Evas_Object *_access_object_get(Evas_Object *obj, const char *part)
 384 {
 385         if(obj == NULL || part == NULL){
 386                 LOCK_SCREEN_TRACE_ERR("");
 387                 return NULL;
 388         }
 389         Evas_Object *to = NULL;
 390         Evas_Object *ao = NULL;
 391         to = (Evas_Object *)edje_object_part_object_get(elm_layout_edje_get(obj), part);
 392         if(to == NULL) {
 393                 LOCK_SCREEN_TRACE_ERR("");
 394                 return NULL;
 395         }
 396         ao = elm_access_object_get(to);
 397         if(ao == NULL) {
 398                 ao = elm_access_object_register(to, obj);
 399         }
 400         return ao;
 401 }
 402
 403 const char *_lock_info_access_activate_cb(void *data, Evas_Object *obj)
 404 {
 405         struct appdata *ad = data;
 406         if(ad == NULL || obj == NULL) {
 407                 return NULL;
 408         }
 409         if(ad->ly_main == NULL || ad->info == NULL) {
 410                 return NULL;
 411         }
 412
 413         const char *text = NULL;
 414         Eina_Strbuf *str_buf = NULL;
 415         str_buf = eina_strbuf_new();
 416         if(str_buf == NULL) {
 417                 LOCK_SCREEN_TRACE_ERR("eina_strbuf_new() failed");
 418                 return NULL;
 419         }
 420
 421         text = elm_object_part_text_get(ad->info, "txt.clock");
 422         if(text) {
 423                 text = evas_textblock_text_markup_to_utf8(NULL, text);
 424                 if(text)
 425                         eina_strbuf_append(str_buf, text);
 426         }
 427
 428         text = elm_object_part_text_get(ad->info, "txt.date");
 429         if(text) {
 430                 text = evas_textblock_text_markup_to_utf8(NULL, text);
 431                 if(text)
 432                         eina_strbuf_append(str_buf, text);
 433         }
 434
 435         text = strdup(eina_strbuf_string_get(str_buf));
 436         eina_strbuf_free(str_buf);
 437
 438         return text?strdup(text):NULL;
 439 }
 440
 441 static void _response_cb(void *data, Evas_Object *obj, void *event_info)
 442 {
 443         elm_exit();
 444 }
 445
 446 static Eina_Bool _init_widget_cb(void *data)
 447 {
 448         struct appdata *ad = data;
 449         LOGD("[ == %s == ]", __func__);
 450         if (ad == NULL)
 451                 return ECORE_CALLBACK_CANCEL;
 452
 453         ad->slider = _make_slider(ad->ly_main);
 454         evas_object_resize(ad->slider, ad->win_w, SLIDER_RATIO_H * ad->win_h);
 455         evas_object_move(ad->slider, 0, SLIDER_RATIO_Y * ad->win_h);
 456         evas_object_show(ad->slider);
 457         evas_object_geometry_get(
 458                         edje_object_part_object_get(_EDJ(ad->slider), "lock.wrapper.image.l"),
 459                         &ad->slider_rel1.x, &ad->slider_rel1.y, &ad->slider_rel1.w,
 460                         &ad->slider_rel1.h);
 461         evas_object_geometry_get(
 462                         edje_object_part_object_get(_EDJ(ad->slider), "lock.wrapper.image.r"),
 463                         &ad->slider_rel2.x, &ad->slider_rel2.y, &ad->slider_rel2.w,
 464                         &ad->slider_rel2.h);
 465
 466         set_sim_state(ad);
 467
 468         ad->info = elm_layout_add(ad->win);
 469         elm_layout_file_set(ad->info, EDJEFILE, "lock-info");
 470         evas_object_show(ad->info);
 471         elm_object_part_content_set(ad->ly_main, "rect.info", ad->info);
 472         _set_info(ad);
 473
 474         if(_init_heynoti(ad) != EXIT_SUCCESS) {
 475                 LOCK_SCREEN_TRACE_DBG("heynoti ERR..!!");
 476         }
 477
 478         if (vconf_notify_key_changed(VCONFKEY_PM_STATE, _pm_state_cb, ad) != 0) {
 479                 LOCK_SCREEN_TRACE_ERR("Fail vconf_notify_key_changed : VCONFKEY_PM_STATE");
 480         }
 481
 482         int state = 0;
 483         vconf_get_bool(VCONFKEY_LOCKSCREEN_EVENT_NOTIFICATION_DISPLAY, &state);
 484         if(state){
 485                 noti_process(ad);
 486         }
 487
 488         //evas_object_event_callback_add(ad->event_bg, EVAS_CALLBACK_MOUSE_DOWN, _mouse_down_cb_s, ad);
 489         //evas_object_event_callback_add(ad->event_bg, EVAS_CALLBACK_MOUSE_UP, _mouse_up_cb_s, ad);
 490         //evas_object_event_callback_add(ad->event_bg, EVAS_CALLBACK_MOUSE_MOVE, _mouse_move_cb_s, ad);
 491         evas_object_event_callback_add(ad->slider, EVAS_CALLBACK_MOUSE_DOWN, _slider_down_cb, ad);
 492         evas_object_event_callback_add(ad->slider, EVAS_CALLBACK_MOUSE_UP, _slider_up_cb, ad);
 493         evas_object_event_callback_add(ad->slider, EVAS_CALLBACK_MOUSE_MOVE, _slider_move_cb, ad);
 494         if(evas_alloc_error() != EVAS_ALLOC_ERROR_NONE) {
 495                 LOCK_SCREEN_TRACE_ERR("evas_object_event_callback_add() failed");
 496                 Evas_Object *popup = NULL;
 497                 Evas_Object *button = NULL;
 498                 popup = elm_popup_add(ad->ly_main);
 499                 evas_object_size_hint_weight_set(popup, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
 500                 elm_object_text_set(popup, _NOT_LOCALIZED("callback add failed"));
 501                 button = elm_button_add(popup);
 502                 elm_object_text_set(button, _S("IDS_COM_SK_OK"));
 503                 elm_object_part_content_set(popup, "button1", button);
 504                 evas_object_smart_callback_add(button, "clicked", _response_cb, popup);
 505                 evas_object_show(popup);
 506                 return ECORE_CALLBACK_CANCEL;
 507         } else {
 508                 LOCK_SCREEN_TRACE_DBG("evas_object_event_callback_add() success");
 509         }
 510
 511         edje_object_signal_callback_add(_EDJ(ad->ly_main), "exit,app", "event", _app_exit, ad);
 512
 513         Eina_List *chain_list = NULL;
 514
 515         ad->ao_bg = _access_object_get(ad->ly_main, "tts.bg");
 516         if(ad->ao_bg) {
 517                 elm_access_action_cb_set(ad->ao_bg, ELM_ACCESS_ACTION_MOUSE, _mouse_cb, ad);
 518                 elm_object_focus_allow_set(ad->ao_bg, EINA_TRUE);
 519                 chain_list = eina_list_append(chain_list, ad->ao_bg);
 520         }
 521         Evas_Object *ao_title = _access_object_get(ad->ly_main, "tts.title");
 522         if(ao_title) {
 523                 elm_access_info_set(ao_title, ELM_ACCESS_INFO, "Life Magazine");
 524                 elm_access_info_set(ao_title, ELM_ACCESS_TYPE, "");
 525                 elm_object_focus_allow_set(ao_title, EINA_TRUE);
 526                 chain_list = eina_list_append(chain_list, ao_title);
 527         }
 528         Evas_Object *ao_sim = _access_object_get(ad->ly_main, "tts.sim.state");
 529         if(ao_sim) {
 530                 const char *text_sim = elm_object_part_text_get(ad->ly_main, "sim.state");
 531                 if(text_sim) {
 532                         elm_access_info_set(ao_sim, ELM_ACCESS_INFO, text_sim);
 533                 }
 534                 elm_access_info_set(ao_sim, ELM_ACCESS_TYPE, "");
 535                 elm_object_focus_allow_set(ao_sim, EINA_TRUE);
 536                 chain_list = eina_list_append(chain_list, ao_sim);
 537         }
 538         Evas_Object *ao_info = _access_object_get(ad->ly_main, "tts.info");
 539         if(ao_info) {
 540                 elm_access_info_cb_set(ao_info, ELM_ACCESS_INFO, _lock_info_access_activate_cb, ad);
 541                 elm_access_info_set(ao_info, ELM_ACCESS_TYPE, "");
 542                 elm_object_focus_allow_set(ao_info, EINA_TRUE);
 543                 chain_list = eina_list_append(chain_list, ao_info);
 544         }
 545         elm_object_focus_custom_chain_set(ad->ly_main, chain_list);
 546
 547         vconf_set_int(VCONFKEY_IDLE_LOCK_STATE, VCONFKEY_IDLE_LOCK);
 548
 549         return ECORE_CALLBACK_CANCEL;
 550 }
 551
 552 int _app_create(struct appdata *ad)
 553 {
 554         if (ad == NULL)
 555                 return -1;
 556         LOGD("[ == %s == ]", __func__);
 557
 558         ecore_x_icccm_name_class_set(elm_win_xwindow_get(ad->win), "LOCK_SCREEN", "LOCK_SCREEN");
 559         evas_object_show(ad->win);
 560         _set_win_property(ad->win);
 561
 562         elm_win_indicator_mode_set(ad->win, ELM_WIN_INDICATOR_SHOW);
 563
 564         ad->ly_main = _make_top_layout(ad);
 565         if (ad->ly_main == NULL)
 566                 return -1;
 567         ad->event_bg = _get_bg_image(ad->ly_main);
 568         if (ad->event_bg == NULL)
 569                 return -1;
 570         elm_object_part_content_set(ad->ly_main, "sw.bg", ad->event_bg);
 571
 572         return 0;
 573 }
 574
 575 #define _MAKE_ATOM(a, s)                              \
 576    do {                                               \
 577         a = ecore_x_atom_get(s);                      \
 578         if (!a)                                       \
 579                         LOCK_SCREEN_TRACE_ERR("%s creation failed.", s); \
 580    } while(0)
 581
 582 #define STR_ATOM_PANEL_SCROLLABLE_STATE         "_E_MOVE_PANEL_SCROLLABLE_STATE"
 583
 584 int _app_reset(struct appdata *ad)
 585 {
 586         if (ad == NULL)
 587                 return -1;
 588
 589         if (ad->emgc_ug) {
 590                 ug_destroy(ad->emgc_ug);
 591                 ad->emgc_ug = NULL;
 592         }
 593
 594         static int initted = 0;
 595         if (ad->lock_type == SETTING_SCREEN_LOCK_TYPE_SIMPLE_PASSWORD) {
 596                 if(initted == 0) {
 597                         Ecore_X_Atom ATOM_PANEL_SCROLLABLE_STATE = 0;
 598                         unsigned int val[3];
 599
 600                         // init atoms
 601                         _MAKE_ATOM(ATOM_PANEL_SCROLLABLE_STATE, STR_ATOM_PANEL_SCROLLABLE_STATE );
 602
 603                         val[0] = 0; // always enable F
 604                         val[1] = 0; // quickpanel enable F
 605                         val[2] = 0; // apptray enable F
 606
 607                         LOCK_SCREEN_TRACE_DBG("Set quickpanel disable");
 608                         ecore_x_window_prop_card32_set(elm_win_xwindow_get(ad->win),
 609                                         ATOM_PANEL_SCROLLABLE_STATE,
 610                                         val,
 611                                         3);
 612
 613                         simple_password_layout_create(ad);
 614                         initted = 1;
 615                 }
 616         }else {
 617                 if(initted == 0) {
 618                         ecore_idler_add(_init_widget_cb, ad);
 619                         initted = 1;
 620                 }
 621         }
 622
 623         return 0;
 624 }
 625
 626 int _app_resume(struct appdata *ad)
 627 {
 628         if (ad == NULL)
 629                 return -1;
 630
 631         return 0;
 632 }
 633
 634 int _app_terminate(struct appdata *ad)
 635 {
 636         if (ad == NULL) {
 637                 LOGD("[_app_terminate] Invalid argument : struct appdata is NULL\n");
 638                 return -1;
 639         }
 640
 641         vconf_ignore_key_changed(VCONFKEY_PM_STATE, _pm_state_cb);
 642         fini_sim_state(ad);
 643         _fini_heynoti(ad);
 644
 645         LOGD("[%s] app termiante", __func__);
 646         elm_exit();
 647
 648         return 0;
 649 }
 650
 651 static void __layout_cb(ui_gadget_h ug, enum ug_mode mode, void *priv)
 652 {
 653         struct appdata *ad;
 654         Evas_Object *base;
 655
 656         if (!ug || !priv)
 657                 return;
 658
 659         ad = priv;
 660         base = ug_get_layout(ug);
 661         if (!base)
 662                 return;
 663
 664         switch(mode) {
 665         case UG_MODE_FULLVIEW:
 666                 LOCK_SCREEN_TRACE_DBG("[%s:%d]", __func__, __LINE__);
 667                 evas_object_size_hint_weight_set(base, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
 668                 elm_win_resize_object_add(ad->win, base);
 669                 evas_object_show(base);
 670                 break;
 671         case UG_MODE_FRAMEVIEW:
 672                 break;
 673         default:
 674                 break;
 675         }
 676 }
 677
 678 static void __result_cb(ui_gadget_h ug, service_h service, void *priv)
 679 {
 680         LOCK_SCREEN_TRACE_DBG("result_cb\n");
 681 }
 682
 683 static void __destroy_cb(ui_gadget_h ug, void *priv)
 684 {
 685         struct appdata *ad = (struct appdata *)priv;
 686
 687         if (!ug || !ad) {
 688                 return;
 689         }
 690         LOCK_SCREEN_TRACE_DBG("[%s:%d]", __func__, __LINE__);
 691
 692         ug_destroy(ug);
 693         ug = NULL;
 694 }
 695
 696 void launch_emgcall(struct appdata *ad)
 697 {
 698         if (ad == NULL)
 699                 return;
 700
 701         service_h service;
 702         service_create(&service);
 703         UG_INIT_EFL(ad->win, UG_OPT_INDICATOR_ENABLE);
 704         struct ug_cbs *cbs = (struct ug_cbs *)calloc(1, sizeof(struct ug_cbs));
 705         if (cbs == NULL) {
 706                 service_destroy(service);
 707                 return;
 708         }
 709         cbs->layout_cb = __layout_cb;
 710         cbs->result_cb = __result_cb;
 711         cbs->destroy_cb = __destroy_cb;
 712         cbs->priv = (void *)ad;
 713
 714         LOCK_SCREEN_TRACE_DBG("[%s:%d]", __func__, __LINE__);
 715
 716         if (!service) {
 717                 service_destroy(service);
 718                 free(cbs);
 719                 return;
 720         }
 721
 722         service_add_extra_data(service, "emergency_dialer", "emergency");
 723         ad->emgc_ug = ug_create(NULL, "dialer-efl", UG_MODE_FULLVIEW, service, cbs);
 724         service_destroy(service);
 725         free(cbs);
 726
 727         if (!ad->emgc_ug) {
 728                 LOCK_SCREEN_TRACE_DBG("dialer ug failed");
 729                 return;
 730         }
 731 }