daemon/quickpanel-ui.c

   1 /*
   2  * Copyright (c) 2009-2015 Samsung Electronics Co., Ltd All Rights Reserved
   3  *
   4  * Licensed under the Apache License, Version 2.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://www.apache.org/licenses/LICENSE-2.0
   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
  18
  19 #include <stdio.h>
  20 #include <signal.h>
  21 #include <sys/utsname.h>
  22 #include <Elementary.h>
  23 #include <Ecore_Input.h>
  24 #include <unistd.h>
  25 #include <malloc.h>
  26
  27 #include <app.h>
  28 #include <vconf.h>
  29 #include <E_DBus.h>
  30 #include <tapi_common.h>
  31 #include <ITapiSim.h>
  32 #include <tzsh_quickpanel_service.h>
  33 #include <notification.h>
  34 #include <sound_manager.h>
  35 #include <media.h>
  36 #include <system_settings.h>
  37
  38 /* quickpanel basics */
  39 #include "common.h"
  40 #include "common_uic.h"
  41 #include "quickpanel-ui.h"
  42 #include "modules.h"
  43 #include "quickpanel_def.h"
  44 #include "list_util.h"
  45 #include "noti_node.h"
  46 #include "vi_manager.h"
  47 #include "pager.h"
  48 #include "page_base.h"
  49 #include "page_setting_all.h"
  50
  51 #include "sim_controller.h"
  52 #include "noti.h"
  53
  54 /* services */
  55 #include "keyboard.h"
  56 #include "uninstall.h"
  57 #ifdef QP_REMINDER_ENABLE
  58 #include "reminder.h"
  59 #endif
  60 #ifdef QP_EMERGENCY_MODE_ENABLE
  61 #include "emergency_mode.h"
  62 #endif
  63 #include "minictrl.h"
  64 #include "util-time.h"
  65
  66 #define QP_WINDOW_PRIO 300
  67
  68 static struct appdata *g_app_data = NULL;
  69
  70 static void _ui_rotate(void *data, int new_angle);
  71 static void _ui_geometry_info_set(void *data);
  72 static void _ui_handler_info_set(void *data);
  73 static void _ui_efl_cache_flush(void *evas);
  74
  75 HAPI void *quickpanel_get_app_data(void)
  76 {
  77         return g_app_data;
  78 }
  79
  80 /******************************************************************************
  81  *
  82  * UI
  83  *
  84  ****************************************************************************/
  85 static void _ui_efl_cache_flush(void *evas)
  86 {
  87         int file_cache;
  88         int collection_cache;
  89         int image_cache;
  90         int font_cache;
  91
  92         retif(evas == NULL, , "Evas is NULL\n");
  93         file_cache = edje_file_cache_get();
  94         collection_cache = edje_collection_cache_get();
  95         image_cache = evas_image_cache_get(evas);
  96         font_cache = evas_font_cache_get(evas);
  97
  98         edje_file_cache_set(file_cache);
  99         edje_collection_cache_set(collection_cache);
 100         evas_image_cache_set(evas, 0);
 101         evas_font_cache_set(evas, 0);
 102
 103         evas_image_cache_flush(evas);
 104         evas_render_idle_flush(evas);
 105         evas_font_cache_flush(evas);
 106
 107         edje_file_cache_flush();
 108         edje_collection_cache_flush();
 109
 110         edje_file_cache_set(file_cache);
 111         edje_collection_cache_set(collection_cache);
 112         evas_image_cache_set(evas, image_cache);
 113         evas_font_cache_set(evas, font_cache);
 114
 115         elm_cache_all_flush();
 116         malloc_trim(0);
 117 }
 118
 119 static void _ui_handler_input_region_set(void *data, int contents_height)
 120 {
 121         struct appdata *ad = NULL;
 122         tzsh_region_h region;
 123         unsigned int window_input_region[4] = {0,};
 124
 125         retif(data == NULL,  , "Invialid parameter!");
 126         ad = data;
 127
 128         region = tzsh_region_create(ad->tzsh);
 129
 130         switch (ad->angle) {
 131         case 0:
 132                 window_input_region[0] = 0; //X
 133                 window_input_region[1] = contents_height; // Y
 134                 window_input_region[2] = ad->win_width; // Width
 135                 window_input_region[3] = ELM_SCALE_SIZE(QP_HANDLE_H); // height
 136                 break;
 137         case 90:
 138                 window_input_region[0] = contents_height; //X
 139                 window_input_region[1] = 0; // Y
 140                 window_input_region[2] = ELM_SCALE_SIZE(QP_HANDLE_H); // Width
 141                 window_input_region[3] = ad->win_height; // height
 142                 break;
 143         case 180:
 144                 window_input_region[0] = 0; //X
 145                 window_input_region[1] = ad->win_height - contents_height - ELM_SCALE_SIZE(QP_HANDLE_H); // Y
 146                 window_input_region[2] = ad->win_width; // Width
 147                 window_input_region[3] = ELM_SCALE_SIZE(QP_HANDLE_H); // height
 148                 break;
 149         case 270:
 150                 window_input_region[0] = ad->win_width - contents_height - ELM_SCALE_SIZE(QP_HANDLE_H); //X
 151                 window_input_region[1] = 0; // Y
 152                 window_input_region[2] = ELM_SCALE_SIZE(QP_HANDLE_H); // Width
 153                 window_input_region[3] = ad->win_height; // height
 154                 break;
 155         }
 156
 157         INFO("win_input_0:%d\nwin_input_1:%d\nwin_input_2:%d\nwin_input_3:%d\n"
 158                         ,window_input_region[0]
 159                         ,window_input_region[1]
 160                         ,window_input_region[2]
 161                         ,window_input_region[3]
 162                 );
 163
 164         tzsh_region_add(region, window_input_region[0], window_input_region[1], window_input_region[2], window_input_region[3]);
 165         tzsh_quickpanel_service_handler_region_set(ad->quickpanel_service, ad->angle, region);
 166         tzsh_region_destroy(region);
 167 }
 168
 169 static void _ui_handler_content_region_set(void *data, int contents_height)
 170 {
 171         struct appdata *ad = NULL;
 172
 173         tzsh_region_h region;
 174
 175         unsigned int window_contents_region[4] = {0,};
 176
 177         retif(data == NULL,  , "Invialid parameter!");
 178         ad = data;
 179
 180         region = tzsh_region_create(ad->tzsh);
 181
 182         switch (ad->angle) {
 183         case 0:
 184                 window_contents_region[0] = 0; //X
 185                 window_contents_region[1] = 0; // Y
 186                 window_contents_region[2] = ad->win_width; // Width
 187                 window_contents_region[3] = contents_height; // height
 188                 break;
 189         case 90:
 190                 window_contents_region[0] = 0; //X
 191                 window_contents_region[1] = 0; // Y
 192                 window_contents_region[2] = contents_height; // Width
 193                 window_contents_region[3] = ad->win_height; // height
 194                 break;
 195         case 180:
 196                 window_contents_region[0] = 0; //X
 197                 window_contents_region[1] = ad->win_height - contents_height; // Y
 198                 window_contents_region[2] = ad->win_width; // Width
 199                 window_contents_region[3] = contents_height; // height
 200                 break;
 201         case 270:
 202                 window_contents_region[0] = ad->win_width - contents_height ; //X
 203                 window_contents_region[1] = 0; // Y
 204                 window_contents_region[2] = contents_height; // Width
 205                 window_contents_region[3] = ad->win_height; // height
 206                 break;
 207         }
 208
 209         DBG("win_contents_0:%d\nwin_contents_1:%d\nwin_contents_2:%d\nwin_contents_3:%d\n"
 210                         ,window_contents_region[0]
 211                         ,window_contents_region[1]
 212                         ,window_contents_region[2]
 213                         ,window_contents_region[3]
 214            );
 215
 216         tzsh_region_add(region, window_contents_region[0], window_contents_region[1], window_contents_region[2], window_contents_region[3]);
 217         tzsh_quickpanel_service_content_region_set(ad->quickpanel_service, ad->angle, region);
 218         tzsh_region_destroy(region);
 219
 220 }
 221
 222 static void _ui_handler_info_set(void *data)
 223 {
 224         int contents_height = 0;
 225         struct appdata *ad = NULL;
 226
 227         retif(data == NULL, , "data is NULL");
 228         ad = data;
 229
 230         contents_height = ad->gl_distance_from_top + ad->gl_limit_height;
 231
 232         _ui_handler_input_region_set(ad, contents_height);
 233         _ui_handler_content_region_set(ad, contents_height);
 234 }
 235
 236 static void _ui_geometry_info_set(void *data)
 237 {
 238         struct appdata *ad = NULL;
 239         int max_height_window = 0;
 240         Evas_Coord genlist_y = 0;
 241
 242         retif(data == NULL, , "data is NULL");
 243         ad = data;
 244
 245         if (ad->angle == 90 || ad->angle == 270 ) {
 246                 max_height_window = ad->win_width;
 247         } else {
 248                 max_height_window = ad->win_height;
 249         }
 250
 251         edje_object_part_geometry_get(_EDJ(ad->ly), "qp.base.list.swallow", NULL, &genlist_y, NULL, NULL);
 252
 253         ad->gl_distance_from_top = genlist_y;
 254         ad->gl_distance_to_bottom = ELM_SCALE_SIZE(QP_HANDLE_H);
 255         ad->gl_limit_height = max_height_window - ad->gl_distance_from_top - ad->gl_distance_to_bottom;
 256 }
 257
 258 /*****************************************************************************
 259  *
 260  * ui rotation functions
 261  *
 262  ****************************************************************************/
 263 static void _ui_rotation_wm_cb(void *data, Evas_Object *obj, void *event)
 264 {
 265         int angle = 0;
 266         struct appdata *ad = data;
 267         retif(ad == NULL, , "Invalid parameter!");
 268
 269         angle = elm_win_rotation_get((Evas_Object *)obj);
 270
 271         DBG("ROTATE:%d", angle);
 272
 273         quickpanel_minictrl_rotation_report(angle);
 274
 275         _ui_rotate(ad, angle);
 276 }
 277
 278 static int _ui_rotation_angle_get(void *data)
 279 {
 280         struct appdata *ad = (struct appdata *)data;
 281         retif(ad == NULL, 0, "Invalid parameter!");
 282         retif(ad->win == NULL, 0, "Invalid parameter!");
 283
 284         return elm_win_rotation_get(ad->win);
 285 }
 286
 287 static void _ui_handler_enable_set(Eina_Bool is_enable)
 288 {
 289         const char *signal = NULL;
 290         struct appdata *ad = quickpanel_get_app_data();
 291         retif(ad == NULL, , "invalid data.");
 292         retif(ad->view_root == NULL, , "data is NULL");
 293
 294         if (is_enable == EINA_TRUE) {
 295                 signal = "mouse,down,1";
 296         } else {
 297                 signal = "mouse,up,1";
 298         }
 299
 300         elm_object_signal_emit(ad->view_root, signal, "qp.handler.bg");
 301 }
 302
 303 static void _ui_rotation_handler(struct appdata *ad, int angle)
 304 {
 305         const char *signal = NULL;
 306
 307         retif(ad == NULL, , "data is NULL");
 308         retif(ad->view_root == NULL, , "data is NULL");
 309
 310
 311         if (angle == 90 || angle == 270) {
 312                 signal = "quickpanel.landscape";
 313         } else {
 314                 signal = "quickpanel.portrait";
 315         }
 316
 317         elm_object_signal_emit(ad->view_root, signal, "quickpanel.prog");
 318 }
 319
 320 static void _ui_rotate(void *data, int new_angle)
 321 {
 322         struct appdata *ad = data;
 323         retif(data == NULL, , "Invalid parameter!");
 324
 325         DBG("ROTATION: new:%d old:%d", new_angle, ad->angle);
 326
 327         if (new_angle == 0 || new_angle == 90 || new_angle == 180 || new_angle == 270) {
 328                 if (new_angle != ad->angle) {
 329                         ad->angle = new_angle;
 330                         quickpanel_modules_refresh(ad);
 331                         _ui_geometry_info_set(ad);
 332                         _ui_handler_info_set(ad);
 333                         _ui_rotation_handler(ad, ad->angle);
 334                 }
 335         }
 336 }
 337 #if 1
 338 static int _tzsh_set(Evas_Object *win)
 339 {
 340         tzsh_h tzsh = NULL;
 341         tzsh_quickpanel_service_h quickpanel_service = NULL;
 342         tzsh_window tz_win;
 343
 344         retif(!win, QP_FAIL, "Invialid parameter!");
 345
 346         tzsh = tzsh_create(TZSH_TOOLKIT_TYPE_EFL);
 347         retif(!tzsh, QP_FAIL, "tzsh_create ERROR!");
 348
 349         struct appdata *ad = quickpanel_get_app_data();
 350
 351         ad->tzsh = tzsh;
 352
 353         tz_win = elm_win_window_id_get(win);
 354         if (!tz_win) {
 355                 tzsh_destroy(tzsh);
 356                 return QP_FAIL;
 357         }
 358
 359         quickpanel_service = tzsh_quickpanel_service_create(tzsh, tz_win);
 360         if (!quickpanel_service) {
 361                 tzsh_destroy(tzsh);
 362                 return QP_FAIL;
 363         }
 364         ad->quickpanel_service = quickpanel_service;
 365
 366         return QP_OK;
 367 }
 368
 369 static void _tzsh_unset(void)
 370 {
 371         struct appdata *ad = quickpanel_get_app_data();
 372
 373         if (ad->quickpanel_service) {
 374                 tzsh_quickpanel_service_destroy(ad->quickpanel_service);
 375                 ad->quickpanel_service = NULL;
 376         }
 377
 378         if (ad->tzsh) {
 379                 tzsh_destroy(ad->tzsh);
 380                 ad->tzsh = NULL;
 381         }
 382 }
 383 #endif
 384
 385 /*****************************************************************************
 386  *
 387  * ui creation/deletion functions
 388  *
 389  ****************************************************************************/
 390 static Evas_Object *_ui_window_add(const char *name, int prio)
 391 {
 392         Evas_Object *eo = NULL;
 393
 394         eo = elm_win_add(NULL, name, ELM_WIN_BASIC);
 395
 396         if (eo != NULL) {
 397                 elm_win_alpha_set(eo, EINA_TRUE);
 398                 elm_win_indicator_mode_set(eo, ELM_WIN_INDICATOR_HIDE);
 399
 400                 elm_win_title_set(eo, name);
 401                 elm_win_borderless_set(eo, EINA_TRUE);
 402                 elm_win_autodel_set(eo, EINA_TRUE);
 403
 404                 /* set this window as a quickpanel */
 405                 elm_win_quickpanel_set(eo, 1);
 406                 elm_win_quickpanel_priority_major_set(eo, prio);
 407
 408                 if (elm_win_wm_rotation_supported_get(eo)) {
 409                         int rots[4] = { 0, 90, 180, 270 };
 410                         elm_win_wm_rotation_available_rotations_set(eo, rots, 4);
 411                 }
 412
 413                 evas_object_show(eo);
 414
 415                 if( QP_OK != _tzsh_set(eo)) {
 416                         ERR("Failed to set tzsh");
 417                 }
 418         }
 419
 420         return eo;
 421 }
 422
 423 static int _ui_gui_create(void *data)
 424 {
 425         struct appdata *ad = data;
 426         int w = 0, h = 0;
 427         int initial_angle = 0;
 428         Evas_Object *page_base = NULL;
 429
 430         retif(data == NULL, QP_FAIL, "Invialid parameter!");
 431
 432         ad->win = _ui_window_add("Quickpanel Window",
 433                         QP_WINDOW_PRIO);
 434         retif(ad->win == NULL, QP_FAIL, "Failed to create main window");
 435         //build error
 436         //elm_win_focus_allow_set(ad->win, EINA_TRUE);
 437
 438         evas_object_smart_callback_add(ad->win, "wm,rotation,changed",
 439                         _ui_rotation_wm_cb, ad);
 440
 441         ad->background = elm_bg_add(ad->win);
 442         if (ad->background  != NULL) {
 443                 evas_object_size_hint_weight_set(ad->background,
 444                                 EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
 445                 elm_win_resize_object_add(ad->win, ad->background);
 446                 evas_object_show(ad->background);
 447         } else {
 448                 ERR("failed to create background");
 449         }
 450
 451         ad->view_root = quickpanel_uic_load_edj(ad->background,
 452                         DEFAULT_EDJ, "quickpanel/root", 0);
 453         retif(ad->view_root == NULL, QP_FAIL, "Failed to create main page");
 454
 455         Evas_Object *pager_scroller = quickpanel_pager_new(ad->view_root, NULL);
 456         Evas_Object *pager_box = quickpanel_pager_view_get("BOX");
 457
 458         page_base = quickpanel_page_base_create(pager_box, NULL);
 459         retif(page_base == NULL, QP_FAIL, "Failed to create main page");
 460         ad->ly = quickpanel_page_base_view_get("LAYOUT");
 461         retif(ad->ly == NULL, QP_FAIL, "Failed to create main page");
 462
 463         elm_box_pack_end(pager_box, page_base);
 464         elm_win_resize_object_add(ad->win, ad->view_root);
 465         elm_object_part_content_set(ad->view_root, "qp.root.swallow", pager_scroller);
 466
 467         /* get noti evas */
 468         ad->evas = evas_object_evas_get(ad->win);
 469         ad->list = quickpanel_page_base_view_get("BOX");
 470         ad->scroller = quickpanel_page_base_view_get("SCROLLER");
 471
 472         //ecore_x_window_size_get(ecore_x_window_root_first_get(), &w, &h);
 473         elm_win_screen_size_get(ad->win, NULL, NULL, &w, &h);
 474         evas_object_resize(ad->win, w, h);
 475
 476         ad->win_width = w;
 477         ad->win_height = h;
 478
 479         _ui_geometry_info_set(ad);
 480
 481         initial_angle = _ui_rotation_angle_get(ad);
 482         _ui_rotate(ad, initial_angle);
 483
 484         quickpanel_pager_page_set(PAGE_IDX_MAIN, 1);
 485
 486         sim_controller_init(ad->ly);
 487
 488         quickpanel_noti_init_noti_section();
 489
 490         return 0;
 491 }
 492
 493 static int _ui_gui_destroy(void *data)
 494 {
 495         struct appdata *ad = data;
 496         retif(data == NULL, QP_FAIL, "Invialid parameter!");
 497
 498         if (ad->list != NULL) {
 499                 evas_object_del(ad->list);
 500                 ad->list = NULL;
 501         }
 502         if (ad->scroller != NULL) {
 503                 evas_object_del(ad->scroller);
 504                 ad->scroller = NULL;
 505         }
 506         if (ad->ly != NULL) {
 507                 evas_object_del(ad->ly);
 508                 ad->ly = NULL;
 509         }
 510         if (ad->win != NULL) {
 511                 evas_object_del(ad->win);
 512                 ad->win = NULL;
 513         }
 514
 515         _tzsh_unset();
 516
 517         return QP_OK;
 518 }
 519
 520 static void _ui_setting_visibility_set(struct appdata *ad, int show)
 521 {
 522         retif(ad == NULL, , "data is NULL");
 523         retif(ad->ly == NULL, , "data is NULL");
 524
 525         elm_object_signal_emit(ad->ly, "quickpanel.setting.show",
 526                         "quickpanel.prog");
 527 }
 528
 529 /*****************************************************************************
 530  *
 531  * event handler initialization functions
 532  *
 533  ****************************************************************************/
 534 static void _vconf_event_powerff_cb(keynode_t *node,
 535                 void *data)
 536 {
 537         int val;
 538         if (vconf_get_int(VCONFKEY_SYSMAN_POWER_OFF_STATUS, &val) == 0 &&
 539                         (val == VCONFKEY_SYSMAN_POWER_OFF_DIRECT || val == VCONFKEY_SYSMAN_POWER_OFF_RESTART)) {
 540                 ui_app_exit();
 541         }
 542 }
 543
 544 static void _vconf_event_lcdoff_cb(keynode_t *node,
 545                 void *data)
 546 {
 547         int ret = 0;
 548         int pm_state = VCONFKEY_PM_STATE_NORMAL;
 549
 550         ret = vconf_get_int(VCONFKEY_PM_STATE, &pm_state);
 551
 552         if (ret == 0 && pm_state == VCONFKEY_PM_STATE_LCDOFF) {
 553                 quickpanel_uic_close_quickpanel(false, 0);
 554         }
 555 }
 556
 557
 558 void _event_message_cb(void *data, Evas_Object *obj, void *event_info)
 559  {
 560         bool visiblity = (bool)event_info;
 561         struct appdata *ad = data;
 562
 563         if(visiblity == 1) { // show
 564                 DBG("quickpanel is opened");
 565
 566                 ad->is_opened = 1;
 567                 quickpanel_util_time_timer_enable_set(1);
 568                 quickpanel_keyboard_openning_init(ad);
 569                 quickpanel_modules_opened(data);
 570                 quickpanel_uic_opened_reason_set(OPENED_NO_REASON);
 571         } else {
 572                 DBG("quickpanel is closed");
 573
 574                 ad->is_opened = 0;
 575                 quickpanel_util_time_timer_enable_set(0);
 576                 quickpanel_keyboard_closing_fini(ad);
 577                 quickpanel_modules_closed(data);
 578         }
 579         quickpanel_media_player_stop();
 580  }
 581
 582 static void _vconf_init(struct appdata *ad)
 583 {
 584         int ret = 0;
 585
 586         ret = vconf_notify_key_changed(VCONFKEY_PM_STATE,
 587                         _vconf_event_lcdoff_cb, ad);
 588         if (ret != 0) {
 589                 ERR("VCONFKEY_PM_STATE: %d", ret);
 590         }
 591
 592         ret = vconf_notify_key_changed(VCONFKEY_SYSMAN_POWER_OFF_STATUS,
 593                         _vconf_event_powerff_cb, ad);
 594         if (ret != 0) {
 595                 ERR("VCONFKEY_PM_STATE: %d", ret);
 596         }
 597 }
 598
 599 static void _vconf_fini(struct appdata *ad)
 600 {
 601         int ret = 0;
 602
 603         ret = vconf_ignore_key_changed(VCONFKEY_PM_STATE,
 604                         _vconf_event_lcdoff_cb);
 605         if (ret != 0) {
 606                 ERR("VCONFKEY_PM_STATE: %d", ret);
 607         }
 608
 609         ret = vconf_ignore_key_changed(VCONFKEY_SYSMAN_POWER_OFF_STATUS,
 610                         _vconf_event_powerff_cb);
 611         if (ret != 0) {
 612                 ERR("VCONFKEY_PM_STATE: %d", ret);
 613         }
 614 }
 615
 616 static void _edbus_init(struct appdata *ad)
 617 {
 618         e_dbus_init();
 619         ad->dbus_connection = e_dbus_bus_get(DBUS_BUS_SYSTEM);
 620         if (ad->dbus_connection == NULL) {
 621                 ERR("noti register : failed to get dbus bus");
 622         }
 623 }
 624
 625 static void _edbus_fini(struct appdata *ad)
 626 {
 627         if (ad->dbus_connection != NULL) {
 628                 e_dbus_connection_close(ad->dbus_connection);
 629                 ad->dbus_connection = NULL;
 630                 e_dbus_shutdown();
 631         }
 632 }
 633
 634 static void _ecore_event_init(struct appdata *ad)
 635 {
 636         DBG("");
 637         evas_object_smart_callback_add(ad->win, "visibility,changed", _event_message_cb, ad);
 638 }
 639
 640 static void _ecore_event_fini(struct appdata *ad)
 641 {
 642         if (ad->hdl_client_message != NULL) {
 643                 ecore_event_handler_del(ad->hdl_client_message);
 644                 ad->hdl_client_message = NULL;
 645         }
 646 }
 647
 648 /*****************************************************************************
 649  *
 650  * App efl main interface
 651  *
 652  ****************************************************************************/
 653 static void _sigaction_terminate_handler(int signum, siginfo_t *info, void *unused)
 654 {
 655         ERR("quickpanel going to be terminated");
 656         ui_app_exit();
 657 }
 658
 659 static void _service_request_process(app_control_h service, void *data)
 660 {
 661         char *value = NULL;
 662         retif(service == NULL, , "Invialid parameter!");
 663
 664         if (!app_control_get_extra_data(service, "HIDE_LAUNCH", &value))
 665         {
 666                 if (value != NULL) {
 667                         ERR("HIDE_LAUNCH: %s", value);
 668                         if (!strcmp(value, "1")) {
 669                                 quickpanel_uic_close_quickpanel(false, 0);
 670                         } else {
 671                                 quickpanel_uic_open_quickpanel(OPENED_BY_CMD_HIDE_LAUNCH);
 672                         }
 673
 674                         free(value);
 675                 }
 676         } else if (!app_control_get_extra_data(service, "SHOW_SETTINGS", &value)) {
 677                 if (value != NULL) {
 678                         ERR("SHOW_SETTINGS: %s", value);
 679                         if (!strcmp(value, "1")) {
 680                                 quickpanel_pager_page_set(PAGE_IDX_EDITING, 0);
 681                                 quickpanel_uic_open_quickpanel(OPENED_BY_CMD_SHOW_SETTINGS);
 682                         }
 683
 684                         free(value);
 685                 }
 686         }
 687 #ifdef QP_EMERGENCY_MODE_ENABLE
 688         else if (!app_control_get_extra_data(service, "EMERGENCY_MODE_LAUNCH", &value)) {
 689                 if (value != NULL) {
 690                         ERR("EMERGENCY_MODE_LAUNCH: %s", value);
 691                         if (!strcmp(value, "1")) {
 692                                 if (quickpanel_emergency_mode_syspopup_launch() == QP_FAIL) {
 693                                         ERR("failed to launch emergency mode syspopup");
 694                                 } else {
 695                                         quickpanel_uic_close_quickpanel(true, 0);
 696                                 }
 697                         }
 698
 699                         free(value);
 700                 }
 701         }
 702 #endif
 703 }
 704
 705 static Eina_Bool _appcore_cache_flush_timer_cb(void *data)
 706 {
 707         if (!quickpanel_uic_is_suspended()) {
 708                 return ECORE_CALLBACK_CANCEL;
 709         }
 710
 711         return ECORE_CALLBACK_CANCEL;
 712 }
 713
 714 static Eina_Bool _ui_refresh_idler_cb(void *data)
 715 {
 716         DBG("");
 717         struct appdata *ad = data;
 718         retif(ad == NULL, QP_FAIL, "Invalid parameter!");
 719
 720         quickpanel_modules_refresh(ad);
 721         _ui_geometry_info_set(ad);
 722         _ui_handler_info_set(ad);
 723
 724         /*      Cache memory is cleared when the application paused (every time, after 5 seconds (in appcore)),
 725          *      but after running in a minimized mode application have status AS_RUNNING.
 726          *      Application have status AS_PAUSED only after change of visibility to hidden condition by user (on hiding window)
 727          *      Cleaning must be performed only once after application loading in hidden condition
 728          *      (and stay in a hidden condition at time of cleaning).
 729          */
 730         ecore_timer_add(10, _appcore_cache_flush_timer_cb, NULL);
 731
 732         return EINA_FALSE;
 733 }
 734
 735 static void _quickpanel_initialize(void *data)
 736 {
 737         int ret = 0;
 738         struct appdata *ad = data;
 739         retif(ad == NULL, , "Invialid parameter!");
 740
 741         INFO(">> Creating Quickpanel");
 742         /* Check emulator */
 743         ad->is_emul = quickpanel_uic_is_emul();
 744         INFO("quickpanel run in %s", ad->is_emul ? "Emul" : "Device");
 745
 746         int w, h;
 747         elm_win_screen_size_get(ad->win, NULL, NULL, &w, &h);
 748         ad->scale = elm_config_scale_get();
 749         if (ad->scale < 0) {
 750                 ad->scale = 1.0;
 751         }
 752
 753         INFO("quickpanel scale %f", ad->scale);
 754
 755         ad->is_suspended = 1;
 756
 757         /* Get theme */
 758         elm_theme_extension_add(NULL, DEFAULT_THEME_EDJ);
 759         /* create quickpanel window */
 760         ret = _ui_gui_create(ad);
 761         retif(ret != QP_OK, , "Failed to create window!");
 762
 763         quickpanel_media_init();
 764
 765         _ecore_event_init(ad);
 766         _vconf_init(ad);
 767         _edbus_init(ad);
 768
 769         quickpanel_uninstall_init(ad);
 770 #ifdef QP_EMERGENCY_MODE_ENABLE
 771         quickpanel_emergency_mode_init(ad);
 772 #endif
 773         quickpanel_keyboard_init(ad);
 774 #ifdef QP_REMINDER_ENABLE
 775         quickpanel_reminder_init(ad);
 776 #endif
 777
 778 #ifdef QP_SETTING_ENABLE
 779         _ui_setting_visibility_set(ad, 1);
 780 #else /* QP_SETTING_ENABLE */
 781         _ui_setting_visibility_set(ad, 0);
 782 #endif /* QP_SETTING_ENABLE */
 783
 784         /* init quickpanel modules */
 785         quickpanel_modules_init(ad);
 786         ecore_idler_add(_ui_refresh_idler_cb, ad);
 787 }
 788
 789 static bool _app_create_cb(void *data)
 790 {
 791         ERR("");
 792
 793         elm_app_base_scale_set(1.8);
 794
 795         pid_t pid;
 796         int r;
 797         char err_buf[128] = {0,};
 798
 799         // signal handler
 800         struct sigaction act;
 801         act.sa_sigaction = _sigaction_terminate_handler;
 802         act.sa_flags = SA_SIGINFO;
 803
 804         int ret = sigemptyset(&act.sa_mask);
 805         if (ret < 0) {
 806                 strerror_r(errno, err_buf, sizeof(err_buf));
 807                 ERR("Failed to sigemptyset[%d / %s]", errno, err_buf);
 808         }
 809         ret = sigaddset(&act.sa_mask, SIGTERM);
 810         if (ret < 0) {
 811                 strerror_r(errno, err_buf, sizeof(err_buf));
 812                 ERR("Failed to sigaddset[%d / %s]", errno, err_buf);
 813         }
 814         ret = sigaction(SIGTERM, &act, NULL);
 815         if (ret < 0) {
 816                 strerror_r(errno, err_buf, sizeof(err_buf));
 817                 ERR("Failed to sigaction[%d / %s]", errno, err_buf);
 818         }
 819
 820         pid = setsid();
 821         if (pid < 0) {
 822                 WARN("Failed to set session id!");
 823         }
 824
 825         r = nice(2);
 826         if (r == -1) {
 827                 WARN("Failed to set nice value!");
 828         }
 829
 830         return TRUE;
 831 }
 832
 833 static void _app_service_cb(app_control_h service, void *data)
 834 {
 835         struct appdata *ad = data;
 836         retif(ad == NULL, , "Invialid parameter!");
 837
 838         if (ad->win == NULL && ad->ly == NULL) {
 839                 _quickpanel_initialize(data);
 840         } else {
 841                 _service_request_process(service, data);
 842         }
 843 }
 844
 845 static void _app_terminate_cb(void *data)
 846 {
 847         ERR("");
 848
 849         struct appdata *ad = data;
 850         retif(ad == NULL, , "invalid data.");
 851
 852         quickpanel_media_fini();
 853
 854         /* fini quickpanel modules */
 855         quickpanel_modules_fini(ad);
 856         _edbus_fini(ad);
 857         _vconf_fini(ad);
 858         _ecore_event_fini(ad);
 859
 860         quickpanel_keyboard_fini(ad);
 861         quickpanel_uninstall_fini(ad);
 862 #ifdef QP_REMINDER_ENABLE
 863         quickpanel_reminder_fini(ad);
 864 #endif
 865 #ifdef QP_EMERGENCY_MODE_ENABLE
 866         quickpanel_emergency_mode_fini(ad);
 867 #endif
 868
 869         /* delete quickpanel window */
 870         _ui_gui_destroy(ad);
 871
 872         INFO("Quickpanel is terminated");
 873 }
 874
 875 static void _app_resume_cb(void *data)
 876 {
 877         DBG("");
 878         struct appdata *ad = data;
 879         retif(ad == NULL,, "invalid data.");
 880
 881         ad->is_suspended = 0;
 882         _ui_handler_enable_set(EINA_FALSE);
 883
 884         quickpanel_modules_resume(data);
 885
 886         sim_controller_resume();
 887 }
 888
 889 static void _app_pause_cb(void *data)
 890 {
 891         DBG("");
 892         struct appdata *ad = data;
 893         retif(ad == NULL,, "invalid data.");
 894
 895
 896         quickpanel_modules_suspend(ad);
 897
 898         ad->is_suspended = 1;
 899
 900         if (ad->evas != NULL) {
 901                 _ui_efl_cache_flush(ad->evas);
 902                 evas_event_feed_mouse_cancel(ad->evas, ecore_time_get(), NULL);
 903         }
 904 }
 905
 906 static void _app_language_changed_cb(app_event_info_h event_info, void *data)
 907 {
 908         DBG("");
 909         quickpanel_modules_lang_change(data);
 910
 911         sim_controller_on_language_change();
 912 }
 913
 914 static void _app_region_format_changed_cb(app_event_info_h event_info, void *data)
 915 {
 916         DBG("");
 917         quickpanel_modules_lang_change(data);
 918 }
 919
 920 int main(int argc, char *argv[])
 921 {
 922         INFO("BUILD START: %s %s", __DATE__, __TIME__);
 923         ERR("BUILD START: %s %s", __DATE__, __TIME__);
 924
 925         int ret = 0;
 926         struct appdata ad;
 927         ui_app_lifecycle_callback_s event_callback = {0,};
 928         app_event_handler_h handlers[5] = {NULL, };
 929
 930         ERR("quickpanel is forked");
 931
 932         event_callback.create = _app_create_cb;
 933         event_callback.terminate = _app_terminate_cb;
 934         event_callback.pause = _app_pause_cb;
 935         event_callback.resume = _app_resume_cb;
 936         event_callback.app_control = _app_service_cb;
 937
 938 //      ui_app_add_event_handler(&handlers[APP_EVENT_LOW_BATTERY], APP_EVENT_LOW_BATTERY, NULL, NULL);
 939 //      ui_app_add_event_handler(&handlers[APP_EVENT_LOW_MEMORY], APP_EVENT_LOW_MEMORY, NULL, NULL);
 940 //      ui_app_add_event_handler(&handlers[APP_EVENT_DEVICE_ORIENTATION_CHANGED], APP_EVENT_DEVICE_ORIENTATION_CHANGED, NULL, NULL);
 941         ui_app_add_event_handler(&handlers[APP_EVENT_LANGUAGE_CHANGED], APP_EVENT_LANGUAGE_CHANGED, _app_language_changed_cb, &ad);
 942         ui_app_add_event_handler(&handlers[APP_EVENT_REGION_FORMAT_CHANGED], APP_EVENT_REGION_FORMAT_CHANGED, _app_region_format_changed_cb, &ad);
 943
 944         memset(&ad, 0x0, sizeof(struct appdata));
 945
 946         g_app_data = &ad;
 947
 948         ret = ui_app_main(argc, argv, &event_callback, (void *)&ad);
 949         if (ret != APP_ERROR_NONE) {
 950                 ERR("ui_app_main() is failed. err = %d", ret);
 951         }
 952
 953         return ret;
 954
 955 }