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 pid");
 689     this->controller->get_surface_properties(surface_id);
 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_source_rectangle(0, 0, w, h);
 877     this->layout_commit();
 878     s->set_destination_rectangle(x, y, w, h);
 879
 880     // update area information
 881     this->area_info[surface_id].x = x;
 882     this->area_info[surface_id].y = y;
 883     this->area_info[surface_id].w = w;
 884     this->area_info[surface_id].h = h;
 885
 886     HMI_DEBUG("wm", "Surface %u now on layer %u with rect { %d, %d, %d, %d }",
 887               surface_id, layer_id, x, y, w, h);
 888 }
 889
 890 void WindowManager::layout_commit()
 891 {
 892     this->controller->commit_changes();
 893     this->display->flush();
 894 }
 895
 896 void WindowManager::emit_activated(char const *label)
 897 {
 898     this->send_event(kListEventName[Event_Active], label);
 899 }
 900
 901 void WindowManager::emit_deactivated(char const *label)
 902 {
 903     this->send_event(kListEventName[Event_Inactive], label);
 904 }
 905
 906 void WindowManager::emit_syncdraw(char const *label, char const *area, int x, int y, int w, int h)
 907 {
 908     this->send_event(kListEventName[Event_SyncDraw], label, area, x, y, w, h);
 909 }
 910
 911 void WindowManager::emit_syncdraw(const std::string &role, const std::string &area)
 912 {
 913     compositor::rect rect = this->layers.getAreaSize(area);
 914     this->send_event(kListEventName[Event_SyncDraw],
 915         role.c_str(), area.c_str(), rect.x, rect.y, rect.w, rect.h);
 916 }
 917
 918 void WindowManager::emit_flushdraw(char const *label)
 919 {
 920     this->send_event(kListEventName[Event_FlushDraw], label);
 921 }
 922
 923 void WindowManager::emit_visible(char const *label, bool is_visible)
 924 {
 925     this->send_event(is_visible ? kListEventName[Event_Visible] : kListEventName[Event_Invisible], label);
 926 }
 927
 928 void WindowManager::emit_invisible(char const *label)
 929 {
 930     return emit_visible(label, false);
 931 }
 932
 933 void WindowManager::emit_visible(char const *label) { return emit_visible(label, true); }
 934
 935 void WindowManager::activate(int id)
 936 {
 937     auto ip = this->controller->sprops.find(id);
 938     if (ip != this->controller->sprops.end())
 939     {
 940         this->controller->surfaces[id]->set_visibility(1);
 941         char const *label =
 942             this->lookup_name(id).value_or("unknown-name").c_str();
 943
 944          // FOR CES DEMO >>>
 945         if ((0 == strcmp(label, "radio")) ||
 946             (0 == strcmp(label, "music")) ||
 947             (0 == strcmp(label, "video")) ||
 948             (0 == strcmp(label, "map")))
 949         {
 950             for (auto i = surface_bg.begin(); i != surface_bg.end(); ++i)
 951             {
 952                 if (id == *i)
 953                 {
 954                     // Remove id
 955                     this->surface_bg.erase(i);
 956
 957                     // Remove from BG layer (999)
 958                     HMI_DEBUG("wm", "Remove %s(%d) from BG layer", label, id);
 959                     this->controller->layers[999]->remove_surface(id);
 960
 961                     // Add to FG layer (1001)
 962                     HMI_DEBUG("wm", "Add %s(%d) to FG layer", label, id);
 963                     this->controller->layers[1001]->add_surface(id);
 964
 965                     for (int j : this->surface_bg)
 966                     {
 967                         HMI_DEBUG("wm", "Stored id:%d", j);
 968                     }
 969                     break;
 970                 }
 971             }
 972         }
 973         // <<< FOR CES DEMO
 974
 975         this->layout_commit();
 976
 977         // TODO: application requests by old role,
 978         //       so convert role new to old for emitting event
 979         const char* old_role = this->rolenew2old[label].c_str();
 980
 981         this->emit_visible(old_role);
 982         this->emit_activated(old_role);
 983     }
 984 }
 985
 986 void WindowManager::deactivate(int id)
 987 {
 988     auto ip = this->controller->sprops.find(id);
 989     if (ip != this->controller->sprops.end())
 990     {
 991         char const *label =
 992             this->lookup_name(id).value_or("unknown-name").c_str();
 993
 994         // FOR CES DEMO >>>
 995         if ((0 == strcmp(label, "radio")) ||
 996             (0 == strcmp(label, "music")) ||
 997             (0 == strcmp(label, "video")) ||
 998             (0 == strcmp(label, "map")))
 999         {
1000
1001             // Store id
1002             this->surface_bg.push_back(id);
1003
1004             // Remove from FG layer (1001)
1005             HMI_DEBUG("wm", "Remove %s(%d) from FG layer", label, id);
1006             this->controller->layers[1001]->remove_surface(id);
1007
1008             // Add to BG layer (999)
1009             HMI_DEBUG("wm", "Add %s(%d) to BG layer", label, id);
1010             this->controller->layers[999]->add_surface(id);
1011
1012             for (int j : surface_bg)
1013             {
1014                 HMI_DEBUG("wm", "Stored id:%d", j);
1015             }
1016         }
1017         else
1018         {
1019             this->controller->surfaces[id]->set_visibility(0);
1020         }
1021         // <<< FOR CES DEMO
1022
1023         this->layout_commit();
1024
1025         // TODO: application requests by old role,
1026         //       so convert role new to old for emitting event
1027         const char* old_role = this->rolenew2old[label].c_str();
1028
1029         this->emit_deactivated(old_role);
1030         this->emit_invisible(old_role);
1031     }
1032 }
1033
1034 WMError WindowManager::setRequest(const std::string& appid, const std::string &role, const std::string &area,
1035                             Task task, unsigned* req_num)
1036 {
1037     if (!g_app_list.contains(appid))
1038     {
1039         return WMError::NOT_REGISTERED;
1040     }
1041
1042     auto client = g_app_list.lookUpClient(appid);
1043
1044     /*
1045      * Queueing Phase
1046      */
1047     unsigned current = g_app_list.currentRequestNumber();
1048     unsigned requested_num = g_app_list.getRequestNumber(appid);
1049     if (requested_num != 0)
1050     {
1051         HMI_SEQ_INFO(requested_num,
1052             "%s %s %s request is already queued", appid.c_str(), role.c_str(), area.c_str());
1053         return REQ_REJECTED;
1054     }
1055
1056     WMRequest req = WMRequest(appid, role, area, task);
1057     unsigned new_req = g_app_list.addRequest(req);
1058     *req_num = new_req;
1059     g_app_list.reqDump();
1060
1061     HMI_SEQ_DEBUG(current, "%s start sequence with %s, %s", appid.c_str(), role.c_str(), area.c_str());
1062
1063     return WMError::SUCCESS;
1064 }
1065
1066 WMError WindowManager::doTransition(unsigned req_num)
1067 {
1068     HMI_SEQ_DEBUG(req_num, "check policy");
1069     WMError ret = this->checkPolicy(req_num);
1070     if (ret != WMError::SUCCESS)
1071     {
1072         return ret;
1073     }
1074     HMI_SEQ_DEBUG(req_num, "Start transition.");
1075     ret = this->startTransition(req_num);
1076     return ret;
1077 }
1078
1079 WMError WindowManager::checkPolicy(unsigned req_num)
1080 {
1081     /*
1082     * Check Policy
1083     */
1084     // get current trigger
1085     bool found = false;
1086     bool split = false;
1087     WMError ret = WMError::LAYOUT_CHANGE_FAIL;
1088     auto trigger = g_app_list.getRequest(req_num, &found);
1089     if (!found)
1090     {
1091         ret = WMError::NO_ENTRY;
1092         return ret;
1093     }
1094     std::string req_area = trigger.area;
1095
1096     // >>>> Compatible with current window manager until policy manager coming
1097     if (trigger.task == Task::TASK_ALLOCATE)
1098     {
1099         HMI_SEQ_DEBUG(req_num, "Check split or not");
1100         const char *msg = this->check_surface_exist(trigger.role.c_str());
1101
1102         if (msg)
1103         {
1104             HMI_SEQ_ERROR(req_num, msg);
1105             ret = WMError::LAYOUT_CHANGE_FAIL;
1106             return ret;
1107         }
1108
1109         auto const &surface_id = this->lookup_id(trigger.role.c_str());
1110         auto o_state = *this->layers.get_layout_state(*surface_id);
1111         struct LayoutState &state = *o_state;
1112
1113         unsigned curernt_sid = state.main;
1114         split = this->can_split(state, *surface_id);
1115
1116         if (split)
1117         {
1118             HMI_SEQ_DEBUG(req_num, "Split happens");
1119             // Get current visible role
1120             std::string add_role = this->lookup_name(state.main).value();
1121             // Set next area
1122             std::string add_area = std::string(kNameLayoutSplit) + "." + std::string(kNameAreaMain);
1123             // Change request area
1124             req_area = std::string(kNameLayoutSplit) + "." + std::string(kNameAreaSub);
1125             HMI_SEQ_NOTICE(req_num, "Change request area from %s to %s, because split happens",
1126                                 trigger.area.c_str(), req_area.c_str());
1127             // set another action
1128             std::string add_name = g_app_list.getAppID(curernt_sid, add_role, &found);
1129             if (!found)
1130             {
1131                 HMI_SEQ_ERROR(req_num, "Couldn't widhdraw with surfaceID : %d", curernt_sid);
1132                 ret = WMError::NOT_REGISTERED;
1133                 return ret;
1134             }
1135             HMI_SEQ_INFO(req_num, "Additional split app %s, role: %s, area: %s",
1136                          add_name.c_str(), add_role.c_str(), add_area.c_str());
1137             // Set split action
1138             bool end_draw_finished = false;
1139             WMAction split_action{
1140                 add_name,
1141                 add_role,
1142                 add_area,
1143                 TaskVisible::VISIBLE,
1144                 end_draw_finished};
1145             WMError ret = g_app_list.setAction(req_num, split_action);
1146             if (ret != WMError::SUCCESS)
1147             {
1148                 HMI_SEQ_ERROR(req_num, "Failed to set action");
1149                 return ret;
1150             }
1151             g_app_list.reqDump();
1152         }
1153     }
1154     else
1155     {
1156         HMI_SEQ_DEBUG(req_num, "split doesn't happen");
1157     }
1158
1159     // Set invisible task(Remove if policy manager finish)
1160     ret = this->setInvisibleTask(trigger.role, split);
1161     if(ret != WMError::SUCCESS)
1162     {
1163         HMI_SEQ_ERROR(req_num, "Failed to set invisible task: %s", errorDescription(ret));
1164         return ret;
1165     }
1166
1167     /*  get new status from Policy Manager */
1168     HMI_SEQ_NOTICE(req_num, "ATM, Policy manager does't exist, then set WMAction as is");
1169     if(trigger.role == "homescreen")
1170     {
1171         // TODO : Remove when Policy Manager completed
1172         HMI_SEQ_NOTICE(req_num, "Hack. This process will be removed. Change HomeScreen code!!");
1173         req_area = "fullscreen";
1174     }
1175     TaskVisible task_visible =
1176         (trigger.task == Task::TASK_ALLOCATE) ? TaskVisible::VISIBLE : TaskVisible::INVISIBLE;
1177
1178     ret = g_app_list.setAction(req_num, trigger.appid, trigger.role, req_area, task_visible);
1179     g_app_list.reqDump();
1180
1181     return ret;
1182 }
1183
1184 WMError WindowManager::startTransition(unsigned req_num)
1185 {
1186     bool sync_draw_happen = false;
1187     bool found = false;
1188     WMError ret = WMError::SUCCESS;
1189     auto actions = g_app_list.getActions(req_num, &found);
1190     if (!found)
1191     {
1192         ret = WMError::NO_ENTRY;
1193         HMI_SEQ_ERROR(req_num,
1194             "Window Manager bug :%s : Action is not set", errorDescription(ret));
1195         return ret;
1196     }
1197
1198     for (const auto &action : actions)
1199     {
1200         if (action.visible != TaskVisible::INVISIBLE)
1201         {
1202             sync_draw_happen = true;
1203
1204             // TODO: application requests by old role,
1205             //       so convert role new to old for emitting event
1206             std::string old_role = this->rolenew2old[action.role];
1207
1208             this->emit_syncdraw(old_role, action.area);
1209             /* TODO: emit event for app not subscriber
1210             if(g_app_list.contains(y.appid))
1211                 g_app_list.lookUpClient(y.appid)->emit_syncdraw(y.role, y.area); */
1212         }
1213     }
1214
1215     if (sync_draw_happen)
1216     {
1217         this->setTimer();
1218     }
1219     else
1220     {
1221         // deactivate only, no syncDraw
1222         // Make it deactivate here
1223         for (const auto &x : actions)
1224         {
1225             if (g_app_list.contains(x.appid))
1226             {
1227                 auto client = g_app_list.lookUpClient(x.appid);
1228                 this->deactivate(client->surfaceID(x.role));
1229             }
1230         }
1231         ret = NO_LAYOUT_CHANGE;
1232     }
1233     return ret;
1234 }
1235
1236 WMError WindowManager::setInvisibleTask(const std::string &role, bool split)
1237 {
1238     unsigned req_num = g_app_list.currentRequestNumber();
1239     HMI_SEQ_DEBUG(req_num, "set current visible app to invisible task");
1240     bool found = false;
1241     auto trigger = g_app_list.getRequest(req_num, &found);
1242     // I don't check found == true here because this is checked in caller.
1243     if(trigger.role == "homescreen")
1244     {
1245         HMI_SEQ_INFO(req_num, "In case of 'homescreen' visible, don't change app to invisible");
1246         return WMError::SUCCESS;
1247     }
1248
1249     // This task is copied from original actiavete surface
1250     const char *drawing_name = this->rolenew2old[role].c_str();
1251     auto const &surface_id = this->lookup_id(role.c_str());
1252     auto layer_id = this->layers.get_layer_id(*surface_id);
1253     auto o_state = *this->layers.get_layout_state(*surface_id);
1254     struct LayoutState &state = *o_state;
1255     std::string add_name, add_role;
1256     std::string add_area = "";
1257     int surface;
1258     TaskVisible task_visible = TaskVisible::INVISIBLE;
1259     bool end_draw_finished = true;
1260
1261     for (auto const &l : this->layers.mapping)
1262     {
1263         if (l.second.layer_id <= *layer_id)
1264         {
1265             continue;
1266         }
1267         HMI_DEBUG("wm", "debug: main %d , sub : %d", l.second.state.main, l.second.state.sub);
1268         if (l.second.state.main != -1)
1269         {
1270             //this->deactivate(l.second.state.main);
1271             surface = l.second.state.main;
1272             add_role = *this->id_alloc.lookup(surface);
1273             add_name = g_app_list.getAppID(surface, add_role, &found);
1274             if(!found){
1275                 return WMError::NOT_REGISTERED;
1276             }
1277             HMI_SEQ_INFO(req_num, "Invisible %s", add_name.c_str());
1278             WMAction act{add_name, add_role, add_area, task_visible, end_draw_finished};
1279             g_app_list.setAction(req_num, act);
1280             l.second.state.main = -1;
1281         }
1282
1283         if (l.second.state.sub != -1)
1284         {
1285             //this->deactivate(l.second.state.sub);
1286             surface = l.second.state.sub;
1287             add_role = *this->id_alloc.lookup(surface);
1288             add_name = g_app_list.getAppID(surface, add_role, &found);
1289             if (!found)
1290             {
1291                 return WMError::NOT_REGISTERED;
1292             }
1293             HMI_SEQ_INFO(req_num, "Invisible %s", add_name.c_str());
1294             WMAction act{add_name, add_role, add_area, task_visible, end_draw_finished};
1295             g_app_list.setAction(req_num, act);
1296             l.second.state.sub = -1;
1297         }
1298     }
1299
1300     // change current state here, but this is hack
1301     auto layer = this->layers.get_layer(*layer_id);
1302
1303     if (state.main == -1)
1304     {
1305         HMI_DEBUG("wm", "Layout: %s", kNameLayoutNormal);
1306     }
1307     else
1308     {
1309         if (0 != strcmp(drawing_name, "HomeScreen"))
1310         {
1311             if (split)
1312             {
1313                 if (state.sub != *surface_id)
1314                 {
1315                     if (state.sub != -1)
1316                     {
1317                         //this->deactivate(state.sub);
1318                         WMAction deact_sub;
1319                         deact_sub.role =
1320                             std::move(*this->id_alloc.lookup(state.sub));
1321                         deact_sub.area = add_area;
1322                         deact_sub.appid = g_app_list.getAppID(state.sub, deact_sub.role, &found);
1323                         if (!found)
1324                         {
1325                             HMI_SEQ_ERROR(req_num, "App doesn't exist for role : %s",
1326                                             deact_sub.role.c_str());
1327                             return WMError::NOT_REGISTERED;
1328                         }
1329                         deact_sub.visible = task_visible;
1330                         deact_sub.end_draw_finished = end_draw_finished;
1331                         HMI_SEQ_DEBUG(req_num, "Set invisible task for %s", deact_sub.appid.c_str());
1332                         g_app_list.setAction(req_num, deact_sub);
1333                     }
1334                 }
1335                 //state = LayoutState{state.main, *surface_id};
1336             }
1337             else
1338             {
1339                 HMI_DEBUG("wm", "Layout: %s", kNameLayoutNormal);
1340
1341                 //this->surface_set_layout(*surface_id);
1342                 if (state.main != *surface_id)
1343                 {
1344                     // this->deactivate(state.main);
1345                     WMAction deact_main;
1346                     deact_main.role = std::move(*this->id_alloc.lookup(state.main));
1347                     ;
1348                     deact_main.area = add_area;
1349                     deact_main.appid = g_app_list.getAppID(state.main, deact_main.role, &found);
1350                     if (!found)
1351                     {
1352                         HMI_SEQ_DEBUG(req_num, "sub surface ddoesn't exist");
1353                         return WMError::NOT_REGISTERED;
1354                     }
1355                     deact_main.visible = task_visible;
1356                     deact_main.end_draw_finished = end_draw_finished;
1357                     HMI_SEQ_DEBUG(req_num, "sub surface doesn't exist");
1358                     g_app_list.setAction(req_num, deact_main);
1359                 }
1360                 if (state.sub != -1)
1361                 {
1362                     if (state.sub != *surface_id)
1363                     {
1364                         //this->deactivate(state.sub);
1365                         WMAction deact_sub;
1366                         deact_sub.role = std::move(*this->id_alloc.lookup(state.sub));
1367                         ;
1368                         deact_sub.area = add_area;
1369                         deact_sub.appid = g_app_list.getAppID(state.sub, deact_sub.role, &found);
1370                         if (!found)
1371                         {
1372                             HMI_SEQ_DEBUG(req_num, "sub surface ddoesn't exist");
1373                             return WMError::NOT_REGISTERED;
1374                         }
1375                         deact_sub.visible = task_visible;
1376                         deact_sub.end_draw_finished = end_draw_finished;
1377                         HMI_SEQ_DEBUG(req_num, "sub surface doesn't exist");
1378                         g_app_list.setAction(req_num, deact_sub);
1379                     }
1380                 }
1381                 //state = LayoutState{*surface_id};
1382             }
1383         }
1384     }
1385     return WMError::SUCCESS;
1386 }
1387
1388 WMError WindowManager::doEndDraw(unsigned req_num)
1389 {
1390     // get actions
1391     bool found;
1392     auto actions = g_app_list.getActions(req_num, &found);
1393     WMError ret = WMError::SUCCESS;
1394     if (!found)
1395     {
1396         ret = WMError::NO_ENTRY;
1397         return ret;
1398     }
1399
1400     HMI_SEQ_INFO(req_num, "do endDraw");
1401
1402     // layout change and make it visible
1403     for (const auto &act : actions)
1404     {
1405         // layout change
1406         if(!g_app_list.contains(act.appid)){
1407             ret = WMError::NOT_REGISTERED;
1408         }
1409         ret = this->layoutChange(act);
1410         if(ret != WMError::SUCCESS)
1411         {
1412             HMI_SEQ_WARNING(req_num,
1413                 "Failed to manipulate surfaces while state change : %s", errorDescription(ret));
1414             return ret;
1415         }
1416         ret = this->visibilityChange(act);
1417         if (ret != WMError::SUCCESS)
1418         {
1419             HMI_SEQ_WARNING(req_num,
1420                 "Failed to manipulate surfaces while state change : %s", errorDescription(ret));
1421             return ret;
1422         }
1423         HMI_SEQ_DEBUG(req_num, "visible %s", act.role.c_str());
1424         //this->lm_enddraw(act.role.c_str());
1425     }
1426
1427     // Change current state
1428     this->changeCurrentState(req_num);
1429
1430     HMI_SEQ_INFO(req_num, "emit flushDraw");
1431
1432     for(const auto &act_flush : actions)
1433     {
1434         if(act_flush.visible != TaskVisible::INVISIBLE)
1435         {
1436             // TODO: application requests by old role,
1437             //       so convert role new to old for emitting event
1438             std::string old_role = this->rolenew2old[act_flush.role];
1439
1440             this->emit_flushdraw(old_role.c_str());
1441         }
1442     }
1443
1444     return ret;
1445 }
1446
1447 WMError WindowManager::layoutChange(const WMAction &action)
1448 {
1449     if (action.visible == TaskVisible::INVISIBLE)
1450     {
1451         // Visibility is not change -> no redraw is required
1452         return WMError::SUCCESS;
1453     }
1454     auto client = g_app_list.lookUpClient(action.appid);
1455     unsigned surface = client->surfaceID(action.role);
1456     if (surface == 0)
1457     {
1458         HMI_SEQ_ERROR(g_app_list.currentRequestNumber(),
1459                       "client doesn't have surface with role(%s)", action.role.c_str());
1460         return WMError::NOT_REGISTERED;
1461     }
1462     // Layout Manager
1463     WMError ret = this->setSurfaceSize(surface, action.area);
1464     return ret;
1465 }
1466
1467 WMError WindowManager::visibilityChange(const WMAction &action)
1468 {
1469     HMI_SEQ_DEBUG(g_app_list.currentRequestNumber(), "Change visibility");
1470     if(!g_app_list.contains(action.appid)){
1471         return WMError::NOT_REGISTERED;
1472     }
1473     auto client = g_app_list.lookUpClient(action.appid);
1474     unsigned surface = client->surfaceID(action.role);
1475     if(surface == 0)
1476     {
1477         HMI_SEQ_ERROR(g_app_list.currentRequestNumber(),
1478                       "client doesn't have surface with role(%s)", action.role.c_str());
1479         return WMError::NOT_REGISTERED;
1480     }
1481
1482     if (action.visible != TaskVisible::INVISIBLE)
1483     {
1484         this->activate(surface); // Layout Manager task
1485     }
1486     else
1487     {
1488         this->deactivate(surface); // Layout Manager task
1489     }
1490     return WMError::SUCCESS;
1491 }
1492
1493 WMError WindowManager::setSurfaceSize(unsigned surface, const std::string &area)
1494 {
1495     this->surface_set_layout(surface, area);
1496
1497     return WMError::SUCCESS;
1498 }
1499
1500 WMError WindowManager::changeCurrentState(unsigned req_num)
1501 {
1502     HMI_SEQ_DEBUG(req_num, "Change current layout state");
1503     bool trigger_found = false, action_found = false;
1504     auto trigger = g_app_list.getRequest(req_num, &trigger_found);
1505     auto actions = g_app_list.getActions(req_num, &action_found);
1506     if (!trigger_found || !action_found)
1507     {
1508         HMI_SEQ_ERROR(req_num, "Action not found");
1509         return WMError::LAYOUT_CHANGE_FAIL;
1510     }
1511
1512     // Layout state reset
1513     struct LayoutState reset_state{-1, -1};
1514     HMI_SEQ_DEBUG(req_num,"Reset layout state");
1515     for (const auto &action : actions)
1516     {
1517         if(!g_app_list.contains(action.appid)){
1518             return WMError::NOT_REGISTERED;
1519         }
1520         auto client = g_app_list.lookUpClient(action.appid);
1521         auto pCurState = *this->layers.get_layout_state((int)client->surfaceID(action.role));
1522         if(pCurState == nullptr)
1523         {
1524             HMI_SEQ_ERROR(req_num, "Counldn't find current status");
1525             continue;
1526         }
1527         pCurState->main = reset_state.main;
1528         pCurState->sub = reset_state.sub;
1529     }
1530
1531     HMI_SEQ_DEBUG(req_num, "Change state");
1532     for (const auto &action : actions)
1533     {
1534         auto client = g_app_list.lookUpClient(action.appid);
1535         auto pLayerCurState = *this->layers.get_layout_state((int)client->surfaceID(action.role));
1536         if (pLayerCurState == nullptr)
1537         {
1538             HMI_SEQ_ERROR(req_num, "Counldn't find current status");
1539             continue;
1540         }
1541         int surface = -1;
1542
1543         if (action.visible != TaskVisible::INVISIBLE)
1544         {
1545             surface = (int)client->surfaceID(action.role);
1546             HMI_SEQ_INFO(req_num, "Change %s surface : %d, state visible area : %s",
1547                             action.role.c_str(), surface, action.area.c_str());
1548             // visible == true -> layout changes
1549             if(action.area == "normal.full" || action.area == "split.main")
1550             {
1551                 pLayerCurState->main = surface;
1552             }
1553             else if (action.area == "split.sub")
1554             {
1555                 pLayerCurState->sub = surface;
1556             }
1557             else
1558             {
1559                 // normalfull
1560                 pLayerCurState->main = surface;
1561             }
1562         }
1563     }
1564
1565     return WMError::SUCCESS;
1566 }
1567
1568 void WindowManager::emitScreenUpdated(unsigned req_num)
1569 {
1570     // Get visible apps
1571     HMI_SEQ_DEBUG(req_num, "emit screen updated");
1572     bool found = false;
1573     auto actions = g_app_list.getActions(req_num, &found);
1574
1575     // create json object
1576     json_object *j = json_object_new_object();
1577     json_object *jarray = json_object_new_array();
1578
1579     for(const auto& action: actions)
1580     {
1581         if(action.visible != TaskVisible::INVISIBLE)
1582         {
1583             json_object_array_add(jarray, json_object_new_string(action.appid.c_str()));
1584         }
1585     }
1586     json_object_object_add(j, kKeyIds, jarray);
1587     HMI_SEQ_INFO(req_num, "Visible app: %s", json_object_get_string(j));
1588
1589     int ret = afb_event_push(
1590         this->map_afb_event[kListEventName[Event_ScreenUpdated]], j);
1591     if (ret != 0)
1592     {
1593         HMI_DEBUG("wm", "afb_event_push failed: %m");
1594     }
1595 }
1596
1597 void WindowManager::setTimer()
1598 {
1599     struct timespec ts;
1600     if (clock_gettime(CLOCK_BOOTTIME, &ts) != 0) {
1601         HMI_ERROR("wm", "Could't set time (clock_gettime() returns with error");
1602         return;
1603     }
1604
1605     HMI_SEQ_DEBUG(g_app_list.currentRequestNumber(), "Timer set activate");
1606     if (g_timer_ev_src == nullptr)
1607     {
1608         // firsttime set into sd_event
1609         int ret = sd_event_add_time(afb_daemon_get_event_loop(), &g_timer_ev_src,
1610             CLOCK_BOOTTIME, (uint64_t)(ts.tv_sec + kTimeOut) * 1000000ULL, 1, processTimerHandler, this);
1611         if (ret < 0)
1612         {
1613             HMI_ERROR("wm", "Could't set timer");
1614         }
1615     }
1616     else
1617     {
1618         // update timer limitation after second time
1619         sd_event_source_set_time(g_timer_ev_src, (uint64_t)(ts.tv_sec + kTimeOut) * 1000000ULL);
1620         sd_event_source_set_enabled(g_timer_ev_src, SD_EVENT_ONESHOT);
1621     }
1622 }
1623
1624 void WindowManager::stopTimer()
1625 {
1626     unsigned req_num = g_app_list.currentRequestNumber();
1627     HMI_SEQ_DEBUG(req_num, "Timer stop");
1628     int rc = sd_event_source_set_enabled(g_timer_ev_src, SD_EVENT_OFF);
1629     if (rc < 0)
1630     {
1631         HMI_SEQ_ERROR(req_num, "Timer stop failed");
1632     }
1633 }
1634
1635 void WindowManager::processNextRequest()
1636 {
1637     g_app_list.next();
1638     g_app_list.reqDump();
1639     unsigned req_num = g_app_list.currentRequestNumber();
1640     if (g_app_list.haveRequest())
1641     {
1642         HMI_SEQ_DEBUG(req_num, "Process next request");
1643         WMError rc = doTransition(req_num);
1644         if (rc != WMError::SUCCESS)
1645         {
1646             HMI_SEQ_ERROR(req_num, errorDescription(rc));
1647         }
1648     }
1649     else
1650     {
1651         HMI_SEQ_DEBUG(req_num, "Nothing Request. Waiting Request");
1652     }
1653 }
1654
1655 const char* WindowManager::convertRoleOldToNew(char const *old_role)
1656 {
1657     const char *new_role = nullptr;
1658
1659     for (auto const &on : this->roleold2new)
1660     {
1661         std::regex regex = std::regex(on.first);
1662         if (std::regex_match(old_role, regex))
1663         {
1664             // role is old. So convert to new.
1665             new_role = on.second.c_str();
1666             break;
1667         }
1668     }
1669
1670     if (nullptr == new_role)
1671     {
1672         // role is new or fallback.
1673         new_role = old_role;
1674     }
1675
1676     HMI_DEBUG("wm", "old:%s -> new:%s", old_role, new_role);
1677
1678     return new_role;
1679 }
1680
1681 int WindowManager::loadOldRoleDb()
1682 {
1683     // Get afm application installed dir
1684     char const *afm_app_install_dir = getenv("AFM_APP_INSTALL_DIR");
1685     HMI_DEBUG("wm", "afm_app_install_dir:%s", afm_app_install_dir);
1686
1687     std::string file_name;
1688     if (!afm_app_install_dir)
1689     {
1690         HMI_ERROR("wm", "AFM_APP_INSTALL_DIR is not defined");
1691     }
1692     else
1693     {
1694         file_name = std::string(afm_app_install_dir) + std::string("/etc/old_roles.db");
1695     }
1696
1697     // Load old_role.db
1698     json_object* json_obj;
1699     int ret = jh::inputJsonFilie(file_name.c_str(), &json_obj);
1700     if (0 > ret)
1701     {
1702         HMI_ERROR("wm", "Could not open old_role.db, so use default old_role information");
1703         json_obj = json_tokener_parse(kDefaultOldRoleDb);
1704     }
1705     HMI_DEBUG("wm", "json_obj dump:%s", json_object_get_string(json_obj));
1706
1707     // Perse apps
1708     json_object* json_cfg;
1709     if (!json_object_object_get_ex(json_obj, "old_roles", &json_cfg))
1710     {
1711         HMI_ERROR("wm", "Parse Error!!");
1712         return -1;
1713     }
1714
1715     int len = json_object_array_length(json_cfg);
1716     HMI_DEBUG("wm", "json_cfg len:%d", len);
1717     HMI_DEBUG("wm", "json_cfg dump:%s", json_object_get_string(json_cfg));
1718
1719     for (int i=0; i<len; i++)
1720     {
1721         json_object* json_tmp = json_object_array_get_idx(json_cfg, i);
1722
1723         const char* old_role = jh::getStringFromJson(json_tmp, "name");
1724         if (nullptr == old_role)
1725         {
1726             HMI_ERROR("wm", "Parse Error!!");
1727             return -1;
1728         }
1729
1730         const char* new_role = jh::getStringFromJson(json_tmp, "new");
1731         if (nullptr == new_role)
1732         {
1733             HMI_ERROR("wm", "Parse Error!!");
1734             return -1;
1735         }
1736
1737         this->roleold2new[old_role] = std::string(new_role);
1738     }
1739
1740     // Check
1741     for(auto itr = this->roleold2new.begin();
1742       itr != this->roleold2new.end(); ++itr)
1743     {
1744         HMI_DEBUG("wm", ">>> role old:%s new:%s",
1745                   itr->first.c_str(), itr->second.c_str());
1746     }
1747
1748     // Release json_object
1749     json_object_put(json_obj);
1750
1751     return 0;
1752 }
1753
1754 const char *WindowManager::check_surface_exist(const char *drawing_name)
1755 {
1756     auto const &surface_id = this->lookup_id(drawing_name);
1757     if (!surface_id)
1758     {
1759         return "Surface does not exist";
1760     }
1761
1762     if (!this->controller->surface_exists(*surface_id))
1763     {
1764         return "Surface does not exist in controller!";
1765     }
1766
1767     auto layer_id = this->layers.get_layer_id(*surface_id);
1768
1769     if (!layer_id)
1770     {
1771         return "Surface is not on any layer!";
1772     }
1773
1774     auto o_state = *this->layers.get_layout_state(*surface_id);
1775
1776     if (o_state == nullptr)
1777     {
1778         return "Could not find layer for surface";
1779     }
1780
1781     HMI_DEBUG("wm", "surface %d is detected", *surface_id);
1782     return nullptr;
1783 }
1784
1785 bool WindowManager::can_split(struct LayoutState const &state, int new_id)
1786 {
1787     if (state.main != -1 && state.main != new_id)
1788     {
1789         auto new_id_layer = this->layers.get_layer_id(new_id).value();
1790         auto current_id_layer = this->layers.get_layer_id(state.main).value();
1791
1792         // surfaces are on separate layers, don't bother.
1793         if (new_id_layer != current_id_layer)
1794         {
1795             return false;
1796         }
1797
1798         std::string const &new_id_str = this->lookup_name(new_id).value();
1799         std::string const &cur_id_str = this->lookup_name(state.main).value();
1800
1801         auto const &layer = this->layers.get_layer(new_id_layer);
1802
1803         HMI_DEBUG("wm", "layer info name: %s", layer->name.c_str());
1804
1805         if (layer->layouts.empty())
1806         {
1807             return false;
1808         }
1809
1810         for (auto i = layer->layouts.cbegin(); i != layer->layouts.cend(); i++)
1811         {
1812             HMI_DEBUG("wm", "%d main_match '%s'", new_id_layer, i->main_match.c_str());
1813             auto rem = std::regex(i->main_match);
1814             if (std::regex_match(cur_id_str, rem))
1815             {
1816                 // build the second one only if the first already matched
1817                 HMI_DEBUG("wm", "%d sub_match '%s'", new_id_layer, i->sub_match.c_str());
1818                 auto res = std::regex(i->sub_match);
1819                 if (std::regex_match(new_id_str, res))
1820                 {
1821                     HMI_DEBUG("wm", "layout matched!");
1822                     return true;
1823                 }
1824             }
1825         }
1826     }
1827
1828     return false;
1829 }
1830
1831 const char* WindowManager::kDefaultOldRoleDb = "{ \
1832     \"old_roles\": [ \
1833         { \
1834             \"name\": \"HomeScreen\", \
1835             \"new\": \"homescreen\" \
1836         }, \
1837         { \
1838             \"name\": \"Music\", \
1839             \"new\": \"music\" \
1840         }, \
1841         { \
1842             \"name\": \"MediaPlayer\", \
1843             \"new\": \"music\" \
1844         }, \
1845         { \
1846             \"name\": \"Video\", \
1847             \"new\": \"video\" \
1848         }, \
1849         { \
1850             \"name\": \"VideoPlayer\", \
1851             \"new\": \"video\" \
1852         }, \
1853         { \
1854             \"name\": \"WebBrowser\", \
1855             \"new\": \"browser\" \
1856         }, \
1857         { \
1858             \"name\": \"Radio\", \
1859             \"new\": \"radio\" \
1860         }, \
1861         { \
1862             \"name\": \"Phone\", \
1863             \"new\": \"phone\" \
1864         }, \
1865         { \
1866             \"name\": \"Navigation\", \
1867             \"new\": \"map\" \
1868         }, \
1869         { \
1870             \"name\": \"HVAC\", \
1871             \"new\": \"hvac\" \
1872         }, \
1873         { \
1874             \"name\": \"Settings\", \
1875             \"new\": \"settings\" \
1876         }, \
1877         { \
1878             \"name\": \"Dashboard\", \
1879             \"new\": \"dashboard\" \
1880         }, \
1881         { \
1882             \"name\": \"POI\", \
1883             \"new\": \"poi\" \
1884         }, \
1885         { \
1886             \"name\": \"Mixer\", \
1887             \"new\": \"mixer\" \
1888         }, \
1889         { \
1890             \"name\": \"Restriction\", \
1891             \"new\": \"restriction\" \
1892         }, \
1893         { \
1894             \"name\": \"^OnScreen.*\", \
1895             \"new\": \"on_screen\" \
1896         } \
1897     ] \
1898 }";
1899
1900 /**
1901  * controller_hooks
1902  */
1903 void controller_hooks::surface_created(uint32_t surface_id)
1904 {
1905     this->wmgr->surface_created(surface_id);
1906 }
1907
1908 void controller_hooks::surface_removed(uint32_t surface_id)
1909 {
1910     this->wmgr->surface_removed(surface_id);
1911 }
1912
1913 void controller_hooks::surface_visibility(uint32_t /*surface_id*/,
1914                                           uint32_t /*v*/) {}
1915
1916 void controller_hooks::surface_destination_rectangle(uint32_t /*surface_id*/,
1917                                                      uint32_t /*x*/,
1918                                                      uint32_t /*y*/,
1919                                                      uint32_t /*w*/,
1920                                                      uint32_t /*h*/) {}
1921
1922 void controller_hooks::surface_properties(uint32_t surface_id, uint32_t pid)
1923 {
1924     this->wmgr->surface_properties(surface_id, pid);
1925 }
1926
1927 } // namespace wm