Update wm_layer* : Render order change

Change-Id: I3e417785d36e113a2b97076774d80c46defd3be4
Signed-off-by: Kazumasa Mitsunari <knimitz@witz-inc.co.jp>

diff --git a/src/wm_layer.cpp b/src/wm_layer.cpp
index cd381c2..154d874 100644 (file)
--- a/src/wm_layer.cpp
+++ b/src/wm_layer.cpp
@@ -71,6 +71,8 @@ void LayerState::removeLayer(unsigned layer)
     auto fwd_itr = std::remove_if(
         this->render_order.begin(), this->render_order.end(),
         [layer](unsigned elm) {
+            if(elm == layer)
+                HMI_DEBUG("remove layer %d", elm);
             return elm == layer;
         }
     );
@@ -82,6 +84,17 @@ void LayerState::setArea(const string& app, const string& area)
     this->area2appid[area] = app;
 }
 
+void LayerState::dump()
+{
+    std::string str;
+    for(const auto& ro : this->render_order)
+    {
+        str += std::to_string(ro);
+        str += ",";
+    }
+    DUMP("    render order : %s", str.c_str());
+}
+
 WMLayer::WMLayer(json_object* j, unsigned uuid) : tmp_state(), state(), uuid(uuid)
 {
     this->name = jh::getStringFromJson(j, "name");
@@ -107,6 +120,8 @@ WMLayer::WMLayer(json_object* j, unsigned uuid) : tmp_state(), state(), uuid(uui
 unsigned WMLayer::getNewLayerID(const string& role)
 {
     unsigned ret = 0;
+    if(this->name == BG_LAYER_NAME)
+        return ret;
 
     // generate new layer id;
     if(this->hasRole(role))
@@ -166,23 +181,31 @@ WMError WMLayer::setLayerState(const LayerState& l)
     return WMError::SUCCESS;
 }
 
-void WMLayer::addLayer(unsigned layer)
+void WMLayer::addLayerToState(unsigned layer)
 {
     this->tmp_state.addLayer(layer);
 }
 
+void WMLayer::removeLayerFromState(unsigned layer)
+{
+    this->tmp_state.removeLayer(layer);
+}
+
 void WMLayer::appendArea(const string& area)
 {
     this->area_list.push_back(area);
 }
 
-void WMLayer::removeLayerID(unsigned id)
+void WMLayer::terminateApp(unsigned id)
 {
     auto fwd_itr = std::remove_if(this->id_list.begin(), this->id_list.end(),
         [id](unsigned elm) {
             return elm == id;
         });
     this->id_list.erase(fwd_itr, this->id_list.end());
+    this->tmp_state.removeLayer(id);
+    this->state.removeLayer(id);
+    ilm_layerRemove(id);
 }
 
 bool WMLayer::hasLayerID(unsigned id)
@@ -196,9 +219,6 @@ bool WMLayer::hasLayerID(unsigned id)
 
 bool WMLayer::hasRole(const string& role)
 {
-    // TODO : use virtual to avoid compare
-    if(this->name == BG_LAYER_NAME)
-        return false;
     auto re = std::regex(this->role_list);
     if (std::regex_match(role, re))
     {
@@ -214,6 +234,16 @@ WMError WMLayer::commitChange()
     return WMError::SUCCESS;
 }
 
+void WMLayer::dump()
+{
+    DUMP("===== wm layer status =====");
+    DUMP("Layer :%s", this->name.c_str());
+    this->tmp_state.dump();
+    this->state.dump();
+    DUMP("===== wm layer status end =====");
+
+}
+
 /* void WMLayer::undo()
 {
     this->tmp_state = this->state;

diff --git a/src/wm_layer.hpp b/src/wm_layer.hpp
index 4002c4b..65182b0 100644 (file)
--- a/src/wm_layer.hpp
+++ b/src/wm_layer.hpp
@@ -42,6 +42,9 @@ class LayerState
     void removeLayer(unsigned layer);
     void setArea(const std::string& app, const std::string& area);
 
+    // Debug
+    void dump();
+
   private:
     std::vector<unsigned> render_order;
     std::unordered_map<std::string, std::string> area2appid;
@@ -67,16 +70,20 @@ class WMLayer
     const std::string& layerName();
     MANAGEMENT_TYPE    layerType() { return this->type; }
     void appendArea(const std::string& area);
-    void removeLayerID(unsigned id);
     LayerState& getLayerState() { return tmp_state; }
     WMError setLayerState(const LayerState& l);
     bool hasLayerID(unsigned id);
     bool hasRole(const std::string& role);
 
     // Manipulation
-    void addLayer(unsigned layer);
+    void addLayerToState(unsigned layer);
+    void removeLayerFromState(unsigned layer);
+    void terminateApp(unsigned layer);
     WMError commitChange();
 
+    // Debug
+    void dump();
+
   private:
     LayerState tmp_state;
     LayerState state;

diff --git a/src/wm_layer_control.cpp b/src/wm_layer_control.cpp
index 13072a4..62fe91d 100644 (file)
--- a/src/wm_layer_control.cpp
+++ b/src/wm_layer_control.cpp
@@ -24,6 +24,7 @@
 #define LC_AREA_PATH "/etc/areas.db"
 #define LC_LAYER_SETTING_PATH "/etc/layers_setting.json"
 #define LC_DEFAULT_AREA "fullscreen"
+#define BACK_GROUND_LAYER "BackGroundLayer"
 
 using std::string;
 using std::vector;
@@ -128,7 +129,7 @@ void LayerControl::createNewLayer(unsigned id)
     ilm_layerSetVisibility(id, ILM_FALSE);
     ilm_commitChanges();
     auto wm_layer = getWMLayer(id);
-    wm_layer->addLayer(id);
+    wm_layer->addLayerToState(id);
     this->commitChange();
 }
 
@@ -155,6 +156,18 @@ shared_ptr<WMLayer> LayerControl::getWMLayer(unsigned layer)
     return this->wm_layers[uuid];
 }
 
+std::shared_ptr<WMLayer> LayerControl::getWMLayer(std::string layer_name)
+{
+    for(auto &l : this->wm_layers)
+    {
+        if(l->layerName() == layer_name)
+        {
+            return l;
+        }
+    }
+    return nullptr;
+}
+
 struct rect LayerControl::getAreaSize(const std::string& area)
 {
     return area2size[area];
@@ -204,8 +217,10 @@ WMError LayerControl::commitChange()
     for(auto& l : this->wm_layers)
     {
         auto state = l->getLayerState();
+        HMI_DEBUG("layer %s", l->layerName().c_str());
         for(const auto& id : state.getIviIdList())
         {
+            HMI_DEBUG("Add %d", id);
             ivi_l_ids.push_back(id);
         }
     }
@@ -230,6 +245,13 @@ WMError LayerControl::commitChange()
         this->undoUpdate();
         rc = WMError::FAIL;
     }
+    else
+    {
+        for(auto& l : this->wm_layers)
+        {
+            l->commitChange();
+        }
+    }
     ilm_commitChanges();
     delete id_array;
     return rc;
@@ -559,6 +581,8 @@ WMError LayerControl::makeVisible(const shared_ptr<WMClient> client)
     // Don't check here the client is not nullptr
     unsigned layer = client->layerID();
 
+    this->moveForeGround(client);
+
     ilm_layerSetVisibility(layer, ILM_TRUE);
 
     /* for(auto& wm_layer : this->wm_layers)
@@ -592,14 +616,15 @@ WMError LayerControl::makeInvisible(const shared_ptr<WMClient> client)
     WMError ret = WMError::SUCCESS;
     unsigned layer = client->layerID(); // Don't check here the client is not nullptr
 
-    /* bool mv_ok = this->mvBackGround(client);
+    bool mv_ok = this->moveBackGround(client);
 
     if(!mv_ok)
     {
+        HMI_INFO("make invisible client %s", client->appID().c_str());
         ilm_layerSetVisibility(layer, ILM_FALSE);
-    } */
+    }
 
-    ilm_layerSetDestinationRectangle(layer, 0, 0, 0, 0);
+    //ilm_layerSetDestinationRectangle(layer, 0, 0, 0, 0);
 
     /* for(auto& wm_layer : this->wm_layers)
     {
@@ -615,50 +640,61 @@ WMError LayerControl::makeInvisible(const shared_ptr<WMClient> client)
     return ret;
 }
 
-/* bool LayerControl::mvBackGround(const shared_ptr<WMClient> client)
+bool LayerControl::moveBackGround(const shared_ptr<WMClient> client)
 {
     bool ret = false;
 
     // Move background from foreground layer
-    auto bg = this->getWMLayer("BackGroundLayer");
+    auto bg = this->getWMLayer(BACK_GROUND_LAYER);
     if(bg != nullptr)
     {
+        HMI_DEBUG("client %s role %s", client->appID().c_str(), client->role().c_str());
         unsigned layer = client->layerID();
         if(bg->hasRole(client->role()))
         {
+            HMI_INFO("%s go to background", client->appID().c_str());
+            bg->addLayerToState(layer);
+            auto wm_layer = this->getWMLayer(layer);
+            wm_layer->removeLayerFromState(layer);
+            /* TODO: manipulate state directly
             LayerState bg_ls = bg->getLayerState();
             bg_ls.addLayer(layer);
-            auto wm_layer = this->getWMLayer(layer);
             LayerState ls = wm_layer->getLayerState();
-            ls.removeLayer(layer);
+            ls.removeLayer(layer); */
+            bg->dump();
+            wm_layer->dump();
+            ret = true;
         }
-        ret = true;
     }
     return ret;
 }
 
