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.front()->proxy.get(),
 188                 wl_proxy_get_id(reinterpret_cast<struct wl_proxy *>(
 189                     this->outputs.front()->proxy.get())));
 190
 191             // Create screen
 192             this->controller->create_screen(this->outputs.front()->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     this->controller->get_surface_properties(surface_id, IVI_WM_PARAM_SIZE);
 578
 579     auto layer_id = this->layers.get_layer_id(surface_id);
 580     if (!layer_id)
 581     {
 582         HMI_DEBUG("wm", "Newly created surfce %d is not associated with any layer!",
 583                   surface_id);
 584         return;
 585     }
 586
 587     HMI_DEBUG("wm", "surface_id is %u, layer_id is %u", surface_id, *layer_id);
 588
 589     this->controller->layers[*layer_id]->add_surface(surface_id);
 590     this->layout_commit();
 591 }
 592
 593 void WindowManager::surface_removed(uint32_t surface_id)
 594 {
 595     HMI_DEBUG("wm", "surface_id is %u", surface_id);
 596     g_app_list.removeSurface(surface_id);
 597 }
 598
 599 void WindowManager::removeClient(const std::string &appid)
 600 {
 601     HMI_DEBUG("wm", "Remove clinet %s from list", appid.c_str());
 602     g_app_list.removeClient(appid);
 603 }
 604
 605 void WindowManager::exceptionProcessForTransition()
 606 {
 607     unsigned req_num = g_app_list.currentRequestNumber();
 608     HMI_SEQ_NOTICE(req_num, "Process exception handling for request. Remove current request %d", req_num);
 609     g_app_list.removeRequest(req_num);
 610     HMI_SEQ_NOTICE(g_app_list.currentRequestNumber(), "Process next request if exists");
 611     this->processNextRequest();
 612 }
 613
 614 void WindowManager::timerHandler()
 615 {
 616     unsigned req_num = g_app_list.currentRequestNumber();
 617     HMI_SEQ_DEBUG(req_num, "Timer expired remove Request");
 618     g_app_list.reqDump();
 619     g_app_list.removeRequest(req_num);
 620     this->processNextRequest();
 621 }
 622
 623 /*
 624  ******* Private Functions *******
 625  */
 626
 627 bool WindowManager::pop_pending_events()
 628 {
 629     bool x{true};
 630     return this->pending_events.compare_exchange_strong(
 631         x, false, std::memory_order_consume);
 632 }
 633
 634 optional<int> WindowManager::lookup_id(char const *name)
 635 {
 636     return this->id_alloc.lookup(std::string(name));
 637 }
 638 optional<std::string> WindowManager::lookup_name(int id)
 639 {
 640     return this->id_alloc.lookup(id);
 641 }
 642
 643 /**
 644  * init_layers()
 645  */
 646 int WindowManager::init_layers()
 647 {
 648     if (!this->controller)
 649     {
 650         HMI_ERROR("wm", "ivi_controller global not available");
 651         return -1;
 652     }
 653
 654     if (this->outputs.empty())
 655     {
 656         HMI_ERROR("wm", "no output was set up!");
 657         return -1;
 658     }
 659
 660     auto &c = this->controller;
 661
 662     auto &o = this->outputs.front();
 663     auto &s = c->screens.begin()->second;
 664     auto &layers = c->layers;
 665
 666     // Write output dimensions to ivi controller...
 667     c->output_size = compositor::size{uint32_t(o->width), uint32_t(o->height)};
 668     c->physical_size = compositor::size{uint32_t(o->physical_width),
 669                                         uint32_t(o->physical_height)};
 670
 671
 672     HMI_DEBUG("wm", "SCALING: screen (%dx%d), physical (%dx%d)",
 673               o->width, o->height, o->physical_width, o->physical_height);
 674
 675     this->layers.loadAreaDb();
 676
 677     const compositor::rect css_bg = this->layers.getAreaSize("fullscreen");
 678     rectangle dp_bg(o->width, o->height);
 679
 680     dp_bg.set_aspect(static_cast<double>(css_bg.w) / css_bg.h);
 681     dp_bg.fit(o->width, o->height);
 682     dp_bg.center(o->width, o->height);
 683     HMI_DEBUG("wm", "SCALING: CSS BG(%dx%d) -> DDP %dx%d,(%dx%d)",
 684               css_bg.w, css_bg.h, dp_bg.left(), dp_bg.top(), dp_bg.width(), dp_bg.height());
 685
 686     // Clear scene
 687     layers.clear();
 688
 689     // Clear screen
 690     s->clear();
 691
 692     // Quick and dirty setup of layers
 693     for (auto const &i : this->layers.mapping)
 694     {
 695         c->layer_create(i.second.layer_id, dp_bg.width(), dp_bg.height());
 696         auto &l = layers[i.second.layer_id];
 697         l->set_destination_rectangle(dp_bg.left(), dp_bg.top(), dp_bg.width(), dp_bg.height());
 698         l->set_visibility(1);
 699         HMI_DEBUG("wm", "Setting up layer %s (%d) for surface role match \"%s\"",
 700                   i.second.name.c_str(), i.second.layer_id, i.second.role.c_str());
 701     }
 702
 703     // Add layers to screen
 704     s->set_render_order(this->layers.layers);
 705
 706     this->layout_commit();
 707
 708     c->scale = static_cast<double>(dp_bg.height()) / css_bg.h;
 709     this->layers.setupArea(c->scale);
 710
 711     return 0;
 712 }
 713
 714 void WindowManager::surface_set_layout(int surface_id, const std::string& area)
 715 {
 716     if (!this->controller->surface_exists(surface_id))
 717     {
 718         HMI_ERROR("wm", "Surface %d does not exist", surface_id);
 719         return;
 720     }
 721
 722     auto o_layer_id = this->layers.get_layer_id(surface_id);
 723
 724     if (!o_layer_id)
 725     {
 726         HMI_ERROR("wm", "Surface %d is not associated with any layer!", surface_id);
 727         return;
 728     }
 729
 730     uint32_t layer_id = *o_layer_id;
 731
 732     auto const &layer = this->layers.get_layer(layer_id);
 733     auto rect = this->layers.getAreaSize(area);
 734     HMI_SEQ_DEBUG(g_app_list.currentRequestNumber(), "%s : x:%d y:%d w:%d h:%d", area.c_str(),
 735                     rect.x, rect.y, rect.w, rect.h);
 736     auto &s = this->controller->surfaces[surface_id];
 737
 738     int x = rect.x;
 739     int y = rect.y;
 740     int w = rect.w;
 741     int h = rect.h;
 742
 743     HMI_DEBUG("wm", "surface_set_layout for surface %u on layer %u", surface_id,
 744               layer_id);
 745
 746     // set destination to the display rectangle
 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         if (l.second.role == "homescreen")
1137         {
1138             continue;
1139         }
1140         HMI_DEBUG("wm", "debug: main %d , sub : %d", l.second.state.main, l.second.state.sub);
1141         if (l.second.state.main != -1)
1142         {
1143             //this->deactivate(l.second.state.main);
1144             surface = l.second.state.main;
1145             add_role = *this->id_alloc.lookup(surface);
1146             add_name = g_app_list.getAppID(surface, add_role, &found);
1147             if(!found){
1148                 return WMError::NOT_REGISTERED;
1149             }
1150             HMI_SEQ_INFO(req_num, "Invisible %s", add_name.c_str());
1151             WMAction act{add_name, add_role, add_area, task_visible, end_draw_finished};
1152             g_app_list.setAction(req_num, act);
1153             l.second.state.main = -1;
1154         }
1155
1156         if (l.second.state.sub != -1)
1157         {
1158             //this->deactivate(l.second.state.sub);
1159             surface = l.second.state.sub;
1160             add_role = *this->id_alloc.lookup(surface);
1161             add_name = g_app_list.getAppID(surface, add_role, &found);
1162             if (!found)
1163             {
1164                 return WMError::NOT_REGISTERED;
1165             }
1166             HMI_SEQ_INFO(req_num, "Invisible %s", add_name.c_str());
1167             WMAction act{add_name, add_role, add_area, task_visible, end_draw_finished};
1168             g_app_list.setAction(req_num, act);
1169             l.second.state.sub = -1;
1170         }
1171     }
1172
1173     // change current state here, but this is hack
1174     auto layer = this->layers.get_layer(*layer_id);
1175
1176     if (state.main == -1)
1177     {
1178         HMI_DEBUG("wm", "Layout: %s", kNameLayoutNormal);
1179     }
1180     else
1181     {
1182         if (0 != strcmp(drawing_name, "HomeScreen"))
1183         {
1184             if (split)
1185             {
1186                 if (state.sub != *surface_id)
1187                 {
1188                     if (state.sub != -1)
1189                     {
1190                         //this->deactivate(state.sub);
1191                         WMAction deact_sub;
1192                         deact_sub.role =
1193                             std::move(*this->id_alloc.lookup(state.sub));
1194                         deact_sub.area = add_area;
1195                         deact_sub.appid = g_app_list.getAppID(state.sub, deact_sub.role, &found);
1196                         if (!found)
1197                         {
1198                             HMI_SEQ_ERROR(req_num, "App doesn't exist for role : %s",
1199                                             deact_sub.role.c_str());
1200                             return WMError::NOT_REGISTERED;
1201                         }
1202                         deact_sub.visible = task_visible;
1203                         deact_sub.end_draw_finished = end_draw_finished;
1204                         HMI_SEQ_DEBUG(req_num, "Set invisible task for %s", deact_sub.appid.c_str());
1205                         g_app_list.setAction(req_num, deact_sub);
1206                     }
1207                 }
1208                 //state = LayoutState{state.main, *surface_id};
1209             }
1210             else
1211             {
1212                 HMI_DEBUG("wm", "Layout: %s", kNameLayoutNormal);
1213
1214                 //this->surface_set_layout(*surface_id);
1215                 if (state.main != *surface_id)
1216                 {
1217                     // this->deactivate(state.main);
1218                     WMAction deact_main;
1219                     deact_main.role = std::move(*this->id_alloc.lookup(state.main));
1220                     ;
1221                     deact_main.area = add_area;
1222                     deact_main.appid = g_app_list.getAppID(state.main, deact_main.role, &found);
1223                     if (!found)
1224                     {
1225                         HMI_SEQ_DEBUG(req_num, "sub surface ddoesn't exist");
1226                         return WMError::NOT_REGISTERED;
1227                     }
1228                     deact_main.visible = task_visible;
1229                     deact_main.end_draw_finished = end_draw_finished;
1230                     HMI_SEQ_DEBUG(req_num, "sub surface doesn't exist");
1231                     g_app_list.setAction(req_num, deact_main);
1232                 }
1233                 if (state.sub != -1)
1234                 {
1235                     if (state.sub != *surface_id)
1236                     {
1237                         //this->deactivate(state.sub);
1238                         WMAction deact_sub;
1239                         deact_sub.role = std::move(*this->id_alloc.lookup(state.sub));
1240                         ;
1241                         deact_sub.area = add_area;
1242                         deact_sub.appid = g_app_list.getAppID(state.sub, deact_sub.role, &found);
1243                         if (!found)
1244                         {
1245                             HMI_SEQ_DEBUG(req_num, "sub surface ddoesn't exist");
1246                             return WMError::NOT_REGISTERED;
1247                         }
1248                         deact_sub.visible = task_visible;
1249                         deact_sub.end_draw_finished = end_draw_finished;
1250                         HMI_SEQ_DEBUG(req_num, "sub surface doesn't exist");
1251                         g_app_list.setAction(req_num, deact_sub);
1252                     }
1253                 }
1254                 //state = LayoutState{*surface_id};
1255             }
1256         }
1257     }
1258     return WMError::SUCCESS;
1259 }
1260
1261 WMError WindowManager::doEndDraw(unsigned req_num)
1262 {
1263     // get actions
1264     bool found;
1265     auto actions = g_app_list.getActions(req_num, &found);
1266     WMError ret = WMError::SUCCESS;
1267     if (!found)
1268     {
1269         ret = WMError::NO_ENTRY;
1270         return ret;
1271     }
1272
1273     HMI_SEQ_INFO(req_num, "do endDraw");
1274
1275     // layout change and make it visible
1276     for (const auto &act : actions)
1277     {
1278         // layout change
1279         if(!g_app_list.contains(act.appid)){
1280             ret = WMError::NOT_REGISTERED;
1281         }
1282         ret = this->layoutChange(act);
1283         if(ret != WMError::SUCCESS)
1284         {
1285             HMI_SEQ_WARNING(req_num,
1286                 "Failed to manipulate surfaces while state change : %s", errorDescription(ret));
1287             return ret;
1288         }
1289         ret = this->visibilityChange(act);
1290         if (ret != WMError::SUCCESS)
1291         {
1292             HMI_SEQ_WARNING(req_num,
1293                 "Failed to manipulate surfaces while state change : %s", errorDescription(ret));
1294             return ret;
1295         }
1296         HMI_SEQ_DEBUG(req_num, "visible %s", act.role.c_str());
1297         //this->lm_enddraw(act.role.c_str());
1298     }
1299     this->layout_commit();
1300
1301     // Change current state
1302     this->changeCurrentState(req_num);
1303
1304     HMI_SEQ_INFO(req_num, "emit flushDraw");
1305
1306     for(const auto &act_flush : actions)
1307     {
1308         if(act_flush.visible != TaskVisible::INVISIBLE)
1309         {
1310             // TODO: application requests by old role,
1311             //       so convert role new to old for emitting event
1312             std::string old_role = this->rolenew2old[act_flush.role];
1313
1314             this->emit_flushdraw(old_role.c_str());
1315         }
1316     }
1317
1318     return ret;
1319 }
1320
1321 WMError WindowManager::layoutChange(const WMAction &action)
1322 {
1323     if (action.visible == TaskVisible::INVISIBLE)
1324     {
1325         // Visibility is not change -> no redraw is required
1326         return WMError::SUCCESS;
1327     }
1328     auto client = g_app_list.lookUpClient(action.appid);
1329     unsigned surface = client->surfaceID(action.role);
1330     if (surface == 0)
1331     {
1332         HMI_SEQ_ERROR(g_app_list.currentRequestNumber(),
1333                       "client doesn't have surface with role(%s)", action.role.c_str());
1334         return WMError::NOT_REGISTERED;
1335     }
1336     // Layout Manager
1337     WMError ret = this->setSurfaceSize(surface, action.area);
1338     return ret;
1339 }
1340
1341 WMError WindowManager::visibilityChange(const WMAction &action)
1342 {
1343     HMI_SEQ_DEBUG(g_app_list.currentRequestNumber(), "Change visibility");
1344     if(!g_app_list.contains(action.appid)){
1345         return WMError::NOT_REGISTERED;
1346     }
1347     auto client = g_app_list.lookUpClient(action.appid);
1348     unsigned surface = client->surfaceID(action.role);
1349     if(surface == 0)
1350     {
1351         HMI_SEQ_ERROR(g_app_list.currentRequestNumber(),
1352                       "client doesn't have surface with role(%s)", action.role.c_str());
1353         return WMError::NOT_REGISTERED;
1354     }
1355
1356     if (action.visible != TaskVisible::INVISIBLE)
1357     {
1358         this->activate(surface); // Layout Manager task
1359     }
1360     else
1361     {
1362         this->deactivate(surface); // Layout Manager task
1363     }
1364     return WMError::SUCCESS;
1365 }
1366
1367 WMError WindowManager::setSurfaceSize(unsigned surface, const std::string &area)
1368 {
1369     this->surface_set_layout(surface, area);
1370
1371     return WMError::SUCCESS;
1372 }
1373
1374 WMError WindowManager::changeCurrentState(unsigned req_num)
1375 {
1376     HMI_SEQ_DEBUG(req_num, "Change current layout state");
1377     bool trigger_found = false, action_found = false;
1378     auto trigger = g_app_list.getRequest(req_num, &trigger_found);
1379     auto actions = g_app_list.getActions(req_num, &action_found);
1380     if (!trigger_found || !action_found)
1381     {
1382         HMI_SEQ_ERROR(req_num, "Action not found");
1383         return WMError::LAYOUT_CHANGE_FAIL;
1384     }
1385
1386     // Layout state reset
1387     struct LayoutState reset_state{-1, -1};
1388     HMI_SEQ_DEBUG(req_num,"Reset layout state");
1389     for (const auto &action : actions)
1390     {
1391         if(!g_app_list.contains(action.appid)){
1392             return WMError::NOT_REGISTERED;
1393         }
1394         auto client = g_app_list.lookUpClient(action.appid);
1395         auto pCurState = *this->layers.get_layout_state((int)client->surfaceID(action.role));
1396         if(pCurState == nullptr)
1397         {
1398             HMI_SEQ_ERROR(req_num, "Counldn't find current status");
1399             continue;
1400         }
1401         pCurState->main = reset_state.main;
1402         pCurState->sub = reset_state.sub;
1403     }
1404
1405     HMI_SEQ_DEBUG(req_num, "Change state");
1406     for (const auto &action : actions)
1407     {
1408         auto client = g_app_list.lookUpClient(action.appid);
1409         auto pLayerCurState = *this->layers.get_layout_state((int)client->surfaceID(action.role));
1410         if (pLayerCurState == nullptr)
1411         {
1412             HMI_SEQ_ERROR(req_num, "Counldn't find current status");
1413             continue;
1414         }
1415         int surface = -1;
1416
1417         if (action.visible != TaskVisible::INVISIBLE)
1418         {
1419             surface = (int)client->surfaceID(action.role);
1420             HMI_SEQ_INFO(req_num, "Change %s surface : %d, state visible area : %s",
1421                             action.role.c_str(), surface, action.area.c_str());
1422             // visible == true -> layout changes
1423             if(action.area == "normal.full" || action.area == "split.main")
1424             {
1425                 pLayerCurState->main = surface;
1426             }
1427             else if (action.area == "split.sub")
1428             {
1429                 pLayerCurState->sub = surface;
1430             }
1431             else
1432             {
1433                 // normalfull
1434                 pLayerCurState->main = surface;
1435             }
1436         }
1437     }
1438
1439     return WMError::SUCCESS;
1440 }
1441
1442 void WindowManager::emitScreenUpdated(unsigned req_num)
1443 {
1444     // Get visible apps
1445     HMI_SEQ_DEBUG(req_num, "emit screen updated");
1446     bool found = false;
1447     auto actions = g_app_list.getActions(req_num, &found);
1448
1449     // create json object
1450     json_object *j = json_object_new_object();
1451     json_object *jarray = json_object_new_array();
1452
1453     for(const auto& action: actions)
1454     {
1455         if(action.visible != TaskVisible::INVISIBLE)
1456         {
1457             json_object_array_add(jarray, json_object_new_string(action.appid.c_str()));
1458         }
1459     }
1460     json_object_object_add(j, kKeyIds, jarray);
1461     HMI_SEQ_INFO(req_num, "Visible app: %s", json_object_get_string(j));
1462
1463     int ret = afb_event_push(
1464         this->map_afb_event[kListEventName[Event_ScreenUpdated]], j);
1465     if (ret != 0)
1466     {
1467         HMI_DEBUG("wm", "afb_event_push failed: %m");
1468     }
1469 }
1470
1471 void WindowManager::setTimer()
1472 {
1473     struct timespec ts;
1474     if (clock_gettime(CLOCK_BOOTTIME, &ts) != 0) {
1475         HMI_ERROR("wm", "Could't set time (clock_gettime() returns with error");
1476         return;
1477     }
1478
1479     HMI_SEQ_DEBUG(g_app_list.currentRequestNumber(), "Timer set activate");
1480     if (g_timer_ev_src == nullptr)
1481     {
1482         // firsttime set into sd_event
1483         int ret = sd_event_add_time(afb_daemon_get_event_loop(), &g_timer_ev_src,
1484             CLOCK_BOOTTIME, (uint64_t)(ts.tv_sec + kTimeOut) * 1000000ULL, 1, processTimerHandler, this);
1485         if (ret < 0)
1486         {
1487             HMI_ERROR("wm", "Could't set timer");
1488         }
1489     }
1490     else
1491     {
1492         // update timer limitation after second time
1493         sd_event_source_set_time(g_timer_ev_src, (uint64_t)(ts.tv_sec + kTimeOut) * 1000000ULL);
1494         sd_event_source_set_enabled(g_timer_ev_src, SD_EVENT_ONESHOT);
1495     }
1496 }
1497
1498 void WindowManager::stopTimer()
1499 {
1500     unsigned req_num = g_app_list.currentRequestNumber();
1501     HMI_SEQ_DEBUG(req_num, "Timer stop");
1502     int rc = sd_event_source_set_enabled(g_timer_ev_src, SD_EVENT_OFF);
1503     if (rc < 0)
1504     {
1505         HMI_SEQ_ERROR(req_num, "Timer stop failed");
1506     }
1507 }
1508
1509 void WindowManager::processNextRequest()
1510 {
1511     g_app_list.next();
1512     g_app_list.reqDump();
1513     unsigned req_num = g_app_list.currentRequestNumber();
1514     if (g_app_list.haveRequest())
1515     {
1516         HMI_SEQ_DEBUG(req_num, "Process next request");
1517         WMError rc = doTransition(req_num);
1518         if (rc != WMError::SUCCESS)
1519         {
1520             HMI_SEQ_ERROR(req_num, errorDescription(rc));
1521         }
1522     }
1523     else
1524     {
1525         HMI_SEQ_DEBUG(req_num, "Nothing Request. Waiting Request");
1526     }
1527 }
1528
1529 const char* WindowManager::convertRoleOldToNew(char const *old_role)
1530 {
1531     const char *new_role = nullptr;
1532
1533     for (auto const &on : this->roleold2new)
1534     {
1535         std::regex regex = std::regex(on.first);
1536         if (std::regex_match(old_role, regex))
1537         {
1538             // role is old. So convert to new.
1539             new_role = on.second.c_str();
1540             break;
1541         }
1542     }
1543
1544     if (nullptr == new_role)
1545     {
1546         // role is new or fallback.
1547         new_role = old_role;
1548     }
1549
1550     HMI_DEBUG("wm", "old:%s -> new:%s", old_role, new_role);
1551
1552     return new_role;
1553 }
1554
1555 int WindowManager::loadOldRoleDb()
1556 {
1557     // Get afm application installed dir
1558     char const *afm_app_install_dir = getenv("AFM_APP_INSTALL_DIR");
1559     HMI_DEBUG("wm", "afm_app_install_dir:%s", afm_app_install_dir);
1560
1561     std::string file_name;
1562     if (!afm_app_install_dir)
1563     {
1564         HMI_ERROR("wm", "AFM_APP_INSTALL_DIR is not defined");
1565     }
1566     else
1567     {
1568         file_name = std::string(afm_app_install_dir) + std::string("/etc/old_roles.db");
1569     }
1570
1571     // Load old_role.db
1572     json_object* json_obj;
1573     int ret = jh::inputJsonFilie(file_name.c_str(), &json_obj);
1574     if (0 > ret)
1575     {
1576         HMI_ERROR("wm", "Could not open old_role.db, so use default old_role information");
1577         json_obj = json_tokener_parse(kDefaultOldRoleDb);
1578     }
1579     HMI_DEBUG("wm", "json_obj dump:%s", json_object_get_string(json_obj));
1580
1581     // Perse apps
1582     json_object* json_cfg;
1583     if (!json_object_object_get_ex(json_obj, "old_roles", &json_cfg))
1584     {
1585         HMI_ERROR("wm", "Parse Error!!");
1586         return -1;
1587     }
1588
1589     int len = json_object_array_length(json_cfg);
1590     HMI_DEBUG("wm", "json_cfg len:%d", len);
1591     HMI_DEBUG("wm", "json_cfg dump:%s", json_object_get_string(json_cfg));
1592
1593     for (int i=0; i<len; i++)
1594     {
1595         json_object* json_tmp = json_object_array_get_idx(json_cfg, i);
1596
1597         const char* old_role = jh::getStringFromJson(json_tmp, "name");
1598         if (nullptr == old_role)
1599         {
1600             HMI_ERROR("wm", "Parse Error!!");
1601             return -1;
1602         }
1603
1604         const char* new_role = jh::getStringFromJson(json_tmp, "new");
1605         if (nullptr == new_role)
1606         {
1607             HMI_ERROR("wm", "Parse Error!!");
1608             return -1;
1609         }
1610
1611         this->roleold2new[old_role] = std::string(new_role);
1612     }
1613
1614     // Check
1615     for(auto itr = this->roleold2new.begin();
1616       itr != this->roleold2new.end(); ++itr)
1617     {
1618         HMI_DEBUG("wm", ">>> role old:%s new:%s",
1619                   itr->first.c_str(), itr->second.c_str());
1620     }
1621
1622     // Release json_object
1623     json_object_put(json_obj);
1624
1625     return 0;
1626 }
1627
1628 const char *WindowManager::check_surface_exist(const char *drawing_name)
1629 {
1630     auto const &surface_id = this->lookup_id(drawing_name);
1631     if (!surface_id)
1632     {
1633         return "Surface does not exist";
1634     }
1635
1636     if (!this->controller->surface_exists(*surface_id))
1637     {
1638         return "Surface does not exist in controller!";
1639     }
1640
1641     auto layer_id = this->layers.get_layer_id(*surface_id);
1642
1643     if (!layer_id)
1644     {
1645         return "Surface is not on any layer!";
1646     }
1647
1648     auto o_state = *this->layers.get_layout_state(*surface_id);
1649
1650     if (o_state == nullptr)
1651     {
1652         return "Could not find layer for surface";
1653     }
1654
1655     HMI_DEBUG("wm", "surface %d is detected", *surface_id);
1656     return nullptr;
1657 }
1658
1659 bool WindowManager::can_split(struct LayoutState const &state, int new_id)
1660 {
1661     if (state.main != -1 && state.main != new_id)
1662     {
1663         auto new_id_layer = this->layers.get_layer_id(new_id).value();
1664         auto current_id_layer = this->layers.get_layer_id(state.main).value();
1665
1666         // surfaces are on separate layers, don't bother.
1667         if (new_id_layer != current_id_layer)
1668         {
1669             return false;
1670         }
1671
1672         std::string const &new_id_str = this->lookup_name(new_id).value();
1673         std::string const &cur_id_str = this->lookup_name(state.main).value();
1674
1675         auto const &layer = this->layers.get_layer(new_id_layer);
1676
1677         HMI_DEBUG("wm", "layer info name: %s", layer->name.c_str());
1678
1679         if (layer->layouts.empty())
1680         {
1681             return false;
1682         }
1683
1684         for (auto i = layer->layouts.cbegin(); i != layer->layouts.cend(); i++)
1685         {
1686             HMI_DEBUG("wm", "%d main_match '%s'", new_id_layer, i->main_match.c_str());
1687             auto rem = std::regex(i->main_match);
1688             if (std::regex_match(cur_id_str, rem))
1689             {
1690                 // build the second one only if the first already matched
1691                 HMI_DEBUG("wm", "%d sub_match '%s'", new_id_layer, i->sub_match.c_str());
1692                 auto res = std::regex(i->sub_match);
1693                 if (std::regex_match(new_id_str, res))
1694                 {
1695                     HMI_DEBUG("wm", "layout matched!");
1696                     return true;
1697                 }
1698             }
1699         }
1700     }
1701
1702     return false;
1703 }
1704
1705 const char* WindowManager::kDefaultOldRoleDb = "{ \
1706     \"old_roles\": [ \
1707         { \
1708             \"name\": \"HomeScreen\", \
1709             \"new\": \"homescreen\" \
1710         }, \
1711         { \
1712             \"name\": \"Music\", \
1713             \"new\": \"music\" \
1714         }, \
1715         { \
1716             \"name\": \"MediaPlayer\", \
1717             \"new\": \"music\" \
1718         }, \
1719         { \
1720             \"name\": \"Video\", \
1721             \"new\": \"video\" \
1722         }, \
1723         { \
1724             \"name\": \"VideoPlayer\", \
1725             \"new\": \"video\" \
1726         }, \
1727         { \
1728             \"name\": \"WebBrowser\", \
1729             \"new\": \"browser\" \
1730         }, \
1731         { \
1732             \"name\": \"Radio\", \
1733             \"new\": \"radio\" \
1734         }, \
1735         { \
1736             \"name\": \"Phone\", \
1737             \"new\": \"phone\" \
1738         }, \
1739         { \
1740             \"name\": \"Navigation\", \
1741             \"new\": \"map\" \
1742         }, \
1743         { \
1744             \"name\": \"HVAC\", \
1745             \"new\": \"hvac\" \
1746         }, \
1747         { \
1748             \"name\": \"Settings\", \
1749             \"new\": \"settings\" \
1750         }, \
1751         { \
1752             \"name\": \"Dashboard\", \
1753             \"new\": \"dashboard\" \
1754         }, \
1755         { \
1756             \"name\": \"POI\", \
1757             \"new\": \"poi\" \
1758         }, \
1759         { \
1760             \"name\": \"Mixer\", \
1761             \"new\": \"mixer\" \
1762         }, \
1763         { \
1764             \"name\": \"Restriction\", \
1765             \"new\": \"restriction\" \
1766         }, \
1767         { \
1768             \"name\": \"^OnScreen.*\", \
1769             \"new\": \"on_screen\" \
1770         } \
1771     ] \
1772 }";
1773
1774 /**
1775  * controller_hooks
1776  */
1777 void controller_hooks::surface_created(uint32_t surface_id)
1778 {
1779     this->wmgr->surface_created(surface_id);
1780 }
1781
1782 void controller_hooks::surface_removed(uint32_t surface_id)
1783 {
1784     this->wmgr->surface_removed(surface_id);
1785 }
1786
1787 void controller_hooks::surface_visibility(uint32_t /*surface_id*/,
1788                                           uint32_t /*v*/) {}
1789
1790 void controller_hooks::surface_destination_rectangle(uint32_t /*surface_id*/,
1791                                                      uint32_t /*x*/,
1792                                                      uint32_t /*y*/,
1793                                                      uint32_t /*w*/,
1794                                                      uint32_t /*h*/) {}
1795
1796 } // namespace wm