Fix top surface becomes invisible when background surface is crashed.

Fix top surface becomes invisible when surface on same layer,
such like application layer, is crashed.
To fix this issue, I refactored attaching app to layer.
Originally, window manager attached app to surface.
This patch is the backport of master branch.

Bug-AGL : SPEC-1635

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

1 files changed, 189 insertions, 91 deletions

diff --git a/src/wm_client.cpp b/src/wm_client.cpp
index 2e12a69..da7e626 100644
--- a/src/wm_client.cpp
+++ b/src/wm_client.cpp
@@ -16,7 +16,7 @@
 
 #include <json-c/json.h>
 #include "wm_client.hpp"
-#include "util.hpp"
+#include <ilm/ilm_control.h>
 
 #define INVALID_SURFACE_ID 0
 
@@ -26,19 +26,34 @@ using std::vector;
 namespace wm
 {
 
-static const vector<string> kWMEvents = {
-    // Private event for applications
-    "syncDraw", "flushDraw", "visible", "invisible", "active", "inactive", "error"};
-static const vector<string> kErrorDescription = {
-    "unknown-error"};
-
+static const char kActive[] = "active";
+static const char kInactive[] = "inactive";
+static const char kVisible[] = "visible";
+static const char kInvisible[] = "invisible";
+static const char kSyncDraw[] = "syncDraw";
+static const char kFlushDraw[] = "flushDraw";
 static const char kKeyDrawingName[] = "drawing_name";
+static const char kKeyDrawingArea[] = "drawing_area";
+static const char kKeyRole[] = "role";
+static const char kKeyArea[] = "area";
 static const char kKeyrole[] = "role";
 static const char kKeyError[] = "error";
-static const char kKeyErrorDesc[] = "kErrorDescription";
+static const char kKeyErrorDesc[] = "errorDescription";
+static const char kKeyX[] = "x";
+static const char kKeyY[] = "y";
+static const char kKeyWidth[] = "width";
+static const char kKeyHeight[] = "height";
+static const char kKeyDrawingRect[] = "drawing-rect";
+
+static const vector<string> kWMEvents = {
+    // Private event for applications
+    kActive, kInactive,
+    kVisible, kInvisible,
+    kSyncDraw, kFlushDraw,
+    kKeyError};
 
 WMClient::WMClient(const string &appid, unsigned layer, unsigned surface, const string &role)
-    : id(appid), layer(layer),
+    : id(appid), layer(layer), is_source_set(false),
       role2surface(0)
 {
     role2surface[role] = surface;
@@ -47,17 +62,18 @@ WMClient::WMClient(const string &appid, unsigned layer, unsigned surface, const
 #if GTEST_ENABLED
         string ev = x;
 #else
-        afb_event ev = afb_daemon_make_event(x.c_str());
+        afb_event_t ev = afb_daemon_make_event(x.c_str());
 #endif
-        event2list[x] = ev;
+        evname2afb_event[x] = ev;
     }
 }
 
 WMClient::WMClient(const string &appid, const string &role)
     : id(appid),
       layer(0),
+      is_source_set(false),
       role2surface(0),
-      event2list(0)
+      evname2afb_event(0)
 {
     role2surface[role] = INVALID_SURFACE_ID;
     for (auto x : kWMEvents)
@@ -65,14 +81,29 @@ WMClient::WMClient(const string &appid, const string &role)
 #if GTEST_ENABLED
         string ev = x;
 #else
-        afb_event ev = afb_daemon_make_event(x.c_str());
+        afb_event_t ev = afb_daemon_make_event(x.c_str());
 #endif
-        event2list[x] = ev;
+        evname2afb_event[x] = ev;
     }
 }
 
-WMClient::~WMClient()
+WMClient::WMClient(const string &appid, unsigned layer, const string &role)
+    : id(appid),
+      layer(layer),
+      main_role(role),
+      role2surface(0),
+      evname2afb_event(0)
 {
+    role2surface[role] = INVALID_SURFACE_ID;
+    for (auto x : kWMEvents)
+    {
+#if GTEST_ENABLED
+        string ev = x;
+#else
+        afb_event_t ev = afb_daemon_make_event(x.c_str());
+#endif
+        evname2afb_event[x] = ev;
+    }
 }
 
 string WMClient::appID() const
@@ -80,108 +111,70 @@ string WMClient::appID() const
     return this->id;
 }
 
-unsigned WMClient::surfaceID(const string &role) const
+string WMClient::role() const
 {
-    if (0 == this->role2surface.count(role))
-    {
-        return INVALID_SURFACE_ID;
-    }
-    return this->role2surface.at(role);
+    return this->main_role;
 }
 
