src/util.c

   1 /*
   2  * Copyright 2012  Samsung Electronics Co., Ltd
   3  *
   4  * Licensed under the Flora License, Version 1.0 (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 "info.h"
  28 #include "bg.h"
  29 #include "noti.h"
  30
  31 #define DEFAULT_BG_PATH     "/opt/share/settings/Wallpapers/Home_default.jpg"
  32 #define SYSTEM_RESUME       "system_wakeup"
  33
  34 static Evas_Coord pos_down_y = 0;
  35
  36 void _set_win_property(Evas_Object * win)
  37 {
  38         Ecore_X_Window xwin;
  39
  40         if (win == NULL) {
  41                 LOGD("[Error:%s] Invalid argument: win is NULL", __func__);
  42                 return;
  43         }
  44         xwin = elm_win_xwindow_get(win);
  45         if (xwin == 0) {
  46                 LOGD("[Error:%s] Cannot get xwindow", __func__);
  47                 return;
  48         }
  49
  50         ecore_x_netwm_window_type_set(xwin, ECORE_X_WINDOW_TYPE_NOTIFICATION);
  51
  52         utilx_set_system_notification_level(ecore_x_display_get(), xwin, UTILX_NOTIFICATION_LEVEL_NORMAL);
  53
  54         utilx_set_window_opaque_state(ecore_x_display_get(), xwin, UTILX_OPAQUE_STATE_ON);
  55 }
  56
  57 Evas_Object *_add_layout(Evas_Object *parent, const char *file, const char *group)
  58 {
  59         if (parent == NULL)
  60                 return NULL;
  61
  62         Evas_Object *ly;
  63         int r;
  64
  65         ly = elm_layout_add(parent);
  66         if (ly == NULL)
  67                 return NULL;
  68
  69         r = elm_layout_file_set(ly, file, group);
  70         if (!r) {
  71                 evas_object_del(ly);
  72                 return NULL;
  73         }
  74         evas_object_size_hint_weight_set(ly, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
  75
  76         evas_object_show(ly);
  77
  78         return ly;
  79 }
  80
  81 Evas_Object *_make_top_layout(struct appdata *ad)
  82 {
  83         if (ad == NULL)
  84                 return NULL;
  85
  86         Evas_Object *eo = NULL;
  87         Evas_Object *conform = NULL;
  88
  89         conform = elm_conformant_add(ad->win);
  90         if(conform == NULL) {
  91                 return NULL;
  92         }
  93         elm_object_style_set(conform, "indicator_overlap");
  94
  95         eo = _add_layout(conform, EDJEFILE, "lock-main");
  96         if (eo == NULL)
  97                 return NULL;
  98
  99         evas_object_size_hint_weight_set(conform, EVAS_HINT_EXPAND,
 100                                                  EVAS_HINT_EXPAND);
 101         elm_win_resize_object_add(ad->win, conform);
 102         elm_object_content_set(conform, eo);
 103         evas_object_show(conform);
 104         evas_object_resize(eo, ad->win_w, ad->win_h);
 105
 106         return eo;
 107 }
 108
 109 Evas_Object *_make_slider(Evas_Object *parent)
 110 {
 111         Evas_Object *layout = NULL;
 112
 113         if (parent == NULL) {
 114                 LOCK_SCREEN_TRACE_DBG("The parent of slider is null");
 115                 return NULL;
 116         }
 117
 118         layout = _add_layout(parent, EDJEFILE, "lock-slider");
 119         if (layout == NULL) {
 120                 return NULL;
 121         }
 122
 123         return layout;
 124 }
 125
 126 Evas_Object *_get_bg_image(Evas_Object *parent)
 127 {
 128         Evas_Object *bg = NULL;
 129         char *file = NULL;
 130         Eina_Bool ret = EINA_FALSE;
 131
 132         if (parent == NULL)
 133                 return NULL;
 134
 135         if ((file = vconf_get_str(VCONFKEY_IDLE_LOCK_BGSET)) ==  NULL) {
 136                 file = vconf_get_str(VCONFKEY_BGSET);
 137         }
 138
 139         bg = elm_icon_add(parent);
 140         if (bg == NULL)
 141                 return NULL;
 142         elm_icon_aspect_fixed_set(bg, EINA_FALSE);
 143
 144         if (file) {
 145                 ret = elm_icon_file_set(bg, file, NULL);
 146                 if (ret == EINA_FALSE) {
 147                         elm_icon_file_set(bg, DEFAULT_BG_PATH, NULL);
 148                 }
 149                 free(file);
 150         } else {
 151                 elm_icon_file_set(bg, DEFAULT_BG_PATH, NULL);
 152         }
 153         return bg;
 154 }
 155
 156 void lockscreen_info_show(struct appdata *ad)
 157 {
 158         if(ad == NULL){
 159                 return;
 160         }
 161
 162         edje_object_signal_emit(_EDJ(ad->ly_main), "show,text.area", "text.area");
 163         edje_object_signal_emit(_EDJ(ad->ly_main), "show,sw.noti", "sw.noti");
 164         edje_object_signal_emit(_EDJ(ad->ly_main), "show,sim.state", "sim.state");
 165         edje_object_signal_emit(_EDJ(ad->ly_main), "show,rect.info", "rect.info");
 166         if(ad->slider != NULL) {
 167                 evas_object_show(ad->slider);
 168         }
 169 }
 170
 171 void lockscreen_info_hide(struct appdata *ad)
 172 {
 173         if(ad == NULL){
 174                 return;
 175         }
 176
 177         edje_object_signal_emit(_EDJ(ad->ly_main), "hide,text.area", "text.area");
 178         edje_object_signal_emit(_EDJ(ad->ly_main), "hide,sw.noti", "sw.noti");
 179         edje_object_signal_emit(_EDJ(ad->ly_main), "hide,sim.state", "sim.state");
 180         edje_object_signal_emit(_EDJ(ad->ly_main), "hide,rect.info", "rect.info");
 181         if(ad->slider != NULL) {
 182                 evas_object_hide(ad->slider);
 183         }
 184 }
 185
 186 static void _set_sim_state(void *data)
 187 {
 188         struct appdata *ad = data;
 189         if (ad == NULL)
 190                 return;
 191
 192         int state = 0;
 193         int ret = 0;
 194         char *buf = NULL;
 195
 196         int service_type = VCONFKEY_TELEPHONY_SVCTYPE_NONE;
 197
 198         if(vconf_get_int(VCONFKEY_TELEPHONY_SVCTYPE, &service_type) != 0) {
 199                 LOGD("fail to get VCONFKEY_TELEPHONY_SVCTYPE");
 200         }
 201
 202         ret = (vconf_get_int(VCONFKEY_TELEPHONY_SPN_DISP_CONDITION, &state));
 203         if (ret == 0) {
 204                 LOGD("[%s:%d] VCONFKEY(%s) = %d", __func__, __LINE__, VCONFKEY_TELEPHONY_SPN_DISP_CONDITION, state);
 205                 if (state != VCONFKEY_TELEPHONY_DISP_INVALID
 206                         && service_type > VCONFKEY_TELEPHONY_SVCTYPE_SEARCH) {
 207                         if (state & VCONFKEY_TELEPHONY_DISP_SPN) {
 208                                 buf = vconf_get_str(VCONFKEY_TELEPHONY_SPN_NAME);
 209                                 edje_object_part_text_set(_EDJ(ad->ly_main), "sim.state", buf);
 210                         }
 211
 212                         if (state & VCONFKEY_TELEPHONY_DISP_PLMN) {
 213                                 buf = vconf_get_str(VCONFKEY_TELEPHONY_NWNAME);
 214                                 edje_object_part_text_set(_EDJ(ad->ly_main), "sim.state", buf);
 215                         }
 216                 } else {
 217                         edje_object_part_text_set(_EDJ(ad->ly_main), "sim.state", "");
 218                 }
 219         }
 220 }
 221
 222 static void _app_exit(void *data, Evas_Object *obj, const char *emission, const char *source)
 223 {
 224         struct appdata *ad = data;
 225         _app_terminate(ad);
 226 }
 227
 228 static int _init_heynoti(void *data)
 229 {
 230         struct appdata *ad = data;
 231         if (ad == NULL) {
 232                 return EXIT_FAILURE;
 233         }
 234         int fd = -1, ret = -1;
 235         LOCK_SCREEN_TRACE_DBG("[ == %s == ]", __func__);
 236
 237         fd = heynoti_init();
 238         if (fd == -1) {
 239                 LOCK_SCREEN_TRACE_DBG("Heynoti init error\n");
 240                 return EXIT_FAILURE;
 241         }
 242
 243         ret = heynoti_subscribe(fd, SYSTEM_RESUME, update_time, ad);
 244         if (ret == -1) {
 245                 LOCK_SCREEN_TRACE_DBG("[Error] heynoti_subscribe : system_wakeup\n");
 246                 return EXIT_FAILURE;
 247         }
 248
 249         ret = heynoti_attach_handler(fd);
 250         if (ret == -1) {
 251                 LOCK_SCREEN_TRACE_DBG("[Error] heynoti_attach_handler failed.\n");
 252                 return EXIT_FAILURE;
 253         }
 254
 255         ad->heynoti_fd = fd;
 256
 257         return EXIT_SUCCESS;
 258 }
 259
 260 static void _fini_heynoti(void *data)
 261 {
 262         struct appdata *ad = data;
 263         if (ad == NULL) {
 264                 return;
 265         }
 266         LOCK_SCREEN_TRACE_DBG("[ == %s == ]", __func__);
 267         heynoti_unsubscribe(ad->heynoti_fd, SYSTEM_RESUME, update_time);
 268         heynoti_close(ad->heynoti_fd);
 269         ad->heynoti_fd = 0;
 270 }
 271
 272 static void _pm_state_cb(keynode_t * node, void *data)
 273 {
 274         LOCK_SCREEN_TRACE_DBG("_pm_state_cb");
 275
 276         struct appdata *ad = data;
 277         int val = -1;
 278
 279         if (vconf_get_int(VCONFKEY_PM_STATE, &val) < 0) {
 280                 LOCK_SCREEN_TRACE_ERR("Cannot get VCONFKEY_PM_STATE");
 281                 return;
 282         }
 283
 284         if (val == VCONFKEY_PM_STATE_NORMAL) {
 285                 LOCK_SCREEN_TRACE_DBG("LCD on");
 286                 update_time(ad);
 287         }
 288 }
 289
 290 static Eina_Bool _init_widget_cb(void *data)
 291 {
 292         struct appdata *ad = data;
 293         LOGD("[ == %s == ]", __func__);
 294         if (ad == NULL)
 295                 return ECORE_CALLBACK_CANCEL;
 296
 297         ad->slider = _make_slider(ad->ly_main);
 298         evas_object_resize(ad->slider, ad->win_w, SLIDER_RATIO_H * ad->win_h);
 299         evas_object_move(ad->slider, 0, SLIDER_RATIO_Y * ad->win_h);
 300         evas_object_show(ad->slider);
 301         evas_object_geometry_get(
 302                         edje_object_part_object_get(_EDJ(ad->slider), "lock.wrapper.image.l"),
 303                         &ad->slider_rel1.x, &ad->slider_rel1.y, &ad->slider_rel1.w,
 304                         &ad->slider_rel1.h);
 305         evas_object_geometry_get(
 306                         edje_object_part_object_get(_EDJ(ad->slider), "lock.wrapper.image.r"),
 307                         &ad->slider_rel2.x, &ad->slider_rel2.y, &ad->slider_rel2.w,
 308                         &ad->slider_rel2.h);
 309
 310         _set_sim_state(ad);
 311
 312         ad->info = elm_layout_add(ad->win);
 313         elm_layout_file_set(ad->info, EDJEFILE, "lock-info");
 314         evas_object_show(ad->info);
 315         elm_object_part_content_set(ad->ly_main, "rect.info", ad->info);
 316         _set_info(ad);
 317
 318         if(_init_heynoti(ad) != EXIT_SUCCESS) {
 319                 LOCK_SCREEN_TRACE_DBG("heynoti ERR..!!");
 320         }
 321
 322         if (vconf_notify_key_changed(VCONFKEY_PM_STATE, _pm_state_cb, ad) != 0) {
 323                 LOCK_SCREEN_TRACE_ERR("Fail vconf_notify_key_changed : VCONFKEY_PM_STATE");
 324         }
 325
 326         int state = 0;
 327         vconf_get_bool(VCONFKEY_LOCKSCREEN_EVENT_NOTIFICATION_DISPLAY, &state);
 328         if(state){
 329                 noti_process(ad);
 330         }
 331
 332         evas_object_event_callback_add(ad->event_bg, EVAS_CALLBACK_MOUSE_DOWN, _mouse_down_cb_s, ad);
 333         evas_object_event_callback_add(ad->event_bg, EVAS_CALLBACK_MOUSE_UP, _mouse_up_cb_s, ad);
 334         evas_object_event_callback_add(ad->event_bg, EVAS_CALLBACK_MOUSE_MOVE, _mouse_move_cb_s, ad);
 335
 336         evas_object_event_callback_add(ad->slider, EVAS_CALLBACK_MOUSE_DOWN, _slider_down_cb, ad);
 337         evas_object_event_callback_add(ad->slider, EVAS_CALLBACK_MOUSE_UP, _slider_up_cb, ad);
 338         evas_object_event_callback_add(ad->slider, EVAS_CALLBACK_MOUSE_MOVE, _slider_move_cb, ad);
 339
 340         edje_object_signal_callback_add(_EDJ(ad->ly_main), "exit,app", "event", _app_exit, ad);
 341
 342         vconf_set_int(VCONFKEY_IDLE_LOCK_STATE, VCONFKEY_IDLE_LOCK);
 343
 344         return ECORE_CALLBACK_CANCEL;
 345 }
 346
 347 int _app_create(struct appdata *ad)
 348 {
 349         if (ad == NULL)
 350                 return -1;
 351         LOGD("[ == %s == ]", __func__);
 352
 353         ecore_x_icccm_name_class_set(elm_win_xwindow_get(ad->win), "LOCK_SCREEN", "LOCK_SCREEN");
 354         evas_object_show(ad->win);
 355         _set_win_property(ad->win);
 356
 357         elm_win_indicator_mode_set(ad->win, ELM_WIN_INDICATOR_SHOW);
 358
 359         ad->ly_main = _make_top_layout(ad);
 360         if (ad->ly_main == NULL)
 361                 return -1;
 362         ad->event_bg = _get_bg_image(ad->ly_main);
 363         if (ad->event_bg == NULL)
 364                 return -1;
 365         elm_object_part_content_set(ad->ly_main, "sw.bg", ad->event_bg);
 366
 367         return 0;
 368 }
 369
 370 int _app_reset(struct appdata *ad)
 371 {
 372         if (ad == NULL)
 373                 return -1;
 374
 375         if (ad->emgc_ug) {
 376                 ug_destroy(ad->emgc_ug);
 377                 ad->emgc_ug = NULL;
 378         }
 379
 380         static int initted = 0;
 381         if(initted == 0) {
 382                 ecore_idler_add(_init_widget_cb, ad);
 383                 initted = 1;
 384         }
 385
 386         return 0;
 387 }
 388
 389 int _app_resume(struct appdata *ad)
 390 {
 391         if (ad == NULL)
 392                 return -1;
 393
 394         return 0;
 395 }
 396
 397 int _app_terminate(struct appdata *ad)
 398 {
 399         vconf_set_int(VCONFKEY_IDLE_LOCK_STATE, VCONFKEY_IDLE_UNLOCK);
 400
 401         if (ad == NULL) {
 402                 LOGD("[_app_terminate] Invalid argument : struct appdata is NULL\n");
 403                 return -1;
 404         }
 405
 406         vconf_ignore_key_changed(VCONFKEY_PM_STATE, _pm_state_cb);
 407         _fini_heynoti(ad);
 408
 409         LOGD("[%s] app termiante", __func__);
 410         elm_exit();
 411
 412         return 0;
 413 }
 414
 415 static void __layout_cb(ui_gadget_h ug, enum ug_mode mode, void *priv)
 416 {
 417         struct appdata *ad;
 418         Evas_Object *base;
 419
 420         if (!ug || !priv)
 421                 return;
 422
 423         ad = priv;
 424         base = ug_get_layout(ug);
 425         if (!base)
 426                 return;
 427
 428         switch(mode) {
 429         case UG_MODE_FULLVIEW:
 430                 LOCK_SCREEN_TRACE_DBG("[%s:%d]", __func__, __LINE__);
 431                 evas_object_size_hint_weight_set(base, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
 432                 elm_win_resize_object_add(ad->win, base);
 433                 evas_object_show(base);
 434                 break;
 435         case UG_MODE_FRAMEVIEW:
 436                 break;
 437         default:
 438                 break;
 439         }
 440 }
 441
 442 static void __result_cb(ui_gadget_h ug, service_h service, void *priv)
 443 {
 444         LOCK_SCREEN_TRACE_DBG("result_cb\n");
 445 }
 446
 447 static void __destroy_cb(ui_gadget_h ug, void *priv)
 448 {
 449         struct appdata *ad = (struct appdata *)priv;
 450
 451         if (!ug || !ad) {
 452                 return;
 453         }
 454         LOCK_SCREEN_TRACE_DBG("[%s:%d]", __func__, __LINE__);
 455
 456         ug_destroy(ug);
 457         ug = NULL;
 458 }
 459
 460 void launch_emgcall(struct appdata *ad)
 461 {
 462         if (ad == NULL)
 463                 return;
 464
 465         service_h service;
 466         service_create(&service);
 467         UG_INIT_EFL(ad->win, UG_OPT_INDICATOR_ENABLE);
 468         struct ug_cbs *cbs = (struct ug_cbs *)calloc(1, sizeof(struct ug_cbs));
 469         if (cbs == NULL) {
 470                 service_destroy(service);
 471                 return;
 472         }
 473         cbs->layout_cb = __layout_cb;
 474         cbs->result_cb = __result_cb;
 475         cbs->destroy_cb = __destroy_cb;
 476         cbs->priv = (void *)ad;
 477
 478         LOCK_SCREEN_TRACE_DBG("[%s:%d]", __func__, __LINE__);
 479
 480         if (!service) {
 481                 service_destroy(service);
 482                 free(cbs);
 483                 return;
 484         }
 485
 486         service_add_extra_data(service, "emergency_dialer", "emergency");
 487         ad->emgc_ug = ug_create(NULL, "dialer-efl", UG_MODE_FULLVIEW, service, cbs);
 488         service_destroy(service);
 489         free(cbs);
 490
 491         if (!ad->emgc_ug) {
 492                 LOCK_SCREEN_TRACE_DBG("dialer ug failed");
 493                 return;
 494         }
 495 }