add source for ces2019

2 files changed, 195 insertions, 2 deletions

diff --git a/src/libwindowmanager.cpp b/src/libwindowmanager.cpp
index 515fea1..dfc0886 100644
--- a/src/libwindowmanager.cpp
+++ b/src/libwindowmanager.cpp
@@ -70,6 +70,7 @@ class LibWindowmanager::Impl {
     int api_call(const char *verb, json_object *object,
                  const std::function<void(bool, json_object *)> &onReply);
     void event(char const *et, json_object *object);
+    void event(char const *et);
 private:
     int runEventLoop();
 
@@ -88,6 +89,14 @@ private:
       std::string("syncDraw"),
       std::string("flushDraw"),
       std::string("screenUpdated"),
+      std::string("headlampOff"),
+      std::string("headlampOn"),
+      std::string("parkingBrakeOff"),
+      std::string("parkingBrakeOn"),
+      std::string("lightstatusBrakeOff"),
+      std::string("lightstatusBrakeOn"),
+      std::string("carStop"),
+      std::string("carRun"),
       std::string("error")
     };
 
@@ -147,7 +156,7 @@ void onEvent(void *closure, const char *event, afb_wsj1_msg *msg) {
         static_cast<LibWindowmanager::Impl *>(closure)->event(event, val);
     }
     else {
-        HMI_ERROR("libwm", "Not found key \"data\"");
+        static_cast<LibWindowmanager::Impl *>(closure)->event(event);
     }
 }
 
@@ -613,6 +622,14 @@ std::pair<bool, LibWindowmanager::EventType> make_event_type(char const *et) {
     ET("syncdraw", SyncDraw);
     ET("flushdraw", FlushDraw);
     ET("screenUpdated", ScreenUpdated);
+    ET("headlampOff", HeadlampOff);
+    ET("headlampOn", HeadlampOn);
+    ET("parkingBrakeOff", ParkingBrakeOff);
+    ET("parkingBrakeOn", ParkingBrakeOn);
+    ET("lightstatusBrakeOff", LightstatusBrakeOff);
+    ET("lightstatusBrakeOn", LightstatusBrakeOn);
+    ET("carStop", CarStop);
+    ET("carRun", CarRun);
     ET("error", Error);
 #undef ET
 
@@ -754,12 +771,100 @@ void LibWindowmanager::Impl::setEventHandler(const WMHandler &wmh)
         }
     }
 
