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