Readd Policy Manager as plugin

This patch reverts commit c6f9a9b8468b3746a3dec7ee2a0b7d84ec9fb44a
and update it.

Policy Manager decides next layout by inputed event and current state
based on the policy table.

And Policy Manager is plugin for Window Manager.
Therefore the OEMs can replace it.

This patch provides Policy Manager I/F as reference implementation
and does not have policy table.
Therefore Policy Manager updates each layers
to draw the applications in requested area
in accordance with just like activate/deactivate request.

[APIs of Policy Manager class]
  - int initialize(void)
      Initialize Policy Manger.
        in:  none
        out: 0(success), -1(error)

  - void registerCallback(CallbackTable callback_table)
      Register callback functions.
        in:  the pointers of callback handlers
        out: none

      "CallbackTable" type is as follows:
        typedef struct
        {
            Handler onStateTransitioned;
            Handler onError;
        } CallbackTable;

      "Handler" type is as follows:
        using Handler = std::function<void(json_object *)>;

  - int setInputEventData(json_object *json_in)
      Set input event data for the policy table.
        in:  input event data as json_object
        out: 0(success), -1(error)

  - int executeStateTransition(void)
      Execute state transition by using set input event data.
        in:  none
        out: 0(success), -1(error)

  - void undoState(void)
      Undo state only once per once state transition.
        in:  none
        out: none

[Callbacks of Policy Manager class]
 - void onStateTransitioned(json_object *json_out)
     When state transition succeeds, this callback is called.
     The argument json_out has the state after transition.

 - void onError(json_object *json_out)
     When state transition fails, this callback is called.
     The argument json_out has the error information
     like message, inputed event datas and etc..

Bug-AGL: SPEC-1537

Change-Id: Ib8c71f2e544cb90b6763d07fad56dc1c453e9a97
Signed-off-by: Yuta Doi <yuta-d@witz-inc.co.jp>

8 files changed, 520 insertions, 410 deletions

diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt
index 42b81b7..3c8da4c 100644
--- a/src/CMakeLists.txt
+++ b/src/CMakeLists.txt
@@ -37,20 +37,23 @@ add_library(${TARGETS_WM} MODULE
    wm_client.cpp
    wm_error.cpp
    applist.cpp
-   request.cpp)
+   request.cpp
+   pm_wrapper.cpp)
 
 target_include_directories(${TARGETS_WM}
     PRIVATE
         ${AFB_INCLUDE_DIRS}
         ${SD_INCLUDE_DIRS}
         ../include
-        ../src)
+        ../src
+        ../${PLUGIN_PM})
 
 target_link_libraries(${TARGETS_WM}
     PRIVATE
         ${AFB_LIBRARIES}
         ${WLC_LIBRARIES}
-        ${SD_LIBRARIES})
+        ${SD_LIBRARIES}
+        ${PLUGIN_PM})
 
 target_compile_definitions(${TARGETS_WM}
     PRIVATE
@@ -82,12 +85,12 @@ set_target_properties(${TARGETS_WM}
         C_STANDARD 99
         C_STANDARD_REQUIRED ON
 
-        LINK_FLAGS "-Wl,--version-script=${CMAKE_CURRENT_SOURCE_DIR}/../export.map")
+        LINK_FLAGS "-Wl,--version-script=${CMAKE_CURRENT_SOURCE_DIR}/../export.map -Wl,-rpath,'$ORIGIN'")
 
 if (LINK_LIBCXX)
    set_target_properties(${TARGETS_WM}
            PROPERTIES
-           LINK_FLAGS "-Wl,--version-script=${CMAKE_CURRENT_SOURCE_DIR}/../export.map -lc++")
+           LINK_FLAGS "-Wl,--version-script=${CMAKE_CURRENT_SOURCE_DIR}/../export.map -lc++ -Wl,-rpath,'$ORIGIN'")
 endif()
 
 if (NOT ${SANITIZER_MODE} STREQUAL "none" AND NOT ${SANITIZER_MODE} STREQUAL "")
diff --git a/src/json_helper.cpp b/src/json_helper.cpp
index c2f4173..b97f21d 100644
--- a/src/json_helper.cpp
+++ b/src/json_helper.cpp
@@ -136,6 +136,18 @@ int getIntFromJson(json_object *obj, const char *key)
     return json_object_get_int(tmp);
 }
 
+json_bool getBoolFromJson(json_object *obj, const char *key)
+{
+    json_object *tmp;
+    if (!json_object_object_get_ex(obj, key, &tmp))
+    {
+        HMI_DEBUG("wm:jh", "Not found key \"%s\"", key);
+        return FALSE;
+    }
+
+    return json_object_get_boolean(tmp);
+}
+
 int inputJsonFilie(const char* file, json_object** obj)
 {
     const int input_size = 128;
diff --git a/src/json_helper.hpp b/src/json_helper.hpp
index 2f6b817..5333130 100644
--- a/src/json_helper.hpp
+++ b/src/json_helper.hpp
@@ -30,6 +30,7 @@ json_object *to_json(std::vector<uint32_t> const &v);
 namespace jh {
 const char* getStringFromJson(json_object* obj, const char* key);
 int getIntFromJson(json_object *obj, const char *key);
+json_bool getBoolFromJson(json_object *obj, const char *key);
 int inputJsonFilie(const char* file, json_object** obj);
 }  // namespace jh
 
diff --git a/src/main.cpp b/src/main.cpp
index 261df8b..0447f86 100644
--- a/src/main.cpp
+++ b/src/main.cpp
@@ -184,27 +184,19 @@ static void cbRemoveClientCtxt(void *data)
         return;
     }
     HMI_DEBUG("wm", "remove app %s", ctxt->name.c_str());