-bool LayerControl::mvForeGround(const shared_ptr<WMClient> client)
+bool LayerControl::moveForeGround(const shared_ptr<WMClient> client)
 {
     bool ret = false;
 
     // Move foreground from foreground layer
-    auto bg = this->getWMLayer("BackGroundLayer");
+    auto bg = this->getWMLayer(BACK_GROUND_LAYER);
     if(bg != nullptr)
     {
-        unsigned layer = client->layerID();
         if(bg->hasRole(client->role()))
         {
+            unsigned layer = client->layerID();
+            HMI_INFO("%s go to foreground", client->appID().c_str());
+            bg->removeLayerFromState(layer);
+            auto wm_layer = this->getWMLayer(layer);
+            wm_layer->addLayerToState(layer);
+            /* TODO: manipulate state directly
             LayerState bg_ls = bg->getLayerState();
             bg_ls.removeLayer(layer);
-            auto wm_layer = this->getWMLayer(layer);
             LayerState ls = wm_layer->getLayerState();
-            ls.addLayer(layer);
+            ls.addLayer(layer); */
+            bg->dump();
+            wm_layer->dump();
+            ret = true;
         }
-        ret = true;
     }
     return ret;
 }
 
-*/
-
 } // namespace wm
\ No newline at end of file

diff --git a/src/wm_layer_control.hpp b/src/wm_layer_control.hpp
index f637d8d..9620410 100644 (file)
--- a/src/wm_layer_control.hpp
+++ b/src/wm_layer_control.hpp
@@ -65,7 +65,7 @@ class LayerControl
     void createNewLayer(unsigned id);
     unsigned getNewLayerID(const std::string& role, std::string* layer_name);
     std::shared_ptr<WMLayer> getWMLayer(unsigned layer);
-    // std::shared_ptr<WMLayer> getWMLayer(std::string layer_name);
+    std::shared_ptr<WMLayer> getWMLayer(std::string layer_name);
     struct rect getAreaSize(const std::string& area);
     void setupArea(const rectangle& base_rct, double scaling);
     Screen getScreenInfo();
@@ -88,6 +88,8 @@ class LayerControl
   private:
     WMError makeVisible(const std::shared_ptr<WMClient> client);
     WMError makeInvisible(const std::shared_ptr<WMClient> client);
+    bool moveForeGround(const std::shared_ptr<WMClient> client);
+    bool moveBackGround(const std::shared_ptr<WMClient> client);
     WMError loadLayerSetting(const std::string& path);
     WMError loadAreaDb(const std::string& path);