+    if(wmh.on_headlamp_off != nullptr) {
+        struct json_object* j = json_object_new_object();
+        json_object_object_add(j, ev, json_object_new_int(Event_HeadlampOff));
+
+        int ret = afb_wsj1_call_j(this->wsj1, wmAPI, "wm_subscribe", j, _on_reply_static, this);
+        if (0 > ret) {
+            HMI_ERROR("libwm", "Failed to subscribe event active");
+        }
+    }
+
+    if(wmh.on_headlamp_on != nullptr) {
+        struct json_object* j = json_object_new_object();
+        json_object_object_add(j, ev, json_object_new_int(Event_HeadlampOn));
+
+        int ret = afb_wsj1_call_j(this->wsj1, wmAPI, "wm_subscribe", j, _on_reply_static, this);
+        if (0 > ret) {
+            HMI_ERROR("libwm", "Failed to subscribe event active");
+        }
+    }
+
+    if(wmh.on_parking_brake_off != nullptr) {
+        struct json_object* j = json_object_new_object();
+        json_object_object_add(j, ev, json_object_new_int(Event_ParkingBrakeOff));
+
+        int ret = afb_wsj1_call_j(this->wsj1, wmAPI, "wm_subscribe", j, _on_reply_static, this);
+        if (0 > ret) {
+            HMI_ERROR("libwm", "Failed to subscribe event active");
+        }
+    }
+
+    if(wmh.on_parking_brake_on != nullptr) {
+        struct json_object* j = json_object_new_object();
+        json_object_object_add(j, ev, json_object_new_int(Event_ParkingBrakeOn));
+
+        int ret = afb_wsj1_call_j(this->wsj1, wmAPI, "wm_subscribe", j, _on_reply_static, this);
+        if (0 > ret) {
+            HMI_ERROR("libwm", "Failed to subscribe event active");
+        }
+    }
+
+    if(wmh.on_lightstatus_brake_off != nullptr) {
+        struct json_object* j = json_object_new_object();
+        json_object_object_add(j, ev, json_object_new_int(Event_LightstatusBrakeOff));
+
+        int ret = afb_wsj1_call_j(this->wsj1, wmAPI, "wm_subscribe", j, _on_reply_static, this);
+        if (0 > ret) {
+            HMI_ERROR("libwm", "Failed to subscribe event active");
+        }
+    }
+
+    if(wmh.on_lightstatus_brake_on != nullptr) {
+        struct json_object* j = json_object_new_object();
+        json_object_object_add(j, ev, json_object_new_int(Event_LightstatusBrakeOn));
+
+        int ret = afb_wsj1_call_j(this->wsj1, wmAPI, "wm_subscribe", j, _on_reply_static, this);
+        if (0 > ret) {
+            HMI_ERROR("libwm", "Failed to subscribe event active");
+        }
+    }
+
+    if(wmh.on_car_stop != nullptr) {
+        struct json_object* j = json_object_new_object();
+        json_object_object_add(j, ev, json_object_new_int(Event_CarStop));
+
+        int ret = afb_wsj1_call_j(this->wsj1, wmAPI, "wm_subscribe", j, _on_reply_static, this);
+        if (0 > ret) {
+            HMI_ERROR("libwm", "Failed to subscribe event active");
+        }
+    }
+
+    if(wmh.on_car_run != nullptr) {
+        struct json_object* j = json_object_new_object();
+        json_object_object_add(j, ev, json_object_new_int(Event_CarRun));
+
+        int ret = afb_wsj1_call_j(this->wsj1, wmAPI, "wm_subscribe", j, _on_reply_static, this);
+        if (0 > ret) {
+            HMI_ERROR("libwm", "Failed to subscribe event active");
+        }
+    }
+
     // Register
     this->_wmh.on_visible = wmh.on_visible;
     this->_wmh.on_active = wmh.on_active;
     this->_wmh.on_sync_draw = wmh.on_sync_draw;
     this->_wmh.on_flush_draw = wmh.on_flush_draw;
     this->_wmh.on_screen_updated = wmh.on_screen_updated;
+    this->_wmh.on_headlamp_off = wmh.on_headlamp_off;
+    this->_wmh.on_headlamp_on = wmh.on_headlamp_on;
+    this->_wmh.on_parking_brake_off = wmh.on_parking_brake_off;
+    this->_wmh.on_parking_brake_on = wmh.on_parking_brake_on;
+    this->_wmh.on_lightstatus_brake_off = wmh.on_lightstatus_brake_off;
+    this->_wmh.on_lightstatus_brake_on = wmh.on_lightstatus_brake_on;
+    this->_wmh.on_car_stop = wmh.on_car_stop;
+    this->_wmh.on_car_run = wmh.on_car_run;
 }
 
 void LibWindowmanager::Impl::event(char const *et, json_object *object) {
@@ -857,6 +962,65 @@ void LibWindowmanager::Impl::event(char const *et, json_object *object) {
     }
 }
 