-    // Lookup surfaceID and remove it because App is dead.
-    auto pSid = g_afb_instance->wmgr.id_alloc.lookup(ctxt->role.c_str());
-    if (pSid)
-    {
-        auto sid = *pSid;
-        auto o_state = *g_afb_instance->wmgr.layers.get_layout_state(sid);
-        if (o_state != nullptr)
-        {
-            if (o_state->main == sid)
-            {
-                o_state->main = -1;
-            }
-            else if (o_state->sub == sid)
+
+    // Policy Manager does not know this app was killed,
+    // so notify it by deactivate request.
+    g_afb_instance->wmgr.api_deactivate_surface(
+        ctxt->name.c_str(), ctxt->role.c_str(),
+        [](const char *errmsg) {
+            if (errmsg != nullptr)
             {
-                o_state->sub = -1;
+                HMI_ERROR("wm", errmsg);
+                return;
             }
-        }
-        g_afb_instance->wmgr.id_alloc.remove_id(sid);
-        g_afb_instance->wmgr.layers.remove_surface(sid);
-        HMI_DEBUG("wm", "delete surfaceID %d", sid);
-    }
+        });
+
     g_afb_instance->wmgr.removeClient(ctxt->name);
     delete ctxt;
 }
diff --git a/src/pm_wrapper.cpp b/src/pm_wrapper.cpp
new file mode 100644
index 0000000..1454bf9
--- /dev/null
+++ b/src/pm_wrapper.cpp
@@ -0,0 +1,261 @@
+/*
+ * Copyright (c) 2018 TOYOTA MOTOR CORPORATION
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "pm_wrapper.hpp"
+#include "json_helper.hpp"
+#include "hmi-debug.h"
+
+namespace wm
+{
+
+static PMWrapper *g_context;
+
+namespace
+{
+
+static void onStateTransitioned(json_object *json_out)
+{
+    g_context->updateStates(json_out);
+}
+
+static void onError(json_object *json_out)
+{
+    HMI_DEBUG("wm", "error message from PolicyManager:%s",
+              json_object_get_string(json_out));
+
+    g_context->processError();
+}
+
+} // namespace
+
+PMWrapper::PMWrapper() {}
+
+int PMWrapper::initialize()
+{
+    int ret = 0;
+
+    ret = this->pm.initialize();
+    if (0 > ret)
+    {
+        HMI_ERROR("wm:pmw", "Faild to initialize PolicyManager");
+    }
+
+    g_context = this;
+
+    return ret;
+}
+
+void PMWrapper::registerCallback(StateTransitionHandler on_state_transitioned,
+                                 ErrorHandler on_error)
+{
+    this->on_state_transitioned = on_state_transitioned;
+    this->on_error = on_error;
+
+    PolicyManager::CallbackTable my_callback;
+    my_callback.onStateTransitioned = onStateTransitioned;
+    my_callback.onError = onError;
+    this->pm.registerCallback(my_callback);
+}
+
+int PMWrapper::setInputEventData(Task task, std::string role, std::string area)
+{
+    const char* event;
+    if (Task::TASK_ALLOCATE == task)
+    {
+        event = "activate";
+    }
+    else if (Task::TASK_RELEASE == task)
+    {
+        event = "deactivate";
+    }
+    else
+    {
+        event = "";
+    }
+
+    json_object *json_in = json_object_new_object();
+    json_object_object_add(json_in, "event", json_object_new_string(event));
+    json_object_object_add(json_in, "role", json_object_new_string(role.c_str()));
+    json_object_object_add(json_in, "area", json_object_new_string(area.c_str()));
+
+    int ret;
+    ret = this->pm.setInputEventData(json_in);
+    if (0 > ret)
+    {
+        HMI_ERROR("wm:pmw", "Faild to set input event data to PolicyManager");
+    }
+    json_object_put(json_in);
+
+    return ret;
+}
+
+int PMWrapper::executeStateTransition()
+{
+    int ret;
+    ret = this->pm.executeStateTransition();
+    if (0 > ret)
+    {
+        HMI_ERROR("wm:pmw", "Failed to execute state transition for PolicyManager");
+    }
+
+    return ret;
+}
+
+void PMWrapper::undoState()
+{
+    this->pm.undoState();
+
+    this->crrlayer2rolestate = this->prvlayer2rolestate;
+}
+
+void PMWrapper::updateStates(json_object *json_out)
+{
+    std::vector<WMAction> actions;
+
+    HMI_DEBUG("wm", "json_out dump:%s", json_object_get_string(json_out));
+
+    this->createLayoutChangeAction(json_out, actions);
+
+    this->on_state_transitioned(actions);
+}
+
+void PMWrapper::createLayoutChangeAction(json_object *json_out, std::vector<WMAction> &actions)
+{
+    // Get displayed roles from previous layout
+    json_object *json_layers;
+    if (!json_object_object_get_ex(json_out, "layers", &json_layers))
+    {
+        HMI_DEBUG("wm", "Not found key \"layers\"");
+        return;
+    }
+
+    int len = json_object_array_length(json_layers);
+    HMI_DEBUG("wm", "json_layers len:%d", len);
+
+    for (int i = 0; i < len; i++)
+    {
+        json_object *json_tmp = json_object_array_get_idx(json_layers, i);
+
+        std::string layer_name = jh::getStringFromJson(json_tmp, "name");
+        json_bool changed = jh::getBoolFromJson(json_tmp, "changed");
+        HMI_DEBUG("wm", "layer:%s changed:%d", layer_name.c_str(), changed);
+
+        if (changed)
+        {
+            json_object *json_areas;
+            if (!json_object_object_get_ex(json_tmp, "areas", &json_areas))
+            {
+                HMI_DEBUG("wm", "Not found key \"areas\"");
+                return;
+            }
+
+            int len = json_object_array_length(json_areas);
+            HMI_DEBUG("wm", "json_layers len:%d", len);
+
+            // Store previous role state in this layer
+            this->prvlayer2rolestate[layer_name] = this->crrlayer2rolestate[layer_name];
+
+            RoleState crr_roles;
+            RoleState prv_roles = this->prvlayer2rolestate[layer_name];
+            for (int j = 0; j < len; j++)
+            {
+                json_object *json_tmp2 = json_object_array_get_idx(json_areas, j);
+
+                std::string area_name = jh::getStringFromJson(json_tmp2, "name");
+                std::string role_name = jh::getStringFromJson(json_tmp2, "role");
+
+                crr_roles[role_name] = area_name;
+
+                auto i_prv = prv_roles.find(role_name);
+                HMI_DEBUG("wm", "current role:%s area:%s",
+                          role_name.c_str(), area_name.c_str());
+
+                // If current role does not exist in previous
+                if (prv_roles.end() == i_prv)
+                {
+                    HMI_DEBUG("wm", "current role does not exist in previous");
+
+                    // Set activate action
+                    bool end_draw_finished = false;
+                    WMAction act
+                    {
+                        "",
+                        role_name,
+                        area_name,
+                        TaskVisible::VISIBLE,
+                        end_draw_finished
+                    };
+                    actions.push_back(act);
+                }
+                else
+                {
+                    HMI_DEBUG("wm", "previous role:%s area:%s",
+                              i_prv->first.c_str(), i_prv->second.c_str());
+
+                    // If current role exists in previous and area is different with previous
+                    if (area_name != i_prv->second)
+                    {
+                        HMI_DEBUG("wm", "current role exists in previous and area is different with previous");
+
+                        // Set activate action
+                        bool end_draw_finished = false;
+                        WMAction act
+                        {
+                            "",
+                            role_name,
+                            area_name,
+                            TaskVisible::VISIBLE,
+                            end_draw_finished
+                        };
+                        actions.push_back(act);
+                    }
+
+                    // Remove role which exist in current list from previous list
+                    prv_roles.erase(i_prv);
+                }
+            }
+
+            // Deactivate roles which remains in previous list
+            // because these are not displayed in current layout
+            for (auto i_prv : prv_roles)
+            {
+                HMI_DEBUG("wm", "Deactivate role:%s", i_prv.first.c_str());
+
+                // Set deactivate action
+                bool end_draw_finished = true;
+                WMAction act
+                {
+                    "",
+                    i_prv.first,
+                    "",
+                    TaskVisible::INVISIBLE,
+                    end_draw_finished
+                };
+                actions.push_back(act);
+            }
+
+            // Update previous role list
+            this->crrlayer2rolestate[layer_name] = crr_roles;
+        }
+    }
+}
+
+void PMWrapper::processError()
+{
+    this->on_error();
+}
+
+} // namespace wm
diff --git a/src/pm_wrapper.hpp b/src/pm_wrapper.hpp
new file mode 100644
index 0000000..31ec002
--- /dev/null
+++ b/src/pm_wrapper.hpp
@@ -0,0 +1,75 @@
+/*
+ * Copyright (c) 2018 TOYOTA MOTOR CORPORATION
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef TMCAGLWM_PM_WRAPPER_HPP
+#define TMCAGLWM_PM_WRAPPER_HPP
+
+#include <functional>
+#include <vector>
+#include <string>
+#include <map>
+#include "policy_manager.hpp"
+#include "request.hpp"
+
+struct json_object;
+struct sd_event;
+struct sd_event_source;
+struct StmState;
+
+namespace wm
+{
+
+class PMWrapper
+{
+  public:
+    explicit PMWrapper();
+    ~PMWrapper() = default;
+
+    using StateTransitionHandler = std::function<void(std::vector<WMAction>)>;
+    using ErrorHandler = std::function<void(void)>;
+
+    int initialize();
+    void registerCallback(StateTransitionHandler on_state_transitioned,
+                          ErrorHandler on_error);
+    int setInputEventData(Task task, std::string role, std::string area);
+    int executeStateTransition();
+    void undoState();
+
+    // Do not use these functions
+    void updateStates(json_object *json_out);
+    void processError();
+
+  private:
+    // Disable copy and move
+    PMWrapper(PMWrapper const &) = delete;
+    PMWrapper &operator=(PMWrapper const &) = delete;
+    PMWrapper(PMWrapper &&) = delete;
+    PMWrapper &operator=(PMWrapper &&) = delete;
+
+    typedef std::map<std::string, std::string> RoleState;
+
+    PolicyManager pm;
+    StateTransitionHandler on_state_transitioned;
+    ErrorHandler on_error;
+    std::map<std::string, RoleState> prvlayer2rolestate;
+    std::map<std::string, RoleState> crrlayer2rolestate;
+
+    void createLayoutChangeAction(json_object *json_out, std::vector<WMAction> &actions);
+};
+
+} // namespace wm
+
+#endif // TMCAGLWM_PM_WRAPPER_HPP
diff --git a/src/window_manager.cpp b/src/window_manager.cpp
index aa42d82..24b6f30 100644
--- a/src/window_manager.cpp
+++ b/src/window_manager.cpp
@@ -55,6 +55,7 @@ const char kKeyIds[]         = "ids";
 
 static sd_event_source *g_timer_ev_src = nullptr;
 static AppList g_app_list;
+static WindowManager *g_context;
 
 namespace
 {
@@ -99,6 +100,15 @@ static int processTimerHandler(sd_event_source *s, uint64_t usec, void *userdata
     return 0;
 }
 
+static void onStateTransitioned(std::vector<WMAction> actions)
+{
+    g_context->startTransitionWrapper(actions);
+}
+
+static void onError()
+{
+    g_context->processError(WMError::LAYOUT_CHANGE_FAIL);
+}
 } // namespace
 
 /**
@@ -163,6 +173,15 @@ int WindowManager::init()
     // Load old_role.db
     this->loadOldRoleDb();
 
+    // Store my context for calling callback from PolicyManager
+    g_context = this;
+
+    // Initialize PMWrapper
+    this->pmw.initialize();
+
+    // Register callback to PolicyManager
+    this->pmw.registerCallback(onStateTransitioned, onError);
+
     // Make afb event
     for (int i = Event_Val_Min; i <= Event_Val_Max; i++)
     {
@@ -444,6 +463,9 @@ void WindowManager::api_enddraw(char const *appid, char const *drawing_name)
         if(ret != WMError::SUCCESS)
         {
             //this->emit_error();
+
+            // Undo state of PolicyManager
+            this->pmw.undoState();
         }
         this->emitScreenUpdated(current_req);
         HMI_SEQ_INFO(current_req, "Finish request status: %s", errorDescription(ret));
@@ -506,18 +528,6 @@ result<json_object *> WindowManager::api_get_area_info(char const *drawing_name)
         return Err<json_object *>("Surface is not on any layer!");
     }
 
-    auto o_state = *this->layers.get_layout_state(*surface_id);
-    if (o_state == nullptr)
-    {
-        return Err<json_object *>("Could not find layer for surface");
-    }
-
-    struct LayoutState &state = *o_state;
-    if ((state.main != *surface_id) && (state.sub != *surface_id))
-    {
-        return Err<json_object *>("Surface is inactive");
-    }
-
     // Set area rectangle
     compositor::rect area_info = this->area_info[*surface_id];
     json_object *object = json_object_new_object();
@@ -592,7 +602,9 @@ void WindowManager::surface_created(uint32_t surface_id)
 
 void WindowManager::surface_removed(uint32_t surface_id)
 {
-    HMI_DEBUG("wm", "surface_id is %u", surface_id);
+    HMI_DEBUG("wm", "Delete surface_id %u", surface_id);
+    this->id_alloc.remove_id(surface_id);
+    this->layers.remove_surface(surface_id);
     g_app_list.removeSurface(surface_id);
 }
 
@@ -620,6 +632,94 @@ void WindowManager::timerHandler()
     this->processNextRequest();
 }
 
+void WindowManager::startTransitionWrapper(std::vector<WMAction> &actions)
+{
+    WMError ret;
+    unsigned req_num = g_app_list.currentRequestNumber();
+
+    if (actions.empty())
+    {
+        if (g_app_list.haveRequest())
+        {
+            HMI_SEQ_DEBUG(req_num, "There is no WMAction for this request");
+            goto proc_remove_request;
+        }
+        else
+        {
+            HMI_SEQ_DEBUG(req_num, "There is no request");
+            return;
+        }
+    }
+
+    for (auto &act : actions)
+    {
+        if ("" != act.role)
+        {
+            bool found;
+            auto const &surface_id = this->lookup_id(act.role.c_str());
+            std::string appid = g_app_list.getAppID(*surface_id, act.role, &found);
+            if (!found)
+            {
+                if (TaskVisible::INVISIBLE == act.visible)
+                {
+                    // App is killed, so do not set this action
+                    continue;
+                }
+                else
+                {
+                    HMI_SEQ_ERROR(req_num, "appid which is visible is not found");
+                    ret = WMError::FAIL;
+                    goto error;
+                }
+            }
+            act.appid = appid;
+        }
+
+        ret = g_app_list.setAction(req_num, act);
+        if (ret != WMError::SUCCESS)
+        {
+            HMI_SEQ_ERROR(req_num, "Setting action is failed");
+            goto error;
+        }
+    }
+
+    HMI_SEQ_DEBUG(req_num, "Start transition.");
+    ret = this->startTransition(req_num);
+    if (ret != WMError::SUCCESS)
+    {
+        if (ret == WMError::NO_LAYOUT_CHANGE)
+        {
+            goto proc_remove_request;
+        }
+        else
+        {
+            HMI_SEQ_ERROR(req_num, "Transition state is failed");
+            goto error;
+        }
+    }
+
+    return;
+
+error:
+    //this->emit_error()
+    HMI_SEQ_ERROR(req_num, errorDescription(ret));
+    this->pmw.undoState();
+
+proc_remove_request:
+    g_app_list.removeRequest(req_num);
+    this->processNextRequest();
+}
+
+void WindowManager::processError(WMError error)
+{
+    unsigned req_num = g_app_list.currentRequestNumber();
+
+    //this->emit_error()
+    HMI_SEQ_ERROR(req_num, errorDescription(error));
+    g_app_list.removeRequest(req_num);
+    this->processNextRequest();
+}
+
 /*
  ******* Private Functions *******
  */
@@ -936,12 +1036,6 @@ WMError WindowManager::doTransition(unsigned req_num)
 {
     HMI_SEQ_DEBUG(req_num, "check policy");
     WMError ret = this->checkPolicy(req_num);
-    if (ret != WMError::SUCCESS)
-    {
-        return ret;
-    }
-    HMI_SEQ_DEBUG(req_num, "Start transition.");
-    ret = this->startTransition(req_num);
     return ret;
 }
 
@@ -952,7 +1046,6 @@ WMError WindowManager::checkPolicy(unsigned req_num)
     */
     // get current trigger
     bool found = false;
-    bool split = false;
     WMError ret = WMError::LAYOUT_CHANGE_FAIL;
     auto trigger = g_app_list.getRequest(req_num, &found);
     if (!found)
@@ -962,89 +1055,33 @@ WMError WindowManager::checkPolicy(unsigned req_num)
     }
     std::string req_area = trigger.area;
 
-    // >>>> Compatible with current window manager until policy manager coming
     if (trigger.task == Task::TASK_ALLOCATE)
     {
-        HMI_SEQ_DEBUG(req_num, "Check split or not");
         const char *msg = this->check_surface_exist(trigger.role.c_str());
 
         if (msg)
         {
             HMI_SEQ_ERROR(req_num, msg);
-            ret = WMError::LAYOUT_CHANGE_FAIL;
             return ret;
         }
-
-        auto const &surface_id = this->lookup_id(trigger.role.c_str());
-        auto o_state = *this->layers.get_layout_state(*surface_id);
-        struct LayoutState &state = *o_state;
-
-        unsigned curernt_sid = state.main;
-        split = this->can_split(state, *surface_id);
-
-        if (split)
-        {
-            HMI_SEQ_DEBUG(req_num, "Split happens");
-            // 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);
-            HMI_SEQ_NOTICE(req_num, "Change request area from %s to %s, because split happens",
-                                trigger.area.c_str(), req_area.c_str());
-            // set another action
-            std::string add_name = g_app_list.getAppID(curernt_sid, add_role, &found);
-            if (!found)
-            {
-                HMI_SEQ_ERROR(req_num, "Couldn't widhdraw with surfaceID : %d", curernt_sid);
-                ret = WMError::NOT_REGISTERED;
-                return ret;
-            }
-            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 end_draw_finished = false;
-            WMAction split_action{
-                add_name,
-                add_role,
-                add_area,
-                TaskVisible::VISIBLE,
-                end_draw_finished};
-            WMError ret = g_app_list.setAction(req_num, split_action);
-            if (ret != WMError::SUCCESS)
-            {
-                HMI_SEQ_ERROR(req_num, "Failed to set action");
-                return ret;
-            }
-            g_app_list.reqDump();
-        }
-    }
-    else
-    {
-        HMI_SEQ_DEBUG(req_num, "split doesn't happen");
     }
 
-    // Set invisible task(Remove if policy manager finish)
-    ret = this->setInvisibleTask(trigger.role, split);
-    if(ret != WMError::SUCCESS)
+    // Input event data to PolicyManager
+    if (0 > this->pmw.setInputEventData(trigger.task, trigger.role, trigger.area))
     {
-        HMI_SEQ_ERROR(req_num, "Failed to set invisible task: %s", errorDescription(ret));
+        HMI_SEQ_ERROR(req_num, "Failed to set input event data to PolicyManager");
         return ret;
     }
 
-    /*  get new status from Policy Manager */
-    HMI_SEQ_NOTICE(req_num, "ATM, Policy manager does't exist, then set WMAction as is");
-    if(trigger.role == "homescreen")
+    // Execute state transition of PolicyManager
+    if (0 > this->pmw.executeStateTransition())
     {
-        // TODO : Remove when Policy Manager completed
-        HMI_SEQ_NOTICE(req_num, "Hack. This process will be removed. Change HomeScreen code!!");
-        req_area = "fullscreen";
+        HMI_SEQ_ERROR(req_num, "Failed to execute state transition of PolicyManager");
+        return ret;
     }
-    TaskVisible task_visible =
-        (trigger.task == Task::TASK_ALLOCATE) ? TaskVisible::VISIBLE : TaskVisible::INVISIBLE;
 
-    ret = g_app_list.setAction(req_num, trigger.appid, trigger.role, req_area, task_visible);
+    ret = WMError::SUCCESS;
+
     g_app_list.reqDump();
 
     return ret;
@@ -1066,7 +1103,7 @@ WMError WindowManager::startTransition(unsigned req_num)
 
     for (const auto &action : actions)
     {
-        if (action.visible != TaskVisible::INVISIBLE)
+        if (action.visible == TaskVisible::VISIBLE)
         {
             sync_draw_happen = true;
 
@@ -1097,163 +1134,11 @@ WMError WindowManager::startTransition(unsigned req_num)
                 this->deactivate(client->surfaceID(x.role));
             }
         }
-        ret = NO_LAYOUT_CHANGE;
+        ret = WMError::NO_LAYOUT_CHANGE;
     }
     return ret;
 }
 
-WMError WindowManager::setInvisibleTask(const std::string &role, bool split)
-{
-    unsigned req_num = g_app_list.currentRequestNumber();
-    HMI_SEQ_DEBUG(req_num, "set current visible app to invisible task");
-    bool found = false;
-    auto trigger = g_app_list.getRequest(req_num, &found);
-    // I don't check found == true here because this is checked in caller.
-    if(trigger.role == "homescreen")
-    {
-        HMI_SEQ_INFO(req_num, "In case of 'homescreen' visible, don't change app to invisible");
-        return WMError::SUCCESS;
-    }
-
-    // This task is copied from original actiavete surface
-    const char *drawing_name = this->rolenew2old[role].c_str();
-    auto const &surface_id = this->lookup_id(role.c_str());
-    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;
-    std::string add_name, add_role;
-    std::string add_area = "";
-    int surface;
-    TaskVisible task_visible = TaskVisible::INVISIBLE;
-    bool end_draw_finished = true;
-
-    for (auto const &l : this->layers.mapping)
-    {
-        if (l.second.layer_id <= *layer_id)
-        {
-            continue;
-        }
-        HMI_DEBUG("wm", "debug: main %d , sub : %d", l.second.state.main, l.second.state.sub);
-        if (l.second.state.main != -1)
-        {
-            //this->deactivate(l.second.state.main);
-            surface = l.second.state.main;
-            add_role = *this->id_alloc.lookup(surface);
-            add_name = g_app_list.getAppID(surface, add_role, &found);
-            if(!found){
-                return WMError::NOT_REGISTERED;
-            }
-            HMI_SEQ_INFO(req_num, "Invisible %s", add_name.c_str());
-            WMAction act{add_name, add_role, add_area, task_visible, end_draw_finished};
-            g_app_list.setAction(req_num, act);
-            l.second.state.main = -1;
-        }
-
-        if (l.second.state.sub != -1)
-        {
-            //this->deactivate(l.second.state.sub);
-            surface = l.second.state.sub;
-            add_role = *this->id_alloc.lookup(surface);
-            add_name = g_app_list.getAppID(surface, add_role, &found);
-            if (!found)
-            {
-                return WMError::NOT_REGISTERED;
-            }
-            HMI_SEQ_INFO(req_num, "Invisible %s", add_name.c_str());
-            WMAction act{add_name, add_role, add_area, task_visible, end_draw_finished};
-            g_app_list.setAction(req_num, act);
-            l.second.state.sub = -1;
-        }
-    }
-
-    // change current state here, but this is hack
-    auto layer = this->layers.get_layer(*layer_id);
-
-    if (state.main == -1)
-    {
-        HMI_DEBUG("wm", "Layout: %s", kNameLayoutNormal);
-    }
-    else
-    {
-        if (0 != strcmp(drawing_name, "HomeScreen"))
-        {
-            if (split)
-            {
-                if (state.sub != *surface_id)
-                {
-                    if (state.sub != -1)
-                    {
-                        //this->deactivate(state.sub);
-                        WMAction deact_sub;
-                        deact_sub.role =
-                            std::move(*this->id_alloc.lookup(state.sub));
-                        deact_sub.area = add_area;
-                        deact_sub.appid = g_app_list.getAppID(state.sub, deact_sub.role, &found);
-                        if (!found)
-                        {
-                            HMI_SEQ_ERROR(req_num, "App doesn't exist for role : %s",
-                                            deact_sub.role.c_str());
-                            return WMError::NOT_REGISTERED;
-                        }
-                        deact_sub.visible = task_visible;
-                        deact_sub.end_draw_finished = end_draw_finished;
-                        HMI_SEQ_DEBUG(req_num, "Set invisible task for %s", deact_sub.appid.c_str());
-                        g_app_list.setAction(req_num, deact_sub);
-                    }
-                }
-                //state = LayoutState{state.main, *surface_id};
-            }
-            else
-            {
-                HMI_DEBUG("wm", "Layout: %s", kNameLayoutNormal);
-
-                //this->surface_set_layout(*surface_id);
-                if (state.main != *surface_id)
-                {
-                    // this->deactivate(state.main);
-                    WMAction deact_main;
-                    deact_main.role = std::move(*this->id_alloc.lookup(state.main));
-                    ;
-                    deact_main.area = add_area;
-                    deact_main.appid = g_app_list.getAppID(state.main, deact_main.role, &found);
-                    if (!found)
-                    {
-                        HMI_SEQ_DEBUG(req_num, "sub surface ddoesn't exist");
-                        return WMError::NOT_REGISTERED;
-                    }
-                    deact_main.visible = task_visible;
-                    deact_main.end_draw_finished = end_draw_finished;
-                    HMI_SEQ_DEBUG(req_num, "sub surface doesn't exist");
-                    g_app_list.setAction(req_num, deact_main);
-                }
-                if (state.sub != -1)
-                {
-                    if (state.sub != *surface_id)
-                    {
-                        //this->deactivate(state.sub);
-                        WMAction deact_sub;
-                        deact_sub.role = std::move(*this->id_alloc.lookup(state.sub));
-                        ;
-                        deact_sub.area = add_area;
-                        deact_sub.appid = g_app_list.getAppID(state.sub, deact_sub.role, &found);
-                        if (!found)
-                        {
-                            HMI_SEQ_DEBUG(req_num, "sub surface ddoesn't exist");
-                            return WMError::NOT_REGISTERED;
-                        }
-                        deact_sub.visible = task_visible;
-                        deact_sub.end_draw_finished = end_draw_finished;
-                        HMI_SEQ_DEBUG(req_num, "sub surface doesn't exist");
-                        g_app_list.setAction(req_num, deact_sub);
-                    }
-                }
-                //state = LayoutState{*surface_id};
-            }
-        }
-    }
-    return WMError::SUCCESS;
-}
-
 WMError WindowManager::doEndDraw(unsigned req_num)
 {
     // get actions
@@ -1271,37 +1156,37 @@ WMError WindowManager::doEndDraw(unsigned req_num)
     // layout change and make it visible
     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)
