src/app.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 "app.hpp"
  18 #include "json_helper.hpp"
  19 #include "layers.hpp"
  20 #include "layout.hpp"
  21 #include "util.hpp"
  22 #include "wayland_ivi_wm.hpp"
  23
  24 #include <cstdio>
  25 #include <memory>
  26
  27 #include <cassert>
  28
  29 #include <json-c/json.h>
  30
  31 #include <algorithm>
  32 #include <csignal>
  33 #include <fstream>
  34 #include <json.hpp>
  35 #include <regex>
  36 #include <thread>
  37 #include <string>
  38
  39
  40 namespace wm {
  41
  42 /* DrawingArea name used by "{layout}.{area}" */
  43 const char kNameLayoutNormal[] = "normal";
  44 const char kNameLayoutSplit[]  = "split";
  45 const char kNameAreaFull[]     = "full";
  46 const char kNameAreaMain[]     = "main";
  47 const char kNameAreaSub[]      = "sub";
  48
  49 /* Key for json obejct */
  50 const char kKeyDrawingName[] = "drawing_name";
  51 const char kKeyDrawingArea[] = "drawing_area";
  52 const char kKeyDrawingRect[] = "drawing_rect";
  53 const char kKeyX[]           = "x";
  54 const char kKeyY[]           = "y";
  55 const char kKeyWidth[]       = "width";
  56 const char kKeyHeight[]      = "height";
  57 const char kKeyWidthPixel[]  = "width_pixel";
  58 const char kKeyHeightPixel[] = "height_pixel";
  59 const char kKeyWidthMm[]     = "width_mm";
  60 const char kKeyHeightMm[]    = "height_mm";
  61 const char kKeyAppID[]       = "id";
  62
  63
  64 namespace {
  65
  66 using nlohmann::json;
  67
  68 result<json> file_to_json(char const *filename) {
  69    json j;
  70    std::ifstream i(filename);
  71    if (i.fail()) {
  72       HMI_DEBUG("wm", "Could not open config file, so use default layer information");
  73       j = default_layers_json;
  74    }
  75    else {
  76       i >> j;
  77    }
  78
  79    return Ok(j);
  80 }
  81
  82 struct result<layer_map> load_layer_map(char const *filename) {
  83    HMI_DEBUG("wm", "loading IDs from %s", filename);
  84
  85    auto j = file_to_json(filename);
  86    if (j.is_err()) {
  87       return Err<layer_map>(j.unwrap_err());
  88    }
  89    json jids = j.unwrap();
  90
  91    return to_layer_map(jids);
  92 }
  93
  94 }  // namespace
  95
  96
  97 namespace rm {
  98 App *context;
  99 const char *g_new_role; // TODO: workaround
 100 static void eventHandler(json_object* json_out) {
 101     context->updateWindowResource(json_out);
 102 }
 103 }  // namespace rm
 104
 105
 106 void App::updateWindowResource(json_object* json_out) {
 107     HMI_DEBUG("wm", "role:%s", rm::g_new_role);
 108
 109     // Check parking brake state
 110     json_object* json_parking_brake;
 111     if (!json_object_object_get_ex(json_out, "parking_brake", &json_parking_brake)) {
 112         HMI_DEBUG("wm", "Not found key \"parking_brake\"");
 113         return;
 114     }
 115
 116     json_bool is_changed;
 117     is_changed = jh::getBoolFromJson(json_parking_brake, "is_changed");
 118     if (is_changed) {
 119         std::string parking_brake_state = jh::getStringFromJson(json_parking_brake, "state");
 120         HMI_DEBUG("wm", "parking_brake_state: %s", parking_brake_state.c_str());
 121
 122         // Update state and emit event
 123         if ("parking_brake_off" == parking_brake_state) {
 124             this->crr_car_info_.parking_brake_stt = false;
 125 #if 0 // FOR ALS: using lightstatus brake, so do not emit parking brake event
 126             this->emitParkingBrakeOff();
 127 #endif
 128         }
 129         else if ("parking_brake_on" == parking_brake_state) {
 130             this->crr_car_info_.parking_brake_stt = true;
 131 #if 0 // FOR ALS: using lightstatus brake, so do not emit parking brake event
 132             this->emitParkingBrakeOn();
 133 #endif
 134         }
 135         else {
 136             HMI_DEBUG("wm", "Unknown parking brake state");
 137             return;
 138         }
 139     }
 140
 141     // Check accelerator pedal state
 142     json_object* json_accel_pedal;
 143     if (!json_object_object_get_ex(json_out, "accel_pedal", &json_accel_pedal)) {
 144         HMI_DEBUG("wm", "Not found key \"accel_pedal\"");
 145         return;
 146     }
 147
 148     is_changed = jh::getBoolFromJson(json_accel_pedal, "is_changed");
 149     if (is_changed) {
 150         std::string accel_pedal_state = jh::getStringFromJson(json_accel_pedal, "state");
 151         HMI_DEBUG("wm", "accel_pedal_state: %s", accel_pedal_state.c_str());
 152
 153         // Update state
 154         if ("accel_pedal_off" == accel_pedal_state) {
 155             this->crr_car_info_.accel_pedal_stt = false;
 156         }
 157         else if ("accel_pedal_on" == accel_pedal_state) {
 158             this->crr_car_info_.accel_pedal_stt = true;
 159         }
 160         else {
 161             HMI_DEBUG("wm", "Unknown accel pedal state");
 162             return;
 163         }
 164     }
 165
 166     // Check lightstatus brake state
 167     json_object* json_lightstatus_brake;
 168     if (!json_object_object_get_ex(json_out, "lightstatus_brake", &json_lightstatus_brake)) {
 169         HMI_DEBUG("wm", "Not found key \"lightstatus_brake\"");
 170         return;
 171     }
 172
 173     is_changed = jh::getBoolFromJson(json_lightstatus_brake, "is_changed");
 174     if (is_changed) {
 175         std::string lightstatus_brake_state = jh::getStringFromJson(json_lightstatus_brake, "state");
 176         HMI_DEBUG("wm", "lightstatus_brake_state: %s", lightstatus_brake_state.c_str());
 177
 178         // Update state and emit event
 179         if ("lightstatus_brake_off" == lightstatus_brake_state) {
 180             this->crr_car_info_.lightstatus_brake_stt = false;
 181             this->emitLightstatusBrakeOff();
 182         }
 183         else if ("lightstatus_brake_on" == lightstatus_brake_state) {
 184             this->crr_car_info_.lightstatus_brake_stt = true;
 185             this->emitLightstatusBrakeOn();
 186         }
 187         else {
 188             HMI_DEBUG("wm", "Unknown lightstatus brake state");
 189             return;
 190         }
 191     }
 192
 193     // Check car state
 194     json_object* json_car;
 195     if (!json_object_object_get_ex(json_out, "car", &json_car)) {
 196         HMI_DEBUG("wm", "Not found key \"car\"");
 197         return;
 198     }
 199
 200     is_changed = jh::getBoolFromJson(json_car, "is_changed");
 201     if (is_changed) {
 202         std::string car_state = jh::getStringFromJson(json_car, "state");
 203         HMI_DEBUG("wm", "car_state: %s", car_state.c_str());
 204
 205         // Emit car event
 206         if ("car_stop" == car_state) {
 207             this->crr_car_info_.car_stt = "stop";
 208             this->emitCarStop();
 209         }
 210         else if ("car_run" == car_state) {
 211             this->crr_car_info_.car_stt = "run";
 212             this->emitCarRun();
 213         }
 214         else {
 215             HMI_DEBUG("wm", "Unknown car state");
 216             return;
 217         }
 218     }
 219
 220     // Check lamp state
 221     json_object* json_lamp;
 222     if (!json_object_object_get_ex(json_out, "lamp", &json_lamp)) {
 223         HMI_DEBUG("wm", "Not found key \"lamp\"");
 224         return;
 225     }
 226
 227     is_changed = jh::getBoolFromJson(json_lamp, "is_changed");
 228     if (is_changed) {
 229         std::string lamp_state = jh::getStringFromJson(json_lamp, "state");
 230         HMI_DEBUG("wm", "lamp_state: %s", lamp_state.c_str());
 231
 232         // Update state and emit event
 233         if ("lamp_off" == lamp_state) {
 234             this->crr_car_info_.headlamp_stt = false;
 235             this->emitHeadlampOff();
 236         }
 237         else if ("lamp_on" == lamp_state) {
 238             this->crr_car_info_.headlamp_stt = true;
 239             this->emitHeadlampOn();
 240         }
 241         else {
 242             HMI_DEBUG("wm", "Unknown lamp state");
 243             return;
 244         }
 245     }
 246
 247     // Get category
 248     const char* category = nullptr;
 249     std::string str_category;
 250     if (nullptr != rm::g_new_role) {
 251         str_category = this->pm_.roleToCategory(rm::g_new_role);
 252         category = str_category.c_str();
 253         HMI_DEBUG("wm", "role:%s category:%s", rm::g_new_role, category);
 254     }
 255
 256     // Update layout
 257     if (this->lm_.updateLayout(json_out, rm::g_new_role, category)) {
 258         HMI_DEBUG("wm", "Layer is changed!!");
 259
 260         // Allocate surface
 261         this->allocateSurface();
 262     }
 263     else {
 264         HMI_DEBUG("wm", "All layer is NOT changed!!");
 265     }
 266 }
 267
 268
 269 /**
 270  * App Impl
 271  */
 272 App::App(wl::display *d)
 273    : chooks{this},
 274      display{d},
 275      controller{},
 276      outputs(),
 277      config(),
 278      layers(),
 279      id_alloc{},
 280      pending_events(false),
 281      policy{} {
 282    try {
 283       {
 284          auto l = load_layer_map(
 285             this->config.get_string("layers.json").value().c_str());
 286          if (l.is_ok()) {
 287             this->layers = l.unwrap();
 288          } else {
 289             HMI_ERROR("wm", "%s", l.err().value());
 290          }
 291       }
 292    } catch (std::exception &e) {
 293       HMI_ERROR("wm", "Loading of configuration failed: %s", e.what());
 294    }
 295
 296    // Initialize current car info
 297    this->crr_car_info_.parking_brake_stt = true;
 298    this->crr_car_info_.accel_pedal_stt = false;
 299    this->crr_car_info_.accel_pedal_pos = 0;
 300    this->crr_car_info_.car_stt = "stop";
 301    this->crr_car_info_.headlamp_stt = false;
 302 }
 303
 304 int App::init() {
 305    if (!this->display->ok()) {
 306       return -1;
 307    }
 308
 309    if (this->layers.mapping.empty()) {
 310       HMI_ERROR("wm", "No surface -> layer mapping loaded");
 311       return -1;
 312    }
 313
 314    // Store my context for calling callback for PolicyManager
 315    rm::context = this;
 316
 317 #if 1 // @@@@@
 318    // Load app.db
 319    this->loadAppDb();
 320 #endif
 321
 322    // Initialize PolicyManager
 323    this->pm_.initialize();
 324
 325    // Register callback to PolicyManager
 326    PolicyManager::CallbackTable callback;
 327    callback.onStateTransitioned = rm::eventHandler;
 328    callback.onError = nullptr;
 329    this->pm_.registerCallback(callback);
 330
 331    // Initialize LayoutManager
 332    this->lm_.initialize();
 333
 334    // Make afb event
 335    for (int i=Event_Val_Min; i<=Event_Val_Max; i++) {
 336       map_afb_event[kListEventName[i]] = afb_daemon_make_event(kListEventName[i]);
 337    }
 338
 339    this->display->add_global_handler(
 340       "wl_output", [this](wl_registry *r, uint32_t name, uint32_t v) {
 341          this->outputs.emplace_back(std::make_unique<wl::output>(r, name, v));
 342       });
 343
 344    this->display->add_global_handler(
 345       "ivi_wm", [this](wl_registry *r, uint32_t name, uint32_t v) {
 346          this->controller =
 347             std::make_unique<struct compositor::controller>(r, name, v);
 348
 349          // Init controller hooks
 350          this->controller->chooks = &this->chooks;
 351
 352          // This protocol needs the output, so lets just add our mapping here...
 353          this->controller->add_proxy_to_id_mapping(
 354             this->outputs.back()->proxy.get(),
 355             wl_proxy_get_id(reinterpret_cast<struct wl_proxy *>(
 356                this->outputs.back()->proxy.get())));
 357
 358          // Create screen
 359          this->controller->create_screen(this->outputs.back()->proxy.get());
 360
 361          // Set display to controller
 362          this->controller->display = this->display;
 363       });
 364
 365    // First level objects
 366    this->display->roundtrip();
 367    // Second level objects
 368    this->display->roundtrip();
 369    // Third level objects
 370    this->display->roundtrip();
 371
 372    return init_layers();
 373 }
 374
 375 int App::dispatch_pending_events() {
 376    if (this->pop_pending_events()) {
 377       this->display->dispatch_pending();
 378       return 0;
 379    }
 380    return -1;
 381 }
 382
 383 bool App::pop_pending_events() {
 384    bool x{true};
 385    return this->pending_events.compare_exchange_strong(
 386       x, false, std::memory_order_consume);
 387 }
 388
 389 void App::set_pending_events() {
 390    this->pending_events.store(true, std::memory_order_release);
 391 }
 392
 393 optional<int> App::lookup_id(char const *name) {
 394    return this->id_alloc.lookup(std::string(name));
 395 }
 396 optional<std::string> App::lookup_name(int id) {
 397    return this->id_alloc.lookup(id);
 398 }
 399
 400 /**
 401  * init_layers()
 402  */
 403 int App::init_layers() {
 404    if (!this->controller) {
 405       HMI_ERROR("wm", "ivi_controller global not available");
 406       return -1;
 407    }
 408
 409    if (this->outputs.empty()) {
 410       HMI_ERROR("wm", "no output was set up!");
 411       return -1;
 412    }
 413
 414    auto &c = this->controller;
 415
 416    auto &o = this->outputs.front();
 417    auto &s = c->screens.begin()->second;
 418    auto &layers = c->layers;
 419
 420    // Write output dimensions to ivi controller...
 421    c->output_size = compositor::size{uint32_t(o->width), uint32_t(o->height)};
 422    c->physical_size = compositor::size{uint32_t(o->physical_width),
 423                                        uint32_t(o->physical_height)};
 424
 425    // Clear scene
 426    layers.clear();
 427
 428    // Clear screen
 429    s->clear();
 430
 431    // Quick and dirty setup of layers
 432    for (auto const &i : this->layers.mapping) {
 433       c->layer_create(i.second.layer_id, o->width, o->height);
 434       auto &l = layers[i.second.layer_id];
 435       l->set_destination_rectangle(0, 0, o->width, o->height);
 436       l->set_visibility(1);
 437       HMI_DEBUG("wm", "Setting up layer %s (%d) for surface role match \"%s\"",
 438                i.second.name.c_str(), i.second.layer_id, i.second.role.c_str());
 439    }
 440
 441    // Add layers to screen
 442    s->set_render_order(this->layers.layers);
 443
 444    this->layout_commit();
 445
 446    return 0;
 447 }
 448
 449 void App::layout_commit() {
 450    this->controller->commit_changes();
 451    this->display->flush();
 452 }
 453
 454 const char* App::convertDrawingNameToRole(char const *drawing_name) {
 455     const char* role;
 456
 457     if (this->drawingname2role_.find(drawing_name) != this->drawingname2role_.end()) {
 458         // drawing_name is old role. So convert to new role.
 459         role = this->drawingname2role_[drawing_name].c_str();
 460     }
 461     else {
 462         // drawing_name is new role.
 463         role = drawing_name;
 464     }
 465     HMI_DEBUG("wm", "drawing_name:%s -> role: %s", drawing_name, role);
 466
 467     return role;
 468 }
 469
 470 void App::allocateWindowResource(char const *event, char const *drawing_name,
 471                                  char const *drawing_area, const reply_func &reply) {
 472     const char* new_role = nullptr;
 473     const char* new_area = nullptr;
 474
 475     // Convert old role to new role
 476     if ((nullptr != drawing_name) && (0 != strcmp("", drawing_name))) {
 477         new_role = this->convertDrawingNameToRole(drawing_name);
 478     }
 479
 480     if (0 == strcmp("activate", event)) {
 481         // TODO:
 482         // This process will be removed
 483         // because the area "normal.full" and "normalfull" will be prohibited
 484         {
 485             if (0 == strcmp("restriction", new_role)) {
 486                 new_area = drawing_area;
 487             }
 488             else {
 489                 if (nullptr == drawing_area) {
 490                     new_area = "normal";
 491                 }
 492                 else if (0 == strcmp("normal.full", drawing_area)) {
 493                     new_area = "normal";
 494                 }
 495                 else if (0 == strcmp("restriction.split.sub", drawing_area)) {
 496                     new_area = "restriction.split.sub";
 497                 }
 498                 else if (0 == strcmp("homescreen", new_role)) {
 499                     // Now homescreen specifies "normalfull"
 500                     new_area = "full";
 501                 }
 502                 else {
 503                     new_area = "normal";
 504                 }
 505             }
 506             HMI_DEBUG("wm", "drawing_area:%s, new_area: %s", drawing_area, new_area);
 507         }
 508     }
 509     else if (0 == strcmp("deactivate", event)) {
 510         new_area = "";
 511     }
 512
 513     // TODO:
 514     // Check role
 515
 516     // TODO:
 517     // If event is "activate" and area is not specifid,
 518     // get default value by using role
 519
 520     // Input event to PolicyManager
 521     json_object* json_in = json_object_new_object();
 522     json_object_object_add(json_in, "event", json_object_new_string(event));
 523     if (nullptr != new_role) {
 524         json_object_object_add(json_in, "role", json_object_new_string(new_role));
 525     }
 526     if (nullptr != new_area) {
 527         json_object_object_add(json_in, "area", json_object_new_string(new_area));
 528     }
 529     rm::g_new_role = new_role;  // TODO: workaround
 530     this->pm_.inputEvent(json_in);
 531
 532     // Release json_object
 533     json_object_put(json_in);
 534
 535     return;
 536 }
 537
 538 void App::enqueue_flushdraw(int surface_id) {
 539    this->check_flushdraw(surface_id);
 540    HMI_DEBUG("wm", "Enqueuing EndDraw for surface_id %d", surface_id);
 541    this->pending_end_draw.push_back(surface_id);
 542 }
 543
 544 void App::check_flushdraw(int surface_id) {
 545    auto i = std::find(std::begin(this->pending_end_draw),
 546                       std::end(this->pending_end_draw), surface_id);
 547    if (i != std::end(this->pending_end_draw)) {
 548       auto n = this->lookup_name(surface_id);
 549       HMI_ERROR("wm", "Application %s (%d) has pending EndDraw call(s)!",
 550                n ? n->c_str() : "unknown-name", surface_id);
 551       std::swap(this->pending_end_draw[std::distance(
 552                    std::begin(this->pending_end_draw), i)],
 553                 this->pending_end_draw.back());
 554       this->pending_end_draw.resize(this->pending_end_draw.size() - 1);
 555    }
 556 }
 557
 558 void App::api_enddraw(char const *appid, char const *drawing_name) {
 559    // Convert drawing_name to role
 560    const char* role = this->convertDrawingNameToRole(drawing_name);
 561
 562    for (unsigned i = 0, iend = this->pending_end_draw.size(); i < iend; i++) {
 563       auto n = this->lookup_name(this->pending_end_draw[i]);
 564       if (n && *n == role) {
 565          std::swap(this->pending_end_draw[i], this->pending_end_draw[iend - 1]);
 566          this->pending_end_draw.resize(iend - 1);
 567          this->activate(this->pending_end_draw[i]);
 568          this->emit_flushdraw(drawing_name);
 569          this->emitScreenUpdated(appid);
 570       }
 571    }
 572 }
 573
 574 void App::api_ping() { this->dispatch_pending_events(); }
 575
 576 void App::send_event(char const *evname){
 577    HMI_DEBUG("wm", "%s: %s", __func__, evname);
 578
 579    int ret = afb_event_push(this->map_afb_event[evname], nullptr);
 580    if (ret != 0) {
 581       HMI_DEBUG("wm", "afb_event_push failed: %m");
 582    }
 583 }
 584
 585 void App::send_event(char const *evname, char const *label){
 586    HMI_DEBUG("wm", "%s: %s(%s)", __func__, evname, label);
 587
 588    json_object *j = json_object_new_object();
 589    json_object_object_add(j, kKeyDrawingName, json_object_new_string(label));
 590
 591    int ret = afb_event_push(this->map_afb_event[evname], j);
 592    if (ret != 0) {
 593       HMI_DEBUG("wm", "afb_event_push failed: %m");
 594    }
 595 }
 596
 597 void App::send_event(char const *evname, char const *label, char const *area,
 598                              int x, int y, int w, int h) {
 599    HMI_DEBUG("wm", "%s: %s(%s, %s) x:%d y:%d w:%d h:%d",
 600              __func__, evname, label, area, x, y, w, h);
 601
 602    json_object *j_rect = json_object_new_object();
 603    json_object_object_add(j_rect, kKeyX,      json_object_new_int(x));
 604    json_object_object_add(j_rect, kKeyY,      json_object_new_int(y));
 605    json_object_object_add(j_rect, kKeyWidth,  json_object_new_int(w));
 606    json_object_object_add(j_rect, kKeyHeight, json_object_new_int(h));
 607
 608    json_object *j = json_object_new_object();
 609    json_object_object_add(j, kKeyDrawingName, json_object_new_string(label));
 610    json_object_object_add(j, kKeyDrawingArea, json_object_new_string(area));
 611    json_object_object_add(j, kKeyDrawingRect, j_rect);
 612
 613    int ret = afb_event_push(this->map_afb_event[evname], j);
 614    if (ret != 0) {
 615       HMI_DEBUG("wm", "afb_event_push failed: %m");
 616    }
 617 }
 618
 619 /**
 620  * proxied events
 621  */
 622 void App::surface_created(uint32_t surface_id) {
 623    auto layer_id = this->layers.get_layer_id(surface_id);
 624    if (!layer_id) {
 625       HMI_DEBUG("wm", "Newly created surfce %d is not associated with any layer!",
 626                surface_id);
 627       return;
 628    }
 629
 630    HMI_DEBUG("wm", "surface_id is %u, layer_id is %u", surface_id, *layer_id);
 631
 632    this->controller->layers[*layer_id]->add_surface(surface_id);
 633    this->layout_commit();
 634    // activate the main_surface right away
 635    /*if (surface_id == static_cast<unsigned>(this->layers.main_surface)) {
 636       HMI_DEBUG("wm", "Activating main_surface (%d)", surface_id);
 637
 638       this->api_activate_surface(
 639          this->lookup_name(surface_id).value_or("unknown-name").c_str());
 640    }*/
 641 }
 642
 643 void App::surface_removed(uint32_t surface_id) {
 644    HMI_DEBUG("wm", "surface_id is %u", surface_id);
 645
 646    // We cannot normally deactivate the main_surface, so be explicit
 647    // about it:
 648    if (int(surface_id) == this->layers.main_surface) {
 649       this->deactivate_main_surface();
 650    } else {
 651       auto role = this->lookup_name(surface_id);
 652       if (role) {
 653          this->allocateWindowResource("deactivate",
 654                                       role->c_str(), nullptr,
 655                                       [](const char*){});
 656       }
 657    }
 658
 659    this->id_alloc.remove_id(surface_id);
 660    this->layers.remove_surface(surface_id);
 661 }
 662
 663 void App::emit_activated(char const *label) {
 664    this->send_event(kListEventName[Event_Active], label);
 665 }
 666
 667 void App::emit_deactivated(char const *label) {
 668    this->send_event(kListEventName[Event_Inactive], label);
 669 }
 670
 671 void App::emit_syncdraw(char const *label, char const *area, int x, int y, int w, int h) {
 672    this->send_event(kListEventName[Event_SyncDraw], label, area, x, y, w, h);
 673 }
 674
 675 void App::emit_flushdraw(char const *label) {
 676    this->send_event(kListEventName[Event_FlushDraw], label);
 677 }
 678
 679 void App::emit_visible(char const *label, bool is_visible) {
 680    this->send_event(is_visible ? kListEventName[Event_Visible] : kListEventName[Event_Invisible], label);
 681 }
 682
 683 void App::emit_invisible(char const *label) {
 684    return emit_visible(label, false);
 685 }
 686
 687 void App::__send_event_temporary_extend(char const *evname, char const *appid) {
 688     HMI_DEBUG("wm", "send event %s: %s", evname, appid);
 689
 690     json_object *j = json_object_new_object();
 691     json_object_object_add(j, kKeyAppID, json_object_new_string(appid));
 692
 693     int ret = afb_event_push(this->map_afb_event[evname], j);
 694     if (ret != 0) {
 695         HMI_DEBUG("wm", "afb_event_push failed: %m");
 696     }
 697 }
 698
 699 void App::emit_visible(char const *label) { return emit_visible(label, true); }
 700
 701 void App::emitHeadlampOff() {
 702     // Send HeadlampOff event for all application
 703     this->send_event(kListEventName[Event_HeadlampOff]);
 704 }
 705
 706 void App::emitHeadlampOn() {
 707     // Send HeadlampOn event for all application
 708     this->send_event(kListEventName[Event_HeadlampOn]);
 709 }
 710
 711 void App::emitParkingBrakeOff() {
 712     // Send ParkingBrakeOff event for all application
 713     this->send_event(kListEventName[Event_ParkingBrakeOff]);
 714 }
 715
 716 void App::emitParkingBrakeOn() {
 717     // Send ParkingBrakeOn event for all application
 718     this->send_event(kListEventName[Event_ParkingBrakeOn]);
 719 }
 720
 721 void App::emitLightstatusBrakeOff() {
 722     // Send LightstatusBrakeOff event for all application
 723     this->send_event(kListEventName[Event_LightstatusBrakeOff]);
 724 }
 725
 726 void App::emitLightstatusBrakeOn() {
 727     // Send LightstatusBrakeOn event for all application
 728     this->send_event(kListEventName[Event_LightstatusBrakeOn]);
 729 }
 730
 731 void App::emitCarStop() {
 732     // Send CarStop event for all application
 733     this->send_event(kListEventName[Event_CarStop]);
 734 }
 735
 736 void App::emitCarRun() {
 737     // Send CarRun event for all application
 738     this->send_event(kListEventName[Event_CarRun]);
 739 }
 740
 741 void App::emitScreenUpdated(char const* appid) {
 742     // Send ScreenUpdated event for applications which calls wmsubscribe
 743     this->__send_event_temporary_extend(kListEventName[Event_ScreenUpdated], appid);
 744 }
 745
 746 result<int> App::api_request_surface(char const *drawing_name) {
 747    // Convert drawing_name to role
 748    const char* role = this->convertDrawingNameToRole(drawing_name);
 749    auto lid = this->layers.get_layer_id(std::string(role));
 750    if (!lid) {
 751       /**
 752        * register drawing_name as fallback and make it displayed.
 753        */
 754       lid = this->layers.get_layer_id(std::string("Fallback"));
 755       HMI_DEBUG("wm", "%s is not registered in layers.json, then fallback as normal app", drawing_name);
 756       if(!lid){
 757           return Err<int>("Drawing name does not match any role, Fallback is disabled");
 758       }
 759    }
 760
 761    auto rname = this->lookup_id(role);
 762    if (!rname) {
 763       // name does not exist yet, allocate surface id...
 764       auto id = int(this->id_alloc.generate_id(role));
 765       this->layers.add_surface(id, *lid);
 766
 767       // set the main_surface[_name] here and now
 768       if (!this->layers.main_surface_name.empty() &&
 769           this->layers.main_surface_name == drawing_name) {
 770          this->layers.main_surface = id;
 771          HMI_DEBUG("wm", "Set main_surface id to %u", id);
 772       }
 773
 774       // Set map of (role, surface_id)
 775       this->role2surfaceid_[role] = id;
 776
 777       // Set map of (role, drawing_name)
 778       this->role2drawingname_[role] = std::string(drawing_name);
 779
 780       return Ok<int>(id);
 781    }
 782
 783    // Check currently registered drawing names if it is already there.
 784    return Err<int>("Surface already present");
 785 }
 786
 787 char const *App::api_request_surface(char const *drawing_name,
 788                                      char const *ivi_id) {
 789    ST();
 790
 791    auto lid = this->layers.get_layer_id(std::string(drawing_name));
 792    unsigned sid = std::stol(ivi_id);
 793
 794    if (!lid) {
 795       /**
 796        * register drawing_name as fallback and make it displayed.
 797        */
 798       lid = this->layers.get_layer_id(std::string("Fallback"));
 799       HMI_DEBUG("wm", "%s is not registered in layers.json, then fallback as normal app", drawing_name);
 800       if(!lid){
 801           return "Drawing name does not match any role, Fallback is disabled";
 802       }
 803    }
 804
 805    auto rname = this->lookup_id(drawing_name);
 806
 807    if (rname) {
 808        return "Surface already present";
 809    }
 810
 811    // register pair drawing_name and ivi_id
 812    this->id_alloc.register_name_id(drawing_name, sid);
 813    this->layers.add_surface(sid, *lid);
 814
 815    // this surface is already created
 816    HMI_DEBUG("wm", "surface_id is %u, layer_id is %u", sid, *lid);
 817
 818    this->controller->layers[*lid]->add_surface(sid);
 819    this->layout_commit();
 820
 821    return nullptr;
 822 }
 823
 824 result<json_object *> App::api_get_display_info() {
 825    // Check controller
 826    if (!this->controller) {
 827       return Err<json_object *>("ivi_controller global not available");
 828    }
 829
 830    // Set display info
 831    compositor::size o_size = this->controller->output_size;
 832    compositor::size p_size = this->controller->physical_size;
 833
 834    json_object *object = json_object_new_object();
 835    json_object_object_add(object, kKeyWidthPixel,  json_object_new_int(o_size.w));
 836    json_object_object_add(object, kKeyHeightPixel, json_object_new_int(o_size.h));
 837    json_object_object_add(object, kKeyWidthMm,     json_object_new_int(p_size.w));
 838    json_object_object_add(object, kKeyHeightMm,    json_object_new_int(p_size.h));
 839
 840    return Ok<json_object *>(object);
 841 }
 842
 843 result<json_object *> App::api_get_area_info(char const *drawing_name) {
 844    HMI_DEBUG("wm", "called");
 845
 846    // Convert drawing_name to role
 847    const char* role = this->convertDrawingNameToRole(drawing_name);
 848
 849    // Check drawing name, surface/layer id
 850    auto const &surface_id = this->lookup_id(role);
 851    if (!surface_id) {
 852       return Err<json_object *>("Surface does not exist");
 853    }
 854
 855    if (!this->controller->surface_exists(*surface_id)) {
 856       return Err<json_object *>("Surface does not exist in controller!");
 857    }
 858
 859    auto layer_id = this->layers.get_layer_id(*surface_id);
 860    if (!layer_id) {
 861       return Err<json_object *>("Surface is not on any layer!");
 862    }
 863
 864    auto o_state = *this->layers.get_layout_state(*surface_id);
 865    if (o_state == nullptr) {
 866       return Err<json_object *>("Could not find layer for surface");
 867    }
 868
 869    // Set area rectangle
 870    compositor::rect area_info = this->area_info[*surface_id];
 871    json_object *object = json_object_new_object();
 872    json_object_object_add(object, kKeyX,      json_object_new_int(area_info.x));
 873    json_object_object_add(object, kKeyY,      json_object_new_int(area_info.y));
 874    json_object_object_add(object, kKeyWidth,  json_object_new_int(area_info.w));
 875    json_object_object_add(object, kKeyHeight, json_object_new_int(area_info.h));
 876
 877    return Ok<json_object *>(object);
 878 }
 879
 880 result<json_object *> App::api_get_car_info(char const *label) {
 881     HMI_DEBUG("wm", "called");
 882
 883     json_object *j_in  = nullptr;
 884     json_object *j_out = nullptr;
 885
 886     if (0 == strcmp("parking_brake_status", label)) {
 887         // Get parking brake status
 888         json_bool val = this->crr_car_info_.parking_brake_stt;
 889         j_in = json_object_new_boolean(val);
 890     }
 891     else if (0 == strcmp("accelerator.pedal.position", label)) {
 892         // Get accelerator pedal position
 893         double val = this->crr_car_info_.accel_pedal_pos;
 894         j_in = json_object_new_double(val);
 895     }
 896     else if (0 == strcmp("car_state", label)) {
 897         // Get car state
 898         const char* val = this->crr_car_info_.car_stt;
 899         j_in = json_object_new_string(val);
 900     }
 901     else if (0 == strcmp("lightstatus.brake", label)) {
 902         // Get lightstatus brake status
 903         json_bool val = this->crr_car_info_.lightstatus_brake_stt;
 904         j_in = json_object_new_boolean(val);
 905     }
 906     else {
 907        return Err<json_object *>("Car info does not exist");
 908     }
 909
 910     // Create output object
 911     j_out = json_object_new_object();
 912     json_object_object_add(j_out, "value", j_in);
 913
 914     return Ok<json_object *>(j_out);
 915 }
 916
 917 void App::activate(int id) {
 918    auto ip = this->controller->sprops.find(id);
 919    if (ip != this->controller->sprops.end()) {
 920       this->controller->surfaces[id]->set_visibility(1);
 921       char const *label =
 922          this->lookup_name(id).value_or("unknown-name").c_str();
 923
 924       if ((0 == strcmp(label, "radio"))
 925           || (0 == strcmp(label, "music"))
 926           || (0 == strcmp(label, "video"))
 927           || (0 == strcmp(label, "map"))) {
 928         for (auto i = surface_bg.begin(); i != surface_bg.end(); ++i) {
 929             if (id == *i) {
 930                // Remove id
 931                this->surface_bg.erase(i);
 932
 933                // Remove from BG layer (999)
 934                HMI_DEBUG("wm", "Remove %s(%d) from BG layer", label, id);
 935                this->controller->layers[999]->remove_surface(id);
 936
 937                // Add to FG layer (1001)
 938                HMI_DEBUG("wm", "Add %s(%d) to FG layer", label, id);
 939                this->controller->layers[1001]->add_surface(id);
 940
 941                for (int j : this->surface_bg) {
 942                  HMI_DEBUG("wm", "Stored id:%d", j);
 943                }
 944                break;
 945             }
 946          }
 947       }
 948
 949       this->layout_commit();
 950
 951       this->emit_visible(label);
 952       this->emit_activated(label);
 953    }
 954 }
 955
 956 void App::deactivate(int id) {
 957    auto ip = this->controller->sprops.find(id);
 958    if (ip != this->controller->sprops.end()) {
 959       char const *label =
 960          this->lookup_name(id).value_or("unknown-name").c_str();
 961
 962       if ((0 == strcmp(label, "radio"))
 963           || (0 == strcmp(label, "music"))
 964           || (0 == strcmp(label, "video"))
 965           || (0 == strcmp(label, "map"))) {
 966
 967          // Store id
 968          this->surface_bg.push_back(id);
 969
 970          // Remove from FG layer (1001)
 971          HMI_DEBUG("wm", "Remove %s(%d) from FG layer", label, id);
 972          this->controller->layers[1001]->remove_surface(id);
 973
 974          // Add to BG layer (999)
 975          HMI_DEBUG("wm", "Add %s(%d) to BG layer", label, id);
 976          this->controller->layers[999]->add_surface(id);
 977
 978          for (int j : surface_bg) {
 979             HMI_DEBUG("wm", "Stored id:%d", j);
 980          }
 981       }
 982       else {
 983          this->controller->surfaces[id]->set_visibility(0);
 984       }
 985
 986       this->layout_commit();
 987
 988       this->emit_deactivated(label);
 989       this->emit_invisible(label);
 990    }
 991 }
 992
 993 void App::deactivate(std::string role) {
 994     auto const &id = this->lookup_id(role.c_str());
 995     if (!id) {
 996       HMI_ERROR("wm", "Surface does not exist");
 997       return;
 998     }
 999     std::string drawing_name = this->role2drawingname_[role];
1000     HMI_DEBUG("wm", "Deactivate role:%s (drawing_name:%s)",
1001               role.c_str(), drawing_name.c_str());
1002
1003     this->deactivate(*id);
1004 }
1005
1006 void App::deactivate_main_surface() {
1007    this->layers.main_surface = -1;
1008    this->allocateWindowResource("deactivate",
1009                                 this->layers.main_surface_name.c_str(), nullptr,
1010                                 [](const char*){});
1011 }
1012
1013 /**
1014  * controller_hooks
1015  */
1016 void controller_hooks::surface_created(uint32_t surface_id) {
1017    this->app->surface_created(surface_id);
1018 }
1019
1020 void controller_hooks::surface_removed(uint32_t surface_id) {
1021    this->app->surface_removed(surface_id);
1022 }
1023
1024 void controller_hooks::surface_visibility(uint32_t /*surface_id*/,
1025                                           uint32_t /*v*/) {}
1026
1027 void controller_hooks::surface_destination_rectangle(uint32_t /*surface_id*/,
1028                                                      uint32_t /*x*/,
1029                                                      uint32_t /*y*/,
1030                                                      uint32_t /*w*/,
1031                                                      uint32_t /*h*/) {}
1032
1033 int App::allocateSurface() {
1034     HMI_DEBUG("wm", "Call");
1035
1036     // Get current/previous layers
1037     LayoutManager::TypeLayers crr_layers = this->lm_.getCurrentLayers();
1038     LayoutManager::TypeLayers prv_layers = this->lm_.getPreviousLayers();
1039
1040     // Update resource of all layers
1041     for (auto itr_layers = crr_layers.begin();
1042          itr_layers != crr_layers.end(); ++itr_layers) {
1043         // Get layer
1044         std::string layer = itr_layers->first;
1045         HMI_DEBUG("wm", "Try to update resource in %s layer", layer.c_str());
1046
1047         // If layout is changed, update resouce
1048         if (this->lm_.isLayoutChanged(layer.c_str())) {
1049             // Get current/previous layout
1050             LayoutManager::TypeLayouts crr_layout = itr_layers->second;
1051             LayoutManager::TypeLayouts prv_layout = prv_layers[layer];
1052
1053             // Get current/previous layout name
1054             std::string crr_layout_name = crr_layout.begin()->first;
1055             std::string prv_layout_name = prv_layout.begin()->first;
1056             HMI_DEBUG("wm", "layout name crr:%s prv:%s",
1057                       crr_layout_name.c_str(), prv_layout_name.c_str());
1058
1059             // Get current/previous ares
1060             LayoutManager::TypeAreas crr_areas = crr_layout[crr_layout_name];
1061             LayoutManager::TypeAreas prv_areas = prv_layout[prv_layout_name];
1062
1063             // Create previous displayed role list
1064             std::string prv_area_name;
1065             std::vector<std::string> prv_role_list;
1066             for (auto itr_areas = prv_areas.begin();
1067                  itr_areas != prv_areas.end(); ++itr_areas) {
1068                 prv_area_name = itr_areas->first;
1069                 prv_role_list.push_back(prv_areas[prv_area_name]["role"]);
1070                 HMI_DEBUG("wm", "previous displayed role:%s",
1071                           prv_areas[prv_area_name]["role"].c_str());
1072             }
1073
1074             // Allocate surface for each area
1075             std::string crr_area_name;
1076             std::string crr_role_name;
1077             LayoutManager::TypeRolCtg crr_rol_ctg;
1078             for (auto itr_areas = crr_areas.begin();
1079                  itr_areas != crr_areas.end(); ++itr_areas) {
1080                 crr_area_name = itr_areas->first;
1081                 crr_rol_ctg = itr_areas->second;
1082
1083                 // Get role of current area
1084                 if ("category" == crr_rol_ctg.begin()->first) {
1085                     // If current area have category
1086                     // Get category name
1087                     std::string crr_ctg = crr_rol_ctg.begin()->second;
1088
1089                     // Serch relevant role from previous displayed role list
1090                     for (auto itr_role = prv_role_list.begin();
1091                          itr_role != prv_role_list.end(); ++itr_role) {
1092                         std::string prv_ctg = this->pm_.roleToCategory((*itr_role).c_str());
1093                         if (crr_ctg == prv_ctg) {
1094                             // First discovered role is set to current role
1095                             crr_role_name = *itr_role;
1096
1097                             // Delete used role for other areas
1098                             // which have same category
1099                             prv_role_list.erase(itr_role);
1100
1101                             break;
1102                         }
1103                     }
1104                 }
1105                 else {
1106                     crr_role_name = itr_areas->second["role"];
1107                 }
1108                 HMI_DEBUG("wm", "Allocate surface for area:%s role:%s",
1109                           crr_area_name.c_str(), crr_role_name.c_str());
1110
1111                 // Deactivate non-displayed role
1112                 std::string prv_role_name;
1113                 if (crr_layout_name == prv_layout_name) {
1114                     HMI_DEBUG("wm", "Current layout is same with previous");
1115
1116                     // Deactivate previous role in same area
1117                     // if it is different with current
1118                     prv_role_name = prv_areas[crr_area_name]["role"];
1119                     if (crr_role_name != prv_role_name) {
1120                         this->deactivate(prv_role_name);
1121                     }
1122                 }
1123                 else {
1124                     HMI_DEBUG("wm", "Current layout is different with previous");
1125
1126                     if ("none" != prv_layout_name) {
1127                         // Deactivate previous role in all area in previous layout
1128                         // if it is different with current role
1129                         for(auto itr = prv_areas.begin(); itr != prv_areas.end(); ++itr) {
1130                             prv_role_name = itr->second["role"].c_str();
1131                             if (crr_role_name != prv_role_name) {
1132                                 this->deactivate(prv_role_name);
1133                             }
1134                         }
1135                     }
1136                 }
1137
1138                 // Set surface for displayed role
1139                 if ("none" != crr_layout_name) {
1140                     // If current layout is not "none",
1141                     // set surface for current role
1142                     this->setSurfaceSize(crr_role_name.c_str(), crr_area_name.c_str());
1143
1144                     // TODO:
1145                     // This API is workaround.
1146                     // Resource manager should manage each resource infomations
1147                     // according to architecture document.
1148                     this->lm_.updateArea(layer.c_str(), crr_role_name.c_str(), crr_area_name.c_str());
1149                 }
1150             }
1151         }
1152     }
1153     return 0;
1154 }
1155
1156 void App::setSurfaceSize(const char* role, const char* area) {
1157     HMI_DEBUG("wm", "role:%s area:%s", role, area);
1158
1159     // Get size of current area
1160     compositor::rect size = this->lm_.getAreaSize(area);
1161
1162     // Set destination to the display rectangle
1163     int surface_id = this->role2surfaceid_[role];
1164
1165     if (!this->controller->surface_exists(surface_id)) {
1166         // Block until all pending request are processed by wayland display server
1167         // because waiting for the surface of new app is created
1168         this->display->roundtrip();
1169     }
1170     auto &s = this->controller->surfaces[surface_id];
1171     s->set_destination_rectangle(size.x, size.y, size.w, size.h);
1172     this->layout_commit();
1173
1174     // Update area information
1175     this->area_info[surface_id].x = size.x;
1176     this->area_info[surface_id].y = size.y;
1177     this->area_info[surface_id].w = size.w;
1178     this->area_info[surface_id].h = size.h;
1179     HMI_DEBUG("wm", "Surface rect { %d, %d, %d, %d }",
1180               size.x, size.y, size.w, size.h);
1181
1182     // Emit syncDraw event
1183     const char* drawing_name = this->role2drawingname_[role].c_str();
1184     this->emit_syncdraw(drawing_name, area,
1185                         size.x, size.y, size.w, size.h);
1186
1187     // Enqueue flushDraw event
1188     this->enqueue_flushdraw(surface_id);
1189 }
1190
1191 void App::setAccelPedalPos(double val) {
1192     this->crr_car_info_.accel_pedal_pos = val;
1193 }
1194
1195 extern const char* kDefaultAppDb;
1196 int App::loadAppDb() {
1197     HMI_DEBUG("wm", "Call");
1198
1199     // Get afm application installed dir
1200     char const *afm_app_install_dir = getenv("AFM_APP_INSTALL_DIR");
1201     HMI_DEBUG("wm", "afm_app_install_dir:%s", afm_app_install_dir);
1202
1203     std::string file_name;
1204     if (!afm_app_install_dir) {
1205         HMI_ERROR("wm", "AFM_APP_INSTALL_DIR is not defined");
1206     }
1207     else {
1208         file_name = std::string(afm_app_install_dir) + std::string("/etc/app.db");
1209     }
1210
1211     // Load app.db
1212     json_object* json_obj;
1213     int ret = jh::inputJsonFilie(file_name.c_str(), &json_obj);
1214     if (0 > ret) {
1215         HMI_ERROR("wm", "Could not open app.db, so use default role information");
1216         json_obj = json_tokener_parse(kDefaultAppDb);
1217     }
1218     HMI_DEBUG("wm", "json_obj dump:%s", json_object_get_string(json_obj));
1219
1220     // Perse apps
1221     HMI_DEBUG("wm", "Perse apps");
1222     json_object* json_cfg;
1223     if (!json_object_object_get_ex(json_obj, "apps", &json_cfg)) {
1224         HMI_ERROR("wm", "Parse Error!!");
1225         return -1;
1226     }
1227
1228     int len = json_object_array_length(json_cfg);
1229     HMI_DEBUG("wm", "json_cfg len:%d", len);
1230     HMI_DEBUG("wm", "json_cfg dump:%s", json_object_get_string(json_cfg));
1231
1232     for (int i=0; i<len; i++) {
1233         json_object* json_tmp = json_object_array_get_idx(json_cfg, i);
1234         HMI_DEBUG("wm", "> json_tmp dump:%s", json_object_get_string(json_tmp));
1235
1236         const char* app = jh::getStringFromJson(json_tmp, "name");
1237         if (nullptr == app) {
1238             HMI_ERROR("wm", "Parse Error!!");
1239             return -1;
1240         }
1241         HMI_DEBUG("wm", "> app:%s", app);
1242
1243         const char* role = jh::getStringFromJson(json_tmp, "role");
1244         if (nullptr == role) {
1245             HMI_ERROR("wm", "Parse Error!!");
1246             return -1;
1247         }
1248         HMI_DEBUG("wm", "> role:%s", role);
1249
1250         this->drawingname2role_[app] = std::string(role);
1251     }
1252
1253     // Check
1254     for(auto itr = this->drawingname2role_.begin();
1255       itr != this->drawingname2role_.end(); ++itr) {
1256         HMI_DEBUG("wm", "app:%s role:%s",
1257                   itr->first.c_str(), itr->second.c_str());
1258     }
1259
1260     // Release json_object
1261     json_object_put(json_obj);
1262
1263     return 0;
1264 }
1265
1266
1267 const char* kDefaultAppDb = "{ \
1268     \"apps\": [ \
1269         { \
1270             \"name\": \"HomeScreen\", \
1271             \"role\": \"homescreen\" \
1272         }, \
1273         { \
1274             \"name\": \"Music\", \
1275             \"role\": \"music\" \
1276         }, \
1277         { \
1278             \"name\": \"MediaPlayer\", \
1279             \"role\": \"music\" \
1280         }, \
1281         { \
1282             \"name\": \"Video\", \
1283             \"role\": \"video\" \
1284         }, \
1285         { \
1286             \"name\": \"VideoPlayer\", \
1287             \"role\": \"video\" \
1288         }, \
1289         { \
1290             \"name\": \"WebBrowser\", \
1291             \"role\": \"browser\" \
1292         }, \
1293         { \
1294             \"name\": \"Radio\", \
1295             \"role\": \"radio\" \
1296         }, \
1297         { \
1298             \"name\": \"Phone\", \
1299             \"role\": \"phone\" \
1300         }, \
1301         { \
1302             \"name\": \"Navigation\", \
1303             \"role\": \"map\" \
1304         }, \
1305         { \
1306             \"name\": \"HVAC\", \
1307             \"role\": \"hvac\" \
1308         }, \
1309         { \
1310             \"name\": \"Settings\", \
1311             \"role\": \"settings\" \
1312         }, \
1313         { \
1314             \"name\": \"Dashboard\", \
1315             \"role\": \"dashboard\" \
1316         }, \
1317         { \
1318             \"name\": \"POI\", \
1319             \"role\": \"poi\" \
1320         }, \
1321         { \
1322             \"name\": \"Mixer\", \
1323             \"role\": \"mixer\" \
1324         } \
1325     ] \
1326 }";
1327
1328
1329 }  // namespace wm