On the way to move process to endDraw

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

4 files changed, 243 insertions, 34 deletions

diff --git a/src/app.cpp b/src/app.cpp
index 9e6e3d5..c30223c 100644
--- a/src/app.cpp
+++ b/src/app.cpp
@@ -124,12 +124,7 @@ void App::timerHandler()
     HMI_SEQ_DEBUG(req_num, "Timer expired remove Request");
     g_app_list.reqDump();
     g_app_list.removeRequest(req_num);
-    g_app_list.next();
-    g_app_list.reqDump();
-    if (g_app_list.haveRequest())
-    {
-        this->processRequest();
-    }
+    this->processNextRequest();
 }
 
 void App::removeClient(const std::string &appid)
@@ -360,7 +355,7 @@ void App::surface_set_layout(int surface_id, optional<int> sub_surface_id)
         h = this->controller->output_size.h + 1 + h;
     }
 
-    if (sub_surface_id)
+    /* if (sub_surface_id)
     {
         if (o_layer_id != this->layers.get_layer_id(*sub_surface_id))
         {
@@ -397,7 +392,7 @@ void App::surface_set_layout(int surface_id, optional<int> sub_surface_id)
         this->area_info[*sub_surface_id].y = y;
         this->area_info[*sub_surface_id].w = w;
         this->area_info[*sub_surface_id].h = h;
-    }
+    } */
 
     HMI_DEBUG("wm", "surface_set_layout for surface %u on layer %u", surface_id,
               layer_id);
@@ -565,7 +560,7 @@ WMError App::lm_layout_change(const struct WMAction &action)
 
 WMError App::doTransition(unsigned req_num)
 {
-    HMI_SEQ_DEBUG(req_num, "check next state");
+    HMI_SEQ_DEBUG(req_num, "check policy");
     WMError ret = this->checkPolicy(req_num);
     if (ret != WMError::SUCCESS)
     {
@@ -643,6 +638,37 @@ WMError App::checkPolicy(unsigned req_num)
     // >>>> This will be removed
 
     /*  get new status from Policy Manager */
+    if (can_split)
+    {
+        // Get current visible role
+        std::string add_role = this->lookup_name(state.main).value();
+        // Set next area
+        std::string add_area = std::string(kNameLayoutSplit) + "." + std::string(kNameAreaMain);
+        // Change request area
+        req_area = std::string(kNameLayoutSplit) + "." + std::string(kNameAreaSub);
+        // set another action
+        std::string add_name = "navigation";
+
+        HMI_SEQ_INFO(req_num, "Additional split app %s, role: %s, area: %s", add_name.c_str(), add_role.c_str(), add_area.c_str());
+        // Set split action
+        bool visible = true;
+        bool end_draw_finished = false;
+        WMAction new_act{add_name, add_role, add_area, visible, end_draw_finished};
+        WMError ret = g_app_list.setAction(req_num, new_act);
+        if (ret != WMError::SUCCESS)
+        {
+            HMI_SEQ_ERROR(req_num, "Failed to set action");
+            return ret;
+        }
+        g_app_list.reqDump();
+    }
+    }
+    // >>>> This will be removed
+
+    // Set invisible task
+    this->setInvisibleTask(trigger.role, can_split);
+
+    /*  get new status from Policy Manager */
     HMI_SEQ_NOTICE(req_num, "ATM, Policy manager does't exist, then set WMAction as is");
 
     ret = g_app_list.setAction(req_num, trigger.appid, trigger.role, req_area, is_activate);
@@ -1060,33 +1086,56 @@ void App::lm_enddraw(const char *drawing_name)
     }
 }
 
-void App::do_enddraw(unsigned req_num)
+WMError App::doEndDraw(unsigned req_num)
 {
     // get actions
     bool found;
     auto actions = g_app_list.getActions(req_num, &found);
+    WMError ret = WMError::SUCCESS;
     if (!found)
     {
-        WMError err = WMError::NO_ENTRY;
-        HMI_SEQ_ERROR(req_num, errorDescription(err));
-        return;
+        ret = WMError::NO_ENTRY;
+        return ret;
     }
 
     HMI_SEQ_INFO(req_num, "do endDraw");
+    // layout change and make it visible
+
+    // Temporary action
+    /* auto itr = actions.cend();
+    this->currentAppInvisible(itr->role); */
 
     for (const auto &act : actions)
     {
+        // layout change
+        if(!g_app_list.contains(act.appid)){
+            ret = WMError::NOT_REGISTERED;
+        }
+        ret = this->layoutChange(act);
+        if(ret != WMError::SUCCESS)
+        {
+            HMI_SEQ_WARNING(req_num, "Failed to manipulate surfaces while state change : %s", errorDescription(ret));
+            return ret;
+        }
+        ret = this->visibilityChange(act);
+        if (ret != WMError::SUCCESS)
+        {
+            HMI_SEQ_WARNING(req_num, "Failed to manipulate surfaces while state change : %s", errorDescription(ret));
+            return ret;
+        }
         HMI_SEQ_DEBUG(req_num, "visible %s", act.role.c_str());
-        this->lm_enddraw(act.role.c_str());
+        //this->lm_enddraw(act.role.c_str());
     }
 
     HMI_SEQ_INFO(req_num, "emit flushDraw");
-    /*     do
+
+    for(const auto &act_flush : actions)
     {
-        // emit flush Draw
-        //emitFlushDrawToAll(&g_app_list, req_num);
-        // emit status change event
-    } while (!g_app_list.requestFinished());*/
+        if(act_flush.visible)
+        {
+            this->emit_flushdraw(act_flush.role.c_str());
+        }
+    }
 }
 
 void App::processRequest()
