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