+        if(act.visible != TaskVisible::NO_CHANGE)
         {
-            HMI_SEQ_WARNING(req_num,
-                "Failed to manipulate surfaces while state change : %s", errorDescription(ret));
-            return ret;
+            // 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());
         }
-        HMI_SEQ_DEBUG(req_num, "visible %s", act.role.c_str());
-        //this->lm_enddraw(act.role.c_str());
     }
     this->layout_commit();
 
-    // Change current state
-    this->changeCurrentState(req_num);
-
     HMI_SEQ_INFO(req_num, "emit flushDraw");
 
     for(const auto &act_flush : actions)
     {
-        if(act_flush.visible != TaskVisible::INVISIBLE)
+        if(act_flush.visible == TaskVisible::VISIBLE)
         {
             // TODO: application requests by old role,
             //       so convert role new to old for emitting event
@@ -1367,74 +1252,6 @@ WMError WindowManager::setSurfaceSize(unsigned surface, const std::string &area)
     return WMError::SUCCESS;
 }
 
-WMError WindowManager::changeCurrentState(unsigned req_num)
-{
-    HMI_SEQ_DEBUG(req_num, "Change current layout state");
-    bool trigger_found = false, action_found = false;
-    auto trigger = g_app_list.getRequest(req_num, &trigger_found);
-    auto actions = g_app_list.getActions(req_num, &action_found);
-    if (!trigger_found || !action_found)
-    {
-        HMI_SEQ_ERROR(req_num, "Action not found");
-        return WMError::LAYOUT_CHANGE_FAIL;
-    }
-
-    // Layout state reset
-    struct LayoutState reset_state{-1, -1};
-    HMI_SEQ_DEBUG(req_num,"Reset layout state");
-    for (const auto &action : actions)
-    {
-        if(!g_app_list.contains(action.appid)){
-            return WMError::NOT_REGISTERED;
-        }
-        auto client = g_app_list.lookUpClient(action.appid);
-        auto pCurState = *this->layers.get_layout_state((int)client->surfaceID(action.role));
-        if(pCurState == nullptr)
-        {
-            HMI_SEQ_ERROR(req_num, "Counldn't find current status");
-            continue;
-        }
-        pCurState->main = reset_state.main;
-        pCurState->sub = reset_state.sub;
-    }
-
-    HMI_SEQ_DEBUG(req_num, "Change state");
-    for (const auto &action : actions)
-    {
-        auto client = g_app_list.lookUpClient(action.appid);
-        auto pLayerCurState = *this->layers.get_layout_state((int)client->surfaceID(action.role));
-        if (pLayerCurState == nullptr)
-        {
-            HMI_SEQ_ERROR(req_num, "Counldn't find current status");
-            continue;
-        }
-        int surface = -1;
-
-        if (action.visible != TaskVisible::INVISIBLE)
-        {
-            surface = (int)client->surfaceID(action.role);
-            HMI_SEQ_INFO(req_num, "Change %s surface : %d, state visible area : %s",
-                            action.role.c_str(), surface, action.area.c_str());
-            // visible == true -> layout changes
-            if(action.area == "normal.full" || action.area == "split.main")
-            {
-                pLayerCurState->main = surface;
-            }
-            else if (action.area == "split.sub")
-            {
-                pLayerCurState->sub = surface;
-            }
-            else
-            {
-                // normalfull
-                pLayerCurState->main = surface;
-            }
-        }
-    }
-
-    return WMError::SUCCESS;
-}
-
 void WindowManager::emitScreenUpdated(unsigned req_num)
 {
     // Get visible apps
@@ -1641,63 +1458,10 @@ const char *WindowManager::check_surface_exist(const char *drawing_name)
         return "Surface is not on any layer!";
     }
 
-    auto o_state = *this->layers.get_layout_state(*surface_id);
-
-    if (o_state == nullptr)
-    {
-        return "Could not find layer for surface";
-    }
-
     HMI_DEBUG("wm", "surface %d is detected", *surface_id);
     return nullptr;
 }
 