-std::string WMClient::role(unsigned surface) const
+unsigned WMClient::layerID() const
 {
-    for(const auto& x : this->role2surface)
-    {
-        if(x.second == surface)
-        {
-            return x.first;
-        }
-    }
-    return std::string("");
+    return this->layer;
 }
 
-unsigned WMClient::layerID() const
+unsigned WMClient::surfaceID() const
 {
-    return this->layer;
+    return this->surface;
 }
 
-/**
- * Set layerID the client belongs to
- *
- * This function set layerID the client belongs to.
- * But this function may not used because the layer should be fixed at constructor.
- * So this function will be used to change layer by some reasons.
- *
- * @param     unsigned[in] layerID
- * @return    None
- * @attention WMClient can't have multiple layer
- */
-void WMClient::registerLayer(unsigned layer)
+void WMClient::registerSurface(unsigned surface)
 {
-    this->layer = layer;
+    this->surface = surface;
 }
 
 /**
- * Add the pair of role and surface to the client
+ * Add surface to the client
  *
- * This function set the pair of role and surface to the client.
- * This function is used for the client which has multi surfaces.
- * If the model and relationship for role and surface(layer)
- * is changed, this function will be changed
- * Current Window Manager doesn't use this function.
+ * This function add main surface to the client(ivi_layer).
  *
  * @param     string[in] role
- * @param     unsigned[in] surface
- * @return    true
+ * @return    WMError
  */
-bool WMClient::addSurface(const string &role, unsigned surface)
+WMError WMClient::addSurface(unsigned surface)
 {
-    HMI_DEBUG("Add role %s with surface %d", role.c_str(), surface);
-    if (0 != this->role2surface.count(role))
+    this->surface = surface;
+    ilmErrorTypes err = ilm_layerAddSurface(this->layer, surface);
+
+    if(err == ILM_SUCCESS)
     {
-        HMI_NOTICE("override surfaceID %d with %d", this->role2surface[role], surface);
+        err = ilm_commitChanges();
     }
-    this->role2surface[role] = surface;
-    return true;
+    return (err == ILM_SUCCESS) ? WMError::SUCCESS : WMError::FAIL;
 }
 
-bool WMClient::removeSurfaceIfExist(unsigned surface)
+void WMClient::setSurfaceSizeCorrectly()
 {
-    bool ret = false;
-    for (auto &x : this->role2surface)
-    {
-        if (surface == x.second)
-        {
-            HMI_INFO("Remove surface from client %s: role %s, surface: %d",
-                                this->id.c_str(), x.first.c_str(), x.second);
-            this->role2surface.erase(x.first);
-            ret = true;
-            break;
-        }
-    }
-    return ret;
+    this->is_source_set = true;
+}
+
+bool WMClient::isSourceSizeSet()
+{
+    return this->is_source_set;
 }
 
-bool WMClient::removeRole(const string &role)
+bool WMClient::removeSurfaceIfExist(unsigned surface)
 {
     bool ret = false;
-    if (this->role2surface.count(role) != 0)
+    if(surface == this->surface)
     {
-        this->role2surface.erase(role);
+        this->surface = INVALID_SURFACE_ID;
         ret = true;
     }
     return ret;
 }
 
