From 55be85ed4bdfea6fc037d781b8cd8f58487718d1 Mon Sep 17 00:00:00 2001
From: Yuta Doi <yuta-d@witz-inc.co.jp>
Date: Fri, 27 Apr 2018 19:01:36 +0900
Subject: Add PolicyManager, related classes and some config files

- PolicyManager
    Decide next layout by using occured event and current state
    based on policy table.
    This PolicyManger is reference and the OEMs can replace it.

- LayoutManager
    Change the current layout to the layout
    which decided by PolicyManager.

    NOTE:
    The functions of this class had been included in App class.
    The part of function of this class remain there yet.

- LowCanClient
    Receive the CAN signal from low level CAN service.

- app.db
    Define the applications name and its role.
    This file will be deleted
    when the names and roles can be given by other module.

- layout.cb
    Define the layouts and areas which are included by the layout.

- role.db
    Define the roles of the applications.

Change-Id: I2f84bdf5e68355e022f516cee9a1db88efe58825
Signed-off-by: Yuta Doi <yuta-d@witz-inc.co.jp>
---
 src/main.cpp | 79 +++++++++++++++++++++++++++++++++++++++++++++++++++++++-----
 1 file changed, 73 insertions(+), 6 deletions(-)

(limited to 'src/main.cpp')

diff --git a/src/main.cpp b/src/main.cpp
index 2f813a3..067a006 100644
--- a/src/main.cpp
+++ b/src/main.cpp
@@ -24,6 +24,7 @@
 #include "json_helper.hpp"
 #include "util.hpp"
 #include "wayland_ivi_wm.hpp"
+#include "low_can_client.hpp"
 
 extern "C" {
 #include <afb/afb-binding.h>
@@ -39,9 +40,10 @@ typedef struct wmClientCtxt{
 
 struct afb_instance {
    std::unique_ptr<wl::display> display;
+   wm::LowCanClient lcc_;
    wm::App app;
 
-   afb_instance() : display{new wl::display}, app{this->display.get()} {}
+   afb_instance() : display{new wl::display}, lcc_{}, app{this->display.get()} {}
 
    int init();
 };
@@ -50,6 +52,10 @@ struct afb_instance *g_afb_instance;
 std::mutex binding_m;
 
 int afb_instance::init() {
+   // Initialize LowCanClient class
+   this->lcc_.initialize();
+
+   // Initialize App class
    return this->app.init();
 }
 
@@ -298,8 +304,14 @@ void windowmanager_activatesurface(afb_req req) noexcept {
        return;
    }
 
-   g_afb_instance->app.api_activate_surface(a_drawing_name, a_drawing_area,
-      [&req](const char* errmsg){
+   const char* a_role = afb_req_value(req, "role");
+   if(!a_role){
+       a_role = "";
+   }
+
+   g_afb_instance->app.allocateWindowResource("activate", a_drawing_name,
+                                              a_drawing_area, a_role,
+                                              [&req](const char* errmsg){
       if (errmsg != nullptr) {
          HMI_ERROR("wm", errmsg);
          afb_req_fail(req, "failed", errmsg);
@@ -332,8 +344,14 @@ void windowmanager_deactivatesurface(afb_req req) noexcept {
        return;
    }
 
-   g_afb_instance->app.api_deactivate_surface(a_drawing_name,
-      [&req](const char* errmsg){
+   const char* a_role = afb_req_value(req, "role");
+   if(!a_role){
+       a_role = "";
+   }
+
+   g_afb_instance->app.allocateWindowResource("deactivate", a_drawing_name,
+                                              nullptr, a_role,
+                                              [&req](const char* errmsg){
       if (errmsg != nullptr) {
          HMI_ERROR("wm", errmsg);
          afb_req_fail(req, "failed", errmsg);
@@ -452,6 +470,12 @@ void windowmanager_wm_subscribe(afb_req req) noexcept {
       return;
    }
    int event_type = json_object_get_int(j);
+   if ((wm::App::Event_Val_Min > event_type)
+       || (wm::App::Event_Val_Max < event_type)) {
+      afb_req_fail(req, "failed", "Invalid EventType");
+      return;
+   }
+
    const char *event_name = g_afb_instance->app.kListEventName[event_type];
    struct afb_event event = g_afb_instance->app.map_afb_event[event_name];
    int ret = afb_req_subscribe(req, event);
@@ -635,5 +659,48 @@ const struct afb_verb_v2 windowmanager_verbs[] = {
    {}
 };
 
+void on_event(const char *event, struct json_object *object){
+    HMI_DEBUG("wm", "event:%s", event);
+
+    // If receive low can signal
+    if (strstr(event, "low-can")) {
+        // Analyze low can signal
+        g_afb_instance->lcc_.analyzeCanSignal(object);
+
+        if (g_afb_instance->lcc_.isChangedCarState()) {
+            // If car state is changed
+            HMI_DEBUG("wm", "Car state is changed");
+
+            // Get car state
+            const char* car_state = g_afb_instance->lcc_.getCurrentCarState();
+
+            // Allocate window resource
+            g_afb_instance->app.allocateWindowResource(car_state, nullptr,
+                                                       nullptr, nullptr,
+                                                       [](const char* errmsg){
+                if (errmsg != nullptr) {
+                    HMI_ERROR("wm", errmsg);
+                }
+            });
+        }
+        else if (g_afb_instance->lcc_.isChangedLampState()) {
+            // If lamp state is changed
+            HMI_DEBUG("wm", "Lamp state is changed");
+
+            // Get lamp state
+            const char* lamp_state = g_afb_instance->lcc_.getCurrentLampState();
+
+            // Allocate window resource
+            g_afb_instance->app.allocateWindowResource(lamp_state, nullptr,
+                                                       nullptr, nullptr,
+                                                       [](const char* errmsg){
+                if (errmsg != nullptr) {
+                    HMI_ERROR("wm", errmsg);
+                }
+            });
+        }
+    }
+}
+
 extern "C" const struct afb_binding_v2 afbBindingV2 = {
-   "windowmanager", nullptr, nullptr, windowmanager_verbs, nullptr, binding_init, nullptr, 0};
+   "windowmanager", nullptr, nullptr, windowmanager_verbs, nullptr, binding_init, on_event, 0};
-- 
cgit 1.2.3-korg