From 681bb3f7b1618a083ac07878d9513e56e9279967 Mon Sep 17 00:00:00 2001 From: Yuta Doi Date: Tue, 29 May 2018 23:14:11 +0900 Subject: 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 --- src/layout_manager/layout.cpp | 40 ++++ src/policy_manager/policy_manager.cpp | 416 ++++++++++++++++++++-------------- src/policy_manager/policy_manager.hpp | 4 - src/policy_manager/zipc/dummy_stm.c | 79 +++++-- src/policy_manager/zipc/dummy_stm.h | 11 +- 5 files changed, 346 insertions(+), 204 deletions(-) (limited to 'src') 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 #include #include +#include #include #include #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 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": , + // "state": + // }, + addStateToJson("parking_brake", + crr_state.parking_brake.is_changed, + stm::gStmParkingBrakeStateNo2Name[crr_state.parking_brake.state], + &json_out); + + // "accel_pedal": { + // "is_changed": , + // "state": + // }, + addStateToJson("accel_pedal", + crr_state.accel_pedal.is_changed, + stm::gStmAccelPedalStateNo2Name[crr_state.accel_pedal.state], + &json_out); + + // "lightstatus_brake": { + // "is_changed": , + // "state": + // }, + addStateToJson("lightstatus_brake", + crr_state.lightstatus_brake.is_changed, + stm::gStmLightstatusBrakeStateNo2Name[crr_state.lightstatus_brake.state], + &json_out); + + // "car": { + // "is_changed": , + // "state": + // }, + addStateToJson("car", + crr_state.car.is_changed, + stm::gStmCarStateNo2Name[crr_state.car.state], + &json_out); + + // "lamp": { + // "is_changed": , + // "state": + // }, + addStateToJson("lamp", + crr_state.lamp.is_changed, + stm::gStmLampStateNo2Name[crr_state.lamp.state], + &json_out); + + // "restriction_mode": { + // "is_changed": , + // "state": + // }, + 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": , + // "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": , + // "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": , + // "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": , + // "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); + + 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": , - // "state": - // }, - 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": , - // "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]); - addStateToJson("accel_pedal", - crr_state.accel_pedal.is_changed, - stm::gStmAccelPedalStateNo2Name[crr_state.accel_pedal.state], - &json_out); - - // "lightstatus_brake": { - // "is_changed": , - // "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]); - addStateToJson("lightstatus_brake", - crr_state.lightstatus_brake.is_changed, - stm::gStmLightstatusBrakeStateNo2Name[crr_state.lightstatus_brake.state], - &json_out); - - // "car": { - // "is_changed": , - // "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]); - addStateToJson("car", - crr_state.car.is_changed, - stm::gStmCarStateNo2Name[crr_state.car.state], - &json_out); - - // "lamp": { - // "is_changed": , - // "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]); - 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": , - // "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]); - 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": , - // "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]); - 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": , - // "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]); - 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": , - // "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_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; 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 category2role_; std::unordered_map 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 #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; -- cgit 1.2.3-korg