+void LibWindowmanager::Impl::event(char const *et) {
+    TRACE();
+    auto oet = make_event_type(et);
+    if (!oet.first) {
+        HMI_ERROR("libwm", "Unknown event type string '%s'", et);
+        return;
+    }
+
+    switch(oet.second) {
+        case  Event_HeadlampOff:
+            if(this->_wmh.on_headlamp_off) {
+                return this->_wmh.on_headlamp_off(nullptr);
+            }
+            break;
+        case  Event_HeadlampOn:
+            if(this->_wmh.on_headlamp_on) {
+                return this->_wmh.on_headlamp_on(nullptr);
+            }
+            break;
+        case  Event_ParkingBrakeOff:
+            if(this->_wmh.on_parking_brake_off) {
+                return this->_wmh.on_parking_brake_off(nullptr);
+            }
+            break;
+        case  Event_ParkingBrakeOn:
+            if(this->_wmh.on_parking_brake_on) {
+                return this->_wmh.on_parking_brake_on(nullptr);
+            }
+            break;
+        case  Event_LightstatusBrakeOff:
+            if(this->_wmh.on_lightstatus_brake_off) {
+                return this->_wmh.on_lightstatus_brake_off(nullptr);
+            }
+            break;
+        case  Event_LightstatusBrakeOn:
+            if(this->_wmh.on_lightstatus_brake_on) {
+                return this->_wmh.on_lightstatus_brake_on(nullptr);
+            }
+            break;
+        case  Event_CarStop:
+            if(this->_wmh.on_car_stop) {
+                return this->_wmh.on_car_stop(nullptr);
+            }
+            break;
+        case  Event_CarRun:
+            if(this->_wmh.on_car_run) {
+                return this->_wmh.on_car_run(nullptr);
+            }
+            break;
+        default :
+            break;
+    }
+
+    auto i = this->handlers.find(oet.second);
+    if (i != this->handlers.end()) {
+        i->second(nullptr);
+    }
+}
+
 static void *event_loop_run(void *args){
     struct sd_event* loop = (struct sd_event*)(args);
     for(;;)
@@ -1042,5 +1206,13 @@ WMHandler::WMHandler()
       on_active(nullptr),
       on_sync_draw(nullptr),
       on_flush_draw(nullptr),
-      on_screen_updated(nullptr)
+      on_screen_updated(nullptr),
+      on_headlamp_off(nullptr),
+      on_headlamp_on(nullptr),
+      on_parking_brake_off(nullptr),
+      on_parking_brake_on(nullptr),
+      on_lightstatus_brake_off(nullptr),
+      on_lightstatus_brake_on(nullptr),
+      on_car_stop(nullptr),
+      on_car_run(nullptr)
 {}
diff --git a/src/libwindowmanager.h b/src/libwindowmanager.h
index cc65136..e963798 100644
--- a/src/libwindowmanager.h
+++ b/src/libwindowmanager.h
@@ -62,12 +62,21 @@ class WMHandler {
     using sync_draw_handler = std::function<void(const char*, const char*, Rect)>;
     using flush_draw_handler= std::function<void(const char*)>;
     using screen_updated_handler = std::function<void(const std::vector<std::string>&)>;
+    using car_event_handler= std::function<void(const char*)>;
 
     visible_handler on_visible;
     active_handler on_active;
     sync_draw_handler on_sync_draw;
     flush_draw_handler on_flush_draw;
     screen_updated_handler on_screen_updated;
+    car_event_handler on_headlamp_off;
+    car_event_handler on_headlamp_on;
+    car_event_handler on_parking_brake_off;
+    car_event_handler on_parking_brake_on;
+    car_event_handler on_lightstatus_brake_off;
+    car_event_handler on_lightstatus_brake_on;
+    car_event_handler on_car_stop;
+    car_event_handler on_car_run;
 };
 
 class LibWindowmanager {
@@ -106,6 +115,18 @@ public:
 
        Event_ScreenUpdated,
 
+       Event_HeadlampOff,
+       Event_HeadlampOn,
+
+       Event_ParkingBrakeOff,
+       Event_ParkingBrakeOn,
+
+       Event_LightstatusBrakeOff,
+       Event_LightstatusBrakeOn,
+
+       Event_CarStop,
+       Event_CarRun,
+
        Event_Error,
 
        Event_Val_Max = Event_Error