@@ -1094,39 +1143,146 @@ void App::processRequest()
     unsigned req = g_app_list.currentRequestNumber();
     HMI_SEQ_DEBUG(req, "Do next request");
     WMError rc = doTransition(req);
-    if(rc != WMError::SUCCESS){
+    if(rc != WMError::SUCCESS)
+    {
         HMI_SEQ_ERROR(req, errorDescription(rc));
     }
 }
 
+WMError App::setSurfaceSize(unsigned surface, const std::string &area)
+{
+    // Actually this function is under Layout Manager
+    /* compositor::rect size = this->lm.getAreaSize(area); // compositor::rect size = this->lm_.getAreaSize(area);
+
+    if (!this->controller->surface_exists(surface))
+    {
+        // Block until all pending request are processed by wayland display server
+        // because waiting for the surface of new app is created
+        this->display->roundtrip();
+    }
+    auto &s = this->controller->surfaces[surface];
+    s->set_destination_rectangle(size.x, size.y, size.w, size.h);
+    this->layout_commit();
+
+    // Update area information
+    this->area_info[surface].x = size.x;
+    this->area_info[surface].y = size.y;
+    this->area_info[surface].w = size.w;
+    this->area_info[surface].h = size.h;
+    HMI_DEBUG("wm", "Surface %d rect { %d, %d, %d, %d }",
+              surface, size.x, size.y, size.w, size.h); */
+    this->surface_set_layout(surface);
+
+    return WMError::SUCCESS;
+}
+
+WMError App::layoutChange(const WMAction &action)
+{
+    if(act.visible == false)
+    {
+        return WMError::SUCCESS;
+    }
+    auto client = g_app_list.lookUpClient(action.appid);
+    unsigned surface = client->surfaceID(action.role);
+    if (surface == 0)
+    {
+        HMI_SEQ_ERROR(g_app_list.currentRequestNumber(),
+                      "client doesn't have surface with role(%s)", action.role.c_str());
+        return WMError::NOT_REGISTERED;
+    }
+    // Layout Manager
+    WMError ret = this->setSurfaceSize(surface, action.area);
+    return ret;
+}
+
+/* void App::currentAppInvisible(const std::string &role)
+{
+    const char *drawing_name = role.c_str();
+    auto const &surface_id = this->lookup_id(drawing_name);
+    auto layer_id = this->layers.get_layer_id(*surface_id);
+    auto o_state = *this->layers.get_layout_state(*surface_id);
+    struct LayoutState &state = *o_state;
+
+    // disable layers that are above our current layer
+    for (auto const &l : this->layers.mapping)
+    {
+        if (l.second.layer_id <= *layer_id)
+        {
+            continue;
+        }
+
+        bool flush = false;
+        if (l.second.state.main != -1)
+        {
+            this->deactivate(l.second.state.main);
+            l.second.state.main = -1;
+            flush = true;
+        }
+
+        if (l.second.state.sub != -1)
+        {
+            this->deactivate(l.second.state.sub);
+            l.second.state.sub = -1;
+            flush = true;
+        }
+
+        if (flush)
+        {
+            this->layout_commit();
+        }
+    }
+} */
+
+WMError App::visibilityChange(const WMAction &action)
+{
+    auto client = g_app_list.lookUpClient(action.appid);
+    unsigned surface = client->surfaceID(action.role);
+    if(surface == 0)
+    {
+        HMI_SEQ_ERROR(g_app_list.currentRequestNumber(),
+                      "client doesn't have surface with role(%s)", action.role.c_str());
+        return WMError::NOT_REGISTERED;
+    }
+
+    if (action.visible)
+    {
+        this->activate(surface); // Layout Manager task
+    }
+    else
+    {
+        this->deactivate(surface); // Layout Manager task
+    }
+    return WMError::SUCCESS;
+}
+
 void App::api_enddraw(char const *appid, char const *drawing_name)
 {
-    std::string id(appid);
-    std::string role(drawing_name);
+    std::string id = appid;
+    std::string role = drawing_name;
     unsigned current_req = g_app_list.currentRequestNumber();
     bool result = g_app_list.setEndDrawFinished(current_req, id, role);
 
     if (!result)
     {
-        HMI_ERROR("wm", "%s doesn't have Window Resource", id.c_str());
+        HMI_ERROR("wm", "%s is not in transition state", id.c_str());
         return;
     }
 
     if (g_app_list.endDrawFullfilled(current_req))
     {
         // do task for endDraw
-        //this->stopTimer();
-        this->do_enddraw(current_req);
-
         this->stopTimer();
+        WMError ret = this->doEndDraw(current_req);
 
-        g_app_list.removeRequest(current_req);
-        HMI_SEQ_INFO(current_req, "Finish request");
-        g_app_list.next();
-        if (g_app_list.haveRequest())
+        if(ret != WMError::SUCCESS)
         {
-            this->processRequest();
+            //this->emit_error();
         }
+        HMI_SEQ_INFO(current_req, "Finish request status: %s", errorDescription(ret));
+
+        g_app_list.removeRequest(current_req);
+
+        this->processNextRequest();
     }
     else
     {
@@ -1135,6 +1291,26 @@ void App::api_enddraw(char const *appid, char const *drawing_name)
     }
 }
 