-#if GTEST_ENABLED
-bool WMClient::subscribe(afb_req req, const string &evname)
+bool WMClient::subscribe(afb_req_t req, const string &evname)
 {
-    if(evname != kKeyError){
-        HMI_DEBUG("error is only enabeled for now");
-        return false;
-    }
-    int ret = afb_req_subscribe(req, this->event2list[evname]);
+    int ret = afb_req_subscribe(req, this->evname2afb_event[evname]);
     if (ret)
     {
         HMI_DEBUG("Failed to subscribe %s", evname.c_str());
@@ -190,24 +183,129 @@ bool WMClient::subscribe(afb_req req, const string &evname)
     return true;
 }
 
-void WMClient::emitError(WM_CLIENT_ERROR_EVENT ev)
+void WMClient::emitVisible(bool visible)
+{
+    // error check
+    bool allow_send = false;
+    if(visible)
+    {
+        allow_send = afb_event_is_valid(this->evname2afb_event[kVisible]);
+    }
+    else
+    {
+        allow_send = afb_event_is_valid(this->evname2afb_event[kInvisible]);
+    }
+    if(allow_send)
+    {
+        json_object* j = json_object_new_object();
+        json_object_object_add(j, kKeyRole, json_object_new_string(this->role().c_str()));
+        json_object_object_add(j, kKeyDrawingName, json_object_new_string(this->role().c_str()));
+
+        if(visible)
+        {
+            afb_event_push(this->evname2afb_event[kVisible], j);
+        }
+        else
+        {
+            afb_event_push(this->evname2afb_event[kInvisible], j);
+        }
+    }
+    else
+    {
+        HMI_ERROR("Failed to send %s", __func__);
+    }
+}
+
+void WMClient::emitActive(bool active)
+{
+    // error check
+    bool allow_send = false;
+    if(active)
+    {
+        allow_send = afb_event_is_valid(this->evname2afb_event[kActive]);
+    }
+    else
+    {
+        allow_send = afb_event_is_valid(this->evname2afb_event[kInactive]);
+    }
+    if(allow_send)
+    {
+        json_object* j = json_object_new_object();
+        json_object_object_add(j, kKeyRole, json_object_new_string(this->role().c_str()));
+        json_object_object_add(j, kKeyDrawingName, json_object_new_string(this->role().c_str()));
+
+        if(active)
+        {
+            afb_event_push(this->evname2afb_event[kActive], j);
+        }
+        else
+        {
+            afb_event_push(this->evname2afb_event[kInactive], j);
+        }
+    }
+    else
+    {
+        HMI_ERROR("Failed to send %s", __func__);
+    }
+}
+
+void WMClient::emitSyncDraw(const string& area, struct rect& r)
+{
+    HMI_NOTICE("trace");
+    if(afb_event_is_valid(this->evname2afb_event[kSyncDraw]))
+    {
+        json_object *j_rect = json_object_new_object();
+        json_object_object_add(j_rect, kKeyX, json_object_new_int(r.x));
+        json_object_object_add(j_rect, kKeyY, json_object_new_int(r.y));
+        json_object_object_add(j_rect, kKeyWidth, json_object_new_int(r.w));
+        json_object_object_add(j_rect, kKeyHeight, json_object_new_int(r.h));
+
+        json_object* j = json_object_new_object();
+        json_object_object_add(j, kKeyRole, json_object_new_string(this->role().c_str()));
+        json_object_object_add(j, kKeyDrawingName, json_object_new_string(this->role().c_str()));
+        json_object_object_add(j, kKeyDrawingArea, json_object_new_string(area.c_str()));
+        json_object_object_add(j, kKeyArea, json_object_new_string(this->role().c_str()));
+
+        json_object_object_add(j, kKeyDrawingRect, j_rect);
+        afb_event_push(this->evname2afb_event[kSyncDraw], j);
+    }
+    else
+    {
+        HMI_ERROR("Failed to send %s", __func__);
+    }
+}
+
+void WMClient::emitFlushDraw()
+{
+    if(afb_event_is_valid(this->evname2afb_event[kFlushDraw]))
+    {
+        json_object* j = json_object_new_object();
+        json_object_object_add(j, kKeyRole, json_object_new_string(this->role().c_str()));
+        json_object_object_add(j, kKeyDrawingName, json_object_new_string(this->role().c_str()));
+        afb_event_push(this->evname2afb_event[kFlushDraw], nullptr);
+    }
+    else
+    {
+        HMI_ERROR("Failed to send %s", __func__);
+    }
+}
+
+void WMClient::emitError(WMError error)
 {
-    if (!afb_event_is_valid(this->event2list[kKeyError])){
+    if (!afb_event_is_valid(this->evname2afb_event[kKeyError])){
         HMI_ERROR("event err is not valid");
         return;
     }
     json_object *j = json_object_new_object();
-    json_object_object_add(j, kKeyError, json_object_new_int(ev));
-    json_object_object_add(j, kKeyErrorDesc, json_object_new_string(kErrorDescription[ev].c_str()));
-    HMI_DEBUG("error: %d, description:%s", ev, kErrorDescription[ev].c_str());
-
-    int ret = afb_event_push(this->event2list[kKeyError], j);
+    json_object_object_add(j, kKeyError, json_object_new_int(error));
+    json_object_object_add(j, kKeyErrorDesc, json_object_new_string(errorDescription(error)));
+    HMI_DEBUG("error: %d, description:%s", error, errorDescription(error));
+    int ret = afb_event_push(this->evname2afb_event[kKeyError], j);
     if (ret != 0)
     {
         HMI_DEBUG("afb_event_push failed: %m");
     }
 }
-#endif
 
 void WMClient::dumpInfo()
 {