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_SEARCH;
 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 if (service_type == VCONFKEY_TELEPHONY_SVCTYPE_NOSVC) {
 217                         edje_object_part_text_set(_EDJ(ad->ly_main), "sim.state", _S("IDS_COM_BODY_NO_SERVICE"));
 218                 } else if (service_type == VCONFKEY_TELEPHONY_SVCTYPE_EMERGENCY) {
 219                         edje_object_part_text_set(_EDJ(ad->ly_main), "sim.state", _("IDS_LCKSCN_HEADER_EMERGENCY_CALLS_ONLY"));
 220                 } else {
 221                         if (service_type > VCONFKEY_TELEPHONY_SVCTYPE_SEARCH) {
 222                                 buf = vconf_get_str(VCONFKEY_TELEPHONY_NWNAME);
 223                                 edje_object_part_text_set(_EDJ(ad->ly_main), "sim.state", buf);
 224                         }else {
 225                                 edje_object_part_text_set(_EDJ(ad->ly_main), "sim.state", _S("IDS_COM_BODY_SEARCHING"));
 226                         }
 227                 }
 228         }
 229 }
 230
 231 static void _app_exit(void *data, Evas_Object *obj, const char *emission, const char *source)
 232 {
 233         struct appdata *ad = data;
 234         _app_terminate(ad);
 235 }
 236
 237 static int _init_heynoti(void *data)
 238 {
 239         struct appdata *ad = data;
 240         if (ad == NULL) {
 241                 return EXIT_FAILURE;
 242         }
 243         int fd = -1, ret = -1;
 244         LOCK_SCREEN_TRACE_DBG("[ == %s == ]", __func__);
 245
 246         fd = heynoti_init();
 247         if (fd == -1) {
 248                 LOCK_SCREEN_TRACE_DBG("Heynoti init error\n");
 249                 return EXIT_FAILURE;
 250         }
 251
 252         ret = heynoti_subscribe(fd, SYSTEM_RESUME, update_time, ad);
 253         if (ret == -1) {
 254                 LOCK_SCREEN_TRACE_DBG("[Error] heynoti_subscribe : system_wakeup\n");
 255                 return EXIT_FAILURE;
 256         }
 257
 258         ret = heynoti_attach_handler(fd);
 259         if (ret == -1) {
 260                 LOCK_SCREEN_TRACE_DBG("[Error] heynoti_attach_handler failed.\n");
 261                 return EXIT_FAILURE;
 262         }
 263
 264         ad->heynoti_fd = fd;
 265
 266         return EXIT_SUCCESS;
 267 }
 268
 269 static void _fini_heynoti(void *data)
 270 {
 271         struct appdata *ad = data;
 272         if (ad == NULL) {
 273                 return;
 274         }
 275         LOCK_SCREEN_TRACE_DBG("[ == %s == ]", __func__);
 276         heynoti_unsubscribe(ad->heynoti_fd, SYSTEM_RESUME, update_time);
 277         heynoti_close(ad->heynoti_fd);
 278         ad->heynoti_fd = 0;
 279 }
 280
 281 static void _pm_state_cb(keynode_t * node, void *data)
 282 {
 283         LOCK_SCREEN_TRACE_DBG("_pm_state_cb");
 284
 285         struct appdata *ad = data;
 286         int val = -1;
 287
 288         if (vconf_get_int(VCONFKEY_PM_STATE, &val) < 0) {
 289                 LOCK_SCREEN_TRACE_ERR("Cannot get VCONFKEY_PM_STATE");
 290                 return;
 291         }
 292
 293         if (val == VCONFKEY_PM_STATE_NORMAL) {
 294                 LOCK_SCREEN_TRACE_DBG("LCD on");
 295                 update_time(ad);
 296         }
 297 }
 298
 299 static Eina_Bool _init_widget_cb(void *data)
 300 {
 301         struct appdata *ad = data;
 302         LOGD("[ == %s == ]", __func__);
 303         if (ad == NULL)
 304                 return ECORE_CALLBACK_CANCEL;
 305
 306         ad->slider = _make_slider(ad->ly_main);
 307         evas_object_resize(ad->slider, ad->win_w, SLIDER_RATIO_H * ad->win_h);
 308         evas_object_move(ad->slider, 0, SLIDER_RATIO_Y * ad->win_h);
 309         evas_object_show(ad->slider);
 310         evas_object_geometry_get(
 311                         edje_object_part_object_get(_EDJ(ad->slider), "lock.wrapper.image.l"),
 312                         &ad->slider_rel1.x, &ad->slider_rel1.y, &ad->slider_rel1.w,
 313                         &ad->slider_rel1.h);
 314         evas_object_geometry_get(
 315                         edje_object_part_object_get(_EDJ(ad->slider), "lock.wrapper.image.r"),
 316                         &ad->slider_rel2.x, &ad->slider_rel2.y, &ad->slider_rel2.w,
 317                         &ad->slider_rel2.h);
 318
 319         _set_sim_state(ad);
 320
 321         ad->info = elm_layout_add(ad->win);
 322         elm_layout_file_set(ad->info, EDJEFILE, "lock-info");
 323         evas_object_show(ad->info);
 324         elm_object_part_content_set(ad->ly_main, "rect.info", ad->info);
 325         _set_info(ad);
 326
 327         if(_init_heynoti(ad) != EXIT_SUCCESS) {
 328                 LOCK_SCREEN_TRACE_DBG("heynoti ERR..!!");
 329         }
 330
 331         if (vconf_notify_key_changed(VCONFKEY_PM_STATE, _pm_state_cb, ad) != 0) {
 332                 LOCK_SCREEN_TRACE_ERR("Fail vconf_notify_key_changed : VCONFKEY_PM_STATE");
 333         }
 334
 335         int state = 0;
 336         vconf_get_bool(VCONFKEY_LOCKSCREEN_EVENT_NOTIFICATION_DISPLAY, &state);
 337         if(state){
 338                 noti_process(ad);
 339         }
 340
 341         evas_object_event_callback_add(ad->event_bg, EVAS_CALLBACK_MOUSE_DOWN, _mouse_down_cb_s, ad);
 342         evas_object_event_callback_add(ad->event_bg, EVAS_CALLBACK_MOUSE_UP, _mouse_up_cb_s, ad);
 343         evas_object_event_callback_add(ad->event_bg, EVAS_CALLBACK_MOUSE_MOVE, _mouse_move_cb_s, ad);
 344
 345         evas_object_event_callback_add(ad->slider, EVAS_CALLBACK_MOUSE_DOWN, _slider_down_cb, ad);
 346         evas_object_event_callback_add(ad->slider, EVAS_CALLBACK_MOUSE_UP, _slider_up_cb, ad);
 347         evas_object_event_callback_add(ad->slider, EVAS_CALLBACK_MOUSE_MOVE, _slider_move_cb, ad);
 348
 349         edje_object_signal_callback_add(_EDJ(ad->ly_main), "exit,app", "event", _app_exit, ad);
 350
 351         vconf_set_int(VCONFKEY_IDLE_LOCK_STATE, VCONFKEY_IDLE_LOCK);
 352
 353         return ECORE_CALLBACK_CANCEL;
 354 }
 355
 356 int _app_create(struct appdata *ad)
 357 {
 358         if (ad == NULL)
 359                 return -1;
 360         LOGD("[ == %s == ]", __func__);
 361
 362         ecore_x_icccm_name_class_set(elm_win_xwindow_get(ad->win), "LOCK_SCREEN", "LOCK_SCREEN");
 363         evas_object_show(ad->win);
 364         _set_win_property(ad->win);
 365
 366         elm_win_indicator_mode_set(ad->win, ELM_WIN_INDICATOR_SHOW);
 367
 368         ad->ly_main = _make_top_layout(ad);
 369         if (ad->ly_main == NULL)
 370                 return -1;
 371         ad->event_bg = _get_bg_image(ad->ly_main);
 372         if (ad->event_bg == NULL)
 373                 return -1;
 374         elm_object_part_content_set(ad->ly_main, "sw.bg", ad->event_bg);
 375
 376         return 0;
 377 }
 378
 379 int _app_reset(struct appdata *ad)
 380 {
 381         if (ad == NULL)
 382                 return -1;
 383
 384         if (ad->emgc_ug) {
 385                 ug_destroy(ad->emgc_ug);
 386                 ad->emgc_ug = NULL;
 387         }
 388
 389         static int initted = 0;
 390         if(initted == 0) {
 391                 ecore_idler_add(_init_widget_cb, ad);
 392                 initted = 1;
 393         }
 394
 395         return 0;
 396 }
 397
 398 int _app_resume(struct appdata *ad)
 399 {
 400         if (ad == NULL)
 401                 return -1;
 402
 403         return 0;
 404 }
 405
 406 int _app_terminate(struct appdata *ad)
 407 {
 408         vconf_set_int(VCONFKEY_IDLE_LOCK_STATE, VCONFKEY_IDLE_UNLOCK);
 409
 410         if (ad == NULL) {
 411                 LOGD("[_app_terminate] Invalid argument : struct appdata is NULL\n");
 412                 return -1;
 413         }
 414
 415         vconf_ignore_key_changed(VCONFKEY_PM_STATE, _pm_state_cb);
 416         _fini_heynoti(ad);
 417
 418         LOGD("[%s] app termiante", __func__);
 419         elm_exit();
 420
 421         return 0;
 422 }
 423
 424 static void __layout_cb(ui_gadget_h ug, enum ug_mode mode, void *priv)
 425 {
 426         struct appdata *ad;
 427         Evas_Object *base;
 428
 429         if (!ug || !priv)
 430                 return;
 431
 432         ad = priv;
 433         base = ug_get_layout(ug);
 434         if (!base)
 435                 return;
 436
 437         switch(mode) {
 438         case UG_MODE_FULLVIEW:
 439                 LOCK_SCREEN_TRACE_DBG("[%s:%d]", __func__, __LINE__);
 440                 evas_object_size_hint_weight_set(base, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
 441                 elm_win_resize_object_add(ad->win, base);
 442                 evas_object_show(base);
 443                 break;
 444         case UG_MODE_FRAMEVIEW:
 445                 break;
 446         default:
 447                 break;
 448         }
 449 }
 450
 451 static void __result_cb(ui_gadget_h ug, service_h service, void *priv)
 452 {
 453         LOCK_SCREEN_TRACE_DBG("result_cb\n");
 454 }
 455
 456 static void __destroy_cb(ui_gadget_h ug, void *priv)
 457 {
 458         struct appdata *ad = (struct appdata *)priv;
 459
 460         if (!ug || !ad) {
 461                 return;
 462         }
 463         LOCK_SCREEN_TRACE_DBG("[%s:%d]", __func__, __LINE__);
 464
 465         ug_destroy(ug);
 466         ug = NULL;
 467 }
 468
 469 void launch_emgcall(struct appdata *ad)
 470 {
 471         if (ad == NULL)
 472                 return;
 473
 474         service_h service;
 475         service_create(&service);
 476         UG_INIT_EFL(ad->win, UG_OPT_INDICATOR_ENABLE);
 477         struct ug_cbs *cbs = (struct ug_cbs *)calloc(1, sizeof(struct ug_cbs));
 478         if (cbs == NULL) {
 479                 service_destroy(service);
 480                 return;
 481         }
 482         cbs->layout_cb = __layout_cb;
 483         cbs->result_cb = __result_cb;
 484         cbs->destroy_cb = __destroy_cb;
 485         cbs->priv = (void *)ad;
 486
 487         LOCK_SCREEN_TRACE_DBG("[%s:%d]", __func__, __LINE__);
 488
 489         if (!service) {
 490                 service_destroy(service);
 491                 free(cbs);
 492                 return;
 493         }
 494
 495         service_add_extra_data(service, "emergency_dialer", "emergency");
 496         ad->emgc_ug = ug_create(NULL, "dialer-efl", UG_MODE_FULLVIEW, service, cbs);
 497         service_destroy(service);
 498         free(cbs);
 499
 500         if (!ad->emgc_ug) {
 501                 LOCK_SCREEN_TRACE_DBG("dialer ug failed");
 502                 return;
 503         }
 504 }