+void App::processNextRequest()
+{
+    g_app_list.next();
+    g_app_list.reqDump();
+    unsigned req_num = g_app_list.currentRequestNumber();
+    if (g_app_list.haveRequest())
+    {
+        HMI_SEQ_DEBUG(req_num, "Process next request");
+        WMError rc = doTransition(req_num);
+        if (rc != WMError::SUCCESS)
+        {
+            HMI_SEQ_ERROR(req_num, errorDescription(rc));
+        }
+    }
+    else
+    {
+        HMI_SEQ_DEBUG(req_num, "Nothing Request. Waiting Request");
+    }
+}
+
 void App::api_ping() { this->dispatch_pending_events(); }
 
 void App::send_event(char const *evname, char const *label)
diff --git a/src/app.hpp b/src/app.hpp
index 9f53f84..9ebdda5 100644
--- a/src/app.hpp
+++ b/src/app.hpp
@@ -233,11 +233,11 @@ struct App
     void surface_created(uint32_t surface_id);
     void surface_removed(uint32_t surface_id);
 
+    void removeClient(const std::string &appid);
+    bool subscribeEventForApp(const std::string &appid, afb_req req, const std::string &evname);
     // Do not use this function
     //static int processTimerHandler(sd_event_source *s, uint64_t usec, void *userdata);
     void timerHandler();
-    void removeClient(const std::string &appid);
-    bool subscribeEventForApp(const std::string &appid, afb_req req, const std::string &evname);
 
   private:
     optional<int> lookup_id(char const *name);
@@ -272,7 +272,24 @@ struct App
     void setTimer();
     void stopTimer();
     void processRequest();
-    void do_enddraw(unsigned req_num);
+
+    WMError setRequest(const std::string &appid, const std::string &role, const std::string &area,
+                             Task task, unsigned *req_num);
+    WMError doTransition(unsigned req_num);
+    WMError checkPolicy(unsigned req_num);
+    void setInvisibleTask(const std::string &role);
+    WMError startTransition(unsigned req_num);
+    WMError layoutChange(const WMAction &action);
+    WMError visibilityChange(const WMAction &action);
+    WMError setSurfaceSize(unsigned surface, const std::string& area);
+    void processNextRequest();
+    //void currentAppInvisible(const std::string &role);
+
+
+    void setTimer();
+    void stopTimer();
+    void processRequest();
+    WMError doEndDraw(unsigned req_num);
     const char *check_surface_exist(const char *drawing_name);
 
     void activate(int id);
@@ -291,6 +308,10 @@ struct App
     WMError lm_release(const struct WMAction &action);
     void    lm_enddraw(const char *drawing_name);
     void    lm_get_area_info(const std::string &area);
+    void    lm_get_area_info(const std::string &area);
+
+  private:
+    std::unordered_map<std::string, struct compositor::rect> area2size;
 };
 
 } // namespace wm
diff --git a/src/wm_client.cpp b/src/wm_client.cpp
index 6f1aa20..24e2247 100644
--- a/src/wm_client.cpp
+++ b/src/wm_client.cpp
@@ -90,6 +90,17 @@ unsigned WMClient::surfaceID(const string &role) const
     return this->role2surface.at(role);
 }
 
+std::string WMClient::role(unsigned surface) const
+{
+    for(const auto& [key, value] : this->role2surface)
+    {
+        if(value == surface){
+            return key;
+        }
+    }
+    return std::string("");
+}
+
 unsigned WMClient::layerID() const
 {
     return this->layer;
diff --git a/src/wm_client.hpp b/src/wm_client.hpp
index 5fa9444..e1ef75b 100644
--- a/src/wm_client.hpp
+++ b/src/wm_client.hpp
@@ -46,6 +46,7 @@ class WMClient
     std::string appID() const;
     unsigned surfaceID(const std::string &role) const;
     unsigned layerID() const;
+    std::string role(unsigned surface) const;
     void registerLayer(unsigned layer);
     bool addSurface(const std::string& role, unsigned surface);
     bool removeSurfaceIfExist(unsigned surface);