src/appcore-efl.c

   1 /*
   2  * Copyright (c) 2000 - 2016 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 #include <sys/types.h>
  18 #include <sys/socket.h>
  19 #include <sys/un.h>
  20 #include <stdio.h>
  21 #include <unistd.h>
  22 #include <stdarg.h>
  23 #include <errno.h>
  24 #include <string.h>
  25 #include <stdlib.h>
  26
  27 #include <Ecore_Wayland.h>
  28 #include <wayland-client.h>
  29 #include <wayland-tbm-client.h>
  30 #include <tizen-extension-client-protocol.h>
  31
  32 #include <Ecore.h>
  33 #include <Ecore_Evas.h>
  34 #include <Ecore_Input_Evas.h>
  35 #include <Elementary.h>
  36 #include <glib-object.h>
  37 #include <malloc.h>
  38 #include <glib.h>
  39 #include <gio/gio.h>
  40 #include <stdbool.h>
  41 #include <aul.h>
  42 #include <aul_svc.h>
  43 #include <bundle_internal.h>
  44 #include <ttrace.h>
  45
  46 #include "appcore-internal.h"
  47 #include "appcore-efl.h"
  48 #include <system_info.h>
  49
  50 static pid_t _pid;
  51 static bool resource_reclaiming = TRUE;
  52 static int tmp_val = 0;
  53
  54 struct ui_priv {
  55         const char *name;
  56         enum app_state state;
  57
  58         Ecore_Event_Handler *hshow;
  59         Ecore_Event_Handler *hhide;
  60         Ecore_Event_Handler *hvchange;
  61         Ecore_Event_Handler *hlower;
  62         Ecore_Event_Handler *hcmsg; /* WM_ROTATE */
  63
  64         Ecore_Timer *mftimer; /* Ecore Timer for memory flushing */
  65
  66         struct appcore *app_core;
  67         void (*prepare_to_suspend) (void *data);
  68         void (*exit_from_suspend) (void *data);
  69         struct appcore_ops *ops;
  70         void (*mfcb) (void); /* Memory Flushing Callback */
  71
  72         /* WM_ROTATE */
  73         int wm_rot_supported;
  74         int rot_started;
  75         int (*rot_cb) (void *event_info, enum appcore_rm, void *);
  76         void *rot_cb_data;
  77         enum appcore_rm rot_mode;
  78         char *below_app;
  79 };
  80
  81 static struct ui_priv priv;
  82
  83 static const char *_ae_name[AE_MAX] = {
  84         [AE_UNKNOWN] = "UNKNOWN",
  85         [AE_CREATE] = "CREATE",
  86         [AE_TERMINATE] = "TERMINATE",
  87         [AE_PAUSE] = "PAUSE",
  88         [AE_RESUME] = "RESUME",
  89         [AE_RESET] = "RESET",
  90         [AE_LOWMEM_POST] = "LOWMEM_POST",
  91         [AE_MEM_FLUSH] = "MEM_FLUSH",
  92         [AE_UPDATE_REQUESTED] = "UPDATE_REQUESTED",
  93 };
  94
  95 static const char *_as_name[] = {
  96         [AS_NONE] = "NONE",
  97         [AS_CREATED] = "CREATED",
  98         [AS_RUNNING] = "RUNNING",
  99         [AS_PAUSED] = "PAUSED",
 100         [AS_DYING] = "DYING",
 101 };
 102
 103 static bool b_active = FALSE;
 104 static bool first_launch = TRUE;
 105
 106 struct win_node {
 107         unsigned int win;
 108         unsigned int surf;
 109         bool bfobscured;
 110 };
 111
 112 static Eina_Bool __visibility_cb(void *data, int type, void *event);
 113 static GSList *g_winnode_list;
 114
 115 static struct wl_display *dsp;
 116 static struct wl_registry *reg;
 117 static struct tizen_policy *tz_policy;
 118 static bool bg_state = false;
 119
 120 static void __wl_listener_cb(void *data, struct wl_registry *reg,
 121                 uint32_t id, const char *interface, uint32_t ver)
 122 {
 123         if (interface && !strcmp(interface, "tizen_policy")) {
 124                 if (!tz_policy)
 125                         tz_policy = wl_registry_bind(reg, id,
 126                                         &tizen_policy_interface, 1);
 127         }
 128 }
 129
 130 static void __wl_listener_remove_cb(void *data, struct wl_registry *reg,
 131                 unsigned int id)
 132 {
 133         /* do nothing */
 134 }
 135
 136 static const struct wl_registry_listener reg_listener = {
 137         __wl_listener_cb,
 138         __wl_listener_remove_cb
 139 };
 140
 141 static int __init_wl(void)
 142 {
 143         _DBG("initialize wayland");
 144         dsp = wl_display_connect(NULL);
 145         if (dsp == NULL) {
 146                 _ERR("Failed to connect wl display");
 147                 return -1;
 148         }
 149
 150         reg = wl_display_get_registry(dsp);
 151         if (reg == NULL) {
 152                 _ERR("Failed to get registry");
 153                 wl_display_disconnect(dsp);
 154                 return -1;
 155         }
 156
 157         wl_registry_add_listener(reg, &reg_listener, NULL);
 158         wl_display_roundtrip(dsp);
 159
 160         if (!tz_policy) {
 161                 _ERR("Failed to get tizen policy interface");
 162                 wl_registry_destroy(reg);
 163                 wl_display_disconnect(dsp);
 164                 return -1;
 165         }
 166
 167         return 0;
 168 }
 169
 170 static void __finish_wl(void)
 171 {
 172         if (tz_policy) {
 173                 tizen_policy_destroy(tz_policy);
 174                 tz_policy = NULL;
 175         }
 176
 177         if (reg) {
 178                 wl_registry_destroy(reg);
 179                 reg = NULL;
 180         }
 181
 182         if (dsp) {
 183                 wl_display_disconnect(dsp);
 184                 dsp = NULL;
 185         }
 186 }
 187
 188 static void __set_bg_state(void)
 189 {
 190         if (!tz_policy && __init_wl() < 0)
 191                 return;
 192
 193         tizen_policy_set_background_state(tz_policy, getpid());
 194         wl_display_roundtrip(dsp);
 195         bg_state = true;
 196         _DBG("bg state: %d", bg_state);
 197 }
 198
 199 static void __unset_bg_state(void)
 200 {
 201         if (!tz_policy)
 202                 return;
 203
 204         tizen_policy_unset_background_state(tz_policy, getpid());
 205         wl_display_roundtrip(dsp);
 206         bg_state = false;
 207         _DBG("bg state: %d", bg_state);
 208 }
 209
 210 static void __appcore_efl_prepare_to_suspend(void *data)
 211 {
 212         struct ui_priv *ui = (struct ui_priv *)data;
 213         struct sys_op *op = NULL;
 214         int suspend = APPCORE_SUSPENDED_STATE_WILL_ENTER_SUSPEND;
 215
 216         if (ui->app_core && !ui->app_core->allowed_bg && !ui->app_core->suspended_state) {
 217                 op = &ui->app_core->sops[SE_SUSPENDED_STATE];
 218                 if (op && op->func)
 219                         op->func((void *)&suspend, op->data); /* calls c-api handler */
 220
 221                 ui->app_core->suspended_state = true;
 222         }
 223         _DBG("[__SUSPEND__]");
 224 }
 225
 226 static void __appcore_efl_exit_from_suspend(void *data)
 227 {
 228         struct ui_priv *ui = (struct ui_priv *)data;
 229         struct sys_op *op = NULL;
 230         int suspend = APPCORE_SUSPENDED_STATE_DID_EXIT_FROM_SUSPEND;
 231
 232         if (ui->app_core && !ui->app_core->allowed_bg && ui->app_core->suspended_state) {
 233                 op = &ui->app_core->sops[SE_SUSPENDED_STATE];
 234                 if (op && op->func)
 235                         op->func((void *)&suspend, op->data); /* calls c-api handler */
 236
 237                 ui->app_core->suspended_state = false;
 238         }
 239         _DBG("[__SUSPEND__]");
 240 }
 241
 242 static void __appcore_efl_update_requested(void *data)
 243 {
 244         struct ui_priv *ui = (struct ui_priv *)data;
 245         struct sys_op *op;
 246         int dummy = 0;
 247
 248         if (ui->app_core) {
 249                 op = &ui->app_core->sops[SE_UPDATE_REQUESTED];
 250                 if (op && op->func)
 251                         op->func((void *)&dummy, op->data);
 252         }
 253         _DBG("[__UPDATE_REQUESTED__]");
 254 }
 255
 256 #if defined(MEMORY_FLUSH_ACTIVATE)
 257 static Eina_Bool __appcore_memory_flush_cb(void *data)
 258 {
 259         struct ui_priv *ui = (struct ui_priv *)data;
 260
 261         appcore_flush_memory();
 262         if (ui)
 263                 ui->mftimer = NULL;
 264
 265         if (_APPFW_FEATURE_BACKGROUND_MANAGEMENT && ui && ui->prepare_to_suspend) {
 266                 _DBG("[__SUSPEND__] flush case");
 267                 ui->prepare_to_suspend(ui);
 268         }
 269
 270         return ECORE_CALLBACK_CANCEL;
 271 }
 272
 273 static int __appcore_low_memory_post_cb(struct ui_priv *ui)
 274 {
 275         if (ui->state == AS_PAUSED)
 276                 appcore_flush_memory();
 277         else
 278                 malloc_trim(0);
 279
 280         return 0;
 281 }
 282
 283 static void __appcore_timer_add(struct ui_priv *ui)
 284 {
 285         ui->mftimer = ecore_timer_add(5, __appcore_memory_flush_cb, ui);
 286 }
 287
 288 static void __appcore_timer_del(struct ui_priv *ui)
 289 {
 290         if (ui->mftimer) {
 291                 ecore_timer_del(ui->mftimer);
 292                 ui->mftimer = NULL;
 293         }
 294 }
 295
 296 #else
 297
 298 static int __appcore_low_memory_post_cb(ui_priv *ui)
 299 {
 300         return -1;
 301 }
 302
 303 #define __appcore_timer_add(ui) 0
 304 #define __appcore_timer_del(ui) 0
 305
 306 #endif
 307
 308 static void __appcore_efl_memory_flush_cb(void)
 309 {
 310         _DBG("[APP %d]   __appcore_efl_memory_flush_cb()", _pid);
 311         elm_cache_all_flush();
 312 }
 313 static void wl_raise_win(void)
 314 {
 315         Ecore_Wl_Window *win;
 316         unsigned int win_id = appcore_get_main_window();
 317
 318         _DBG("Raise window: %d", win_id);
 319         win = ecore_wl_window_find(win_id);
 320         ecore_wl_window_activate(win);
 321 }
 322
 323 static void wl_pause_win(void)
 324 {
 325         Ecore_Wl_Window *win;
 326         GSList *wlist = g_winnode_list;
 327         struct win_node *entry = NULL;
 328
 329         _DBG("Pause window");
 330
 331         while (wlist) {
 332                 entry = wlist->data;
 333
 334                 _DBG("Pause window: %d", entry->win);
 335                 win = ecore_wl_window_find(entry->win);
 336                 ecore_wl_window_iconified_set(win, EINA_TRUE);
 337
 338                 wlist = wlist->next;
 339         }
 340 }
 341
 342
 343 static void __do_app(enum app_event event, void *data, bundle * b)
 344 {
 345         int r = -1;
 346         struct ui_priv *ui = data;
 347         const char *below_app;
 348         const char *bg_launch;
 349
 350         _DBG("[APP %d] Event: %d", _pid, event);
 351         _ret_if(ui == NULL || event >= AE_MAX);
 352         _DBG("[APP %d] Event: %s State: %s", _pid, _ae_name[event],
 353              _as_name[ui->state]);
 354
 355         if (event == AE_MEM_FLUSH) {
 356                 ui->mfcb();
 357                 return;
 358         }
 359
 360         if (event == AE_LOWMEM_POST) {
 361                 if (__appcore_low_memory_post_cb(ui) == 0)
 362                         return;
 363         }
 364
 365         if (!(ui->state == AS_PAUSED && event == AE_PAUSE))
 366                 __appcore_timer_del(ui);
 367
 368         if (ui->state == AS_DYING) {
 369                 _ERR("Skip the event in dying state");
 370                 return;
 371         }
 372
 373         if (event == AE_TERMINATE) {
 374                 _DBG("[APP %d] TERMINATE", _pid);
 375                 elm_exit();
 376                 aul_status_update(STATUS_DYING);
 377                 return;
 378         }
 379
 380         if (event == AE_RAISE) {
 381                 wl_raise_win();
 382                 return;
 383         }
 384
 385         if (event == AE_LOWER) {
 386                 wl_pause_win();
 387                 return;
 388         }
 389
 390         _ret_if(ui->ops == NULL);
 391
 392         switch (event) {
 393         case AE_RESET:
 394                 _DBG("[APP %d] RESET", _pid);
 395                 LOG(LOG_DEBUG, "LAUNCH", "[%s:Application:reset:start]", ui->name);
 396
 397                 if (ui->below_app) {
 398                         free(ui->below_app);
 399                         ui->below_app = NULL;
 400                 }
 401
 402                 below_app = bundle_get_val(b, AUL_SVC_K_RELOCATE_BELOW);
 403                 if (below_app)
 404                         ui->below_app = strdup(below_app);
 405                 if (_APPFW_FEATURE_BACKGROUND_MANAGEMENT && ui->exit_from_suspend) {
 406                         _DBG("[__SUSPEND__] reset case");
 407                         ui->exit_from_suspend(ui);
 408                 }
 409
 410                 if (ui->ops->reset) {
 411                         traceBegin(TTRACE_TAG_APPLICATION_MANAGER,
 412                                         "APPCORE:RESET");
 413                         r = ui->ops->reset(b, ui->ops->data);
 414                         traceEnd(TTRACE_TAG_APPLICATION_MANAGER);
 415                 }
 416                 LOG(LOG_DEBUG, "LAUNCH", "[%s:Application:reset:done]", ui->name);
 417
 418                 if (first_launch) {
 419                         if (_APPFW_FEATURE_BACKGROUND_MANAGEMENT && ui->app_core->allowed_bg)
 420                                 __appcore_timer_add(ui);
 421                         first_launch = FALSE;
 422                 } else {
 423                         _INFO("[APP %d] App already running, raise the window", _pid);
 424                         bg_launch = bundle_get_val(b, AUL_SVC_K_BG_LAUNCH);
 425                         if (bg_launch && strcmp(bg_launch, "enable") == 0) {
 426                                 if (!bg_state && ui->state != AS_RUNNING)
 427                                         __set_bg_state();
 428                         } else {
 429                                 if (bg_state)
 430                                         __unset_bg_state();
 431                         }
 432                         if (!bg_state)
 433                                 wl_raise_win();
 434                 }
 435                 LOG(LOG_DEBUG, "LAUNCH", "[%s:Application:reset:done]",
 436                     ui->name);
 437                 break;
 438         case AE_PAUSE:
 439                 if (ui->state == AS_RUNNING) {
 440                         _DBG("[APP %d] PAUSE", _pid);
 441                         if (ui->ops->pause) {
 442                                 traceBegin(TTRACE_TAG_APPLICATION_MANAGER,
 443                                                 "APPCORE:PAUSE");
 444                                 r = ui->ops->pause(ui->ops->data);
 445                                 traceEnd(TTRACE_TAG_APPLICATION_MANAGER);
 446                         }
 447                         ui->state = AS_PAUSED;
 448                         if (r >= 0 && resource_reclaiming == TRUE)
 449                                 __appcore_timer_add(ui);
 450                         else if (_APPFW_FEATURE_BACKGROUND_MANAGEMENT && r >= 0 && resource_reclaiming == FALSE
 451                                         && ui->prepare_to_suspend) {
 452                                 _DBG("[__SUSPEND__] pause case");
 453                                 ui->prepare_to_suspend(ui);
 454                         }
 455                 }
 456                 /* TODO : rotation stop */
 457                 /* r = appcore_pause_rotation_cb(); */
 458                 aul_status_update(STATUS_BG);
 459                 break;
 460         case AE_RESUME:
 461                 LOG(LOG_DEBUG, "LAUNCH", "[%s:Application:resume:start]",
 462                                 ui->name);
 463                 if (_APPFW_FEATURE_BACKGROUND_MANAGEMENT) {
 464                         if (ui->exit_from_suspend) {
 465                                 _DBG("[__SUSPEND__] resume case");
 466                                 ui->exit_from_suspend(ui);
 467                         }
 468                         if (ui->app_core->allowed_bg)
 469                                 __appcore_timer_del(ui);
 470                 }
 471
 472                 if (ui->state == AS_PAUSED || ui->state == AS_CREATED) {
 473                         _DBG("[APP %d] RESUME", _pid);
 474
 475                         if (ui->ops->resume) {
 476                                 traceBegin(TTRACE_TAG_APPLICATION_MANAGER,
 477                                         "APPCORE:RESUME");
 478                                 ui->ops->resume(ui->ops->data);
 479                                 traceEnd(TTRACE_TAG_APPLICATION_MANAGER);
 480                         }
 481                         ui->state = AS_RUNNING;
 482
 483                         if (ui->below_app) {
 484                                 aul_app_group_activate_below(ui->below_app);
 485                                 free(ui->below_app);
 486                                 ui->below_app = NULL;
 487                         }
 488                 }
 489                 /*TODO : rotation start*/
 490                 /* r = appcore_resume_rotation_cb(); */
 491                 LOG(LOG_DEBUG, "LAUNCH", "[%s:Application:resume:done]",
 492                     ui->name);
 493                 LOG(LOG_DEBUG, "LAUNCH", "[%s:Application:Launching:done]",
 494                     ui->name);
 495                 aul_status_update(STATUS_VISIBLE);
 496                 break;
 497         case AE_TERMINATE_BGAPP:
 498                 if (ui->state == AS_PAUSED) {
 499                         _DBG("[APP %d] is paused. TERMINATE", _pid);
 500                         ui->state = AS_DYING;
 501                         aul_status_update(STATUS_DYING);
 502                         elm_exit();
 503                 } else if (ui->state == AS_RUNNING) {
 504                         _DBG("[APP %d] is running.", _pid);
 505                 } else {
 506                         _DBG("[APP %d] is another state", _pid);
 507                 }
 508                 break;
 509         case AE_UPDATE_REQUESTED:
 510                 __appcore_efl_update_requested(ui);
 511                 break;
 512         default:
 513                 /* do nothing */
 514                 break;
 515         }
 516 }
 517
 518 static struct ui_ops efl_ops = {
 519         .data = &priv,
 520         .cb_app = __do_app,
 521 };
 522
 523 static bool __check_visible(void)
 524 {
 525         GSList *iter = NULL;
 526         struct win_node *entry = NULL;
 527
 528         _DBG("[EVENT_TEST][EVENT] __check_visible\n");
 529
 530         for (iter = g_winnode_list; iter != NULL; iter = g_slist_next(iter)) {
 531                 entry = iter->data;
 532                 _DBG("win : %x obscured : %d\n", entry->win, entry->bfobscured);
 533                 if (entry->bfobscured == FALSE)
 534                         return TRUE;
 535         }
 536
 537         return FALSE;
 538 }
 539
 540 static GSList *__find_win(unsigned int win)
 541 {
 542         GSList *iter;
 543         struct win_node *t;
 544
 545         for (iter = g_winnode_list; iter; iter = g_slist_next(iter)) {
 546                 t = iter->data;
 547                 if (t && t->win == win)
 548                         return iter;
 549         }
 550
 551         return NULL;
 552 }
 553
 554 static bool __add_win(unsigned int win, unsigned int surf)
 555 {
 556         struct win_node *t;
 557         GSList *f;
 558
 559         _DBG("[EVENT_TEST][EVENT] __add_win WIN:%x\n", win);
 560
 561         f = __find_win(win);
 562         if (f) {
 563                 errno = ENOENT;
 564                 _DBG("[EVENT_TEST][EVENT] ERROR There is already window : %x \n", win);
 565                 return FALSE;
 566         }
 567
 568         t = calloc(1, sizeof(struct win_node));
 569         if (t == NULL)
 570                 return FALSE;
 571
 572         t->win = win;
 573         t->surf = surf;
 574         t->bfobscured = FALSE;
 575
 576         g_winnode_list = g_slist_append(g_winnode_list, t);
 577
 578         return TRUE;
 579 }
 580
 581 static bool __delete_win(unsigned int win)
 582 {
 583         GSList *f;
 584
 585         f = __find_win(win);
 586         if (!f) {
 587                 errno = ENOENT;
 588                 _DBG("[EVENT_TEST][EVENT] ERROR There is no window : %x \n",
 589                                 win);
 590                 return FALSE;
 591         }
 592
 593         free(f->data);
 594         g_winnode_list = g_slist_delete_link(g_winnode_list, f);
 595
 596         return TRUE;
 597 }
 598
 599 static bool __update_win(unsigned int win, unsigned int surf, bool bfobscured)
 600 {
 601         GSList *f;
 602         struct win_node *t;
 603
 604         _DBG("[EVENT_TEST][EVENT] __update_win WIN:%x fully_obscured %d\n", win,
 605              bfobscured);
 606
 607         f = __find_win(win);
 608         if (!f) {
 609                 errno = ENOENT;
 610                 _DBG("[EVENT_TEST][EVENT] ERROR There is no window : %x \n", win);
 611                 return FALSE;
 612         }
 613
 614         t = (struct win_node *)f->data;
 615         t->win = win;
 616         if (surf != 0)
 617                 t->surf = surf;
 618         t->bfobscured = bfobscured;
 619
 620         return TRUE;
 621 }
 622
 623 static Eina_Bool __show_cb(void *data, int type, void *event)
 624 {
 625         Ecore_Wl_Event_Window_Show *ev;
 626
 627         ev = event;
 628         if (ev->parent_win != 0) {
 629                 /* This is child window. Skip!!! */
 630                 return ECORE_CALLBACK_PASS_ON;
 631         }
 632
 633         _DBG("[EVENT_TEST][EVENT] GET SHOW EVENT!!!. WIN:%x, %d\n", ev->win, ev->data[0]);
 634
 635         if (!__find_win((unsigned int)ev->win))
 636                 __add_win((unsigned int)ev->win, (unsigned int)ev->data[0]);
 637         else
 638                 __update_win((unsigned int)ev->win, (unsigned int)ev->data[0], FALSE);
 639
 640         if (ev->data[0] != 0)
 641                 appcore_group_attach();
 642         return ECORE_CALLBACK_RENEW;
 643 }
 644
 645 static Eina_Bool __hide_cb(void *data, int type, void *event)
 646 {
 647         Ecore_Wl_Event_Window_Hide *ev;
 648         int bvisibility = 0;
 649
 650         ev = event;
 651
 652         _DBG("[EVENT_TEST][EVENT] GET HIDE EVENT!!!. WIN:%x\n", ev->win);
 653
 654         if (__find_win((unsigned int)ev->win)) {
 655                 __delete_win((unsigned int)ev->win);
 656                 bvisibility = __check_visible();
 657                 if (!bvisibility && b_active == TRUE) {
 658                         _DBG(" Go to Pasue state \n");
 659                         b_active = FALSE;
 660                         __do_app(AE_PAUSE, data, NULL);
 661                 }
 662         }
 663
 664         return ECORE_CALLBACK_RENEW;
 665 }
 666
 667 static Eina_Bool __lower_cb(void *data, int type, void *event)
 668 {
 669         Ecore_Wl_Event_Window_Lower *ev;
 670         ev = event;
 671         if (!ev) return ECORE_CALLBACK_RENEW;
 672         _DBG("ECORE_WL_EVENT_WINDOW_LOWER window id:%u\n", ev->win);
 673         appcore_group_lower();
 674         return ECORE_CALLBACK_RENEW;
 675 }
 676
 677 static Eina_Bool __visibility_cb(void *data, int type, void *event)
 678 {
 679         Ecore_Wl_Event_Window_Visibility_Change *ev;
 680         int bvisibility = 0;
 681         ev = event;
 682         __update_win((unsigned int)ev->win, 0, ev->fully_obscured);
 683         bvisibility = __check_visible();
 684
 685         _DBG("bvisibility %d, b_active %d", bvisibility, b_active);
 686
 687         if (bvisibility && b_active == FALSE) {
 688                 _DBG(" Go to Resume state\n");
 689                 b_active = TRUE;
 690                 __do_app(AE_RESUME, data, NULL);
 691
 692         } else if (!bvisibility && b_active == TRUE) {
 693                 _DBG(" Go to Pasue state \n");
 694                 b_active = FALSE;
 695                 __do_app(AE_PAUSE, data, NULL);
 696         } else
 697                 _DBG(" No change state \n");
 698
 699         return ECORE_CALLBACK_RENEW;
 700
 701 }
 702
 703 static void __add_climsg_cb(struct ui_priv *ui)
 704 {
 705         _ret_if(ui == NULL);
 706         ui->hshow =
 707                 ecore_event_handler_add(ECORE_WL_EVENT_WINDOW_SHOW, __show_cb, ui);
 708         ui->hhide =
 709                 ecore_event_handler_add(ECORE_WL_EVENT_WINDOW_HIDE, __hide_cb, ui);
 710         ui->hvchange =
 711                 ecore_event_handler_add(ECORE_WL_EVENT_WINDOW_VISIBILITY_CHANGE,
 712                                 __visibility_cb, ui);
 713         ui->hlower =
 714                 ecore_event_handler_add(ECORE_WL_EVENT_WINDOW_LOWER,
 715                                 __lower_cb, ui);
 716 }
 717
 718 static int __before_loop(struct ui_priv *ui, int *argc, char ***argv)
 719 {
 720         int r;
 721         char *hwacc = NULL;
 722         struct appcore *ac = NULL;
 723         bundle *b;
 724         const char *bg_launch;
 725
 726         if (argc == NULL || argv == NULL) {
 727                 _ERR("argc/argv is NULL");
 728                 errno = EINVAL;
 729                 return -1;
 730         }
 731
 732 #if !(GLIB_CHECK_VERSION(2, 36, 0))
 733         g_type_init();
 734 #endif
 735         elm_init(*argc, *argv);
 736
 737         hwacc = getenv("HWACC");
 738         if (hwacc == NULL) {
 739                 _DBG("elm_config_accel_preference_set is not called");
 740         } else if (strcmp(hwacc, "USE") == 0) {
 741                 elm_config_accel_preference_set("hw");
 742                 _DBG("elm_config_accel_preference_set : hw");
 743         } else if (strcmp(hwacc, "NOT_USE") == 0) {
 744                 elm_config_accel_preference_set("none");
 745                 _DBG("elm_config_accel_preference_set : none");
 746         } else {
 747                 _DBG("elm_config_accel_preference_set is not called");
 748         }
 749
 750         r = appcore_init(ui->name, &efl_ops, *argc, *argv);
 751         _retv_if(r == -1, -1);
 752
 753         if (_APPFW_FEATURE_BACKGROUND_MANAGEMENT) {
 754                 appcore_get_app_core(&ac);
 755                 ui->app_core = ac;
 756                 SECURE_LOGD("[__SUSPEND__] appcore initialized, appcore addr: #%x", ac);
 757         }
 758
 759         b = bundle_import_from_argv(*argc, *argv);
 760         if (b) {
 761                 bg_launch = bundle_get_val(b, AUL_SVC_K_BG_LAUNCH);
 762                 if (bg_launch && strcmp(bg_launch, "enable") == 0)
 763                         __set_bg_state();
 764
 765                 bundle_free(b);
 766         }
 767
 768         LOG(LOG_DEBUG, "LAUNCH", "[%s:Platform:appcore_init:done]", ui->name);
 769         if (ui->ops && ui->ops->create) {
 770                 traceBegin(TTRACE_TAG_APPLICATION_MANAGER, "APPCORE:CREATE");
 771                 r = ui->ops->create(ui->ops->data);
 772                 traceEnd(TTRACE_TAG_APPLICATION_MANAGER);
 773                 if (r < 0) {
 774                         _ERR("create() return error");
 775                         appcore_exit();
 776                         if (ui->ops && ui->ops->terminate) {
 777                                 traceBegin(TTRACE_TAG_APPLICATION_MANAGER,
 778                                         "APPCORE:TERMINATE");
 779                                 ui->ops->terminate(ui->ops->data);
 780                                 traceEnd(TTRACE_TAG_APPLICATION_MANAGER);
 781                         }
 782                         errno = ECANCELED;
 783                         return -1;
 784                 }
 785                 LOG(LOG_DEBUG, "LAUNCH", "[%s:Application:create:done]",
 786                     ui->name);
 787         }
 788         ui->state = AS_CREATED;
 789
 790         __add_climsg_cb(ui);
 791
 792         return 0;
 793 }
 794
 795 static void __after_loop(struct ui_priv *ui)
 796 {
 797         appcore_unset_rotation_cb();
 798         appcore_exit();
 799
 800         if (ui->state == AS_RUNNING) {
 801                 _DBG("[APP %d] PAUSE before termination", _pid);
 802                 if (ui->ops && ui->ops->pause) {
 803                         traceBegin(TTRACE_TAG_APPLICATION_MANAGER,
 804                                         "APPCORE:PAUSE");
 805                         ui->ops->pause(ui->ops->data);
 806                         traceEnd(TTRACE_TAG_APPLICATION_MANAGER);
 807                 }
 808         }
 809
 810         if (ui->ops && ui->ops->terminate) {
 811                 traceBegin(TTRACE_TAG_APPLICATION_MANAGER, "APPCORE:TERMINATE");
 812                 ui->ops->terminate(ui->ops->data);
 813                 traceEnd(TTRACE_TAG_APPLICATION_MANAGER);
 814         }
 815
 816         ui->state = AS_DYING;
 817
 818         if (ui->hshow)
 819                 ecore_event_handler_del(ui->hshow);
 820         if (ui->hhide)
 821                 ecore_event_handler_del(ui->hhide);
 822         if (ui->hvchange)
 823                 ecore_event_handler_del(ui->hvchange);
 824         if (ui->hlower)
 825                 ecore_event_handler_del(ui->hlower);
 826
 827         __appcore_timer_del(ui);
 828         __finish_wl();
 829
 830         elm_shutdown();
 831
 832         /* Check loader case */
 833         if (getenv("AUL_LOADER_INIT")) {
 834                 unsetenv("AUL_LOADER_INIT");
 835                 elm_shutdown();
 836         }
 837 }
 838
 839 static int __set_data(struct ui_priv *ui, const char *name,
 840                     struct appcore_ops *ops)
 841 {
 842         if (ui->name) {
 843                 _ERR("Mainloop already started");
 844                 errno = EINPROGRESS;
 845                 return -1;
 846         }
 847
 848         if (name == NULL || name[0] == '\0') {
 849                 _ERR("Invalid name");
 850                 errno = EINVAL;
 851                 return -1;
 852         }
 853
 854         if (ops == NULL) {
 855                 _ERR("ops is NULL");
 856                 errno = EINVAL;
 857                 return -1;
 858         }
 859
 860         ui->name = strdup(name);
 861         _retv_if(ui->name == NULL, -1);
 862
 863         ui->ops = ops;
 864         ui->mfcb = __appcore_efl_memory_flush_cb;
 865         _pid = getpid();
 866
 867         /* WM_ROTATE */
 868         ui->wm_rot_supported = 0;
 869         ui->rot_started = 0;
 870         ui->rot_cb = NULL;
 871         ui->rot_cb_data = NULL;
 872         ui->rot_mode = APPCORE_RM_UNKNOWN;
 873
 874         if (_APPFW_FEATURE_BACKGROUND_MANAGEMENT) {
 875                 ui->app_core = NULL;
 876                 ui->prepare_to_suspend = __appcore_efl_prepare_to_suspend;
 877                 ui->exit_from_suspend = __appcore_efl_exit_from_suspend;
 878         }
 879
 880         return 0;
 881 }
 882
 883 static void __unset_data(struct ui_priv *ui)
 884 {
 885         if (ui->name)
 886                 free((void *)ui->name);
 887
 888         memset(ui, 0, sizeof(struct ui_priv));
 889 }
 890
 891 EXPORT_API int appcore_efl_init(const char *name, int *argc, char ***argv,
 892                      struct appcore_ops *ops)
 893 {
 894         int r;
 895
 896         LOG(LOG_DEBUG, "LAUNCH", "[%s:Application:main:done]", name);
 897
 898         r = __set_data(&priv, name, ops);
 899         _retv_if(r == -1, -1);
 900
 901         r = __before_loop(&priv, argc, argv);
 902         if (r == -1) {
 903                 aul_status_update(STATUS_DYING);
 904                 __unset_data(&priv);
 905                 return -1;
 906         }
 907
 908         return 0;
 909 }
 910
 911 EXPORT_API void appcore_efl_fini(void)
 912 {
 913         aul_status_update(STATUS_DYING);
 914
 915         __after_loop(&priv);
 916
 917         __unset_data(&priv);
 918 }
 919
 920 EXPORT_API int appcore_efl_main(const char *name, int *argc, char ***argv,
 921                                 struct appcore_ops *ops)
 922 {
 923         int r;
 924
 925         r = appcore_efl_init(name, argc, argv, ops);
 926         _retv_if(r == -1, -1);
 927
 928         elm_run();
 929
 930         appcore_efl_fini();
 931
 932         return 0;
 933 }
 934
 935 EXPORT_API int appcore_set_system_resource_reclaiming(bool enable)
 936 {
 937         resource_reclaiming = enable;
 938
 939         return 0;
 940 }
 941
 942 EXPORT_API int appcore_set_app_state(int state)
 943 {
 944         priv.state = state;
 945
 946         tmp_val = 1;
 947
 948         return 0;
 949 }
 950
 951 EXPORT_API int appcore_set_preinit_window_name(const char *win_name)
 952 {
 953         int ret = -1;
 954         void *preinit_window = NULL;
 955         const Evas *e = NULL;
 956
 957         if (!win_name) {
 958                 _ERR("invalid parameter");
 959                 return ret;
 960         }
 961
 962         preinit_window = elm_win_precreated_object_get();
 963         if (!preinit_window) {
 964                 _ERR("Failed to get preinit window");
 965                 return ret;
 966         }
 967
 968         e = evas_object_evas_get((const Evas_Object *)preinit_window);
 969         if (e) {
 970                 Ecore_Evas *ee = ecore_evas_ecore_evas_get(e);
 971                 if (ee) {
 972                         ecore_evas_name_class_set(ee, win_name, win_name);
 973                         ret = 0;
 974                 }
 975         }
 976
 977         return ret;
 978 }
 979
 980 EXPORT_API unsigned int appcore_get_main_window(void)
 981 {
 982         struct win_node *entry = NULL;
 983
 984         if (g_winnode_list != NULL) {
 985                 entry = g_winnode_list->data;
 986                 return (unsigned int) entry->win;
 987         }
 988
 989         return 0;
 990 }
 991
 992 EXPORT_API unsigned int appcore_get_main_surface(void)
 993 {
 994         struct win_node *entry = NULL;
 995
 996         if (g_winnode_list != NULL) {
 997                 entry = g_winnode_list->data;
 998                 return (unsigned int) entry->surf;
 999         }
1000
1001         return 0;
1002 }
1003
1004 tizen_profile_t _get_tizen_profile()
1005 {
1006         static tizen_profile_t profile = TIZEN_PROFILE_UNKNOWN;
1007         if (__builtin_expect(profile != TIZEN_PROFILE_UNKNOWN, 1))
1008                 return profile;
1009
1010         char *profileName;
1011         system_info_get_platform_string("http://tizen.org/feature/profile", &profileName);
1012         switch (*profileName) {
1013         case 'm':
1014         case 'M':
1015                 profile = TIZEN_PROFILE_MOBILE;
1016                 break;
1017         case 'w':
1018         case 'W':
1019                 profile = TIZEN_PROFILE_WEARABLE;
1020                 break;
1021         case 't':
1022         case 'T':
1023                 profile = TIZEN_PROFILE_TV;
1024                 break;
1025         case 'i':
1026         case 'I':
1027                 profile = TIZEN_PROFILE_IVI;
1028                 break;
1029         default: // common or unTIZEN_nown ==> ALL ARE COMMON.
1030                 profile = TIZEN_PROFILE_COMMON;
1031         }
1032         free(profileName);
1033
1034         return profile;
1035 }