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