src/window_manager.cpp

   1 /*
   2  * Copyright (c) 2017 TOYOTA MOTOR CORPORATION
   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 <fstream>
  18 #include <regex>
  19
  20 #include "window_manager.hpp"
  21 #include "json_helper.hpp"
  22 #include "applist.hpp"
  23
  24 extern "C"
  25 {
  26 #include <systemd/sd-event.h>
  27 }
  28
  29 namespace wm
  30 {
  31
  32 static const uint64_t kTimeOut = 3ULL; /* 3s */
  33
  34 /* DrawingArea name used by "{layout}.{area}" */
  35 const char kNameLayoutNormal[] = "normal";
  36 const char kNameLayoutSplit[]  = "split";
  37 const char kNameAreaFull[]     = "full";
  38 const char kNameAreaMain[]     = "main";
  39 const char kNameAreaSub[]      = "sub";
  40
  41 /* Key for json obejct */
  42 const char kKeyDrawingName[] = "drawing_name";
  43 const char kKeyDrawingArea[] = "drawing_area";
  44 const char kKeyDrawingRect[] = "drawing_rect";
  45 const char kKeyX[]           = "x";
  46 const char kKeyY[]           = "y";
  47 const char kKeyWidth[]       = "width";
  48 const char kKeyHeight[]      = "height";
  49 const char kKeyWidthPixel[]  = "width_pixel";
  50 const char kKeyHeightPixel[] = "height_pixel";
  51 const char kKeyWidthMm[]     = "width_mm";
  52 const char kKeyHeightMm[]    = "height_mm";
  53 const char kKeyScale[]       = "scale";
  54 const char kKeyIds[]         = "ids";
  55
  56 static sd_event_source *g_timer_ev_src = nullptr;
  57 static AppList g_app_list;
  58
  59 namespace
  60 {
  61
  62 using nlohmann::json;
  63
  64 result<json> file_to_json(char const *filename)
  65 {
  66     json j;
  67     std::ifstream i(filename);
  68     if (i.fail())
  69     {
  70         HMI_DEBUG("wm", "Could not open config file, so use default layer information");
  71         j = default_layers_json;
  72     }
  73     else
  74     {
  75         i >> j;
  76     }
  77
  78     return Ok(j);
  79 }
  80
  81 struct result<layer_map> load_layer_map(char const *filename)
  82 {
  83     HMI_DEBUG("wm", "loading IDs from %s", filename);
  84
  85     auto j = file_to_json(filename);
  86     if (j.is_err())
  87     {
  88         return Err<layer_map>(j.unwrap_err());
  89     }
  90     json jids = j.unwrap();
  91
  92     return to_layer_map(jids);
  93 }
  94
  95 static int processTimerHandler(sd_event_source *s, uint64_t usec, void *userdata)
  96 {
  97     HMI_NOTICE("wm", "Time out occurs because the client replys endDraw slow, so revert the request");
  98     reinterpret_cast<wm::WindowManager *>(userdata)->timerHandler();
  99     return 0;
 100 }
 101
 102 } // namespace
 103
 104 /**
 105  * WindowManager Impl
 106  */
 107 WindowManager::WindowManager(wl::display *d)
 108     : chooks{this},
 109       display{d},
 110       controller{},
 111       outputs(),
 112       layers(),
 113       id_alloc{},
 114       pending_events(false)
 115 {
 116     char const *path_layers_json = getenv("AFM_APP_INSTALL_DIR");
 117     std::string path;
 118     if (!path_layers_json)
 119     {
 120         HMI_ERROR("wm", "AFM_APP_INSTALL_DIR is not defined");
 121         path = std::string(path_layers_json);
 122     }
 123     else
 124     {
 125         path = std::string(path_layers_json) + std::string("/etc/layers.json");
 126     }
 127
 128     try
 129     {
 130         {
 131             auto l = load_layer_map(path.c_str());
 132             if (l.is_ok())
 133             {
 134                 this->layers = l.unwrap();
 135             }
 136             else
 137             {
 138                 HMI_ERROR("wm", "%s", l.err().value());
 139             }
 140         }
 141     }
 142     catch (std::exception &e)
 143     {
 144         HMI_ERROR("wm", "Loading of configuration failed: %s", e.what());
 145     }
 146 }
 147
 148 int WindowManager::init()
 149 {
 150     if (!this->display->ok())
 151     {
 152         return -1;
 153     }
 154
 155     if (this->layers.mapping.empty())
 156     {
 157         HMI_ERROR("wm", "No surface -> layer mapping loaded");
 158         return -1;
 159     }
 160
 161     // TODO: application requests by old role,
 162     //       so create role map (old, new)
 163     // Load old_role.db
 164     this->loadOldRoleDb();
 165
 166     // Make afb event
 167     for (int i = Event_Val_Min; i <= Event_Val_Max; i++)
 168     {
 169         map_afb_event[kListEventName[i]] = afb_daemon_make_event(kListEventName[i]);
 170     }
 171
 172     this->display->add_global_handler(
 173         "wl_output", [this](wl_registry *r, uint32_t name, uint32_t v) {
 174             this->outputs.emplace_back(std::make_unique<wl::output>(r, name, v));
 175         });
 176
 177     this->display->add_global_handler(
 178         "ivi_wm", [this](wl_registry *r, uint32_t name, uint32_t v) {
 179             this->controller =
 180                 std::make_unique<struct compositor::controller>(r, name, v);
 181
 182             // Init controller hooks
 183             this->controller->chooks = &this->chooks;
 184
 185             // This protocol needs the output, so lets just add our mapping here...
 186             this->controller->add_proxy_to_id_mapping(
 187                 this->outputs.back()->proxy.get(),
 188                 wl_proxy_get_id(reinterpret_cast<struct wl_proxy *>(
 189                     this->outputs.back()->proxy.get())));
 190
 191             // Create screen
 192             this->controller->create_screen(this->outputs.back()->proxy.get());
 193
 194             // Set display to controller
 195             this->controller->display = this->display;
 196         });
 197
 198     // First level objects
 199     this->display->roundtrip();
 200     // Second level objects
 201     this->display->roundtrip();
 202     // Third level objects
 203     this->display->roundtrip();
 204
 205     return init_layers();
 206 }
 207
 208 int WindowManager::dispatch_pending_events()
 209 {
 210     if (this->pop_pending_events())
 211     {
 212         this->display->dispatch_pending();
 213         return 0;
 214     }
 215     return -1;
 216 }
 217
 218 void WindowManager::set_pending_events()
 219 {
 220     this->pending_events.store(true, std::memory_order_release);
 221 }
 222
 223 result<int> WindowManager::api_request_surface(char const *appid, char const *drawing_name)
 224 {
 225     // TODO: application requests by old role,
 226     //       so convert role old to new
 227     const char *role = this->convertRoleOldToNew(drawing_name);
 228
 229     auto lid = this->layers.get_layer_id(std::string(role));
 230     if (!lid)
 231     {
 232         /**
 233        * register drawing_name as fallback and make it displayed.
 234        */
 235         lid = this->layers.get_layer_id(std::string("fallback"));
 236         HMI_DEBUG("wm", "%s is not registered in layers.json, then fallback as normal app", role);
 237         if (!lid)
 238         {
 239             return Err<int>("Drawing name does not match any role, fallback is disabled");
 240         }
 241     }
 242
 243     auto rname = this->lookup_id(role);
 244     if (!rname)
 245     {
 246         // name does not exist yet, allocate surface id...
 247         auto id = int(this->id_alloc.generate_id(role));
 248         this->layers.add_surface(id, *lid);
 249
 250         // set the main_surface[_name] here and now
 251         if (!this->layers.main_surface_name.empty() &&
 252             this->layers.main_surface_name == drawing_name)
 253         {
 254             this->layers.main_surface = id;
 255             HMI_DEBUG("wm", "Set main_surface id to %u", id);
 256         }
 257
 258         // add client into the db
 259         std::string appid_str(appid);
 260         g_app_list.addClient(appid_str, *lid, id, std::string(role));
 261
 262         // Set role map of (new, old)
 263         this->rolenew2old[role] = std::string(drawing_name);
 264
 265         return Ok<int>(id);
 266     }
 267
 268     // Check currently registered drawing names if it is already there.
 269     return Err<int>("Surface already present");
 270 }
 271
 272 char const *WindowManager::api_request_surface(char const *appid, char const *drawing_name,
 273                                      char const *ivi_id)
 274 {
 275     ST();
 276
 277     // TODO: application requests by old role,
 278     //       so convert role old to new
 279     const char *role = this->convertRoleOldToNew(drawing_name);
 280
 281     auto lid = this->layers.get_layer_id(std::string(role));
 282     unsigned sid = std::stol(ivi_id);
 283
 284     if (!lid)
 285     {
 286         /**
 287        * register drawing_name as fallback and make it displayed.
 288        */
 289         lid = this->layers.get_layer_id(std::string("fallback"));
 290         HMI_DEBUG("wm", "%s is not registered in layers.json, then fallback as normal app", role);
 291         if (!lid)
 292         {
 293             return "Drawing name does not match any role, fallback is disabled";
 294         }
 295     }
 296
 297     auto rname = this->lookup_id(role);
 298
 299     if (rname)
 300     {
 301         return "Surface already present";
 302     }
 303
 304     // register pair drawing_name and ivi_id
 305     this->id_alloc.register_name_id(role, sid);
 306     this->layers.add_surface(sid, *lid);
 307
 308     // this surface is already created
 309     HMI_DEBUG("wm", "surface_id is %u, layer_id is %u", sid, *lid);
 310
 311     this->controller->layers[*lid]->add_surface(sid);
 312     this->layout_commit();
 313
 314     // add client into the db
 315     std::string appid_str(appid);
 316     g_app_list.addClient(appid_str, *lid, sid, std::string(role));
 317
 318     // Set role map of (new, old)
 319     this->rolenew2old[role] = std::string(drawing_name);
 320
 321     return nullptr;
 322 }
 323
 324 void WindowManager::api_activate_surface(char const *appid, char const *drawing_name,
 325                                char const *drawing_area, const reply_func &reply)
 326 {
 327     ST();
 328
 329     // TODO: application requests by old role,
 330     //       so convert role old to new
 331     const char *c_role = this->convertRoleOldToNew(drawing_name);
 332
 333     std::string id = appid;
 334     std::string role = c_role;
 335     std::string area = drawing_area;
 336     Task task = Task::TASK_ALLOCATE;
 337     unsigned req_num = 0;
 338     WMError ret = WMError::UNKNOWN;
 339
 340     ret = this->setRequest(id, role, area, task, &req_num);
 341
 342     if(ret != WMError::SUCCESS)
 343     {
 344         HMI_ERROR("wm", errorDescription(ret));
 345         reply("Failed to set request");
 346         return;
 347     }
 348
 349     reply(nullptr);
 350     if (req_num != g_app_list.currentRequestNumber())
 351     {
 352         // Add request, then invoked after the previous task is finished
 353         HMI_SEQ_DEBUG(req_num, "request is accepted");
 354         return;
 355     }
 356
 357     /*
 358      * Do allocate tasks
 359      */
 360     ret = this->doTransition(req_num);
 361
 362     if (ret != WMError::SUCCESS)
 363     {
 364         //this->emit_error()
 365         HMI_SEQ_ERROR(req_num, errorDescription(ret));
 366         g_app_list.removeRequest(req_num);
 367         this->processNextRequest();
 368     }
 369 }
 370
 371 void WindowManager::api_deactivate_surface(char const *appid, char const *drawing_name,
 372                                  const reply_func &reply)
 373 {
 374     ST();
 375
 376     // TODO: application requests by old role,
 377     //       so convert role old to new
 378     const char *c_role = this->convertRoleOldToNew(drawing_name);
 379
 380     /*
 381     * Check Phase
 382     */
 383     std::string id = appid;
 384     std::string role = c_role;
 385     std::string area = ""; //drawing_area;
 386     Task task = Task::TASK_RELEASE;
 387     unsigned req_num = 0;
 388     WMError ret = WMError::UNKNOWN;
 389
 390     ret = this->setRequest(id, role, area, task, &req_num);
 391
 392     if (ret != WMError::SUCCESS)
 393     {
 394         HMI_ERROR("wm", errorDescription(ret));
 395         reply("Failed to set request");
 396         return;
 397     }
 398
 399     reply(nullptr);
 400     if (req_num != g_app_list.currentRequestNumber())
 401     {
 402         // Add request, then invoked after the previous task is finished
 403         HMI_SEQ_DEBUG(req_num, "request is accepted");
 404         return;
 405     }
 406
 407     /*
 408     * Do allocate tasks
 409     */
 410     ret = this->doTransition(req_num);
 411
 412     if (ret != WMError::SUCCESS)
 413     {
 414         //this->emit_error()
 415         HMI_SEQ_ERROR(req_num, errorDescription(ret));
 416         g_app_list.removeRequest(req_num);
 417         this->processNextRequest();
 418     }
 419 }
 420
 421 void WindowManager::api_enddraw(char const *appid, char const *drawing_name)
 422 {
 423     // TODO: application requests by old role,
 424     //       so convert role old to new
 425     const char *c_role = this->convertRoleOldToNew(drawing_name);
 426
 427     std::string id = appid;
 428     std::string role = c_role;
 429     unsigned current_req = g_app_list.currentRequestNumber();
 430     bool result = g_app_list.setEndDrawFinished(current_req, id, role);
 431
 432     if (!result)
 433     {
 434         HMI_ERROR("wm", "%s is not in transition state", id.c_str());
 435         return;
 436     }
 437
 438     if (g_app_list.endDrawFullfilled(current_req))
 439     {
 440         // do task for endDraw
 441         this->stopTimer();
 442         WMError ret = this->doEndDraw(current_req);
 443
 444         if(ret != WMError::SUCCESS)
 445         {
 446             //this->emit_error();
 447         }
 448         this->emitScreenUpdated(current_req);
 449         HMI_SEQ_INFO(current_req, "Finish request status: %s", errorDescription(ret));
 450
 451         g_app_list.removeRequest(current_req);
 452
 453         this->processNextRequest();
 454     }
 455     else
 456     {
 457         HMI_SEQ_INFO(current_req, "Wait other App call endDraw");
 458         return;
 459     }
 460 }
 461
 462 result<json_object *> WindowManager::api_get_display_info()
 463 {
 464     if (!this->display->ok())
 465     {
 466         return Err<json_object *>("Wayland compositor is not available");
 467     }
 468
 469     // Set display info
 470     compositor::size o_size = this->controller->output_size;
 471     compositor::size p_size = this->controller->physical_size;
 472
 473     json_object *object = json_object_new_object();
 474     json_object_object_add(object, kKeyWidthPixel, json_object_new_int(o_size.w));
 475     json_object_object_add(object, kKeyHeightPixel, json_object_new_int(o_size.h));
 476     json_object_object_add(object, kKeyWidthMm, json_object_new_int(p_size.w));
 477     json_object_object_add(object, kKeyHeightMm, json_object_new_int(p_size.h));
 478     json_object_object_add(object, kKeyScale, json_object_new_double(this->controller->scale));
 479
 480     return Ok<json_object *>(object);
 481 }
 482
 483 result<json_object *> WindowManager::api_get_area_info(char const *drawing_name)
 484 {
 485     HMI_DEBUG("wm", "called");
 486
 487     // TODO: application requests by old role,
 488     //       so convert role old to new
 489     const char *role = this->convertRoleOldToNew(drawing_name);
 490
 491     // Check drawing name, surface/layer id
 492     auto const &surface_id = this->lookup_id(role);
 493     if (!surface_id)
 494     {
 495         return Err<json_object *>("Surface does not exist");
 496     }
 497
 498     if (!this->controller->surface_exists(*surface_id))
 499     {
 500         return Err<json_object *>("Surface does not exist in controller!");
 501     }
 502
 503     auto layer_id = this->layers.get_layer_id(*surface_id);
 504     if (!layer_id)
 505     {
 506         return Err<json_object *>("Surface is not on any layer!");
 507     }
 508
 509     auto o_state = *this->layers.get_layout_state(*surface_id);
 510     if (o_state == nullptr)
 511     {
 512         return Err<json_object *>("Could not find layer for surface");
 513     }
 514
 515     struct LayoutState &state = *o_state;
 516     if ((state.main != *surface_id) && (state.sub != *surface_id))
 517     {
 518         return Err<json_object *>("Surface is inactive");
 519     }
 520
 521     // Set area rectangle
 522     compositor::rect area_info = this->area_info[*surface_id];
 523     json_object *object = json_object_new_object();
 524     json_object_object_add(object, kKeyX, json_object_new_int(area_info.x));
 525     json_object_object_add(object, kKeyY, json_object_new_int(area_info.y));
 526     json_object_object_add(object, kKeyWidth, json_object_new_int(area_info.w));
 527     json_object_object_add(object, kKeyHeight, json_object_new_int(area_info.h));
 528
 529     return Ok<json_object *>(object);
 530 }
 531
 532 void WindowManager::api_ping() { this->dispatch_pending_events(); }
 533
 534 void WindowManager::send_event(char const *evname, char const *label)
 535 {
 536     HMI_DEBUG("wm", "%s: %s(%s)", __func__, evname, label);
 537
 538     json_object *j = json_object_new_object();
 539     json_object_object_add(j, kKeyDrawingName, json_object_new_string(label));
 540
 541     int ret = afb_event_push(this->map_afb_event[evname], j);
 542     if (ret != 0)
 543     {
 544         HMI_DEBUG("wm", "afb_event_push failed: %m");
 545     }
 546 }
 547
 548 void WindowManager::send_event(char const *evname, char const *label, char const *area,
 549                      int x, int y, int w, int h)
 550 {
 551     HMI_DEBUG("wm", "%s: %s(%s, %s) x:%d y:%d w:%d h:%d",
 552               __func__, evname, label, area, x, y, w, h);
 553
 554     json_object *j_rect = json_object_new_object();
 555     json_object_object_add(j_rect, kKeyX, json_object_new_int(x));
 556     json_object_object_add(j_rect, kKeyY, json_object_new_int(y));
 557     json_object_object_add(j_rect, kKeyWidth, json_object_new_int(w));
 558     json_object_object_add(j_rect, kKeyHeight, json_object_new_int(h));
 559
 560     json_object *j = json_object_new_object();
 561     json_object_object_add(j, kKeyDrawingName, json_object_new_string(label));
 562     json_object_object_add(j, kKeyDrawingArea, json_object_new_string(area));
 563     json_object_object_add(j, kKeyDrawingRect, j_rect);
 564
 565     int ret = afb_event_push(this->map_afb_event[evname], j);
 566     if (ret != 0)
 567     {
 568         HMI_DEBUG("wm", "afb_event_push failed: %m");
 569     }
 570 }
 571
 572 /**
 573  * proxied events
 574  */
 575 void WindowManager::surface_created(uint32_t surface_id)
 576 {
 577     auto layer_id = this->layers.get_layer_id(surface_id);
 578     if (!layer_id)
 579     {
 580         HMI_DEBUG("wm", "Newly created surfce %d is not associated with any layer!",
 581                   surface_id);
 582         return;
 583     }
 584
 585     HMI_DEBUG("wm", "surface_id is %u, layer_id is %u", surface_id, *layer_id);
 586
 587     this->controller->layers[*layer_id]->add_surface(surface_id);
 588     this->layout_commit();
 589 }
 590
 591 void WindowManager::surface_removed(uint32_t surface_id)
 592 {
 593     HMI_DEBUG("wm", "surface_id is %u", surface_id);
 594     g_app_list.removeSurface(surface_id);
 595 }
 596
 597 void WindowManager::removeClient(const std::string &appid)
 598 {
 599     HMI_DEBUG("wm", "Remove clinet %s from list", appid.c_str());
 600     g_app_list.removeClient(appid);
 601 }
 602
 603 void WindowManager::exceptionProcessForTransition()
 604 {
 605     unsigned req_num = g_app_list.currentRequestNumber();
 606     HMI_SEQ_NOTICE(req_num, "Process exception handling for request. Remove current request %d", req_num);
 607     g_app_list.removeRequest(req_num);
 608     HMI_SEQ_NOTICE(g_app_list.currentRequestNumber(), "Process next request if exists");
 609     this->processNextRequest();
 610 }
 611
 612 void WindowManager::timerHandler()
 613 {
 614     unsigned req_num = g_app_list.currentRequestNumber();
 615     HMI_SEQ_DEBUG(req_num, "Timer expired remove Request");
 616     g_app_list.reqDump();
 617     g_app_list.removeRequest(req_num);
 618     this->processNextRequest();
 619 }
 620
 621 /*
 622  ******* Private Functions *******
 623  */
 624
 625 bool WindowManager::pop_pending_events()
 626 {
 627     bool x{true};
 628     return this->pending_events.compare_exchange_strong(
 629         x, false, std::memory_order_consume);
 630 }
 631
 632 optional<int> WindowManager::lookup_id(char const *name)
 633 {
 634     return this->id_alloc.lookup(std::string(name));
 635 }
 636 optional<std::string> WindowManager::lookup_name(int id)
 637 {
 638     return this->id_alloc.lookup(id);
 639 }
 640
 641 /**
 642  * init_layers()
 643  */
 644 int WindowManager::init_layers()
 645 {
 646     if (!this->controller)
 647     {
 648         HMI_ERROR("wm", "ivi_controller global not available");
 649         return -1;
 650     }
 651
 652     if (this->outputs.empty())
 653     {
 654         HMI_ERROR("wm", "no output was set up!");
 655         return -1;
 656     }
 657
 658     auto &c = this->controller;
 659
 660     auto &o = this->outputs.front();
 661     auto &s = c->screens.begin()->second;
 662     auto &layers = c->layers;
 663
 664     // Write output dimensions to ivi controller...
 665     c->output_size = compositor::size{uint32_t(o->width), uint32_t(o->height)};
 666     c->physical_size = compositor::size{uint32_t(o->physical_width),
 667                                         uint32_t(o->physical_height)};
 668
 669
 670     HMI_DEBUG("wm", "SCALING: screen (%dx%d), physical (%dx%d)",
 671               o->width, o->height, o->physical_width, o->physical_height);
 672
 673     this->layers.loadAreaDb();
 674
 675     const compositor::rect css_bg = this->layers.getAreaSize("fullscreen");
 676     rectangle dp_bg(o->width, o->height);
 677
 678     dp_bg.set_aspect(static_cast<double>(css_bg.w) / css_bg.h);
 679     dp_bg.fit(o->width, o->height);
 680     dp_bg.center(o->width, o->height);
 681     HMI_DEBUG("wm", "SCALING: CSS BG(%dx%d) -> DDP %dx%d,(%dx%d)",
 682               css_bg.w, css_bg.h, dp_bg.left(), dp_bg.top(), dp_bg.width(), dp_bg.height());
 683
 684     // Clear scene
 685     layers.clear();
 686
 687     // Clear screen
 688     s->clear();
 689
 690     // Quick and dirty setup of layers
 691     for (auto const &i : this->layers.mapping)
 692     {
 693         c->layer_create(i.second.layer_id, dp_bg.width(), dp_bg.height());
 694         auto &l = layers[i.second.layer_id];
 695         l->set_destination_rectangle(dp_bg.left(), dp_bg.top(), dp_bg.width(), dp_bg.height());
 696         l->set_visibility(1);
 697         HMI_DEBUG("wm", "Setting up layer %s (%d) for surface role match \"%s\"",
 698                   i.second.name.c_str(), i.second.layer_id, i.second.role.c_str());
 699     }
 700
 701     // Add layers to screen
 702     s->set_render_order(this->layers.layers);
 703
 704     this->layout_commit();
 705
 706     c->scale = static_cast<double>(dp_bg.height()) / css_bg.h;
 707     this->layers.setupArea(c->scale);
 708
 709     return 0;
 710 }
 711
 712 void WindowManager::surface_set_layout(int surface_id, const std::string& area)
 713 {
 714     if (!this->controller->surface_exists(surface_id))
 715     {
 716         HMI_ERROR("wm", "Surface %d does not exist", surface_id);
 717         return;
 718     }
 719
 720     auto o_layer_id = this->layers.get_layer_id(surface_id);
 721
 722     if (!o_layer_id)
 723     {
 724         HMI_ERROR("wm", "Surface %d is not associated with any layer!", surface_id);
 725         return;
 726     }
 727
 728     uint32_t layer_id = *o_layer_id;
 729
 730     auto const &layer = this->layers.get_layer(layer_id);
 731     auto rect = this->layers.getAreaSize(area);
 732     HMI_SEQ_DEBUG(g_app_list.currentRequestNumber(), "%s : x:%d y:%d w:%d h:%d", area.c_str(),
 733                     rect.x, rect.y, rect.w, rect.h);
 734     auto &s = this->controller->surfaces[surface_id];
 735
 736     int x = rect.x;
 737     int y = rect.y;
 738     int w = rect.w;
 739     int h = rect.h;
 740
 741     HMI_DEBUG("wm", "surface_set_layout for surface %u on layer %u", surface_id,
 742               layer_id);
 743
 744     // set destination to the display rectangle
 745     s->set_source_rectangle(0, 0, w, h);
 746     this->layout_commit();
 747     s->set_destination_rectangle(x, y, w, h);
 748
 749     // update area information
 750     this->area_info[surface_id].x = x;
 751     this->area_info[surface_id].y = y;
 752     this->area_info[surface_id].w = w;
 753     this->area_info[surface_id].h = h;
 754
 755     HMI_DEBUG("wm", "Surface %u now on layer %u with rect { %d, %d, %d, %d }",
 756               surface_id, layer_id, x, y, w, h);
 757 }
 758
 759 void WindowManager::layout_commit()
 760 {
 761     this->controller->commit_changes();
 762     this->display->flush();
 763 }
 764
 765 void WindowManager::emit_activated(char const *label)
 766 {
 767     this->send_event(kListEventName[Event_Active], label);
 768 }
 769
 770 void WindowManager::emit_deactivated(char const *label)
 771 {
 772     this->send_event(kListEventName[Event_Inactive], label);
 773 }
 774
 775 void WindowManager::emit_syncdraw(char const *label, char const *area, int x, int y, int w, int h)
 776 {
 777     this->send_event(kListEventName[Event_SyncDraw], label, area, x, y, w, h);
 778 }
 779
 780 void WindowManager::emit_syncdraw(const std::string &role, const std::string &area)
 781 {
 782     compositor::rect rect = this->layers.getAreaSize(area);
 783     this->send_event(kListEventName[Event_SyncDraw],
 784         role.c_str(), area.c_str(), rect.x, rect.y, rect.w, rect.h);
 785 }
 786
 787 void WindowManager::emit_flushdraw(char const *label)
 788 {
 789     this->send_event(kListEventName[Event_FlushDraw], label);
 790 }
 791
 792 void WindowManager::emit_visible(char const *label, bool is_visible)
 793 {
 794     this->send_event(is_visible ? kListEventName[Event_Visible] : kListEventName[Event_Invisible], label);
 795 }
 796
 797 void WindowManager::emit_invisible(char const *label)
 798 {
 799     return emit_visible(label, false);
 800 }
 801
 802 void WindowManager::emit_visible(char const *label) { return emit_visible(label, true); }
 803
 804 void WindowManager::activate(int id)
 805 {
 806     auto ip = this->controller->sprops.find(id);
 807     if (ip != this->controller->sprops.end())
 808     {
 809         this->controller->surfaces[id]->set_visibility(1);
 810         char const *label =
 811             this->lookup_name(id).value_or("unknown-name").c_str();
 812
 813          // FOR CES DEMO >>>
 814         if ((0 == strcmp(label, "radio")) ||
 815             (0 == strcmp(label, "music")) ||
 816             (0 == strcmp(label, "video")) ||
 817             (0 == strcmp(label, "map")))
 818         {
 819             for (auto i = surface_bg.begin(); i != surface_bg.end(); ++i)
 820             {
 821                 if (id == *i)
 822                 {
 823                     // Remove id
 824                     this->surface_bg.erase(i);
 825
 826                     // Remove from BG layer (999)
 827                     HMI_DEBUG("wm", "Remove %s(%d) from BG layer", label, id);
 828                     this->controller->layers[999]->remove_surface(id);
 829
 830                     // Add to FG layer (1001)
 831                     HMI_DEBUG("wm", "Add %s(%d) to FG layer", label, id);
 832                     this->controller->layers[1001]->add_surface(id);
 833
 834                     for (int j : this->surface_bg)
 835                     {
 836                         HMI_DEBUG("wm", "Stored id:%d", j);
 837                     }
 838                     break;
 839                 }
 840             }
 841         }
 842         // <<< FOR CES DEMO
 843
 844         this->layout_commit();
 845
 846         // TODO: application requests by old role,
 847         //       so convert role new to old for emitting event
 848         const char* old_role = this->rolenew2old[label].c_str();
 849
 850         this->emit_visible(old_role);
 851         this->emit_activated(old_role);
 852     }
 853 }
 854
 855 void WindowManager::deactivate(int id)
 856 {
 857     auto ip = this->controller->sprops.find(id);
 858     if (ip != this->controller->sprops.end())
 859     {
 860         char const *label =
 861             this->lookup_name(id).value_or("unknown-name").c_str();
 862
 863         // FOR CES DEMO >>>
 864         if ((0 == strcmp(label, "radio")) ||
 865             (0 == strcmp(label, "music")) ||
 866             (0 == strcmp(label, "video")) ||
 867             (0 == strcmp(label, "map")))
 868         {
 869
 870             // Store id
 871             this->surface_bg.push_back(id);
 872
 873             // Remove from FG layer (1001)
 874             HMI_DEBUG("wm", "Remove %s(%d) from FG layer", label, id);
 875             this->controller->layers[1001]->remove_surface(id);
 876
 877             // Add to BG layer (999)
 878             HMI_DEBUG("wm", "Add %s(%d) to BG layer", label, id);
 879             this->controller->layers[999]->add_surface(id);
 880
 881             for (int j : surface_bg)
 882             {
 883                 HMI_DEBUG("wm", "Stored id:%d", j);
 884             }
 885         }
 886         else
 887         {
 888             this->controller->surfaces[id]->set_visibility(0);
 889         }
 890         // <<< FOR CES DEMO
 891
 892         this->layout_commit();
 893
 894         // TODO: application requests by old role,
 895         //       so convert role new to old for emitting event
 896         const char* old_role = this->rolenew2old[label].c_str();
 897
 898         this->emit_deactivated(old_role);
 899         this->emit_invisible(old_role);
 900     }
 901 }
 902
 903 WMError WindowManager::setRequest(const std::string& appid, const std::string &role, const std::string &area,
 904                             Task task, unsigned* req_num)
 905 {
 906     if (!g_app_list.contains(appid))
 907     {
 908         return WMError::NOT_REGISTERED;
 909     }
 910
 911     auto client = g_app_list.lookUpClient(appid);
 912
 913     /*
 914      * Queueing Phase
 915      */
 916     unsigned current = g_app_list.currentRequestNumber();
 917     unsigned requested_num = g_app_list.getRequestNumber(appid);
 918     if (requested_num != 0)
 919     {
 920         HMI_SEQ_INFO(requested_num,
 921             "%s %s %s request is already queued", appid.c_str(), role.c_str(), area.c_str());
 922         return REQ_REJECTED;
 923     }
 924
 925     WMRequest req = WMRequest(appid, role, area, task);
 926     unsigned new_req = g_app_list.addRequest(req);
 927     *req_num = new_req;
 928     g_app_list.reqDump();
 929
 930     HMI_SEQ_DEBUG(current, "%s start sequence with %s, %s", appid.c_str(), role.c_str(), area.c_str());
 931
 932     return WMError::SUCCESS;
 933 }
 934
 935 WMError WindowManager::doTransition(unsigned req_num)
 936 {
 937     HMI_SEQ_DEBUG(req_num, "check policy");
 938     WMError ret = this->checkPolicy(req_num);
 939     if (ret != WMError::SUCCESS)
 940     {
 941         return ret;
 942     }
 943     HMI_SEQ_DEBUG(req_num, "Start transition.");
 944     ret = this->startTransition(req_num);
 945     return ret;
 946 }
 947
 948 WMError WindowManager::checkPolicy(unsigned req_num)
 949 {
 950     /*
 951     * Check Policy
 952     */
 953     // get current trigger
 954     bool found = false;
 955     bool split = false;
 956     WMError ret = WMError::LAYOUT_CHANGE_FAIL;
 957     auto trigger = g_app_list.getRequest(req_num, &found);
 958     if (!found)
 959     {
 960         ret = WMError::NO_ENTRY;
 961         return ret;
 962     }
 963     std::string req_area = trigger.area;
 964
 965     // >>>> Compatible with current window manager until policy manager coming
 966     if (trigger.task == Task::TASK_ALLOCATE)
 967     {
 968         HMI_SEQ_DEBUG(req_num, "Check split or not");
 969         const char *msg = this->check_surface_exist(trigger.role.c_str());
 970
 971         if (msg)
 972         {
 973             HMI_SEQ_ERROR(req_num, msg);
 974             ret = WMError::LAYOUT_CHANGE_FAIL;
 975             return ret;
 976         }
 977
 978         auto const &surface_id = this->lookup_id(trigger.role.c_str());
 979         auto o_state = *this->layers.get_layout_state(*surface_id);
 980         struct LayoutState &state = *o_state;
 981
 982         unsigned curernt_sid = state.main;
 983         split = this->can_split(state, *surface_id);
 984
 985         if (split)
 986         {
 987             HMI_SEQ_DEBUG(req_num, "Split happens");
 988             // Get current visible role
 989             std::string add_role = this->lookup_name(state.main).value();
 990             // Set next area
 991             std::string add_area = std::string(kNameLayoutSplit) + "." + std::string(kNameAreaMain);
 992             // Change request area
 993             req_area = std::string(kNameLayoutSplit) + "." + std::string(kNameAreaSub);
 994             HMI_SEQ_NOTICE(req_num, "Change request area from %s to %s, because split happens",
 995                                 trigger.area.c_str(), req_area.c_str());
 996             // set another action
 997             std::string add_name = g_app_list.getAppID(curernt_sid, add_role, &found);
 998             if (!found)
 999             {
1000                 HMI_SEQ_ERROR(req_num, "Couldn't widhdraw with surfaceID : %d", curernt_sid);
1001                 ret = WMError::NOT_REGISTERED;
1002                 return ret;
1003             }
1004             HMI_SEQ_INFO(req_num, "Additional split app %s, role: %s, area: %s",
1005                          add_name.c_str(), add_role.c_str(), add_area.c_str());
1006             // Set split action
1007             bool end_draw_finished = false;
1008             WMAction split_action{
1009                 add_name,
1010                 add_role,
1011                 add_area,
1012                 TaskVisible::VISIBLE,
1013                 end_draw_finished};
1014             WMError ret = g_app_list.setAction(req_num, split_action);
1015             if (ret != WMError::SUCCESS)
1016             {
1017                 HMI_SEQ_ERROR(req_num, "Failed to set action");
1018                 return ret;
1019             }
1020             g_app_list.reqDump();
1021         }
1022     }
1023     else
1024     {
1025         HMI_SEQ_DEBUG(req_num, "split doesn't happen");
1026     }
1027
1028     // Set invisible task(Remove if policy manager finish)
1029     ret = this->setInvisibleTask(trigger.role, split);
1030     if(ret != WMError::SUCCESS)
1031     {
1032         HMI_SEQ_ERROR(req_num, "Failed to set invisible task: %s", errorDescription(ret));
1033         return ret;
1034     }
1035
1036     /*  get new status from Policy Manager */
1037     HMI_SEQ_NOTICE(req_num, "ATM, Policy manager does't exist, then set WMAction as is");
1038     if(trigger.role == "homescreen")
1039     {
1040         // TODO : Remove when Policy Manager completed
1041         HMI_SEQ_NOTICE(req_num, "Hack. This process will be removed. Change HomeScreen code!!");
1042         req_area = "fullscreen";
1043     }
1044     TaskVisible task_visible =
1045         (trigger.task == Task::TASK_ALLOCATE) ? TaskVisible::VISIBLE : TaskVisible::INVISIBLE;
1046
1047     ret = g_app_list.setAction(req_num, trigger.appid, trigger.role, req_area, task_visible);
1048     g_app_list.reqDump();
1049
1050     return ret;
1051 }
1052
1053 WMError WindowManager::startTransition(unsigned req_num)
1054 {
1055     bool sync_draw_happen = false;
1056     bool found = false;
1057     WMError ret = WMError::SUCCESS;
1058     auto actions = g_app_list.getActions(req_num, &found);
1059     if (!found)
1060     {
1061         ret = WMError::NO_ENTRY;
1062         HMI_SEQ_ERROR(req_num,
1063             "Window Manager bug :%s : Action is not set", errorDescription(ret));
1064         return ret;
1065     }
1066
1067     for (const auto &action : actions)
1068     {
1069         if (action.visible != TaskVisible::INVISIBLE)
1070         {
1071             sync_draw_happen = true;
1072
1073             // TODO: application requests by old role,
1074             //       so convert role new to old for emitting event
1075             std::string old_role = this->rolenew2old[action.role];
1076
1077             this->emit_syncdraw(old_role, action.area);
1078             /* TODO: emit event for app not subscriber
1079             if(g_app_list.contains(y.appid))
1080                 g_app_list.lookUpClient(y.appid)->emit_syncdraw(y.role, y.area); */
1081         }
1082     }
1083
1084     if (sync_draw_happen)
1085     {
1086         this->setTimer();
1087     }
1088     else
1089     {
1090         // deactivate only, no syncDraw
1091         // Make it deactivate here
1092         for (const auto &x : actions)
1093         {
1094             if (g_app_list.contains(x.appid))
1095             {
1096                 auto client = g_app_list.lookUpClient(x.appid);
1097                 this->deactivate(client->surfaceID(x.role));
1098             }
1099         }
1100         ret = NO_LAYOUT_CHANGE;
1101     }
1102     return ret;
1103 }
1104
1105 WMError WindowManager::setInvisibleTask(const std::string &role, bool split)
1106 {
1107     unsigned req_num = g_app_list.currentRequestNumber();
1108     HMI_SEQ_DEBUG(req_num, "set current visible app to invisible task");
1109     bool found = false;
1110     auto trigger = g_app_list.getRequest(req_num, &found);
1111     // I don't check found == true here because this is checked in caller.
1112     if(trigger.role == "homescreen")
1113     {
1114         HMI_SEQ_INFO(req_num, "In case of 'homescreen' visible, don't change app to invisible");
1115         return WMError::SUCCESS;
1116     }
1117
1118     // This task is copied from original actiavete surface
1119     const char *drawing_name = this->rolenew2old[role].c_str();
1120     auto const &surface_id = this->lookup_id(role.c_str());
1121     auto layer_id = this->layers.get_layer_id(*surface_id);
1122     auto o_state = *this->layers.get_layout_state(*surface_id);
1123     struct LayoutState &state = *o_state;
1124     std::string add_name, add_role;
1125     std::string add_area = "";
1126     int surface;
1127     TaskVisible task_visible = TaskVisible::INVISIBLE;
1128     bool end_draw_finished = true;
1129
1130     for (auto const &l : this->layers.mapping)
1131     {
1132         if (l.second.layer_id <= *layer_id)
1133         {
1134             continue;
1135         }
1136         HMI_DEBUG("wm", "debug: main %d , sub : %d", l.second.state.main, l.second.state.sub);
1137         if (l.second.state.main != -1)
1138         {
1139             //this->deactivate(l.second.state.main);
1140             surface = l.second.state.main;
1141             add_role = *this->id_alloc.lookup(surface);
1142             add_name = g_app_list.getAppID(surface, add_role, &found);
1143             if(!found){
1144                 return WMError::NOT_REGISTERED;
1145             }
1146             HMI_SEQ_INFO(req_num, "Invisible %s", add_name.c_str());
1147             WMAction act{add_name, add_role, add_area, task_visible, end_draw_finished};
1148             g_app_list.setAction(req_num, act);
1149             l.second.state.main = -1;
1150         }
1151
1152         if (l.second.state.sub != -1)
1153         {
1154             //this->deactivate(l.second.state.sub);
1155             surface = l.second.state.sub;
1156             add_role = *this->id_alloc.lookup(surface);
1157             add_name = g_app_list.getAppID(surface, add_role, &found);
1158             if (!found)
1159             {
1160                 return WMError::NOT_REGISTERED;
1161             }
1162             HMI_SEQ_INFO(req_num, "Invisible %s", add_name.c_str());
1163             WMAction act{add_name, add_role, add_area, task_visible, end_draw_finished};
1164             g_app_list.setAction(req_num, act);
1165             l.second.state.sub = -1;
1166         }
1167     }
1168
1169     // change current state here, but this is hack
1170     auto layer = this->layers.get_layer(*layer_id);
1171
1172     if (state.main == -1)
1173     {
1174         HMI_DEBUG("wm", "Layout: %s", kNameLayoutNormal);
1175     }
1176     else
1177     {
1178         if (0 != strcmp(drawing_name, "HomeScreen"))
1179         {
1180             if (split)
1181             {
1182                 if (state.sub != *surface_id)
1183                 {
1184                     if (state.sub != -1)
1185                     {
1186                         //this->deactivate(state.sub);
1187                         WMAction deact_sub;
1188                         deact_sub.role =
1189                             std::move(*this->id_alloc.lookup(state.sub));
1190                         deact_sub.area = add_area;
1191                         deact_sub.appid = g_app_list.getAppID(state.sub, deact_sub.role, &found);
1192                         if (!found)
1193                         {
1194                             HMI_SEQ_ERROR(req_num, "App doesn't exist for role : %s",
1195                                             deact_sub.role.c_str());
1196                             return WMError::NOT_REGISTERED;
1197                         }
1198                         deact_sub.visible = task_visible;
1199                         deact_sub.end_draw_finished = end_draw_finished;
1200                         HMI_SEQ_DEBUG(req_num, "Set invisible task for %s", deact_sub.appid.c_str());
1201                         g_app_list.setAction(req_num, deact_sub);
1202                     }
1203                 }
1204                 //state = LayoutState{state.main, *surface_id};
1205             }
1206             else
1207             {
1208                 HMI_DEBUG("wm", "Layout: %s", kNameLayoutNormal);
1209
1210                 //this->surface_set_layout(*surface_id);
1211                 if (state.main != *surface_id)
1212                 {
1213                     // this->deactivate(state.main);
1214                     WMAction deact_main;
1215                     deact_main.role = std::move(*this->id_alloc.lookup(state.main));
1216                     ;
1217                     deact_main.area = add_area;
1218                     deact_main.appid = g_app_list.getAppID(state.main, deact_main.role, &found);
1219                     if (!found)
1220                     {
1221                         HMI_SEQ_DEBUG(req_num, "sub surface ddoesn't exist");
1222                         return WMError::NOT_REGISTERED;
1223                     }
1224                     deact_main.visible = task_visible;
1225                     deact_main.end_draw_finished = end_draw_finished;
1226                     HMI_SEQ_DEBUG(req_num, "sub surface doesn't exist");
1227                     g_app_list.setAction(req_num, deact_main);
1228                 }
1229                 if (state.sub != -1)
1230                 {
1231                     if (state.sub != *surface_id)
1232                     {
1233                         //this->deactivate(state.sub);
1234                         WMAction deact_sub;
1235                         deact_sub.role = std::move(*this->id_alloc.lookup(state.sub));
1236                         ;
1237                         deact_sub.area = add_area;
1238                         deact_sub.appid = g_app_list.getAppID(state.sub, deact_sub.role, &found);
1239                         if (!found)
1240                         {
1241                             HMI_SEQ_DEBUG(req_num, "sub surface ddoesn't exist");
1242                             return WMError::NOT_REGISTERED;
1243                         }
1244                         deact_sub.visible = task_visible;
1245                         deact_sub.end_draw_finished = end_draw_finished;
1246                         HMI_SEQ_DEBUG(req_num, "sub surface doesn't exist");
1247                         g_app_list.setAction(req_num, deact_sub);
1248                     }
1249                 }
1250                 //state = LayoutState{*surface_id};
1251             }
1252         }
1253     }
1254     return WMError::SUCCESS;
1255 }
1256
1257 WMError WindowManager::doEndDraw(unsigned req_num)
1258 {
1259     // get actions
1260     bool found;
1261     auto actions = g_app_list.getActions(req_num, &found);
1262     WMError ret = WMError::SUCCESS;
1263     if (!found)
1264     {
1265         ret = WMError::NO_ENTRY;
1266         return ret;
1267     }
1268
1269     HMI_SEQ_INFO(req_num, "do endDraw");
1270
1271     // layout change and make it visible
1272     for (const auto &act : actions)
1273     {
1274         // layout change
1275         if(!g_app_list.contains(act.appid)){
1276             ret = WMError::NOT_REGISTERED;
1277         }
1278         ret = this->layoutChange(act);
1279         if(ret != WMError::SUCCESS)
1280         {
1281             HMI_SEQ_WARNING(req_num,
1282                 "Failed to manipulate surfaces while state change : %s", errorDescription(ret));
1283             return ret;
1284         }
1285         ret = this->visibilityChange(act);
1286         if (ret != WMError::SUCCESS)
1287         {
1288             HMI_SEQ_WARNING(req_num,
1289                 "Failed to manipulate surfaces while state change : %s", errorDescription(ret));
1290             return ret;
1291         }
1292         HMI_SEQ_DEBUG(req_num, "visible %s", act.role.c_str());
1293         //this->lm_enddraw(act.role.c_str());
1294     }
1295
1296     // Change current state
1297     this->changeCurrentState(req_num);
1298
1299     HMI_SEQ_INFO(req_num, "emit flushDraw");
1300
1301     for(const auto &act_flush : actions)
1302     {
1303         if(act_flush.visible != TaskVisible::INVISIBLE)
1304         {
1305             // TODO: application requests by old role,
1306             //       so convert role new to old for emitting event
1307             std::string old_role = this->rolenew2old[act_flush.role];
1308
1309             this->emit_flushdraw(old_role.c_str());
1310         }
1311     }
1312
1313     return ret;
1314 }
1315
1316 WMError WindowManager::layoutChange(const WMAction &action)
1317 {
1318     if (action.visible == TaskVisible::INVISIBLE)
1319     {
1320         // Visibility is not change -> no redraw is required
1321         return WMError::SUCCESS;
1322     }
1323     auto client = g_app_list.lookUpClient(action.appid);
1324     unsigned surface = client->surfaceID(action.role);
1325     if (surface == 0)
1326     {
1327         HMI_SEQ_ERROR(g_app_list.currentRequestNumber(),
1328                       "client doesn't have surface with role(%s)", action.role.c_str());
1329         return WMError::NOT_REGISTERED;
1330     }
1331     // Layout Manager
1332     WMError ret = this->setSurfaceSize(surface, action.area);
1333     return ret;
1334 }
1335
1336 WMError WindowManager::visibilityChange(const WMAction &action)
1337 {
1338     HMI_SEQ_DEBUG(g_app_list.currentRequestNumber(), "Change visibility");
1339     if(!g_app_list.contains(action.appid)){
1340         return WMError::NOT_REGISTERED;
1341     }
1342     auto client = g_app_list.lookUpClient(action.appid);
1343     unsigned surface = client->surfaceID(action.role);
1344     if(surface == 0)
1345     {
1346         HMI_SEQ_ERROR(g_app_list.currentRequestNumber(),
1347                       "client doesn't have surface with role(%s)", action.role.c_str());
1348         return WMError::NOT_REGISTERED;
1349     }
1350
1351     if (action.visible != TaskVisible::INVISIBLE)
1352     {
1353         this->activate(surface); // Layout Manager task
1354     }
1355     else
1356     {
1357         this->deactivate(surface); // Layout Manager task
1358     }
1359     return WMError::SUCCESS;
1360 }
1361
1362 WMError WindowManager::setSurfaceSize(unsigned surface, const std::string &area)
1363 {
1364     this->surface_set_layout(surface, area);
1365
1366     return WMError::SUCCESS;
1367 }
1368
1369 WMError WindowManager::changeCurrentState(unsigned req_num)
1370 {
1371     HMI_SEQ_DEBUG(req_num, "Change current layout state");
1372     bool trigger_found = false, action_found = false;
1373     auto trigger = g_app_list.getRequest(req_num, &trigger_found);
1374     auto actions = g_app_list.getActions(req_num, &action_found);
1375     if (!trigger_found || !action_found)
1376     {
1377         HMI_SEQ_ERROR(req_num, "Action not found");
1378         return WMError::LAYOUT_CHANGE_FAIL;
1379     }
1380
1381     // Layout state reset
1382     struct LayoutState reset_state{-1, -1};
1383     HMI_SEQ_DEBUG(req_num,"Reset layout state");
1384     for (const auto &action : actions)
1385     {
1386         if(!g_app_list.contains(action.appid)){
1387             return WMError::NOT_REGISTERED;
1388         }
1389         auto client = g_app_list.lookUpClient(action.appid);
1390         auto pCurState = *this->layers.get_layout_state((int)client->surfaceID(action.role));
1391         if(pCurState == nullptr)
1392         {
1393             HMI_SEQ_ERROR(req_num, "Counldn't find current status");
1394             continue;
1395         }
1396         pCurState->main = reset_state.main;
1397         pCurState->sub = reset_state.sub;
1398     }
1399
1400     HMI_SEQ_DEBUG(req_num, "Change state");
1401     for (const auto &action : actions)
1402     {
1403         auto client = g_app_list.lookUpClient(action.appid);
1404         auto pLayerCurState = *this->layers.get_layout_state((int)client->surfaceID(action.role));
1405         if (pLayerCurState == nullptr)
1406         {
1407             HMI_SEQ_ERROR(req_num, "Counldn't find current status");
1408             continue;
1409         }
1410         int surface = -1;
1411
1412         if (action.visible != TaskVisible::INVISIBLE)
1413         {
1414             surface = (int)client->surfaceID(action.role);
1415             HMI_SEQ_INFO(req_num, "Change %s surface : %d, state visible area : %s",
1416                             action.role.c_str(), surface, action.area.c_str());
1417             // visible == true -> layout changes
1418             if(action.area == "normal.full" || action.area == "split.main")
1419             {
1420                 pLayerCurState->main = surface;
1421             }
1422             else if (action.area == "split.sub")
1423             {
1424                 pLayerCurState->sub = surface;
1425             }
1426             else
1427             {
1428                 // normalfull
1429                 pLayerCurState->main = surface;
1430             }
1431         }
1432     }
1433
1434     return WMError::SUCCESS;
1435 }
1436
1437 void WindowManager::emitScreenUpdated(unsigned req_num)
1438 {
1439     // Get visible apps
1440     HMI_SEQ_DEBUG(req_num, "emit screen updated");
1441     bool found = false;
1442     auto actions = g_app_list.getActions(req_num, &found);
1443
1444     // create json object
1445     json_object *j = json_object_new_object();
1446     json_object *jarray = json_object_new_array();
1447
1448     for(const auto& action: actions)
1449     {
1450         if(action.visible != TaskVisible::INVISIBLE)
1451         {
1452             json_object_array_add(jarray, json_object_new_string(action.appid.c_str()));
1453         }
1454     }
1455     json_object_object_add(j, kKeyIds, jarray);
1456     HMI_SEQ_INFO(req_num, "Visible app: %s", json_object_get_string(j));
1457
1458     int ret = afb_event_push(
1459         this->map_afb_event[kListEventName[Event_ScreenUpdated]], j);
1460     if (ret != 0)
1461     {
1462         HMI_DEBUG("wm", "afb_event_push failed: %m");
1463     }
1464 }
1465
1466 void WindowManager::setTimer()
1467 {
1468     struct timespec ts;
1469     if (clock_gettime(CLOCK_BOOTTIME, &ts) != 0) {
1470         HMI_ERROR("wm", "Could't set time (clock_gettime() returns with error");
1471         return;
1472     }
1473
1474     HMI_SEQ_DEBUG(g_app_list.currentRequestNumber(), "Timer set activate");
1475     if (g_timer_ev_src == nullptr)
1476     {
1477         // firsttime set into sd_event
1478         int ret = sd_event_add_time(afb_daemon_get_event_loop(), &g_timer_ev_src,
1479             CLOCK_BOOTTIME, (uint64_t)(ts.tv_sec + kTimeOut) * 1000000ULL, 1, processTimerHandler, this);
1480         if (ret < 0)
1481         {
1482             HMI_ERROR("wm", "Could't set timer");
1483         }
1484     }
1485     else
1486     {
1487         // update timer limitation after second time
1488         sd_event_source_set_time(g_timer_ev_src, (uint64_t)(ts.tv_sec + kTimeOut) * 1000000ULL);
1489         sd_event_source_set_enabled(g_timer_ev_src, SD_EVENT_ONESHOT);
1490     }
1491 }
1492
1493 void WindowManager::stopTimer()
1494 {
1495     unsigned req_num = g_app_list.currentRequestNumber();
1496     HMI_SEQ_DEBUG(req_num, "Timer stop");
1497     int rc = sd_event_source_set_enabled(g_timer_ev_src, SD_EVENT_OFF);
1498     if (rc < 0)
1499     {
1500         HMI_SEQ_ERROR(req_num, "Timer stop failed");
1501     }
1502 }
1503
1504 void WindowManager::processNextRequest()
1505 {
1506     g_app_list.next();
1507     g_app_list.reqDump();
1508     unsigned req_num = g_app_list.currentRequestNumber();
1509     if (g_app_list.haveRequest())
1510     {
1511         HMI_SEQ_DEBUG(req_num, "Process next request");
1512         WMError rc = doTransition(req_num);
1513         if (rc != WMError::SUCCESS)
1514         {
1515             HMI_SEQ_ERROR(req_num, errorDescription(rc));
1516         }
1517     }
1518     else
1519     {
1520         HMI_SEQ_DEBUG(req_num, "Nothing Request. Waiting Request");
1521     }
1522 }
1523
1524 const char* WindowManager::convertRoleOldToNew(char const *old_role)
1525 {
1526     const char *new_role = nullptr;
1527
1528     for (auto const &on : this->roleold2new)
1529     {
1530         std::regex regex = std::regex(on.first);
1531         if (std::regex_match(old_role, regex))
1532         {
1533             // role is old. So convert to new.
1534             new_role = on.second.c_str();
1535             break;
1536         }
1537     }
1538
1539     if (nullptr == new_role)
1540     {
1541         // role is new or fallback.
1542         new_role = old_role;
1543     }
1544
1545     HMI_DEBUG("wm", "old:%s -> new:%s", old_role, new_role);
1546
1547     return new_role;
1548 }
1549
1550 int WindowManager::loadOldRoleDb()
1551 {
1552     // Get afm application installed dir
1553     char const *afm_app_install_dir = getenv("AFM_APP_INSTALL_DIR");
1554     HMI_DEBUG("wm", "afm_app_install_dir:%s", afm_app_install_dir);
1555
1556     std::string file_name;
1557     if (!afm_app_install_dir)
1558     {
1559         HMI_ERROR("wm", "AFM_APP_INSTALL_DIR is not defined");
1560     }
1561     else
1562     {
1563         file_name = std::string(afm_app_install_dir) + std::string("/etc/old_roles.db");
1564     }
1565
1566     // Load old_role.db
1567     json_object* json_obj;
1568     int ret = jh::inputJsonFilie(file_name.c_str(), &json_obj);
1569     if (0 > ret)
1570     {
1571         HMI_ERROR("wm", "Could not open old_role.db, so use default old_role information");
1572         json_obj = json_tokener_parse(kDefaultOldRoleDb);
1573     }
1574     HMI_DEBUG("wm", "json_obj dump:%s", json_object_get_string(json_obj));
1575
1576     // Perse apps
1577     json_object* json_cfg;
1578     if (!json_object_object_get_ex(json_obj, "old_roles", &json_cfg))
1579     {
1580         HMI_ERROR("wm", "Parse Error!!");
1581         return -1;
1582     }
1583
1584     int len = json_object_array_length(json_cfg);
1585     HMI_DEBUG("wm", "json_cfg len:%d", len);
1586     HMI_DEBUG("wm", "json_cfg dump:%s", json_object_get_string(json_cfg));
1587
1588     for (int i=0; i<len; i++)
1589     {
1590         json_object* json_tmp = json_object_array_get_idx(json_cfg, i);
1591
1592         const char* old_role = jh::getStringFromJson(json_tmp, "name");
1593         if (nullptr == old_role)
1594         {
1595             HMI_ERROR("wm", "Parse Error!!");
1596             return -1;
1597         }
1598
1599         const char* new_role = jh::getStringFromJson(json_tmp, "new");
1600         if (nullptr == new_role)
1601         {
1602             HMI_ERROR("wm", "Parse Error!!");
1603             return -1;
1604         }
1605
1606         this->roleold2new[old_role] = std::string(new_role);
1607     }
1608
1609     // Check
1610     for(auto itr = this->roleold2new.begin();
1611       itr != this->roleold2new.end(); ++itr)
1612     {
1613         HMI_DEBUG("wm", ">>> role old:%s new:%s",
1614                   itr->first.c_str(), itr->second.c_str());
1615     }
1616
1617     // Release json_object
1618     json_object_put(json_obj);
1619
1620     return 0;
1621 }
1622
1623 const char *WindowManager::check_surface_exist(const char *drawing_name)
1624 {
1625     auto const &surface_id = this->lookup_id(drawing_name);
1626     if (!surface_id)
1627     {
1628         return "Surface does not exist";
1629     }
1630
1631     if (!this->controller->surface_exists(*surface_id))
1632     {
1633         return "Surface does not exist in controller!";
1634     }
1635
1636     auto layer_id = this->layers.get_layer_id(*surface_id);
1637
1638     if (!layer_id)
1639     {
1640         return "Surface is not on any layer!";
1641     }
1642
1643     auto o_state = *this->layers.get_layout_state(*surface_id);
1644
1645     if (o_state == nullptr)
1646     {
1647         return "Could not find layer for surface";
1648     }
1649
1650     HMI_DEBUG("wm", "surface %d is detected", *surface_id);
1651     return nullptr;
1652 }
1653
1654 bool WindowManager::can_split(struct LayoutState const &state, int new_id)
1655 {
1656     if (state.main != -1 && state.main != new_id)
1657     {
1658         auto new_id_layer = this->layers.get_layer_id(new_id).value();
1659         auto current_id_layer = this->layers.get_layer_id(state.main).value();
1660
1661         // surfaces are on separate layers, don't bother.
1662         if (new_id_layer != current_id_layer)
1663         {
1664             return false;
1665         }
1666
1667         std::string const &new_id_str = this->lookup_name(new_id).value();
1668         std::string const &cur_id_str = this->lookup_name(state.main).value();
1669
1670         auto const &layer = this->layers.get_layer(new_id_layer);
1671
1672         HMI_DEBUG("wm", "layer info name: %s", layer->name.c_str());
1673
1674         if (layer->layouts.empty())
1675         {
1676             return false;
1677         }
1678
1679         for (auto i = layer->layouts.cbegin(); i != layer->layouts.cend(); i++)
1680         {
1681             HMI_DEBUG("wm", "%d main_match '%s'", new_id_layer, i->main_match.c_str());
1682             auto rem = std::regex(i->main_match);
1683             if (std::regex_match(cur_id_str, rem))
1684             {
1685                 // build the second one only if the first already matched
1686                 HMI_DEBUG("wm", "%d sub_match '%s'", new_id_layer, i->sub_match.c_str());
1687                 auto res = std::regex(i->sub_match);
1688                 if (std::regex_match(new_id_str, res))
1689                 {
1690                     HMI_DEBUG("wm", "layout matched!");
1691                     return true;
1692                 }
1693             }
1694         }
1695     }
1696
1697     return false;
1698 }
1699
1700 const char* WindowManager::kDefaultOldRoleDb = "{ \
1701     \"old_roles\": [ \
1702         { \
1703             \"name\": \"HomeScreen\", \
1704             \"new\": \"homescreen\" \
1705         }, \
1706         { \
1707             \"name\": \"Music\", \
1708             \"new\": \"music\" \
1709         }, \
1710         { \
1711             \"name\": \"MediaPlayer\", \
1712             \"new\": \"music\" \
1713         }, \
1714         { \
1715             \"name\": \"Video\", \
1716             \"new\": \"video\" \
1717         }, \
1718         { \
1719             \"name\": \"VideoPlayer\", \
1720             \"new\": \"video\" \
1721         }, \
1722         { \
1723             \"name\": \"WebBrowser\", \
1724             \"new\": \"browser\" \
1725         }, \
1726         { \
1727             \"name\": \"Radio\", \
1728             \"new\": \"radio\" \
1729         }, \
1730         { \
1731             \"name\": \"Phone\", \
1732             \"new\": \"phone\" \
1733         }, \
1734         { \
1735             \"name\": \"Navigation\", \
1736             \"new\": \"map\" \
1737         }, \
1738         { \
1739             \"name\": \"HVAC\", \
1740             \"new\": \"hvac\" \
1741         }, \
1742         { \
1743             \"name\": \"Settings\", \
1744             \"new\": \"settings\" \
1745         }, \
1746         { \
1747             \"name\": \"Dashboard\", \
1748             \"new\": \"dashboard\" \
1749         }, \
1750         { \
1751             \"name\": \"POI\", \
1752             \"new\": \"poi\" \
1753         }, \
1754         { \
1755             \"name\": \"Mixer\", \
1756             \"new\": \"mixer\" \
1757         }, \
1758         { \
1759             \"name\": \"Restriction\", \
1760             \"new\": \"restriction\" \
1761         }, \
1762         { \
1763             \"name\": \"^OnScreen.*\", \
1764             \"new\": \"on_screen\" \
1765         } \
1766     ] \
1767 }";
1768
1769 /**
1770  * controller_hooks
1771  */
1772 void controller_hooks::surface_created(uint32_t surface_id)
1773 {
1774     this->app->surface_created(surface_id);
1775 }
1776
1777 void controller_hooks::surface_removed(uint32_t surface_id)
1778 {
1779     this->app->surface_removed(surface_id);
1780 }
1781
1782 void controller_hooks::surface_visibility(uint32_t /*surface_id*/,
1783                                           uint32_t /*v*/) {}
1784
1785 void controller_hooks::surface_destination_rectangle(uint32_t /*surface_id*/,
1786                                                      uint32_t /*x*/,
1787                                                      uint32_t /*y*/,
1788                                                      uint32_t /*w*/,
1789                                                      uint32_t /*h*/) {}
1790
1791 } // namespace wm