Add timer for restriction mode

When car state is changed stop -> run,
the timer for switching restriction mode off -> on is set.

When car state is changed run -> stop,
restriction mode is changed on -> off.

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

5 files changed, 346 insertions, 204 deletions

diff --git a/src/layout_manager/layout.cpp b/src/layout_manager/layout.cpp
index c888b0e..cd81d8f 100644
--- a/src/layout_manager/layout.cpp
+++ b/src/layout_manager/layout.cpp
@@ -84,6 +84,21 @@ bool LayoutManager::updateLayout(json_object* obj,
         car_state = jh::getStringFromJson(json_car, "state");
     }
 
+    // Check restriction mode change
+    json_object* json_restriction_mode;
+    if (!json_object_object_get_ex(obj, "restriction_mode", &json_restriction_mode)) {
+        HMI_ERROR("wm:lm", "Parse Error!!");
+        return -1;
+    }
+
+    json_bool is_restriction_mode_changed;
+    std::string restriction_mode = "";
+    is_restriction_mode_changed = jh::getBoolFromJson(json_restriction_mode, "is_changed");
+    if (is_restriction_mode_changed) {
+        // If restriction mode is changed, get restriction mode
+        restriction_mode = jh::getStringFromJson(json_restriction_mode, "state");
+    }
+
     // Update layout of all layers
     json_object* json_layers;
     if (!json_object_object_get_ex(obj, "layers", &json_layers)) {
@@ -111,12 +126,21 @@ bool LayoutManager::updateLayout(json_object* obj,
         this->prv_layers_[layer] = this->crr_layers_[layer];
         std::string prv_layout_name = this->prv_layers_[layer].begin()->first;
 
+#if 1
+        // If restriction mode is changed off -> on,
+        // store current state for state of restriction mode off
+        if ((is_restriction_mode_changed) && ("restriction_mode_on" == restriction_mode)) {
+            HMI_DEBUG("wm:lm", "Store current state for state of restriction mode off");
+            this->prv_layers_car_stop_[layer] = this->crr_layers_[layer];
+        }
+#else
         // If car state is changed car_stop -> car_run,
         // store current state for state of car stop
         if ((is_car_state_changed) && ("car_run" == car_state)) {
             HMI_DEBUG("wm:lm", "Store current state for state of car stop");
             this->prv_layers_car_stop_[layer] = this->crr_layers_[layer];
         }
+#endif
 
         json_object* json_is_changed;
         if (!json_object_object_get_ex(json_layer, "is_changed", &json_is_changed)) {
@@ -139,11 +163,19 @@ bool LayoutManager::updateLayout(json_object* obj,
             HMI_DEBUG("wm:lm", "crr state: %s", crr_layout_name);
 
             TypeLayouts crr_layout;
+#if 1
+            if ((is_restriction_mode_changed) && ("restriction_mode_off" == restriction_mode)) {
+                // If restriction mode is changed on -> off,
+                // restore state of restriction mode off
+                HMI_DEBUG("wm:lm", "Restriction mode is changed on -> off, so restore state of restriction mode off");
+                crr_layout = this->prv_layers_car_stop_[layer];
+#else
             if ((is_car_state_changed) && ("car_stop" == car_state)) {
                 // If car state is changed car_run -> car_stop,
                 // restore state of car stop
                 HMI_DEBUG("wm:lm", "Car state is changed car_run -> car_stop, so restore state of car stop");
                 crr_layout = this->prv_layers_car_stop_[layer];
+#endif
             }
             else if ("none" == std::string(crr_layout_name)) {
                 // If current layout is "none",
@@ -170,11 +202,19 @@ bool LayoutManager::updateLayout(json_object* obj,
                 }
 
                 // Update role in new area
+#if 1
+                if (is_restriction_mode_changed) {
+                    // Updating role is not necessary
+                    // because new_role is not specified
+                    // when restriction mode is changed
+                    HMI_DEBUG("wm:lm", "Updating role is not necessary because new_role is not specified when restriction mode is changed");
+#else
                 if (is_car_state_changed) {
                     // Updating role is not necessary
                     // because new_role is not specified
                     // when car state is changed
                     HMI_DEBUG("wm:lm", "Updating role is not necessary because new_role is not specified when car state is changed");
+#endif
                 }
                 else {
                     HMI_DEBUG("wm:lm", "Get new_area for new role");
diff --git a/src/policy_manager/policy_manager.cpp b/src/policy_manager/policy_manager.cpp
index 351c7ce..55d79d9 100644
--- a/src/policy_manager/policy_manager.cpp
+++ b/src/policy_manager/policy_manager.cpp
@@ -19,6 +19,7 @@
 #include <sstream>
 #include <istream>
 #include <thread>
+#include <map>
 #include <systemd/sd-event.h>
 #include <json-c/json.h>
 #include "policy_manager.hpp"
@@ -32,16 +33,18 @@ extern "C" {
 
 
 namespace pm {
-struct EventData {
-    explicit EventData(int event, PolicyManager::Handler handler) {
-        this->event = event;
-        this->handler = handler;
-    };
-    ~EventData() = default;
 
+struct sd_event* event_loop;
+struct sd_event_source* event_source;
+
+struct EventData {
+    PolicyManager *ctx;
     int event;
     PolicyManager::Handler handler;
 };
+
+std::map<int, EventData> event_data_list;
+
 }  // namespace pm
 
 PolicyManager::PolicyManager() :
@@ -98,7 +101,7 @@ int PolicyManager::initialize() {
 
 int PolicyManager::initializeSdEventLoop() {
     // Get default event loop object
-    int ret = sd_event_new(&(this->sd_event_));
+    int ret = sd_event_new(&(pm::event_loop));
     if (0 > ret) {
         HMI_ERROR("wm:pm", "Faild to sd_event_default: errno:%d", ret);
         return -1;
@@ -107,7 +110,7 @@ int PolicyManager::initializeSdEventLoop() {
     // Create thread for sd_event and detach
     std::thread sd_event_loop([this]() {
         while (1) {
-            sd_event_run(this->sd_event_, 1000);
+            sd_event_run(pm::event_loop, 1000);
         }
     });
     sd_event_loop.detach();
@@ -131,173 +134,221 @@ static void addStateToJson(
     json_object_object_add(*json_out, key, json_obj);
 }
 
+static int checkPolicyEntry(PolicyManager* ctx, int event, int delay_ms,
+                            PolicyManager::Handler handler);
 static int checkPolicy(sd_event_source *source, uint64_t usec, void *data) {
     HMI_DEBUG("wm:pm", "Call");
 
-    pm::EventData *event_data = (pm::EventData*)data;
+    int event = *((int*)data);
+
+    pm::EventData event_data;
+    if (pm::event_data_list.find(event) != pm::event_data_list.end()) {
+        event_data = pm::event_data_list[event];
+
+        int event_no, category_no, area_no;
+        event_no    = event & STM_MSK_EVT_NO;
+        category_no = event & STM_MSK_CTG_NO;
+        area_no     = event & STM_MSK_ARA_NO;
+        HMI_DEBUG("wm:pm", ">>>>>>>>>> START CHECK POLICY");
+        HMI_DEBUG("wm:pm", ">>>>>>>>>> event:%s category:%s area:%s",
+                  stm::gStmEventName[event_no - 1],
+                  stm::gStmCategoryName[(category_no >> 8) - 1],
+                  stm::gStmAreaName[(area_no >> 16) - 1]);
+
+        // Transition state
+        stm::stm_state_t crr_state;
+        int ret = stm::stmTransitionState(event_data.event, &crr_state);
+        if (0 > ret) {
+            HMI_ERROR("wm:pm", "Error!!");
+            return -1;
+        }
 
-    // Transition state
-    stm::stm_state_t crr_state;
-    int ret = stm::stmTransitionState(event_data->event, &crr_state);
-    if (0 > ret) {
-        HMI_ERROR("wm:pm", "Error!!");
-        return -1;
-    }
+        HMI_DEBUG("wm", "parking brake state (is_changed:%d state:%d:%s)",
+                  crr_state.parking_brake.is_changed,
+                  crr_state.parking_brake.state,
+                  stm::gStmParkingBrakeStateNo2Name[crr_state.parking_brake.state]);
+        HMI_DEBUG("wm", "accelerator pedal state (is_changed:%d state:%d:%s)",
+                  crr_state.accel_pedal.is_changed,
+                  crr_state.accel_pedal.state,
+                  stm::gStmAccelPedalStateNo2Name[crr_state.accel_pedal.state]);
+        HMI_DEBUG("wm", "lightstatus brake state (is_changed:%d state:%d:%s)",
+                  crr_state.lightstatus_brake.is_changed,
+                  crr_state.lightstatus_brake.state,
+                  stm::gStmLightstatusBrakeStateNo2Name[crr_state.lightstatus_brake.state]);
+        HMI_DEBUG("wm", "car state (is_changed:%d state:%d:%s)",
+                  crr_state.car.is_changed,
+                  crr_state.car.state,
+                  stm::gStmCarStateNo2Name[crr_state.car.state]);
+        HMI_DEBUG("wm", "lamp state (is_changed:%d state:%d:%s)",
+                  crr_state.lamp.is_changed,
+                  crr_state.lamp.state,
+                  stm::gStmLampStateNo2Name[crr_state.lamp.state]);
+        HMI_DEBUG("wm", "restriction mode state (is_changed:%d state:%d:%s)",
+                  crr_state.restriction_mode.is_changed,
+                  crr_state.restriction_mode.state,
+                  stm::gStmRestrictionModeStateNo2Name[crr_state.restriction_mode.state]);
+        HMI_DEBUG("wm", "homescreen state (is_changed:%d state:%d:%s)",
+                  crr_state.layer.homescreen.is_changed,
+                  crr_state.layer.homescreen.state,
+                  stm::gStmLayoutNo2Name[crr_state.layer.homescreen.state]);
+        HMI_DEBUG("wm", "apps state (is_changed:%d state:%d:%s)",
+                  crr_state.layer.apps.is_changed,
+                  crr_state.layer.apps.state,
+                  stm::gStmLayoutNo2Name[crr_state.layer.apps.state]);
+        HMI_DEBUG("wm", "restriction state (is_changed:%d state:%d:%s)",
+                  crr_state.layer.restriction.is_changed,
+                  crr_state.layer.restriction.state,
+                  stm::gStmLayoutNo2Name[crr_state.layer.restriction.state]);
+        HMI_DEBUG("wm", "on_screen state (is_changed:%d state:%d:%s)",
+                  crr_state.layer.on_screen.is_changed,
+                  crr_state.layer.on_screen.state,
+                  stm::gStmLayoutNo2Name[crr_state.layer.on_screen.state]);
+
+        json_object* json_out = json_object_new_object();
+
+        // Create result
+        // {
+        //     "parking_brake": {
+        //         "is_changed": <bool>,
+        //         "state": <const char*>
+        //     },
+        addStateToJson("parking_brake",
+                       crr_state.parking_brake.is_changed,
+                       stm::gStmParkingBrakeStateNo2Name[crr_state.parking_brake.state],
+                       &json_out);
+
+        //     "accel_pedal": {
+        //         "is_changed": <bool>,
+        //         "state": <const char*>
+        //     },
+        addStateToJson("accel_pedal",
+                       crr_state.accel_pedal.is_changed,
+                       stm::gStmAccelPedalStateNo2Name[crr_state.accel_pedal.state],
+                       &json_out);
+
+        //     "lightstatus_brake": {
+        //         "is_changed": <bool>,
+        //         "state": <const char*>
+        //     },
+        addStateToJson("lightstatus_brake",
+                       crr_state.lightstatus_brake.is_changed,
+                       stm::gStmLightstatusBrakeStateNo2Name[crr_state.lightstatus_brake.state],
+                       &json_out);
+
+        //     "car": {
+        //         "is_changed": <bool>,
+        //         "state": <const char*>
+        //     },
+        addStateToJson("car",
+                       crr_state.car.is_changed,
+                       stm::gStmCarStateNo2Name[crr_state.car.state],
+                       &json_out);
+
+        //     "lamp": {
+        //         "is_changed": <bool>,
+        //         "state": <const char*>
+        //     },
+        addStateToJson("lamp",
+                       crr_state.lamp.is_changed,
+                       stm::gStmLampStateNo2Name[crr_state.lamp.state],
+                       &json_out);
+
+        //     "restriction_mode": {
+        //         "is_changed": <bool>,
+        //         "state": <const char*>
+        //     },
+        addStateToJson("restriction_mode",
+                       crr_state.restriction_mode.is_changed,
+                       stm::gStmRestrictionModeStateNo2Name[crr_state.restriction_mode.state],
+                       &json_out);
+
+        //     "layers": [
+        json_object* json_layer = json_object_new_array();
+        json_object* json_tmp;
+
+        //         {
+        //             "homescreen": {
+        //                 "is_changed": <bool>,
+        //                 "state": <const char*>
+        //             }
+        //         },
+        //     ]
+        // }
+        json_tmp = json_object_new_object();
+        addStateToJson("homescreen",
+                       crr_state.layer.homescreen.is_changed,
+                       stm::gStmLayoutNo2Name[crr_state.layer.homescreen.state],
+                       &json_tmp);
+        json_object_array_add(json_layer, json_tmp);
+
+        //         {
+        //             "apps": {
+        //                 "is_changed": <bool>,
+        //                 "state": <const char*>
+        //             }
+        //         },
+        json_tmp = json_object_new_object();
+        addStateToJson("apps",
+                       crr_state.layer.apps.is_changed,
+                       stm::gStmLayoutNo2Name[crr_state.layer.apps.state],
+                       &json_tmp);
+        json_object_array_add(json_layer, json_tmp);
+
+        //         {
+        //             "restriction": {
+        //                 "is_changed": <bool>,
+        //                 "state": <const char*>
+        //             }
+        //         },
+        json_tmp = json_object_new_object();
+        addStateToJson("restriction",
+                       crr_state.layer.restriction.is_changed,
+                       stm::gStmLayoutNo2Name[crr_state.layer.restriction.state],
+                       &json_tmp);
+        json_object_array_add(json_layer, json_tmp);
+
+        //         {
+        //             "on_screen": {
+        //                 "is_changed": <bool>,
+        //                 "state": <const char*>
+        //             }
+        //         },
+        json_tmp = json_object_new_object();
+        addStateToJson("on_screen",
+                       crr_state.layer.on_screen.is_changed,
+                       stm::gStmLayoutNo2Name[crr_state.layer.on_screen.state],
+                       &json_tmp);
+        json_object_array_add(json_layer, json_tmp);
+
+        // Add json array of layer
+        json_object_object_add(json_out, "layers", json_layer);
+
+        // Call event handler
+        event_data.handler(json_out);
+
+        if (crr_state.car.is_changed) {
+            // Set delay event(restriction mode on) when car state is chaged stop -> run 
+            if (stm::gStmCarStateNoRun == crr_state.car.state) {
+                checkPolicyEntry(event_data.ctx, STM_EVT_NO_RESTRICTION_MODE_ON,
+                                 3000, event_data.handler);
+            }
+            else if (stm::gStmCarStateNoStop == crr_state.car.state) {
+                checkPolicyEntry(event_data.ctx, STM_EVT_NO_RESTRICTION_MODE_OFF,
+                                 0, event_data.handler);
+            }
+        }
 
-    json_object* json_out = json_object_new_object();
-
-    // Create result
-    // {
-    //     "parking_brake": {
-    //         "is_changed": <bool>,
-    //         "state": <const char*>
-    //     },
-    HMI_DEBUG("wm", "parking brake state (is_changed:%d state:%d:%s)",
-              crr_state.parking_brake.is_changed,
-              crr_state.parking_brake.state,
-              stm::gStmParkingBrakeStateNo2Name[crr_state.parking_brake.state]);
-    addStateToJson("parking_brake",
-                         crr_state.parking_brake.is_changed,
-                         stm::gStmParkingBrakeStateNo2Name[crr_state.parking_brake.state],
-                         &json_out);
-
-    //     "accel_pedal": {
-    //         "is_changed": <bool>,
-    //         "state": <const char*>
-    //     },
-    HMI_DEBUG("wm", "accelerator pedal state (is_changed:%d state:%d:%s)",
-              crr_state.accel_pedal.is_changed,
-              crr_state.accel_pedal.state,
-              stm::gStmAccelPedalStateNo2Name[crr_state.accel_pedal.state]);
-    addStateToJson("accel_pedal",
-                         crr_state.accel_pedal.is_changed,
-                         stm::gStmAccelPedalStateNo2Name[crr_state.accel_pedal.state],
-                         &json_out);
-
-    //     "lightstatus_brake": {
-    //         "is_changed": <bool>,
-    //         "state": <const char*>
-    //     },
-    HMI_DEBUG("wm", "lightstatus brake state (is_changed:%d state:%d:%s)",
-              crr_state.lightstatus_brake.is_changed,
-              crr_state.lightstatus_brake.state,
-              stm::gStmLightstatusBrakeStateNo2Name[crr_state.lightstatus_brake.state]);
-    addStateToJson("lightstatus_brake",
-                         crr_state.lightstatus_brake.is_changed,
-                         stm::gStmLightstatusBrakeStateNo2Name[crr_state.lightstatus_brake.state],
-                         &json_out);
-
-    //     "car": {
-    //         "is_changed": <bool>,
-    //         "state": <const char*>
-    //     },
-    HMI_DEBUG("wm", "car state (is_changed:%d state:%d:%s)",
-              crr_state.car.is_changed,
-              crr_state.car.state,
-              stm::gStmCarStateNo2Name[crr_state.car.state]);
-    addStateToJson("car",
-                         crr_state.car.is_changed,
-                         stm::gStmCarStateNo2Name[crr_state.car.state],
-                         &json_out);
-
-    //     "lamp": {
-    //         "is_changed": <bool>,
-    //         "state": <const char*>
-    //     },
-    HMI_DEBUG("wm", "lamp state (is_changed:%d state:%d:%s)",
-              crr_state.lamp.is_changed,
-              crr_state.lamp.state,
-              stm::gStmLampStateNo2Name[crr_state.lamp.state]);
-    addStateToJson("lamp",
-                         crr_state.lamp.is_changed,
-                         stm::gStmLampStateNo2Name[crr_state.lamp.state],
-                         &json_out);
-
-    //     "layers": [
-    json_object* json_layer = json_object_new_array();
-    json_object* json_tmp;
+        // Release json_object
+        json_object_put(json_out);
 
-    //         {
-    //             "homescreen": {
-    //                 "is_changed": <bool>,
-    //                 "state": <const char*>
-    //             }
-    //         },
-    //     ]
-    // }
-    HMI_DEBUG("wm", "homescreen state (is_changed:%d state:%d:%s)",
-              crr_state.layer.homescreen.is_changed,
-              crr_state.layer.homescreen.state,
-              stm::gStmLayoutNo2Name[crr_state.layer.homescreen.state]);
-    json_tmp = json_object_new_object();
-    addStateToJson("homescreen",
-                         crr_state.layer.homescreen.is_changed,
-                         stm::gStmLayoutNo2Name[crr_state.layer.homescreen.state],
-                         &json_tmp);
-    json_object_array_add(json_layer, json_tmp);
-
-    //         {
-    //             "apps": {
-    //                 "is_changed": <bool>,
-    //                 "state": <const char*>
-    //             }
-    //         },
-    HMI_DEBUG("wm", "apps state (is_changed:%d state:%d:%s)",
-              crr_state.layer.apps.is_changed,
-              crr_state.layer.apps.state,
-              stm::gStmLayoutNo2Name[crr_state.layer.apps.state]);
-    json_tmp = json_object_new_object();
-    addStateToJson("apps",
-                         crr_state.layer.apps.is_changed,
-                         stm::gStmLayoutNo2Name[crr_state.layer.apps.state],
-                         &json_tmp);
-    json_object_array_add(json_layer, json_tmp);
-
-    //         {
-    //             "restriction": {
-    //                 "is_changed": <bool>,
-    //                 "state": <const char*>
-    //             }
-    //         },
-    HMI_DEBUG("wm", "restriction state (is_changed:%d state:%d:%s)",
-              crr_state.layer.restriction.is_changed,
-              crr_state.layer.restriction.state,
-              stm::gStmLayoutNo2Name[crr_state.layer.restriction.state]);
-    json_tmp = json_object_new_object();
-    addStateToJson("restriction",
-                         crr_state.layer.restriction.is_changed,
-                         stm::gStmLayoutNo2Name[crr_state.layer.restriction.state],
-                         &json_tmp);
-    json_object_array_add(json_layer, json_tmp);
-
-    //         {
-    //             "on_screen": {
-    //                 "is_changed": <bool>,
-    //                 "state": <const char*>
-    //             }
-    //         },
-    HMI_DEBUG("wm", "on_screen state (is_changed:%d state:%d:%s)",
-              crr_state.layer.on_screen.is_changed,
-              crr_state.layer.on_screen.state,
-              stm::gStmLayoutNo2Name[crr_state.layer.on_screen.state]);
-    json_tmp = json_object_new_object();
-    addStateToJson("on_screen",
-                         crr_state.layer.on_screen.is_changed,
-                         stm::gStmLayoutNo2Name[crr_state.layer.on_screen.state],
-                         &json_tmp);
-    json_object_array_add(json_layer, json_tmp);
-
-    // Add json array of layer
-    json_object_object_add(json_out, "layers", json_layer);
-
-    // Call event handler
-    event_data->handler(json_out);
-
-    // Release json_object
-    json_object_put(json_out);
+        HMI_DEBUG("wm:pm", ">>>>>>>>>> FINISH CHECK POLICY");
+    }
+    else {
+        HMI_DEBUG("wm", "Request for event:%d is removed", event);
+    }
 
     // Release data
-    delete (pm::EventData*)data;
+    delete (int*)data;
 
     // Destroy sd_event_soutce object
     sd_event_source_unref(source);
@@ -305,12 +356,26 @@ static int checkPolicy(sd_event_source *source, uint64_t usec, void *data) {
     return 0;
 }
 
-void PolicyManager::checkPolicyEntry(int event, int delay_ms, PolicyManager::Handler handler)
+static int checkPolicyEntry(PolicyManager* ctx, int event, int delay_ms,
+                            PolicyManager::Handler handler)
 {
     HMI_DEBUG("wm:pm", "Call");
+    HMI_DEBUG("wm:pm", "event:0x%x", event);
+
+    // If event is restriction off and there is restriction on event,
+    // remove restriction on event
+    if ((STM_EVT_NO_RESTRICTION_MODE_OFF == event)
+      && (pm::event_data_list.find(event) != pm::event_data_list.end())) {
+        HMI_DEBUG("wm:pm", "Remove event: restriction on");
+        pm::event_data_list.erase(STM_EVT_NO_RESTRICTION_MODE_ON);
+    }
 
     // Create event data
-    pm::EventData *event_data = new pm::EventData(event, handler);
+    pm::EventData event_data;
+    event_data.ctx = ctx;
+    event_data.event = event;
+    event_data.handler = handler;
+    pm::event_data_list[event] = event_data;
 
     // Get current time
     struct timespec time_spec;
@@ -322,12 +387,15 @@ void PolicyManager::checkPolicyEntry(int event, int delay_ms, PolicyManager::Han
                     + (delay_ms * 1000);
 
     // Set timer
-    int ret = sd_event_add_time(this->sd_event_, NULL, CLOCK_MONOTONIC, usec, 1,
-                                &checkPolicy, event_data);
+    struct sd_event_source *source; 
+    int ret = sd_event_add_time(pm::event_loop, &source, CLOCK_MONOTONIC, usec, 1,
+                                &checkPolicy, new int(event));
     if (0 > ret) {
         HMI_ERROR("wm:pm", "Faild to sd_event_add_time: errno:%d", ret);
-        return;
+        return -1;
     }
+
+    return 0;
 }
 
 int PolicyManager::inputEvent(json_object* json_in, PolicyManager::Handler notify_state) {
@@ -376,10 +444,8 @@ int PolicyManager::inputEvent(json_object* json_in, PolicyManager::Handler notif
         HMI_DEBUG("wm:pm", "area(%s:%d)", area, area_no);
     }
 
-    HMI_DEBUG("wm:pm", "set event:0x%x", (event_no | category_no | area_no));
-
     // Check policy
-    this->checkPolicyEntry((event_no | category_no | area_no), 0, notify_state);
+    checkPolicyEntry(this, (event_no | category_no | area_no), 0, notify_state);
 
     return 0;
 }
diff --git a/src/policy_manager/policy_manager.hpp b/src/policy_manager/policy_manager.hpp
index 57856dc..6926bc4 100644
--- a/src/policy_manager/policy_manager.hpp
+++ b/src/policy_manager/policy_manager.hpp
@@ -34,7 +34,6 @@ public:
     using Handler = std::function<void(json_object *)>;
 
     int initialize();
-    void setEventHandler(PolicyManager::Handler handler);
     int inputEvent(json_object* json_in, PolicyManager::Handler notify_state);
     std::string roleToCategory(const char* role);
 
@@ -54,10 +53,7 @@ private:
     std::unordered_map<std::string, std::string> category2role_;
     std::unordered_map<std::string, std::string> role2defaultarea_;
 
-    struct sd_event* sd_event_;
-
     int initializeSdEventLoop();
-    void checkPolicyEntry(int event, int delay_ms, PolicyManager::Handler handler);
 
     // Load role.db
     int loadRoleDb();
diff --git a/src/policy_manager/zipc/dummy_stm.c b/src/policy_manager/zipc/dummy_stm.c
index cc3fe21..3be9964 100644
--- a/src/policy_manager/zipc/dummy_stm.c
+++ b/src/policy_manager/zipc/dummy_stm.c
@@ -1,5 +1,6 @@
 #include <string.h>
 #include "dummy_stm.h"
+#include "hmi-debug.h"
 
 const char* gStmEventName[] = {
     "activate",
@@ -15,6 +16,8 @@ const char* gStmEventName[] = {
     "lamp_on",
     "lightstatus_brake_off",
     "lightstatus_brake_on",
+    "restriction_mode_off",
+    "restriction_mode_on",
 };
 
 const int gStmEventNo[] = {
@@ -31,6 +34,8 @@ const int gStmEventNo[] = {
     STM_EVT_NO_LAMP_ON,
     STM_EVT_NO_LIGHTSTATUS_BRAKE_OFF,
     STM_EVT_NO_LIGHTSTATUS_BRAKE_ON,
+    STM_EVT_NO_RESTRICTION_MODE_OFF,
+    STM_EVT_NO_RESTRICTION_MODE_ON,
 };
 
 const char* gStmCategoryName[] = {
@@ -106,6 +111,11 @@ const char* gStmLightstatusBrakeStateNo2Name[] = {
     "lightstatus_brake_on"
 };
 
+const char* gStmRestrictionModeStateNo2Name[] = {
+    "restriction_mode_off",
+    "restriction_mode_on"
+};
+
 const char* gStmLayoutNo2Name[] = {
     "none",
     "pu",
@@ -142,6 +152,7 @@ void stmInitialize() {
     g_prv_state.car.state               = gStmCarStateNoStop;
     g_prv_state.lamp.state              = gStmLampStateNoOff;
     g_prv_state.parking_brake.state     = gStmParkingBrakeStateNoOn;
+    g_prv_state.restriction_mode.state  = gStmRestrictionModeStateNoOff;
 
     // Initialize current state
     g_crr_state = g_prv_state;
@@ -150,7 +161,7 @@ void stmInitialize() {
 int stmTransitionState(int event, stm_state_t* state) {
     int event_no, category_no, area_no;
     int restriction_state, apps_state;
-    int trans_gear_state, parking_brake_state, lightstatus_brake_state, accel_pedal_state, car_state, lamp_state;
+    int trans_gear_state, parking_brake_state, lightstatus_brake_state, accel_pedal_state, car_state, lamp_state, restriction_mode_state;
 
     event_no    = event & STM_MSK_EVT_NO;
     category_no = event & STM_MSK_CTG_NO;
@@ -168,6 +179,7 @@ int stmTransitionState(int event, stm_state_t* state) {
     car_state               = g_prv_state.car.state;
     lamp_state              = g_prv_state.lamp.state;
     lightstatus_brake_state = g_prv_state.lightstatus_brake.state;
+    restriction_mode_state  = g_prv_state.restriction_mode.state;
 
     // Clear flags
     g_crr_state.layer.on_screen.is_changed   = STM_FALSE;
@@ -180,6 +192,7 @@ int stmTransitionState(int event, stm_state_t* state) {
     g_crr_state.accel_pedal.is_changed       = STM_FALSE;
     g_crr_state.car.is_changed               = STM_FALSE;
     g_crr_state.lamp.is_changed              = STM_FALSE;
+    g_crr_state.restriction_mode.is_changed  = STM_FALSE;
 
 
     // Set car state
@@ -264,18 +277,6 @@ int stmTransitionState(int event, stm_state_t* state) {
                 // Car state is changed stop -> run
                 g_crr_state.car.state = gStmCarStateNoRun;
                 g_crr_state.car.is_changed = STM_TRUE;
-
-                // Update restriction layer
-                g_prv_restriction_state_car_stop = restriction_state;
-                g_crr_state.layer.restriction.state = gStmLayoutNoNone;
-                g_crr_state.layer.restriction.is_changed = STM_TRUE;
-
-                // Update apps layer
-                g_prv_apps_state_car_stop = apps_state;
-                if (STM_TRUE == g_map_is_activated) {
-                    g_crr_state.layer.apps.state = gStmLayoutNoM1;
-                    g_crr_state.layer.apps.is_changed = STM_TRUE;
-                }
             }
         }
         else {
@@ -283,24 +284,54 @@ int stmTransitionState(int event, stm_state_t* state) {
                 // Car state is changed run -> stop
                 g_crr_state.car.state = gStmCarStateNoStop;
                 g_crr_state.car.is_changed = STM_TRUE;
-
-                // Update restriction layer
-                g_crr_state.layer.restriction.state = g_prv_restriction_state_car_stop;
-                g_crr_state.layer.restriction.is_changed = STM_TRUE;
-
-                // Update apps layer
-                if (STM_TRUE == g_map_is_activated) {
-                    g_crr_state.layer.apps.state = g_prv_apps_state_car_stop;
-                    g_crr_state.layer.apps.is_changed = STM_TRUE;
-                }
             }
         }
     }
 
+    // Set restriction mode
+    if ((STM_EVT_NO_RESTRICTION_MODE_ON == event_no)
+      && (gStmRestrictionModeStateNoOn != restriction_mode_state)) {
+        HMI_DEBUG("wm:pm:stm", "Restriction mode OFF -> ON");
+
+        // Restriction mode is changed OFF -> ON
+        g_crr_state.restriction_mode.state = gStmRestrictionModeStateNoOn;
+        g_crr_state.restriction_mode.is_changed = STM_TRUE;
+
+        // Update restriction layer
+        g_prv_restriction_state_car_stop = restriction_state;
+        g_crr_state.layer.restriction.state = gStmLayoutNoNone;
+        g_crr_state.layer.restriction.is_changed = STM_TRUE;
+
+        // Update apps layer
+        g_prv_apps_state_car_stop = apps_state;
+        if (STM_TRUE == g_map_is_activated) {
+            g_crr_state.layer.apps.state = gStmLayoutNoM1;
+            g_crr_state.layer.apps.is_changed = STM_TRUE;
+        }
+    }
+    else if ((STM_EVT_NO_RESTRICTION_MODE_OFF == event_no)
+      && (gStmRestrictionModeStateNoOff != restriction_mode_state)) {
+        HMI_DEBUG("wm:pm:stm", "Restriction mode ON -> OFF");
+
+        // Restriction mode is changed ON -> OFF
+        g_crr_state.restriction_mode.state = gStmRestrictionModeStateNoOff;
+        g_crr_state.restriction_mode.is_changed = STM_TRUE;
+
+        // Update restriction layer
+        g_crr_state.layer.restriction.state = g_prv_restriction_state_car_stop;
+        g_crr_state.layer.restriction.is_changed = STM_TRUE;
+
+        // Update apps layer
+        if (STM_TRUE == g_map_is_activated) {
+            g_crr_state.layer.apps.state = g_prv_apps_state_car_stop;
+            g_crr_state.layer.apps.is_changed = STM_TRUE;
+        }
+    }
+
     // Set apps/homescreen layer
     switch (event_no) {
     case STM_EVT_NO_ACTIVATE:
-        if (gStmCarStateNoStop == car_state) {
+        if (gStmRestrictionModeStateNoOff == restriction_mode_state) {
             switch (category_no) {
             case STM_CTG_NO_HOMESCREEN:
                 // Apps layer
diff --git a/src/policy_manager/zipc/dummy_stm.h b/src/policy_manager/zipc/dummy_stm.h
index 987bd00..e848628 100644
--- a/src/policy_manager/zipc/dummy_stm.h
+++ b/src/policy_manager/zipc/dummy_stm.h
@@ -37,6 +37,8 @@
 #define STM_EVT_NO_LAMP_ON               0x0B
 #define STM_EVT_NO_LIGHTSTATUS_BRAKE_OFF 0x0C
 #define STM_EVT_NO_LIGHTSTATUS_BRAKE_ON  0x0D
+#define STM_EVT_NO_RESTRICTION_MODE_OFF  0x0E
+#define STM_EVT_NO_RESTRICTION_MODE_ON   0x0F
 
 // Category number
 #define STM_CTG_NO_HOMESCREEN   0x0100
@@ -63,7 +65,7 @@
 #define STM_MSK_ARA_NO 0xFF0000
 
 // Number of events, categories and areas
-#define STM_NUM_EVT 13
+#define STM_NUM_EVT 15
 #define STM_NUM_CTG  7
 #define STM_NUM_ARA  8
 
@@ -98,6 +100,11 @@ enum stm_lightstatus_brake_state_ {
     gStmLightstatusBrakeStateNoOn
 };
 
+enum stm_restriction_mode_state_ {
+    gStmRestrictionModeStateNoOff = 0,
+    gStmRestrictionModeStateNoOn
+};
+
 enum stm_layout_ {
     gStmLayoutNoNone = 0,
     gStmLayoutNoPu,
@@ -129,6 +136,7 @@ extern const char* gStmCarStateNo2Name[];
 extern const char* gStmLampStateNo2Name[];
 extern const char* gStmLayoutNo2Name[];
 extern const char* gStmLightstatusBrakeStateNo2Name[];
+extern const char* gStmRestrictionModeStateNo2Name[];
 
 // Struct for state
 typedef struct stm_base_state_ {
@@ -150,6 +158,7 @@ typedef struct {
     stm_base_state car;
     stm_base_state lamp;
     stm_base_state lightstatus_brake;
+    stm_base_state restriction_mode;
     stm_layer_state layer;
 } stm_state_t;