-bool WindowManager::can_split(struct LayoutState const &state, int new_id)
-{
-    if (state.main != -1 && state.main != new_id)
-    {
-        auto new_id_layer = this->layers.get_layer_id(new_id).value();
-        auto current_id_layer = this->layers.get_layer_id(state.main).value();
-
-        // surfaces are on separate layers, don't bother.
-        if (new_id_layer != current_id_layer)
-        {
-            return false;
-        }
-
-        std::string const &new_id_str = this->lookup_name(new_id).value();
-        std::string const &cur_id_str = this->lookup_name(state.main).value();
-
-        auto const &layer = this->layers.get_layer(new_id_layer);
-
-        HMI_DEBUG("wm", "layer info name: %s", layer->name.c_str());
-
-        if (layer->layouts.empty())
-        {
-            return false;
-        }
-
-        for (auto i = layer->layouts.cbegin(); i != layer->layouts.cend(); i++)
-        {
-            HMI_DEBUG("wm", "%d main_match '%s'", new_id_layer, i->main_match.c_str());
-            auto rem = std::regex(i->main_match);
-            if (std::regex_match(cur_id_str, rem))
-            {
-                // build the second one only if the first already matched
-                HMI_DEBUG("wm", "%d sub_match '%s'", new_id_layer, i->sub_match.c_str());
-                auto res = std::regex(i->sub_match);
-                if (std::regex_match(new_id_str, res))
-                {
-                    HMI_DEBUG("wm", "layout matched!");
-                    return true;
-                }
-            }
-        }
-    }
-
-    return false;
-}
-
 const char* WindowManager::kDefaultOldRoleDb = "{ \
     \"old_roles\": [ \
         { \
diff --git a/src/window_manager.hpp b/src/window_manager.hpp
index 2358c5a..6cbd355 100644
--- a/src/window_manager.hpp
+++ b/src/window_manager.hpp
@@ -25,6 +25,7 @@
 #include "layers.hpp"
 #include "layout.hpp"
 #include "wayland_ivi_wm.hpp"
