Modify API of PolicyManager

and change the process for stopping timer

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

4 files changed, 419 insertions, 400 deletions

diff --git a/src/app.cpp b/src/app.cpp
index a117848..47f18aa 100644
--- a/src/app.cpp
+++ b/src/app.cpp
@@ -94,6 +94,178 @@ struct result<layer_map> load_layer_map(char const *filename) {
 }  // namespace
 
 
+namespace rm {
+App *context;
+const char *g_new_role; // TODO: workaround
+static void eventHandler(json_object* json_out) {
+    context->updateWindowResource(json_out);
+}
+}  // namespace rm
+
+
+void App::updateWindowResource(json_object* json_out) {
+    HMI_DEBUG("wm", "role:%s", rm::g_new_role);
+
+    // Check parking brake state
+    json_object* json_parking_brake;
+    if (!json_object_object_get_ex(json_out, "parking_brake", &json_parking_brake)) {
+        HMI_DEBUG("wm", "Not found key \"parking_brake\"");
+        return;
+    }
+
+    json_bool is_changed;
+    is_changed = jh::getBoolFromJson(json_parking_brake, "is_changed");
+    if (is_changed) {
+        std::string parking_brake_state = jh::getStringFromJson(json_parking_brake, "state");
+        HMI_DEBUG("wm", "parking_brake_state: %s", parking_brake_state.c_str());
+
+        // Update state and emit event
+        if ("parking_brake_off" == parking_brake_state) {
+            this->crr_car_info_.parking_brake_stt = false;
+#if 0 // FOR ALS: using lightstatus brake, so do not emit parking brake event
+            this->emitParkingBrakeOff();
+#endif
+        }
+        else if ("parking_brake_on" == parking_brake_state) {
+            this->crr_car_info_.parking_brake_stt = true;
+#if 0 // FOR ALS: using lightstatus brake, so do not emit parking brake event
+            this->emitParkingBrakeOn();
+#endif
+        }
+        else {
+            HMI_DEBUG("wm", "Unknown parking brake state");
+            return;
+        }
+    }
+
+    // Check accelerator pedal state
+    json_object* json_accel_pedal;
+    if (!json_object_object_get_ex(json_out, "accel_pedal", &json_accel_pedal)) {
+        HMI_DEBUG("wm", "Not found key \"accel_pedal\"");
+        return;
+    }
+
+    is_changed = jh::getBoolFromJson(json_accel_pedal, "is_changed");
+    if (is_changed) {
+        std::string accel_pedal_state = jh::getStringFromJson(json_accel_pedal, "state");
+        HMI_DEBUG("wm", "accel_pedal_state: %s", accel_pedal_state.c_str());
+
+        // Update state
+        if ("accel_pedal_off" == accel_pedal_state) {
+            this->crr_car_info_.accel_pedal_stt = false;
+        }
+        else if ("accel_pedal_on" == accel_pedal_state) {
+            this->crr_car_info_.accel_pedal_stt = true;
+        }
+        else {
+            HMI_DEBUG("wm", "Unknown accel pedal state");
+            return;
+        }
+    }
+
+    // Check lightstatus brake state
+    json_object* json_lightstatus_brake;
+    if (!json_object_object_get_ex(json_out, "lightstatus_brake", &json_lightstatus_brake)) {
+        HMI_DEBUG("wm", "Not found key \"lightstatus_brake\"");
+        return;
+    }
+
+    is_changed = jh::getBoolFromJson(json_lightstatus_brake, "is_changed");
+    if (is_changed) {
+        std::string lightstatus_brake_state = jh::getStringFromJson(json_lightstatus_brake, "state");
+        HMI_DEBUG("wm", "lightstatus_brake_state: %s", lightstatus_brake_state.c_str());
+
+        // Update state and emit event
+        if ("lightstatus_brake_off" == lightstatus_brake_state) {
+            this->crr_car_info_.lightstatus_brake_stt = false;
+            this->emitLightstatusBrakeOff();
+        }
+        else if ("lightstatus_brake_on" == lightstatus_brake_state) {
+            this->crr_car_info_.lightstatus_brake_stt = true;
+            this->emitLightstatusBrakeOn();
+        }
+        else {
+            HMI_DEBUG("wm", "Unknown lightstatus brake state");
+            return;
+        }
+    }
+
+    // Check car state
+    json_object* json_car;
+    if (!json_object_object_get_ex(json_out, "car", &json_car)) {
+        HMI_DEBUG("wm", "Not found key \"car\"");
+        return;
+    }
+
+    is_changed = jh::getBoolFromJson(json_car, "is_changed");
+    if (is_changed) {
+        std::string car_state = jh::getStringFromJson(json_car, "state");
+        HMI_DEBUG("wm", "car_state: %s", car_state.c_str());
+
+        // Emit car event
+        if ("car_stop" == car_state) {
+            this->crr_car_info_.car_stt = "stop";
+            this->emitCarStop();
+        }
+        else if ("car_run" == car_state) {
+            this->crr_car_info_.car_stt = "run";
+            this->emitCarRun();
+        }
+        else {
+            HMI_DEBUG("wm", "Unknown car state");
+            return;
+        }
+    }
+
+    // Check lamp state
+    json_object* json_lamp;
+    if (!json_object_object_get_ex(json_out, "lamp", &json_lamp)) {
+        HMI_DEBUG("wm", "Not found key \"lamp\"");
+        return;
+    }
+
+    is_changed = jh::getBoolFromJson(json_lamp, "is_changed");
+    if (is_changed) {
+        std::string lamp_state = jh::getStringFromJson(json_lamp, "state");
+        HMI_DEBUG("wm", "lamp_state: %s", lamp_state.c_str());
+
+        // Update state and emit event
+        if ("lamp_off" == lamp_state) {
+            this->crr_car_info_.headlamp_stt = false;
+            this->emitHeadlampOff();
+        }
+        else if ("lamp_on" == lamp_state) {
+            this->crr_car_info_.headlamp_stt = true;
+            this->emitHeadlampOn();
+        }
+        else {
+            HMI_DEBUG("wm", "Unknown lamp state");
+            return;
+        }
+    }
+
+    // Get category
+    const char* category = nullptr;
+    std::string str_category;
+    if (nullptr != rm::g_new_role) {
+        str_category = this->pm_.roleToCategory(rm::g_new_role);
+        category = str_category.c_str();
+        HMI_DEBUG("wm", "role:%s category:%s", rm::g_new_role, category);
+    }
+
+    // Update layout
+    if (this->lm_.updateLayout(json_out, rm::g_new_role, category)) {
+        HMI_DEBUG("wm", "Layer is changed!!");
+
+        // Allocate surface
+        this->allocateSurface();
+    }
+    else {
+        HMI_DEBUG("wm", "All layer is NOT changed!!");
+    }
+}
+
+
 /**
  * App Impl
  */
