#include "policy_manager.hpp"
#include "hmi-debug.h"
-namespace stm {
extern "C" {
#include "dummy_stm.h"
}
-} // namespace stm
namespace pm {
static PolicyManager *g_context;
static int transitionStateWrapper(sd_event_source *source, void *data) {
- int ret = pm::g_context->transitionState(source, data);
+ int ret = g_context->transitionState(source, data);
return ret;
}
static int timerEventWrapper(sd_event_source *source, uint64_t usec, void *data) {
- int ret = pm::g_context->timerEvent(source, usec, data);
+ int ret = g_context->timerEvent(source, usec, data);
return ret;
}
int ret = 0;
// Create convert map
- for (int i = stm::StmEvtNoMin; i <= stm::StmEvtNoMax; i++) {
- HMI_DEBUG("wm:pm", "event name:%s no:%d", stm::kStmEventName[i], i);
- this->eventname2no[stm::kStmEventName[i]] = i;
+ for (int i = StmEvtNoMin; i <= StmEvtNoMax; i++) {
+ HMI_DEBUG("wm:pm", "event name:%s no:%d", kStmEventName[i], i);
+ this->eventname2no[kStmEventName[i]] = i;
}
- for (int i = stm::StmCtgNoMin; i <= stm::StmCtgNoMax; i++) {
- HMI_DEBUG("wm:pm", "category name:%s no:%d", stm::kStmCategoryName[i], i);
- this->categoryname2no[stm::kStmCategoryName[i]] = i;
+ for (int i = StmCtgNoMin; i <= StmCtgNoMax; i++) {
+ HMI_DEBUG("wm:pm", "category name:%s no:%d", kStmCategoryName[i], i);
+ this->categoryname2no[kStmCategoryName[i]] = i;
}
- for (int i = stm::StmAreaNoMin; i <= stm::StmAreaNoMax; i++) {
- HMI_DEBUG("wm:pm", "area name:%s no:%d", stm::kStmAreaName[i], i);
- this->areaname2no[stm::kStmAreaName[i]] = i;
+ for (int i = StmAreaNoMin; i <= StmAreaNoMax; i++) {
+ HMI_DEBUG("wm:pm", "area name:%s no:%d", kStmAreaName[i], i);
+ this->areaname2no[kStmAreaName[i]] = i;
}
// Load role.db
this->initializeState();
// Initialize StateTransitioner
- stm::stmInitialize();
+ stmInitialize();
// Initialize sd_event loop
ret = this->initializeSdEventLoop();
return ret;
}
+ // Store instance
pm::g_context = this;
return ret;
init_car_ele.state = "none";
init_car_ele.changed = false;
- for (int i = stm::StmCarElementNoMin; i <= stm::StmCarElementNoMax; i++) {
- const char* car_ele_name = stm::kStmCarElementName[i];
+ for (int i = StmCarElementNoMin; i <= StmCarElementNoMax; i++) {
+ const char* car_ele_name = kStmCarElementName[i];
this->crr_car_elements[car_ele_name] = init_car_ele;
}
void PolicyManager::initializeLayerState() {
AreaState init_area;
LayoutState init_layout;
- init_area.name = stm::kStmAreaName[stm::StmAreaNoNone];
+ init_area.name = kStmAreaName[StmAreaNoNone];
init_area.category = "";
init_area.role = "";
- init_layout.name = stm::kStmLayoutName[stm::StmLayoutNoNone];
+ init_layout.name = kStmLayoutName[StmLayoutNoNone];
init_layout.area_list.push_back(init_area);
- for (int i = stm::StmLayerNoMin; i <= stm::StmLayerNoMax; i++) {
- const char* layer_name = stm::kStmLayerName[i];
+ for (int i = StmLayerNoMin; i <= StmLayerNoMax; i++) {
+ const char* layer_name = kStmLayerName[i];
this->crr_layers[layer_name].name = layer_name;
this->crr_layers[layer_name].layout_state = init_layout;
this->crr_layers[layer_name].changed = false;
}
void PolicyManager::addStateToJson(const char* name, bool changed,
- std::string state, json_object** json_out) {
+ std::string state, json_object** json_out) {
if ((nullptr == name) || (nullptr == json_out)) {
HMI_ERROR("wm:pm", "Invalid argument!!!");
return;
}
void PolicyManager::addStateToJson(const char* layer_name, bool changed,
- AreaList area_list, json_object** json_out) {
+ AreaList area_list, json_object** json_out) {
if ((nullptr == layer_name) || (nullptr == json_out)) {
HMI_ERROR("wm:pm", "Invalid argument!!!");
return;
json_tmp = json_object_new_object();
json_object_object_add(json_tmp, "name", json_object_new_string(as.name.c_str()));
json_object_object_add(json_tmp, "role", json_object_new_string(as.role.c_str()));
- json_object_array_add(json_areas, json_tmp);
+ json_object_array_add(json_areas, json_tmp);
}
json_object_object_add(*json_out, "name", json_object_new_string(layer_name));
json_object_object_add(*json_out, "areas", json_areas);
}
-void PolicyManager::updateCarElementState(stm::StmState crr_state) {
+void PolicyManager::updateCarElementState(StmState crr_state) {
int car_state_no;
std::string car_state;
bool changed;
// Update car elements
HMI_DEBUG("wm:pm", ">>> CAR ELEMENT");
- for (int car_ele_no = stm::StmCarElementNoMin;
- car_ele_no <= stm::StmCarElementNoMax; car_ele_no++) {
- const char* car_ele_name = stm::kStmCarElementName[car_ele_no];
+ for (int car_ele_no = StmCarElementNoMin;
+ car_ele_no <= StmCarElementNoMax; car_ele_no++) {
+ const char* car_ele_name = kStmCarElementName[car_ele_no];
car_state_no = crr_state.car_element[car_ele_no].state;
- car_state = stm::kStmCarStateNameList[car_ele_no][car_state_no];
+ car_state = kStmCarStateNameList[car_ele_no][car_state_no];
changed = (crr_state.car_element[car_ele_no].changed) ? true : false;
this->crr_car_elements[car_ele_name].state = car_state;
}
}
-void PolicyManager::updateLayerState(int event_data, stm::StmState crr_state) {
+void PolicyManager::updateLayerState(int event_id, StmState crr_state) {
int event_no, category_no, area_no;
- event_no = STM_GET_EVENT_FROM_ID(event_data);
- category_no = STM_GET_CATEGORY_FROM_ID(event_data);
- area_no = STM_GET_AREA_FROM_ID(event_data);
+ event_no = STM_GET_EVENT_FROM_ID(event_id);
+ category_no = STM_GET_CATEGORY_FROM_ID(event_id);
+ area_no = STM_GET_AREA_FROM_ID(event_id);
- std::string req_evt = stm::kStmEventName[event_no];
- std::string req_ctg = stm::kStmCategoryName[category_no];
- std::string req_area = stm::kStmAreaName[area_no];
- std::string req_role = this->req_role_list[event_data];
+ std::string req_evt = kStmEventName[event_no];
+ std::string req_ctg = kStmCategoryName[category_no];
+ std::string req_area = kStmAreaName[area_no];
+ std::string req_role = this->req_role_list[event_id];
HMI_DEBUG("wm:pm", "REQ: event:%s role:%s category:%s area:%s",
req_evt.c_str(), req_role.c_str(), req_ctg.c_str(), req_area.c_str());
this->prv_layers = this->crr_layers;
// Update layers
- for (int layer_no = stm::StmLayerNoMin;
- layer_no <= stm::StmLayerNoMax; layer_no++) {
- const char* layer_name = stm::kStmLayerName[layer_no];
+ for (int layer_no = StmLayerNoMin;
+ layer_no <= StmLayerNoMax; layer_no++) {
+ const char* layer_name = kStmLayerName[layer_no];
HMI_DEBUG("wm:pm", "LAYER:%s", layer_name);
#if 1
// If restriction mode is changed off -> on,
// store current state for state of restriction mode off
- if ((crr_state.car_element[stm::StmCarElementNoRestrictionMode].changed)
- && (stm::StmRestrictionModeSttNoOn == crr_state.car_element[stm::StmCarElementNoRestrictionMode].state)) {
+ if ((crr_state.car_element[StmCarElementNoRestrictionMode].changed)
+ && (StmRestrictionModeSttNoOn == crr_state.car_element[StmCarElementNoRestrictionMode].state)) {
HMI_DEBUG("wm:pm", "Store current state for state of restriction mode off");
this->prv_layers_car_stop[layer_name] = this->crr_layers[layer_name];
}
// If car state is changed car_stop -> car_run,
// store current state for state of car stop
if ((crr_state.car.changed)
- && (stm::StmRunningNoRun == crr_state.car.state)) {
+ && (StmRunningNoRun == crr_state.car.state)) {
HMI_DEBUG("wm:pm", "Store current state for state of car stop");
this->prv_layers_car_stop[layer_name] = this->crr_layers[layer_name];
}
// Get current layout name of this layer
int crr_layout_state_no = crr_state.layer[layer_no].state;
- std::string crr_layout_name = std::string(stm::kStmLayoutName[crr_layout_state_no]);
+ std::string crr_layout_name = std::string(kStmLayoutName[crr_layout_state_no]);
LayoutState crr_layout_state;
#if 1
- if ((crr_state.car_element[stm::StmCarElementNoRestrictionMode].changed)
- && (stm::StmRestrictionModeSttNoOff == crr_state.car_element[stm::StmCarElementNoRestrictionMode].state)) {
+ if ((crr_state.car_element[StmCarElementNoRestrictionMode].changed)
+ && (StmRestrictionModeSttNoOff == crr_state.car_element[StmCarElementNoRestrictionMode].state)) {
// If restriction mode is changed on -> off,
// restore state of restriction mode off
HMI_DEBUG("wm:pm", "Restriction mode is changed on -> off, so restore state of restriction mode off");
#else
- if ((crr_state.car_element[stm::StmCarElementNoRunning].changed)
- && (stm::StmCarElementNoStop == crr_state.car_element[stm::StmCarElementNoRunning].state)) {
+ if ((crr_state.car_element[StmCarElementNoRunning].changed)
+ && (StmCarElementNoStop == crr_state.car_element[StmCarElementNoRunning].state)) {
// If car state is changed car_run -> car_stop,
// restore state of car stop
HMI_DEBUG("wm:pm", "Car state is changed car_run -> car_stop, so restore state of car stop");
crr_layout_state = this->prv_layers_car_stop[layer_name].layout_state;
crr_layout_name = crr_layout_state.name;
if ((prv_layout_name == crr_layout_name)
- && (stm::kStmAreaName[stm::StmAreaNoNone] == crr_layout_name)) {
+ && (kStmAreaName[StmAreaNoNone] == crr_layout_name)) {
changed = 0;
}
}
else if ((prv_layout_name == crr_layout_name)
- && (stm::kStmAreaName[stm::StmAreaNoNone] == crr_layout_name)) {
+ && (kStmAreaName[StmAreaNoNone] == crr_layout_name)) {
// Copy previous layout state for current
crr_layout_state = prv_layout_state;
changed = 0;
// Create candidate list
std::map<std::string, AreaList> cand_list;
- for (int ctg_no=stm::StmCtgNoMin;
- ctg_no<=stm::StmCtgNoMax; ctg_no++) {
- const char* ctg = stm::kStmCategoryName[ctg_no];
+ for (int ctg_no=StmCtgNoMin;
+ ctg_no<=StmCtgNoMax; ctg_no++) {
+ const char* ctg = kStmCategoryName[ctg_no];
HMI_DEBUG("wm:pm", "ctg:%s", ctg);
// Create candidate list for category from the previous displayed categories
this->crr_layers[layer_name].changed = (changed) ? true : false;
}
- // Erase role for the event_data from list
- this->req_role_list.erase(event_data);
+ // Erase role for the event_id from list
+ this->req_role_list.erase(event_id);
// Check
for (auto itr : this->crr_layers) {
}
}
-void PolicyManager::updateState(int event_data, stm::StmState crr_state) {
+void PolicyManager::updateState(int event_id, StmState crr_state) {
this->updateCarElementState(crr_state);
- this->updateLayerState(event_data, crr_state);
+ this->updateLayerState(event_id, crr_state);
}
-void PolicyManager::createOutputInformation(stm::StmState crr_state, json_object **json_out) {
+void PolicyManager::createOutputInformation(StmState crr_state, json_object **json_out) {
json_object* json_tmp;
// Create car element information
// },
json_object* json_car_ele = json_object_new_array();
const char* car_ele_name;
- for (int car_ele_no = stm::StmCarElementNoMin;
- car_ele_no <= stm::StmCarElementNoMax; car_ele_no++) {
- car_ele_name = stm::kStmCarElementName[car_ele_no];
+ for (int car_ele_no = StmCarElementNoMin;
+ car_ele_no <= StmCarElementNoMax; car_ele_no++) {
+ car_ele_name = kStmCarElementName[car_ele_no];
json_tmp = json_object_new_object();
this->addStateToJson(car_ele_name,
- this->crr_car_elements[car_ele_name].changed,
- this->crr_car_elements[car_ele_name].state,
- &json_tmp);
+ this->crr_car_elements[car_ele_name].changed,
+ this->crr_car_elements[car_ele_name].state,
+ &json_tmp);
json_object_array_add(json_car_ele, json_tmp);
}
json_object_object_add(*json_out, "car_elements", json_car_ele);
// ...
json_object* json_layer = json_object_new_array();
const char* layer_name;
- for (int layer_no = stm::StmLayerNoMin;
- layer_no <= stm::StmLayerNoMax; layer_no++) {
- layer_name = stm::kStmLayerName[layer_no];
+ for (int layer_no = StmLayerNoMin;
+ layer_no <= StmLayerNoMax; layer_no++) {
+ layer_name = kStmLayerName[layer_no];
json_tmp = json_object_new_object();
this->addStateToJson(layer_name,
- this->crr_layers[layer_name].changed,
- this->crr_layers[layer_name].layout_state.area_list,
- &json_tmp);
+ this->crr_layers[layer_name].changed,
+ this->crr_layers[layer_name].layout_state.area_list,
+ &json_tmp);
json_object_array_add(json_layer, json_tmp);
}
json_object_object_add(*json_out, "layers", json_layer);
}
-void PolicyManager::controlTimerEvent(stm::StmState crr_state) {
- if (crr_state.car_element[stm::StmCarElementNoRunning].changed) {
- if (stm::StmRunningNoRun == crr_state.car_element[stm::StmCarElementNoRunning].state) {
+void PolicyManager::controlTimerEvent(StmState crr_state) {
+ if (crr_state.car_element[StmCarElementNoRunning].changed) {
+ if (StmRunningNoRun == crr_state.car_element[StmCarElementNoRunning].state) {
// Set delay event(restriction mode on)
- this->setStateTransitionProcessToSystemd(stm::StmEvtNoRestrictionModeOn, 3000, "");
+ this->setStateTransitionProcessToSystemd(StmEvtNoRestrictionModeOn, 3000, "");
}
- else if (stm::StmRunningNoStop == crr_state.car_element[stm::StmCarElementNoRunning].state) {
+ else if (StmRunningNoStop == crr_state.car_element[StmCarElementNoRunning].state) {
// Stop timer for restriction on event
- if (this->event_source_list.find(stm::StmEvtNoRestrictionModeOn)
+ if (this->event_source_list.find(StmEvtNoRestrictionModeOn)
!= this->event_source_list.end()) {
HMI_DEBUG("wm:pm", "Stop timer for restriction on");
sd_event_source *event_source
- = this->event_source_list[stm::StmEvtNoRestrictionModeOn];
+ = this->event_source_list[StmEvtNoRestrictionModeOn];
int ret = sd_event_source_set_enabled(event_source, SD_EVENT_OFF);
if (0 > ret) {
HMI_ERROR("wm:pm", "Failed to stop timer");
}
// Set event(restriction mode off)
- this->setStateTransitionProcessToSystemd(stm::StmEvtNoRestrictionModeOff, 0, "");
+ this->setStateTransitionProcessToSystemd(StmEvtNoRestrictionModeOff, 0, "");
}
}
}
HMI_DEBUG("wm:pm", "Call");
HMI_DEBUG("wm:pm", ">>>>>>>>>> START CHECK POLICY");
- int event_data = *((int*)data);
+ int event_id = *((int*)data);
int event_no, category_no, area_no;
- event_no = STM_GET_EVENT_FROM_ID(event_data);
- category_no = STM_GET_CATEGORY_FROM_ID(event_data);
- area_no = STM_GET_AREA_FROM_ID(event_data);
+ event_no = STM_GET_EVENT_FROM_ID(event_id);
+ category_no = STM_GET_CATEGORY_FROM_ID(event_id);
+ area_no = STM_GET_AREA_FROM_ID(event_id);
HMI_DEBUG("wm:pm", ">>>>>>>>>> event:%s category:%s area:%s",
- stm::kStmEventName[event_no],
- stm::kStmCategoryName[category_no],
- stm::kStmAreaName[area_no]);
+ kStmEventName[event_no],
+ kStmCategoryName[category_no],
+ kStmAreaName[area_no]);
// Transition state
- stm::StmState crr_state;
- int ret = stm::stmTransitionState(event_data, &crr_state);
+ StmState crr_state;
+ int ret = stmTransitionState(event_id, &crr_state);
if (0 > ret) {
HMI_ERROR("wm:pm", "Failed transition state");
if (nullptr != this->callback.onError) {
json_object_object_add(json_out, "message",
json_object_new_string("Failed to transition state"));
json_object_object_add(json_out, "event",
- json_object_new_string(stm::kStmEventName[event_no]));
+ json_object_new_string(kStmEventName[event_no]));
json_object_object_add(json_out, "role",
- json_object_new_string(this->req_role_list[event_data].c_str()));
+ json_object_new_string(this->req_role_list[event_id].c_str()));
json_object_object_add(json_out, "area",
- json_object_new_string(stm::kStmAreaName[area_no]));
+ json_object_new_string(kStmAreaName[area_no]));
this->callback.onError(json_out);
json_object_put(json_out);
}
}
// Update state which is managed by PolicyManager
- this->updateState(event_data, crr_state);
+ this->updateState(event_id, crr_state);
// Create output information for ResourceManager
json_object* json_out = json_object_new_object();
sd_event_source_unref(source);
// Remove event source from list
- if (this->event_source_list.find(event_data) != this->event_source_list.end()) {
- this->event_source_list.erase(event_data);
+ if (this->event_source_list.find(event_id) != this->event_source_list.end()) {
+ this->event_source_list.erase(event_id);
}
HMI_DEBUG("wm:pm", ">>>>>>>>>> FINISH CHECK POLICY");
return ret;
}
-int PolicyManager::setStateTransitionProcessToSystemd(int event, uint64_t delay_ms, std::string role)
+int PolicyManager::setStateTransitionProcessToSystemd(int event_id, uint64_t delay_ms, std::string role)
{
HMI_DEBUG("wm:pm", "Call");
- HMI_DEBUG("wm:pm", "event:0x%x delay:%d role:%s", event, delay_ms, role.c_str());
+ HMI_DEBUG("wm:pm", "event_id:0x%x delay:%d role:%s", event_id, delay_ms, role.c_str());
// Store requested role
- this->req_role_list[event] = role;
+ this->req_role_list[event_id] = role;
if (0 == delay_ms) {
int ret = sd_event_add_defer(this->event_loop, NULL,
- &pm::transitionStateWrapper, new int(event));
+ &pm::transitionStateWrapper, new int(event_id));
if (0 > ret) {
HMI_ERROR("wm:pm", "Faild to sd_event_add_defer: errno:%d", ret);
- this->req_role_list.erase(event);
+ this->req_role_list.erase(event_id);
return -1;
}
}
// Set timer
struct sd_event_source* event_source;
int ret = sd_event_add_time(this->event_loop, &event_source, CLOCK_MONOTONIC, usec, 1,
- &pm::timerEventWrapper, new int(event));
+ &pm::timerEventWrapper, new int(event_id));
if (0 > ret) {
HMI_ERROR("wm:pm", "Faild to sd_event_add_time: errno:%d", ret);
- this->req_role_list.erase(event);
+ this->req_role_list.erase(event_id);
return -1;
}
// Store event source
- this->event_source_list[event] = event_source;
+ this->event_source_list[event_id] = event_source;
}
return 0;
// Get event from json_object
const char* event = this->getStringFromJson(json_in, "event");
- int event_no = stm::StmEvtNoNone;
+ int event_no = StmEvtNoNone;
if (nullptr != event) {
// Convert name to number
auto itr = this->eventname2no.find(event);
// Get role from json_object
const char* role = this->getStringFromJson(json_in, "role");
- int category_no = stm::StmCtgNoNone;
+ int category_no = StmCtgNoNone;
if (nullptr != role) {
HMI_DEBUG("wm:pm", "role(%s)", role);
}
}
- if (stm::StmCtgNoNone == category_no) {
+ if (StmCtgNoNone == category_no) {
role = "";
}
// Get areat from json_object
const char* area = this->getStringFromJson(json_in, "area");
- int area_no = stm::StmAreaNoNone;
+ int area_no = StmAreaNoNone;
if (nullptr != area) {
auto itr = this->areaname2no.find(area);
if (this->areaname2no.end() != itr) {
}
// If role is set and area is not set, use default area
- if ((stm::StmAreaNoNone == area_no)
- && (stm::StmCtgNoNone != category_no)) {
+ if ((StmAreaNoNone == area_no)
+ && (StmCtgNoNone != category_no)) {
std::string def_area = this->role2defaultarea[role];
area_no = this->areaname2no[def_area];
HMI_DEBUG("wm:pm", "area(%s:%d)", def_area.c_str(), area_no);
HMI_DEBUG("wm:pm", "Call");
// Undo state of STM
- stm::stmUndoState();
+ stmUndoState();
this->crr_layers = this->prv_layers;
}
LayoutState layout_state;
AreaState area_state;
std::map<std::string, int> category_num;
- for (int ctg_no = stm::StmCtgNoMin;
- ctg_no <= stm::StmCtgNoMax; ctg_no++) {
- const char* ctg_name = stm::kStmCategoryName[ctg_no];
+ for (int ctg_no = StmCtgNoMin;
+ ctg_no <= StmCtgNoMax; ctg_no++) {
+ const char* ctg_name = kStmCategoryName[ctg_no];
category_num[ctg_name] = 0;
}
Code Review / apps / agl-service-windowmanager-2017.git / commitdiff