+#include "pm_wrapper.hpp"
 #include "hmi-debug.h"
 #include "request.hpp"
 #include "wm_error.hpp"
@@ -227,8 +228,11 @@ class WindowManager
     void removeClient(const std::string &appid);
     void exceptionProcessForTransition();
     const char* convertRoleOldToNew(char const *role);
+
     // Do not use this function
     void timerHandler();
+    void startTransitionWrapper(std::vector<WMAction> &actions);
+    void processError(WMError error);
 
   private:
     bool pop_pending_events();
@@ -255,13 +259,11 @@ class WindowManager
     WMError doTransition(unsigned sequence_number);
     WMError checkPolicy(unsigned req_num);
     WMError startTransition(unsigned req_num);
-    WMError setInvisibleTask(const std::string &role, bool split);
 
     WMError doEndDraw(unsigned req_num);
     WMError layoutChange(const WMAction &action);
     WMError visibilityChange(const WMAction &action);
     WMError setSurfaceSize(unsigned surface, const std::string& area);
-    WMError changeCurrentState(unsigned req_num);
     void    emitScreenUpdated(unsigned req_num);
 
     void setTimer();
@@ -272,13 +274,13 @@ class WindowManager
 
     const char *check_surface_exist(const char *role);
 
-    bool can_split(struct LayoutState const &state, int new_id);
-
   private:
     std::unordered_map<std::string, struct compositor::rect> area2size;
     std::unordered_map<std::string, std::string> roleold2new;
     std::unordered_map<std::string, std::string> rolenew2old;
 
+    PMWrapper pmw;
+
     static const char* kDefaultOldRoleDb;
 };