@@ -139,6 +311,9 @@ int App::init() {
       return -1;
    }
 
+   // Store my context for calling callback for PolicyManager
+   rm::context = this;
+
 #if 1 // @@@@@
    // Load app.db
    this->loadAppDb();
@@ -147,6 +322,12 @@ int App::init() {
    // Initialize PolicyManager
    this->pm_.initialize();
 
+   // Register callback to PolicyManager
+   PolicyManager::CallbackTable callback;
+   callback.onStateTransitioned = rm::eventHandler;
+   callback.onError = nullptr;
+   this->pm_.registerCallback(callback);
+
    // Initialize LayoutManager
    this->lm_.initialize();
 
@@ -336,180 +517,17 @@ void App::allocateWindowResource(char const *event, char const *drawing_name,
     // If event is "activate" and area is not specifid,
     // get default value by using role
 
-    // Check Policy
+    // Input event to PolicyManager
     json_object* json_in = json_object_new_object();
     json_object_object_add(json_in, "event", json_object_new_string(event));
-
     if (nullptr != new_role) {
         json_object_object_add(json_in, "role", json_object_new_string(new_role));
     }
     if (nullptr != new_area) {
         json_object_object_add(json_in, "area", json_object_new_string(new_area));
     }
-
-    // Input event to PolicyManager
-    this->pm_.inputEvent(json_in,
-        [this, new_role, reply] (json_object* json_out) {
-        HMI_DEBUG("wm", "role:%s", new_role);
-
-    // Check parking brake state
-    json_object* json_parking_brake;
-    if (!json_object_object_get_ex(json_out, "parking_brake", &json_parking_brake)) {
-        reply("Not found key \"parking_brake\"");
-        return;
-    }
-
-    json_bool is_changed;
-    is_changed = jh::getBoolFromJson(json_parking_brake, "is_changed");
-    if (is_changed) {
-        std::string parking_brake_state = jh::getStringFromJson(json_parking_brake, "state");
-        HMI_DEBUG("wm", "parking_brake_state: %s", parking_brake_state.c_str());
-
-        // Update state and emit event
-        if ("parking_brake_off" == parking_brake_state) {
-            this->crr_car_info_.parking_brake_stt = false;
-#if 0 // FOR ALS: using lightstatus brake, so do not emit parking brake event
-            this->emitParkingBrakeOff();
-#endif
-        }
-        else if ("parking_brake_on" == parking_brake_state) {
-            this->crr_car_info_.parking_brake_stt = true;
-#if 0 // FOR ALS: using lightstatus brake, so do not emit parking brake event
-            this->emitParkingBrakeOn();
-#endif
-        }
-        else {
-            reply("Unknown parking brake state");
-            return;
-        }
-    }
-
-    // Check accelerator pedal state
-    json_object* json_accel_pedal;
-    if (!json_object_object_get_ex(json_out, "accel_pedal", &json_accel_pedal)) {
-        reply("Not found key \"accel_pedal\"");
-        return;
-    }
-
-    is_changed = jh::getBoolFromJson(json_accel_pedal, "is_changed");
-    if (is_changed) {
-        std::string accel_pedal_state = jh::getStringFromJson(json_accel_pedal, "state");
-        HMI_DEBUG("wm", "accel_pedal_state: %s", accel_pedal_state.c_str());
-
-        // Update state
-        if ("accel_pedal_off" == accel_pedal_state) {
-            this->crr_car_info_.accel_pedal_stt = false;
-        }
-        else if ("accel_pedal_on" == accel_pedal_state) {
-            this->crr_car_info_.accel_pedal_stt = true;
-        }
-        else {
-            reply("Unknown accel pedal state");
-            return;
-        }
-    }
-
-    // Check lightstatus brake state
-    json_object* json_lightstatus_brake;
-    if (!json_object_object_get_ex(json_out, "lightstatus_brake", &json_lightstatus_brake)) {
-        reply("Not found key \"lightstatus_brake\"");
-        return;
-    }
-
-    is_changed = jh::getBoolFromJson(json_lightstatus_brake, "is_changed");
-    if (is_changed) {
-        std::string lightstatus_brake_state = jh::getStringFromJson(json_lightstatus_brake, "state");
-        HMI_DEBUG("wm", "lightstatus_brake_state: %s", lightstatus_brake_state.c_str());
-
-        // Update state and emit event
-        if ("lightstatus_brake_off" == lightstatus_brake_state) {
-            this->crr_car_info_.lightstatus_brake_stt = false;
-            this->emitLightstatusBrakeOff();
-        }
-        else if ("lightstatus_brake_on" == lightstatus_brake_state) {
-            this->crr_car_info_.lightstatus_brake_stt = true;
-            this->emitLightstatusBrakeOn();
-        }
-        else {
-            reply("Unknown lightstatus brake state");
-            return;
-        }
-    }
-
-    // Check car state
-    json_object* json_car;
-    if (!json_object_object_get_ex(json_out, "car", &json_car)) {
-        reply("Not found key \"car\"");
-        return;
-    }
-
-    is_changed = jh::getBoolFromJson(json_car, "is_changed");
-    if (is_changed) {
-        std::string car_state = jh::getStringFromJson(json_car, "state");
-        HMI_DEBUG("wm", "car_state: %s", car_state.c_str());
-
-        // Emit car event
-        if ("car_stop" == car_state) {
-            this->crr_car_info_.car_stt = "stop";
-            this->emitCarStop();
-        }
-        else if ("car_run" == car_state) {
-            this->crr_car_info_.car_stt = "run";
-            this->emitCarRun();
-        }
-        else {
-            reply("Unknown car state");
-            return;
-        }
-    }
-
-    // Check lamp state
-    json_object* json_lamp;
-    if (!json_object_object_get_ex(json_out, "lamp", &json_lamp)) {
-        reply("Not found key \"lamp\"");
-        return;
-    }
-
-    is_changed = jh::getBoolFromJson(json_lamp, "is_changed");
-    if (is_changed) {
-        std::string lamp_state = jh::getStringFromJson(json_lamp, "state");
-        HMI_DEBUG("wm", "lamp_state: %s", lamp_state.c_str());
-
-        // Update state and emit event
-        if ("lamp_off" == lamp_state) {
-            this->crr_car_info_.headlamp_stt = false;
-            this->emitHeadlampOff();
-        }
-        else if ("lamp_on" == lamp_state) {
-            this->crr_car_info_.headlamp_stt = true;
-            this->emitHeadlampOn();
-        }
-        else {
-            reply("Unknown lamp state");
-            return;
-        }
-    }
-
-    // Get category
-    const char* category = nullptr;
-    std::string str_category;
-    if (nullptr != new_role) {
-        str_category = this->pm_.roleToCategory(new_role);
-        category = str_category.c_str();
-        HMI_DEBUG("wm", "role:%s category:%s", new_role, category);
-    }
-
-    // Update layout
-    if (this->lm_.updateLayout(json_out, new_role, category)) {
-        HMI_DEBUG("wm", "Layer is changed!!");
-
-        // Allocate surface
-        this->allocateSurface();
-    }
-    else {
-        HMI_DEBUG("wm", "All layer is NOT changed!!");
-    }
-});
+    rm::g_new_role = new_role;  // TODO: workaround
+    this->pm_.inputEvent(json_in);
 
     // Release json_object
     json_object_put(json_in);
diff --git a/src/app.hpp b/src/app.hpp
index c3ce674..a0615d5 100644
--- a/src/app.hpp
+++ b/src/app.hpp
@@ -253,6 +253,7 @@ struct App {
    void surface_removed(uint32_t surface_id);
 
    void setAccelPedalPos(double val);
+   void updateWindowResource(json_object* json_out);
 
 private:
    PolicyManager pm_;
diff --git a/src/policy_manager/policy_manager.cpp b/src/policy_manager/policy_manager.cpp
index 0cafdea..a91d98e 100644
--- a/src/policy_manager/policy_manager.cpp
+++ b/src/policy_manager/policy_manager.cpp
@@ -33,20 +33,12 @@ extern "C" {
 
 
 namespace pm {
-
 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;
-
+std::map<int, struct sd_event_source*> event_source_list;
+PolicyManager::CallbackTable callback;
 }  // namespace pm
 
+
 PolicyManager::PolicyManager() :
   eventname2no_(),
   categoryname2no_(),
@@ -134,224 +126,232 @@ static void addStateToJson(
     json_object_object_add(*json_out, key, json_obj);
 }
 
-static int checkPolicyEntry(PolicyManager* ctx, int event, uint64_t delay_ms,
-                            PolicyManager::Handler handler);
+static int checkPolicyEntry(int event, uint64_t delay_ms);
 static int checkPolicy(sd_event_source *source, void *data) {
     HMI_DEBUG("wm:pm", "Call");
     HMI_DEBUG("wm:pm", ">>>>>>>>>> START CHECK POLICY");
 
     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", ">>>>>>>>>> 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;
-        }
+    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", ">>>>>>>>>> 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, &crr_state);
+    if (0 > ret) {
+        HMI_ERROR("wm:pm", "Error!!");
+        return -1;
+    }
 
-        HMI_DEBUG("wm:pm", "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:pm", "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:pm", "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:pm", "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:pm", "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:pm", "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:pm", "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:pm", "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:pm", "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:pm", "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);
+    HMI_DEBUG("wm:pm", "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:pm", "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:pm", "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:pm", "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:pm", "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:pm", "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:pm", "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:pm", "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:pm", "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:pm", "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);
+
+    // Notify state is changed
+    if (nullptr != pm::callback.onStateTransitioned) {
+        pm::callback.onStateTransitioned(json_out);
+    }
+
+    if (crr_state.car.is_changed) {
+        if (stm::gStmCarStateNoRun == crr_state.car.state) {
+            // Set delay event(restriction mode on)
+            checkPolicyEntry(STM_EVT_NO_RESTRICTION_MODE_ON, 3000);
+        }
+        else if (stm::gStmCarStateNoStop == crr_state.car.state) {
+            // Set event(restriction mode off)
+            checkPolicyEntry(STM_EVT_NO_RESTRICTION_MODE_OFF, 0);
+
+            // Stop timer for restriction on event
+            if (pm::event_source_list.find(STM_EVT_NO_RESTRICTION_MODE_ON)
+              != pm::event_source_list.end()) {
+                HMI_DEBUG("wm:pm", "Stop timer for restriction on");
+                sd_event_source *event_source
+                    = pm::event_source_list[STM_EVT_NO_RESTRICTION_MODE_ON];
+                int ret = sd_event_source_set_enabled(event_source, SD_EVENT_OFF);
+                if (0 > ret) {
+                    HMI_ERROR("wm:pm", "Failed to stop timer");
+                }
             }
         }
-
-        // Release json_object
-        json_object_put(json_out);
-
-    }
-    else {
-        HMI_DEBUG("wm:pm", "Request for event:%d is removed", event);
     }
 
+    // Release json_object
+    json_object_put(json_out);
+
     // Release data
     delete (int*)data;
 
-    // Destroy sd_event_soutce object
+    // Destroy sd_event_source object
     sd_event_source_unref(source);
 
+    // Remove event source from list
+    if (pm::event_source_list.find(event) != pm::event_source_list.end()) {
+        pm::event_source_list.erase(event);
+    }
+
     HMI_DEBUG("wm:pm", ">>>>>>>>>> FINISH CHECK POLICY");
     return 0;
 }
@@ -360,27 +360,11 @@ static int timerEvent(sd_event_source *source, uint64_t usec, void *data) {
     checkPolicy(source, data);
 };
 
-static int checkPolicyEntry(PolicyManager* ctx, int event, uint64_t delay_ms,
-                            PolicyManager::Handler handler)
+static int checkPolicyEntry(int event, uint64_t delay_ms)
 {
     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;
-    event_data.ctx = ctx;
-    event_data.event = event;
-    event_data.handler = handler;
-    pm::event_data_list[event] = event_data;
-
     if (0 == delay_ms) {
         int ret = sd_event_add_defer(pm::event_loop, NULL,
                                      &checkPolicy, new int(event));
@@ -400,18 +384,27 @@ static int checkPolicyEntry(PolicyManager* ctx, int event, uint64_t delay_ms,
             + (delay_ms * 1000);
 
         // Set timer
-        int ret = sd_event_add_time(pm::event_loop, NULL, CLOCK_MONOTONIC, usec, 1,
+        struct sd_event_source* event_source;
+        int ret = sd_event_add_time(pm::event_loop, &event_source, CLOCK_MONOTONIC, usec, 1,
                                     &timerEvent, new int(event));
         if (0 > ret) {
             HMI_ERROR("wm:pm", "Faild to sd_event_add_time: errno:%d", ret);
             return -1;
         }
+
+        // Store event source
+        pm::event_source_list[event] = event_source;
     }
 
     return 0;
 }
 
-int PolicyManager::inputEvent(json_object* json_in, PolicyManager::Handler notify_state) {
+void PolicyManager::registerCallback(CallbackTable callback) {
+    pm::callback.onStateTransitioned = callback.onStateTransitioned;
+    pm::callback.onError             = callback.onError;
+}
+
+int PolicyManager::inputEvent(json_object* json_in) {
     HMI_DEBUG("wm:pm", "Call");
 
     // Check arguments
@@ -458,7 +451,7 @@ int PolicyManager::inputEvent(json_object* json_in, PolicyManager::Handler notif
     }
 
     // Check policy
-    checkPolicyEntry(this, (event_no | category_no | area_no), 0, notify_state);
+    checkPolicyEntry((event_no | category_no | area_no), 0);
 
     return 0;
 }
diff --git a/src/policy_manager/policy_manager.hpp b/src/policy_manager/policy_manager.hpp
index 6926bc4..aa5f206 100644
--- a/src/policy_manager/policy_manager.hpp
+++ b/src/policy_manager/policy_manager.hpp
@@ -25,6 +25,7 @@
 struct json_object;
 struct sd_event;
 
+
 class PolicyManager {
 
 public:
@@ -33,8 +34,14 @@ public:
 
     using Handler = std::function<void(json_object *)>;
 
+    typedef struct {
+        Handler  onStateTransitioned;
+        Handler  onError;
+    } CallbackTable;
+
     int initialize();
-    int inputEvent(json_object* json_in, PolicyManager::Handler notify_state);
+    void registerCallback(CallbackTable callback_table);
+    int inputEvent(json_object* json_in);
     std::string roleToCategory(const char* role);
 
 private: