diff options
| -rw-r--r-- | CMakeLists.txt | 4 | ||||
| -rw-r--r-- | layers.json.split | 56 | ||||
| -rw-r--r-- | policy_manager/CMakeLists.txt | 88 | ||||
| -rw-r--r-- | policy_manager/db/roles.db | 40 | ||||
| -rw-r--r-- | policy_manager/db/states.db | 174 | ||||
| -rw-r--r-- | policy_manager/policy_manager.cpp | 1356 | ||||
| -rw-r--r-- | policy_manager/policy_manager.hpp | 149 | ||||
| -rw-r--r-- | policy_manager/stm/stm.c | 118 | ||||
| -rw-r--r-- | policy_manager/stm/stm.h | 175 | ||||
| -rw-r--r-- | policy_manager/stm/stub/CMakeLists.txt | 44 | ||||
| -rw-r--r-- | policy_manager/stm/stub/stm_inner.c | 151 | ||||
| -rw-r--r-- | policy_manager/stm/stub/stm_inner.h | 27 | ||||
| -rw-r--r-- | src/CMakeLists.txt | 13 | ||||
| -rw-r--r-- | src/json_helper.cpp | 12 | ||||
| -rw-r--r-- | src/json_helper.hpp | 1 | ||||
| -rw-r--r-- | src/main.cpp | 30 | ||||
| -rw-r--r-- | src/pm_wrapper.cpp | 261 | ||||
| -rw-r--r-- | src/pm_wrapper.hpp | 75 | ||||
| -rw-r--r-- | src/window_manager.cpp | 528 | ||||
| -rw-r--r-- | src/window_manager.hpp | 10 |
20 files changed, 2846 insertions, 466 deletions
diff --git a/CMakeLists.txt b/CMakeLists.txt index 4ed6d6d..e1cb0db 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -79,4 +79,8 @@ set(SANITIZER_MODE "none" CACHE STRING "Build using a specific sanitizer (e.g. ' set(LINK_LIBCXX OFF CACHE BOOL "Link against LLVMs libc++") +# Add PolicyManager as plugin +set(PLUGIN_PM policy_manager) +add_subdirectory(${PLUGIN_PM}) + add_subdirectory(src) diff --git a/layers.json.split b/layers.json.split deleted file mode 100644 index 641e2f4..0000000 --- a/layers.json.split +++ /dev/null @@ -1,56 +0,0 @@ -{ - "comment": "Surface ID to Layer ID mapping", - - "main_surface": { - "surface_role": "HomeScreen", - "comment": "This surface should never be made invisible (The HomeScreen)" - }, - - "mappings": [ - { - "role": "BackGroundLayer", - "name": "BackGroundLayer", - "layer_id": 999, - "comment": "Single BackGround layer map for the map, radio, music and video" - }, - { - "role": "homescreen", - "name": "FarHomeScreen", - "layer_id": 1000, - "comment": "FarHomeScreen is the part of HomeScreen. The z order of this layer is lower than NearHomeScreen" - }, - { - "role": "music|video|browser|radio|phone|map|hvac|settings|dashboard|poi|mixer|sdl|launcher|fallback", - "name": "Apps", - "layer_id": 1001, - "comment": "Range of IDs that will always be placed on layer 1001", - - "split_layouts": [ - { - "name": "map", - "main_match": "map", - "sub_match": "hvac|music", - "priority": 1000 - } - ] - }, - { - "role": "software_keyboard", - "name": "NearHomeScreen", - "layer_id": 1002, - "comment": "NearHomeScreen is the part of HomeScreen. The z order of this layer is upper than FarHomeScreen" - }, - { - "role": "restriction", - "name": "Restriction", - "layer_id": 1003, - "comment": "This layer is for restriction notification. This is used by restriction role" - }, - { - "role": "^on_screen.*", - "name": "OnScreen", - "layer_id": 9999, - "comment": "Range of IDs that will always be placed on the OnScreen layer, that gets a very high 'dummy' id of 9999" - } - ] -} diff --git a/policy_manager/CMakeLists.txt b/policy_manager/CMakeLists.txt new file mode 100644 index 0000000..23aec19 --- /dev/null +++ b/policy_manager/CMakeLists.txt @@ -0,0 +1,88 @@ +# +# Copyright (c) 2017 TOYOTA MOTOR CORPORATION +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +# + +include(FindPkgConfig) +pkg_check_modules(AFB REQUIRED afb-daemon) +pkg_check_modules(SD REQUIRED libsystemd>=222) + +# Set name of STM +set(STM_DIR stub) + +# Add STM directory +add_subdirectory(stm/${STM_DIR}) + +set(TARGETS_PM ${PLUGIN_PM}) + +add_library(${TARGETS_PM} + SHARED + policy_manager.cpp + stm/stm.c +) + +target_include_directories(${TARGETS_PM} + PRIVATE + ${AFB_INCLUDE_DIRS} + ${SD_INCLUDE_DIRS} + ../include + ../src + ./ + ./stm + ./stm/${STM_DIR} +) + +target_link_libraries(${TARGETS_PM} + PRIVATE + ${AFB_LIBRARIES} + ${SD_LIBRARIES} + pmstm +) + +target_compile_definitions(${TARGETS_PM} + PRIVATE + _GNU_SOURCE +) + +target_compile_options(${TARGETS_PM} + PRIVATE + -Wall -Wextra -Wno-unused-parameter -Wno-comment) + +set_target_properties(${TARGETS_PM} + PROPERTIES + CXX_EXTENSIONS OFF + CXX_STANDARD 14 + CXX_STANDARD_REQUIRED ON + + C_EXTENSIONS OFF + C_STANDARD 99 + C_STANDARD_REQUIRED ON + + LINK_FLAGS "-Wl,-rpath,'$ORIGIN'" +) + +if (LINK_LIBCXX) + set_target_properties(${TARGETS_PM} + PROPERTIES + LINK_FLAGS "-lc++ -Wl,-rpath,'$ORIGIN'" + ) +endif() + +add_custom_command(TARGET ${TARGETS_PM} POST_BUILD + COMMAND mkdir -p ${PROJECT_BINARY_DIR}/package/root/lib + COMMAND cp -f ${PROJECT_BINARY_DIR}/${PLUGIN_PM}/lib${PLUGIN_PM}.so ${PROJECT_BINARY_DIR}/package/root/lib + COMMAND mkdir -p ${PROJECT_BINARY_DIR}/package/root/etc + COMMAND cp -f ${PROJECT_SOURCE_DIR}/${PLUGIN_PM}/db/states.db ${PROJECT_BINARY_DIR}/package/root/etc + COMMAND cp -f ${PROJECT_SOURCE_DIR}/${PLUGIN_PM}/db/roles.db ${PROJECT_BINARY_DIR}/package/root/etc +) diff --git a/policy_manager/db/roles.db b/policy_manager/db/roles.db new file mode 100644 index 0000000..5d31aea --- /dev/null +++ b/policy_manager/db/roles.db @@ -0,0 +1,40 @@ +{ + "roles":[ + { + "category": "homescreen", + "role": "homescreen", + "area": "fullscreen", + "layer": "homescreen", + }, + { + "category": "debug", + "role": "launcher | map | poi | browser | sdl | mixer | radio | hvac | debug | phone | video | music | settings | dashboard | fallback", + "area": "normal.full | split.main | split.sub | fullscreen", + "layer": "apps", + }, + { + "category": "software_keyboard", + "role": "software_keyboard", + "area": "software_keyboard", + "layer": "near_homescreen", + }, + { + "category": "restriction", + "role": "restriction", + "area": "restriction.normal | restriction.split.main | restriction.split.sub", + "layer": "restriction", + }, + { + "category": "pop_up", + "role": "on_screen | on_screen_phone", + "area": "on_screen", + "layer": "on_screen", + }, + { + "category": "system_alert", + "role": "system_alert", + "area": "on_screen", + "layer": "on_screen", + } + ] +} diff --git a/policy_manager/db/states.db b/policy_manager/db/states.db new file mode 100644 index 0000000..371be3b --- /dev/null +++ b/policy_manager/db/states.db @@ -0,0 +1,174 @@ +{ + "states": [ + { + "name": "homescreen", + "areas": [ + { + "name": "fullscreen", + "category": "homescreen" + } + ] + }, + { + "name": "map.normal", + "areas": [ + { + "name": "normal.full", + "category": "map" + } + ] + }, + { + "name": "map.split", + "areas": [ + { + "name": "split.main", + "category": "map" + }, + { + "name": "split.sub", + "category": "splitable" + } + ] + }, + { + "name": "map.fullscreen", + "areas": [ + { + "name": "fullscreen", + "category": "map" + } + ] + }, + { + "name": "splitable.normal", + "areas": [ + { + "name": "normal.full", + "category": "splitable" + } + ] + }, + { + "name": "splitable.split", + "areas": [ + { + "name": "split.main", + "category": "splitable" + }, + { + "name": "split.sub", + "category": "splitable" + } + ] + }, + { + "name": "general.normal", + "areas": [ + { + "name": "normal.full", + "category": "general" + } + ] + }, + { + "name": "system.normal", + "areas": [ + { + "name": "normal.full", + "category": "system" + } + ] + }, + { + "name": "software_keyboard", + "areas": [ + { + "name": "software_keyboard", + "category": "software_keyboard" + } + ] + }, + { + "name": "restriction.normal", + "areas": [ + { + "name": "restriction.normal", + "category": "restriction" + } + ] + }, + { + "name": "restriction.split.main", + "areas": [ + { + "name": "restriction.split.main", + "category": "restriction" + } + ] + }, + { + "name": "restriction.split.sub", + "areas": [ + { + "name": "restriction.split.sub", + "category": "restriction" + } + ] + }, + { + "name": "pop_up", + "areas": [ + { + "name": "on_screen", + "category": "pop_up" + } + ] + }, + { + "name": "system_alert", + "areas": [ + { + "name": "on_screen", + "category": "system_alert" + } + ] + }, + { + "name": "debug.normal", + "areas": [ + { + "name": "normal.full", + "category": "debug" + } + ] + }, + { + "name": "debug.split.main", + "areas": [ + { + "name": "split.main", + "category": "debug" + } + ] + }, + { + "name": "debug.split.sub", + "areas": [ + { + "name": "split.sub", + "category": "debug" + } + ] + }, + { + "name": "debug.fullscreen", + "areas": [ + { + "name": "fullscreen", + "category": "debug" + } + ] + } + ] +} diff --git a/policy_manager/policy_manager.cpp b/policy_manager/policy_manager.cpp new file mode 100644 index 0000000..a482e0c --- /dev/null +++ b/policy_manager/policy_manager.cpp @@ -0,0 +1,1356 @@ +/* + * Copyright (c) 2018 TOYOTA MOTOR CORPORATION + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include <fstream> +#include <sstream> +#include <istream> +#include <thread> +#include <map> +#include <algorithm> +#include <json-c/json.h> +#include "policy_manager.hpp" +#include "hmi-debug.h" + +extern "C" +{ +#define AFB_BINDING_VERSION 2 +#include <afb/afb-binding.h> +#include <systemd/sd-event.h> +#include "stm.h" +} + +namespace pm +{ +static const int kInvisibleRoleHistoryNum = 5; + +static PolicyManager *g_context; + +static int transitionStateWrapper(sd_event_source *source, void *data) +{ + int ret = g_context->transitionState(source, data); + return ret; +} + +static int timerEventWrapper(sd_event_source *source, uint64_t usec, void *data) +{ + int ret = g_context->timerEvent(source, usec, data); + return ret; +} + +} // namespace pm + +PolicyManager::PolicyManager() + : eventname2no(), + categoryname2no(), + areaname2no(), + role2category(), + category2role(), + category2areas() +{} + +int PolicyManager::initialize() +{ + int ret = 0; + + // Create convert map + 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 = StmCtgNoMin; i <= StmCtgNoMax; i++) + { + HMI_DEBUG("wm:pm", "category name:%s no:%d", kStmCategoryName[i], i); + this->categoryname2no[kStmCategoryName[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 roles.db + ret = this->loadRoleDb(); + if (0 > ret) + { + HMI_ERROR("wm:pm", "Load roles.db Error!!"); + return ret; + } + + // Load states.db + ret = this->loadStateDb(); + if (0 > ret) + { + HMI_ERROR("wm:pm", "Load states.db Error!!"); + return ret; + } + + // Initialize state which is managed by PolicyManager + this->initializeState(); + + // Initialize StateTransitioner + stmInitialize(); + + // Store instance + pm::g_context = this; + + return ret; +} + +void PolicyManager::registerCallback(CallbackTable callback) +{ + this->callback.onStateTransitioned = callback.onStateTransitioned; + this->callback.onError = callback.onError; +} + +int PolicyManager::setInputEventData(json_object *json_in) +{ + // Check arguments + if (nullptr == json_in) + { + HMI_ERROR("wm:pm", "Argument is NULL!!"); + return -1; + } + + // Get event from json_object + const char *event = this->getStringFromJson(json_in, "event"); + int event_no = StmEvtNoNone; + if (nullptr != event) + { + // Convert name to number + auto itr = this->eventname2no.find(event); + if (this->eventname2no.end() != itr) + { + event_no = this->eventname2no[event]; + HMI_DEBUG("wm:pm", "event(%s:%d)", event, event_no); + } + else + { + HMI_ERROR("wm:pm", "Invalid event name!!"); + return -1; + } + } + else + { + HMI_ERROR("wm:pm", "Event is not set!!"); + return -1; + } + + // Get role from json_object + const char *role = this->getStringFromJson(json_in, "role"); + std::string category = ""; + int category_no = StmCtgNoNone; + if (nullptr != role) + { + HMI_DEBUG("wm:pm", "role(%s)", role); + + // Convert role to category + auto itr = this->role2category.find(role); + if (this->role2category.end() != itr) + { + category = this->role2category[role]; + } + else + { + itr = this->role2category.find("fallback"); + if (this->role2category.end() != itr) + { + HMI_DEBUG("wm:pm", "Role:%s is not registered in roles.db, fallback as normal app", role); + category = this->role2category["fallback"]; + } + } + + if ("" != category) + { + // Convert name to number + category_no = categoryname2no[category]; + HMI_DEBUG("wm:pm", "category(%s:%d)", category.c_str(), category_no); + } + } + if (StmCtgNoNone == category_no) + { + role = ""; + } + + // Get area from json_object + const char *area = this->getStringFromJson(json_in, "area"); + int area_no = StmAreaNoNone; + if ((nullptr != area) && (StmCtgNoNone != category_no)) + { + for (const auto &x : this->category2areas[category]) + { + if (x == std::string(area)) + { + area_no = this->areaname2no[area]; + break; + } + } + if (StmAreaNoNone == area_no) + { + area = this->category2areas[category].front().c_str(); + area_no = this->areaname2no[area]; + } + HMI_DEBUG("wm:pm", "area(%s:%d)", area, area_no); + } + + // Set event info to the queue + EventInfo event_info; + int event_id = STM_CREATE_EVENT_ID(event_no, category_no, area_no); + event_info.event = event_id; + event_info.role = std::string(role); + event_info.delay = 0; + this->event_info_queue.push(event_info); + + return 0; +} + +int PolicyManager::executeStateTransition() +{ + int ret; + EventInfo event_info; + + // Get event info from queue and delete + event_info = this->event_info_queue.front(); + this->event_info_queue.pop(); + + // Set event info to check policy + ret = this->setStateTransitionProcessToSystemd(event_info.event, + event_info.delay, + event_info.role); + return ret; +} + +void PolicyManager::undoState() +{ + HMI_DEBUG("wm:pm", "Undo State !!!"); + + // Undo state of STM + stmUndoState(); + + HMI_DEBUG("wm:pm", ">>>>>>>>>> BEFORE UNDO"); + this->dumpLayerState(this->crr_layers); + + this->crr_layers = this->prv_layers; + + HMI_DEBUG("wm:pm", ">>>>>>>>>> AFTER UNDO"); + this->dumpLayerState(this->crr_layers); +} + +void PolicyManager::initializeState() +{ + this->initializeLayerState(); +} + +void PolicyManager::initializeLayerState() +{ + AreaState init_area; + LayoutState init_layout; + init_area.name = kStmAreaName[StmAreaNoNone]; + init_area.category = kStmCategoryName[StmCtgNoNone]; + init_area.role = ""; + init_layout.name = kStmLayoutName[StmLayoutNoNone]; + init_layout.area_list.push_back(init_area); + + 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; + } + + this->prv_layers = this->crr_layers; +} + +void PolicyManager::addStateToJson(const char *name, bool changed, + std::string state, json_object **json_out) +{ + if ((nullptr == name) || (nullptr == json_out)) + { + HMI_ERROR("wm:pm", "Invalid argument!!!"); + return; + } + + json_object_object_add(*json_out, "name", json_object_new_string(name)); + json_object_object_add(*json_out, "state", json_object_new_string(state.c_str())); + json_object_object_add(*json_out, "changed", json_object_new_boolean(changed)); +} + +void PolicyManager::addStateToJson(const char *layer_name, bool changed, + AreaList area_list, json_object **json_out) +{ + if ((nullptr == layer_name) || (nullptr == json_out)) + { + HMI_ERROR("wm:pm", "Invalid argument!!!"); + return; + } + + json_object *json_areas = json_object_new_array(); + json_object *json_tmp; + for (const auto &as : area_list) + { + 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_object_add(*json_out, "name", json_object_new_string(layer_name)); + json_object_object_add(*json_out, "changed", json_object_new_boolean(changed)); + json_object_object_add(*json_out, "areas", json_areas); +} + +void PolicyManager::updateState(int event_id, StmState crr_state) +{ + this->updateLayer(event_id, crr_state); +} + +void PolicyManager::updateLayer(int event_id, StmState crr_state) +{ + for (int layer_no = StmLayerNoMin; + layer_no <= StmLayerNoMax; layer_no++) + { + HMI_DEBUG("wm:pm", ">>> LAYER:%s CHANGED:%d LAYOUT:%s", + kStmLayerName[layer_no], crr_state.layer[layer_no].changed, + kStmLayoutName[crr_state.layer[layer_no].state]); + } + + // Store previous layers + this->prv_layers = this->crr_layers; + + // Update layers + for (int layer_no = StmLayerNoMin; + layer_no <= StmLayerNoMax; layer_no++) + { + const char *layer_name = kStmLayerName[layer_no]; + + // This layer is changed? + int changed = crr_state.layer[layer_no].changed; + if (changed) + { + HMI_DEBUG("wm:pm", ">>>>>>>>>> Update layout of layer:%s", 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(kStmLayoutName[crr_layout_state_no]); + + LayoutState crr_layout_state; + this->updateLayout(event_id, layer_no, + crr_layout_name, crr_layout_state); + + // Update current layout of this layer + this->crr_layers[layer_name].layout_state = crr_layout_state; + } + // Update changed flag + this->crr_layers[layer_name].changed = (changed) ? true : false; + } + + // Erase role for the event_id from list + this->req_role_list.erase(event_id); + + HMI_DEBUG("wm:pm", ">>>>>>>>>> DUMP LAYERS (BEFORE)"); + this->dumpLayerState(this->prv_layers); + + HMI_DEBUG("wm:pm", ">>>>>>>>>> DUMP LAYERS (AFTER)"); + this->dumpLayerState(this->crr_layers); + + this->dumpInvisibleRoleHistory(); +} + +int PolicyManager::updateLayout(int event_id, int layer_no, + std::string crr_layout_name, LayoutState &crr_layout_state) +{ + int changed; + + int event_no = STM_GET_EVENT_FROM_ID(event_id); + int category_no = STM_GET_CATEGORY_FROM_ID(event_id); + int area_no = STM_GET_AREA_FROM_ID(event_id); + + 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]; + + const char *layer_name = kStmLayerName[layer_no]; + + // Get previous layout name of this layer + LayoutState prv_layout_state = this->prv_layers[layer_name].layout_state; + std::string prv_layout_name = prv_layout_state.name; + + if ((prv_layout_name == crr_layout_name) && + (kStmLayoutName[StmLayoutNoNone] == crr_layout_name)) + { + // If previous and current layout are none + // Copy previous layout state for current + crr_layout_state = prv_layout_state; + changed = 0; + } + else + { + crr_layout_state = prv_layout_state; + changed = 1; + + HMI_DEBUG("wm:pm", "-- layout name previous:%s current:%s", + prv_layout_name.c_str(), crr_layout_name.c_str()); + if (prv_layout_name == crr_layout_name) + { + HMI_DEBUG("wm:pm", "---- Previous layout is same with current"); + } + else + { + // If previous layout is NOT same with current, + // current areas is set with default value + HMI_DEBUG("wm:pm", "---- Previous layout is NOT same with current"); + crr_layout_state.name = this->default_layouts[crr_layout_name].name; + crr_layout_state.category_num = this->default_layouts[crr_layout_name].category_num; + crr_layout_state.area_list = this->default_layouts[crr_layout_name].area_list; + } + + // Create candidate list + std::map<std::string, AreaList> cand_list; + // for (int ctg_no = StmCtgNoMin; + // ctg_no <= StmCtgNoMax; ctg_no++) + // { + for (const auto &ctg : this->layer2categories[layer_name]) + { + // if (ctg_no == StmCtgNoNone) + // { + // continue; + // } + + // const char *ctg = kStmCategoryName[ctg_no]; + HMI_DEBUG("wm:pm", "-- Create candidate list for ctg:%s", ctg.c_str()); + + AreaList tmp_cand_list; + int candidate_num = 0; + int blank_num = crr_layout_state.category_num[ctg]; + + // If requested event is "activate" + // and there are requested category and area, + // update area with requested role in current layout. + bool request_for_this_layer = false; + std::string used_role = ""; + if ((ctg == req_ctg) && ("activate" == req_evt)) + { + HMI_DEBUG("wm:pm", "---- Requested event is activate"); + for (AreaState &as : crr_layout_state.area_list) + { + if (as.category == req_ctg) + { + request_for_this_layer = true; + + if (as.name == req_area) + { + as.role = req_role; + used_role = req_role; + blank_num--; + HMI_DEBUG("wm:pm", "------ Update current layout: area:%s category:%s role:%s", + as.name.c_str(), as.category.c_str(), as.role.c_str()); + break; + } + } + } + } + + // Create candidate list for category from the previous displayed categories + for (AreaState area_state : prv_layout_state.area_list) + { + if ((ctg == area_state.category) && + (used_role != area_state.role)) + { + // If there is the category + // which is same with new category and not used for updating yet, + // push it to list + HMI_DEBUG("wm:pm", "---- Push previous(category:%s role:%s) to candidate list", + area_state.category.c_str(), area_state.role.c_str()); + tmp_cand_list.push_back(area_state); + candidate_num++; + } + } + + // If NOT updated by requested area: + // there is not requested area in new layout, + // so push requested role to candidate list + if (request_for_this_layer && ("" == used_role)) + { + HMI_DEBUG("wm:pm", "---- Push request(area:%s category:%s role:%s) to candidate list", + req_area.c_str(), req_ctg.c_str(), req_role.c_str()); + AreaState area_state; + area_state.name = req_area; + area_state.category = req_ctg; + area_state.role = req_role; + tmp_cand_list.push_back(area_state); + candidate_num++; + } + + HMI_DEBUG("wm:pm", "---- blank_num:%d candidate_num:%d", blank_num, candidate_num); + + // Compare number of candidate/blank, + // And remove role in order of the oldest as necessary + if (candidate_num < blank_num) + { + // Refer history stack + // and add to the top of tmp_cand_list in order to the newest + while (candidate_num != blank_num) + { + AreaState area_state; + area_state.name = kStmAreaName[StmAreaNoNone]; + area_state.category = ctg; + area_state.role = this->popInvisibleRoleHistory(ctg); + if ("" == area_state.role) + { + HMI_ERROR("wm:pm", "There is no role in history stack!!"); + } + tmp_cand_list.push_back(area_state); + HMI_DEBUG("wm:pm", "------ Add role:%s to candidate list", + area_state.role.c_str()); + candidate_num++; + } + } + else if (candidate_num > blank_num) + { + // Remove the oldest role from candidate list + while (candidate_num != blank_num) + { + std::string removed_role = tmp_cand_list.begin()->role; + HMI_DEBUG("wm:pm", "------ Remove the oldest role:%s from candidate list", + removed_role.c_str()); + tmp_cand_list.erase(tmp_cand_list.begin()); + candidate_num--; + + // Push removed data to history stack + this->pushInvisibleRoleHistory(ctg, removed_role); + + // Remove from current layout + for (AreaState &as : crr_layout_state.area_list) + { + if (as.role == removed_role) + { + as.role = ""; + } + } + } + } + else + { // (candidate_num == blank_num) + // nop + } + + cand_list[ctg] = tmp_cand_list; + } + + // Update areas + HMI_DEBUG("wm:pm", "-- Update areas by using candidate list"); + for (AreaState &as : crr_layout_state.area_list) + { + HMI_DEBUG("wm:pm", "---- Check area:%s category:%s role:%s", + as.name.c_str(), as.category.c_str(), as.role.c_str()); + if ("" == as.role) + { + HMI_DEBUG("wm:pm", "------ Update this area with role:%s", + cand_list[as.category].begin()->role.c_str()); + as.role = cand_list[as.category].begin()->role; + cand_list[as.category].erase(cand_list[as.category].begin()); + } + } + } + return changed; +} + +void PolicyManager::createOutputInformation(StmState crr_state, json_object **json_out) +{ + json_object *json_tmp; + + // Create layout information + // + // "layers": [ + // { + // "homescreen": { + // "changed": <bool>, + // "areas": [ + // { + // "name":<const char*>, + // "role":<const char*> + // }. + // ... + // ] + // } + // }, + // ... + json_object *json_layer = json_object_new_array(); + const char *layer_name; + 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); + json_object_array_add(json_layer, json_tmp); + } + json_object_object_add(*json_out, "layers", json_layer); +} + +int PolicyManager::transitionState(sd_event_source *source, void *data) +{ + HMI_DEBUG("wm:pm", ">>>>>>>>>> START STATE TRANSITION"); + + int event_id = *((int *)data); + + int event_no, category_no, area_no; + 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", + kStmEventName[event_no], + kStmCategoryName[category_no], + kStmAreaName[area_no]); + + // Transition 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 *json_out = json_object_new_object(); + 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(kStmEventName[event_no])); + json_object_object_add(json_out, "role", + json_object_new_string(this->req_role_list[event_id].c_str())); + json_object_object_add(json_out, "area", + json_object_new_string(kStmAreaName[area_no])); + this->callback.onError(json_out); + json_object_put(json_out); + } + return -1; + } + + // Update state which is managed by PolicyManager + this->updateState(event_id, crr_state); + + // Create output information for ResourceManager + json_object *json_out = json_object_new_object(); + this->createOutputInformation(crr_state, &json_out); + + // Notify changed state + if (nullptr != this->callback.onStateTransitioned) + { + this->callback.onStateTransitioned(json_out); + } + + // Release json_object + json_object_put(json_out); + + // Release data + delete (int *)data; + + // Destroy sd_event_source object + sd_event_source_unref(source); + + // Remove event source from list + 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 STATE TRANSITION"); + return 0; +} + +int PolicyManager::timerEvent(sd_event_source *source, uint64_t usec, void *data) +{ + HMI_DEBUG("wm:pm", "Call"); + + int ret = this->transitionState(source, data); + return ret; +} + +int PolicyManager::setStateTransitionProcessToSystemd(int event_id, uint64_t delay_ms, std::string role) +{ + 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_id] = role; + + if (0 == delay_ms) + { + int ret = sd_event_add_defer(afb_daemon_get_event_loop(), NULL, + &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_id); + return -1; + } + } + else + { + // Get current time + struct timespec time_spec; + clock_gettime(CLOCK_MONOTONIC, &time_spec); + + // Calculate timer fired time + uint64_t usec = (time_spec.tv_sec * 1000000) + (time_spec.tv_nsec / 1000) + (delay_ms * 1000); + + // Set timer + struct sd_event_source *event_source; + int ret = sd_event_add_time(afb_daemon_get_event_loop(), &event_source, + CLOCK_MONOTONIC, usec, 1, + &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_id); + return -1; + } + + // Store event source + this->event_source_list[event_id] = event_source; + } + + return 0; +} + +int PolicyManager::loadRoleDb() +{ + std::string file_name; + + // Get afm application installed dir + char const *afm_app_install_dir = getenv("AFM_APP_INSTALL_DIR"); + HMI_DEBUG("wm:pm", "afm_app_install_dir:%s", afm_app_install_dir); + + if (!afm_app_install_dir) + { + HMI_ERROR("wm:pm", "AFM_APP_INSTALL_DIR is not defined"); + } + else + { + file_name = std::string(afm_app_install_dir) + std::string("/etc/roles.db"); + } + + // Load roles.db + json_object *json_obj; + int ret = this->inputJsonFilie(file_name.c_str(), &json_obj); + if (0 > ret) + { + HMI_ERROR("wm:pm", "Could not open roles.db, so use default role information"); + json_obj = json_tokener_parse(kDefaultRoleDb); + } + HMI_DEBUG("wm:pm", "json_obj dump:%s", json_object_get_string(json_obj)); + + json_object *json_roles; + if (!json_object_object_get_ex(json_obj, "roles", &json_roles)) + { + HMI_ERROR("wm:pm", "Parse Error!!"); + return -1; + } + + int len = json_object_array_length(json_roles); + HMI_DEBUG("wm:pm", "json_cfg len:%d", len); + HMI_DEBUG("wm:pm", "json_cfg dump:%s", json_object_get_string(json_roles)); + + json_object *json_tmp; + const char *category; + const char *roles; + const char *areas; + const char *layer; + for (int i = 0; i < len; i++) + { + json_tmp = json_object_array_get_idx(json_roles, i); + + category = this->getStringFromJson(json_tmp, "category"); + roles = this->getStringFromJson(json_tmp, "role"); + areas = this->getStringFromJson(json_tmp, "area"); + layer = this->getStringFromJson(json_tmp, "layer"); + + if ((nullptr == category) || (nullptr == roles) || + (nullptr == areas) || (nullptr == layer)) + { + HMI_ERROR("wm:pm", "Parse Error!!"); + return -1; + } + + // Parse roles by '|' + std::vector<std::string> vct_roles; + vct_roles = this->parseString(std::string(roles), '|'); + + // Parse areas by '|' + Areas vct_areas; + vct_areas = this->parseString(std::string(areas), '|'); + + // Set role, category, areas + for (auto itr = vct_roles.begin(); itr != vct_roles.end(); ++itr) + { + this->role2category[*itr] = std::string(category); + } + this->category2role[category] = std::string(roles); + this->category2areas[category] = vct_areas; + this->layer2categories[layer].push_back(category); + } + + // Check + HMI_DEBUG("wm:pm", "Check role2category"); + for (const auto &x : this->role2category) + { + HMI_DEBUG("wm:pm", "key:%s, val:%s", x.first.c_str(), x.second.c_str()); + } + + HMI_DEBUG("wm:pm", "Check category2role"); + for (const auto &x : this->category2role) + { + HMI_DEBUG("wm:pm", "key:%s, val:%s", x.first.c_str(), x.second.c_str()); + } + + HMI_DEBUG("wm:pm", "Check category2areas"); + for (const auto &x : this->category2areas) + { + for (const auto &y : x.second) + { + HMI_DEBUG("wm:pm", "key:%s, val:%s", x.first.c_str(), y.c_str()); + } + } + return 0; +} + +int PolicyManager::loadStateDb() +{ + HMI_DEBUG("wm:pm", "Call"); + + // Get afm application installed dir + char const *afm_app_install_dir = getenv("AFM_APP_INSTALL_DIR"); + HMI_DEBUG("wm:pm", "afm_app_install_dir:%s", afm_app_install_dir); + + std::string file_name; + if (!afm_app_install_dir) + { + HMI_ERROR("wm:pm", "AFM_APP_INSTALL_DIR is not defined"); + } + else + { + file_name = std::string(afm_app_install_dir) + std::string("/etc/states.db"); + } + + // Load states.db + json_object *json_obj; + int ret = this->inputJsonFilie(file_name.c_str(), &json_obj); + if (0 > ret) + { + HMI_DEBUG("wm:pm", "Could not open states.db, so use default layout information"); + json_obj = json_tokener_parse(kDefaultStateDb); + } + HMI_DEBUG("wm:pm", "json_obj dump:%s", json_object_get_string(json_obj)); + + // Perse states + HMI_DEBUG("wm:pm", "Perse states"); + json_object *json_cfg; + if (!json_object_object_get_ex(json_obj, "states", &json_cfg)) + { + HMI_ERROR("wm:pm", "Parse Error!!"); + return -1; + } + + int len = json_object_array_length(json_cfg); + HMI_DEBUG("wm:pm", "json_cfg len:%d", len); + HMI_DEBUG("wm:pm", "json_cfg dump:%s", json_object_get_string(json_cfg)); + + const char *layout; + const char *role; + const char *category; + for (int i = 0; i < len; i++) + { + json_object *json_tmp = json_object_array_get_idx(json_cfg, i); + + layout = this->getStringFromJson(json_tmp, "name"); + if (nullptr == layout) + { + HMI_ERROR("wm:pm", "Parse Error!!"); + return -1; + } + HMI_DEBUG("wm:pm", "> layout:%s", layout); + + json_object *json_area_array; + if (!json_object_object_get_ex(json_tmp, "areas", &json_area_array)) + { + HMI_ERROR("wm:pm", "Parse Error!!"); + return -1; + } + + int len_area = json_object_array_length(json_area_array); + HMI_DEBUG("wm:pm", "json_area_array len:%d", len_area); + HMI_DEBUG("wm:pm", "json_area_array dump:%s", json_object_get_string(json_area_array)); + + LayoutState layout_state; + AreaState area_state; + std::map<std::string, int> category_num; + for (int ctg_no = StmCtgNoMin; + ctg_no <= StmCtgNoMax; ctg_no++) + { + const char *ctg_name = kStmCategoryName[ctg_no]; + category_num[ctg_name] = 0; + } + + for (int j = 0; j < len_area; j++) + { + json_object *json_area = json_object_array_get_idx(json_area_array, j); + + // Get area name + const char *area = this->getStringFromJson(json_area, "name"); + if (nullptr == area) + { + HMI_ERROR("wm:pm", "Parse Error!!"); + return -1; + } + area_state.name = std::string(area); + HMI_DEBUG("wm:pm", ">> area:%s", area); + + // Get app attribute of the area + category = this->getStringFromJson(json_area, "category"); + if (nullptr == category) + { + HMI_ERROR("wm:pm", "Parse Error!!"); + return -1; + } + area_state.category = std::string(category); + category_num[category]++; + HMI_DEBUG("wm:pm", ">>> category:%s", category); + + role = this->getStringFromJson(json_area, "role"); + if (nullptr != role) + { + // Role is NOT essential here + area_state.role = std::string(role); + } + else + { + area_state.role = std::string(""); + } + HMI_DEBUG("wm:pm", ">>> role:%s", role); + + layout_state.area_list.push_back(area_state); + } + + layout_state.name = layout; + layout_state.category_num = category_num; + this->default_layouts[layout] = layout_state; + } + + // initialize for none layout + LayoutState none_layout_state; + memset(&none_layout_state, 0, sizeof(none_layout_state)); + none_layout_state.name = "none"; + this->default_layouts["none"] = none_layout_state; + + // Check + for (auto itr_layout = this->default_layouts.begin(); + itr_layout != this->default_layouts.end(); ++itr_layout) + { + HMI_DEBUG("wm:pm", ">>> layout:%s", itr_layout->first.c_str()); + + for (auto itr_area = itr_layout->second.area_list.begin(); + itr_area != itr_layout->second.area_list.end(); ++itr_area) + { + HMI_DEBUG("wm:pm", ">>> >>> area :%s", itr_area->name.c_str()); + HMI_DEBUG("wm:pm", ">>> >>> category:%s", itr_area->category.c_str()); + HMI_DEBUG("wm:pm", ">>> >>> role :%s", itr_area->role.c_str()); + } + } + + // Release json_object + json_object_put(json_obj); + + return 0; +} + +void PolicyManager::pushInvisibleRoleHistory(std::string category, std::string role) +{ + auto i = std::remove_if(this->invisible_role_history[category].begin(), + this->invisible_role_history[category].end(), + [role](std::string x) { return (role == x); }); + + if (this->invisible_role_history[category].end() != i) + { + this->invisible_role_history[category].erase(i); + } + + this->invisible_role_history[category].push_back(role); + + if (pm::kInvisibleRoleHistoryNum < invisible_role_history[category].size()) + { + this->invisible_role_history[category].erase( + this->invisible_role_history[category].begin()); + } +} + +std::string PolicyManager::popInvisibleRoleHistory(std::string category) +{ + std::string role; + if (invisible_role_history[category].empty()) + { + role = ""; + } + else + { + role = this->invisible_role_history[category].back(); + this->invisible_role_history[category].pop_back(); + } + return role; +} + +const char *PolicyManager::getStringFromJson(json_object *obj, const char *key) +{ + json_object *tmp; + if (!json_object_object_get_ex(obj, key, &tmp)) + { + HMI_DEBUG("wm:pm", "Not found key \"%s\"", key); + return nullptr; + } + + return json_object_get_string(tmp); +} + +int PolicyManager::inputJsonFilie(const char *file, json_object **obj) +{ + const int input_size = 128; + int ret = -1; + + HMI_DEBUG("wm:pm", "Input file: %s", file); + + // Open json file + FILE *fp = fopen(file, "rb"); + if (nullptr == fp) + { + HMI_ERROR("wm:pm", "Could not open file"); + return ret; + } + + // Parse file data + struct json_tokener *tokener = json_tokener_new(); + enum json_tokener_error json_error; + char buffer[input_size]; + int block_cnt = 1; + while (1) + { + size_t len = fread(buffer, sizeof(char), input_size, fp); + *obj = json_tokener_parse_ex(tokener, buffer, len); + if (nullptr != *obj) + { + HMI_DEBUG("wm:pm", "File input is success"); + ret = 0; + break; + } + + json_error = json_tokener_get_error(tokener); + if ((json_tokener_continue != json_error) || (input_size > len)) + { + HMI_ERROR("wm:pm", "Failed to parse file (byte:%d err:%s)", + (input_size * block_cnt), json_tokener_error_desc(json_error)); + HMI_ERROR("wm:pm", "\n%s", buffer); + *obj = nullptr; + break; + } + block_cnt++; + } + + // Close json file + fclose(fp); + + // Free json_tokener + json_tokener_free(tokener); + + return ret; +} + +void PolicyManager::dumpLayerState(std::unordered_map<std::string, LayerState> &layers) +{ + HMI_DEBUG("wm:pm", "-------------------------------------------------------------------------------------------------------"); + HMI_DEBUG("wm:pm", "|%-15s|%s|%-20s|%-20s|%-20s|%-20s|", + "LAYER", "C", "LAYOUT", "AREA", "CATEGORY", "ROLE"); + for (const auto &itr : layers) + { + LayerState ls = itr.second; + const char* layer = ls.name.c_str(); + const char* changed = (ls.changed) ? "T" : "f"; + const char* layout = ls.layout_state.name.c_str(); + bool first = true; + for (const auto &as : ls.layout_state.area_list) + { + if (first) + { + first = false; + HMI_DEBUG("wm:pm", "|%-15s|%1s|%-20s|%-20s|%-20s|%-20s|", + layer, changed, layout, + as.name.c_str(), as.category.c_str(), as.role.c_str()); + } + else + HMI_DEBUG("wm:pm", "|%-15s|%1s|%-20s|%-20s|%-20s|%-20s|", + "", "", "", as.name.c_str(), as.category.c_str(), as.role.c_str()); + } + } + HMI_DEBUG("wm:pm", "-------------------------------------------------------------------------------------------------------"); +} + +void PolicyManager::dumpInvisibleRoleHistory() +{ + HMI_DEBUG("wm:pm", ">>>>>>>>>> DUMP INVISIBLE ROLE HISTORY ( category [older > newer] )"); + for (int ctg_no = StmCtgNoMin; ctg_no <= StmCtgNoMax; ctg_no++) + { + if (ctg_no == StmCtgNoNone) + continue; + + std::string category = std::string(kStmCategoryName[ctg_no]); + + std::string str = category + " [ "; + for (const auto &i : this->invisible_role_history[category]) + str += (i + " > "); + + str += "]"; + HMI_DEBUG("wm:pm", "%s", str.c_str()); + } +} + +std::vector<std::string> PolicyManager::parseString(std::string str, char delimiter) +{ + // Parse string by delimiter + std::vector<std::string> vct; + std::stringstream ss{str}; + std::string buf; + while (std::getline(ss, buf, delimiter)) + { + if (!buf.empty()) + { + // Delete space and push back to vector + vct.push_back(this->deleteSpace(buf)); + } + } + return vct; +} + +std::string PolicyManager::deleteSpace(std::string str) +{ + std::string ret = str; + size_t pos; + while ((pos = ret.find_first_of(" ")) != std::string::npos) + { + ret.erase(pos, 1); + } + return ret; +} + +const char *PolicyManager::kDefaultRoleDb = "{ \ + \"roles\":[ \ + { \ + \"category\": \"homescreen\", \ + \"role\": \"homescreen\", \ + \"area\": \"fullscreen\", \ + }, \ + { \ + \"category\": \"map\", \ + \"role\": \"map\", \ + \"area\": \"normal.full | split.main\", \ + }, \ + { \ + \"category\": \"general\", \ + \"role\": \"launcher | poi | browser | sdl | mixer | radio | hvac | debug | phone | video | music\", \ + \"area\": \"normal.full\", \ + }, \ + { \ + \"category\": \"system\", \ + \"role\": \"settings | dashboard\", \ + \"area\": \"normal.full\", \ + }, \ + { \ + \"category\": \"software_keyboard\", \ + \"role\": \"software_keyboard\", \ + \"area\": \"software_keyboard\", \ + }, \ + { \ + \"category\": \"restriction\", \ + \"role\": \"restriction\", \ + \"area\": \"restriction.normal | restriction.split.main | restriction.split.sub\", \ + }, \ + { \ + \"category\": \"pop_up\", \ + \"role\": \"pop_up\", \ + \"area\": \"on_screen\", \ + }, \ + { \ + \"category\": \"system_alert\", \ + \"role\": \"system_alert\", \ + \"area\": \"on_screen\", \ + } \ + ] \ +}"; + +const char *PolicyManager::kDefaultStateDb = "{ \ + \"states\": [ \ + { \ + \"name\": \"homescreen\", \ + \"layer\": \"far_homescreen\", \ + \"areas\": [ \ + { \ + \"name\": \"fullscreen\", \ + \"category\": \"homescreen\" \ + } \ + ] \ + }, \ + { \ + \"name\": \"map.normal\", \ + \"layer\": \"apps\", \ + \"areas\": [ \ + { \ + \"name\": \"normal.full\", \ + \"category\": \"map\" \ + } \ + ] \ + }, \ + { \ + \"name\": \"map.split\", \ + \"layer\": \"apps\", \ + \"areas\": [ \ + { \ + \"name\": \"split.main\", \ + \"category\": \"map\" \ + }, \ + { \ + \"name\": \"split.sub\", \ + \"category\": \"splitable\" \ + } \ + ] \ + }, \ + { \ + \"name\": \"map.fullscreen\", \ + \"layer\": \"apps\", \ + \"areas\": [ \ + { \ + \"name\": \"fullscreen\", \ + \"category\": \"map\" \ + } \ + ] \ + }, \ + { \ + \"name\": \"splitable.normal\", \ + \"layer\": \"apps\", \ + \"areas\": [ \ + { \ + \"name\": \"normal.full\", \ + \"category\": \"splitable\" \ + } \ + ] \ + }, \ + { \ + \"name\": \"splitable.split\", \ + \"layer\": \"apps\", \ + \"areas\": [ \ + { \ + \"name\": \"split.main\", \ + \"category\": \"splitable\" \ + }, \ + { \ + \"name\": \"split.sub\", \ + \"category\": \"splitable\" \ + } \ + ] \ + }, \ + { \ + \"name\": \"general.normal\", \ + \"layer\": \"apps\", \ + \"areas\": [ \ + { \ + \"name\": \"normal.full\", \ + \"category\": \"general\" \ + } \ + ] \ + }, \ + { \ + \"name\": \"system.normal\", \ + \"layer\": \"apps\", \ + \"areas\": [ \ + { \ + \"name\": \"normal.full\", \ + \"category\": \"system\" \ + } \ + ] \ + }, \ + { \ + \"name\": \"software_keyboard\", \ + \"layer\": \"near_homescreen\", \ + \"areas\": [ \ + { \ + \"name\": \"software_keyboard\", \ + \"category\": \"software_keyboard\" \ + } \ + ] \ + }, \ + { \ + \"name\": \"restriction.normal\", \ + \"layer\": \"restriction\", \ + \"areas\": [ \ + { \ + \"name\": \"restriction.normal\", \ + \"category\": \"restriction\" \ + } \ + ] \ + }, \ + { \ + \"name\": \"restriction.split.main\", \ + \"layer\": \"restriction\", \ + \"areas\": [ \ + { \ + \"name\": \"restriction.split.main\", \ + \"category\": \"restriction\" \ + } \ + ] \ + }, \ + { \ + \"name\": \"restriction.split.sub\", \ + \"layer\": \"restriction\", \ + \"areas\": [ \ + { \ + \"name\": \"restriction.split.sub\", \ + \"category\": \"restriction\" \ + } \ + ] \ + }, \ + { \ + \"name\": \"pop_up\", \ + \"layer\": \"on_screen\", \ + \"areas\": [ \ + { \ + \"name\": \"on_screen\", \ + \"category\": \"pop_up\" \ + } \ + ] \ + }, \ + { \ + \"name\": \"system_alert\", \ + \"layer\": \"on_screen\", \ + \"areas\": [ \ + { \ + \"name\": \"on_screen\", \ + \"category\": \"system_alert\" \ + } \ + ] \ + } \ + ] \ +}"; diff --git a/policy_manager/policy_manager.hpp b/policy_manager/policy_manager.hpp new file mode 100644 index 0000000..798b706 --- /dev/null +++ b/policy_manager/policy_manager.hpp @@ -0,0 +1,149 @@ +/* + * Copyright (c) 2018 TOYOTA MOTOR CORPORATION + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef TMCAGLWM_POLICY_MANAGER_HPP +#define TMCAGLWM_POLICY_MANAGER_HPP + +#include <functional> +#include <unordered_map> +#include <vector> +#include <queue> + +struct json_object; +struct sd_event; +struct sd_event_source; +struct StmState; + +class PolicyManager +{ + public: + explicit PolicyManager(); + ~PolicyManager() = default; + + using Handler = std::function<void(json_object *)>; + + typedef struct + { + Handler onStateTransitioned; + Handler onError; + } CallbackTable; + + int initialize(); + void registerCallback(CallbackTable callback_table); + int setInputEventData(json_object *json_in); + int executeStateTransition(); + void undoState(); + + // Do not use these functions + int transitionState(sd_event_source *source, void *data); + int timerEvent(sd_event_source *source, uint64_t usec, void *data); + + private: + // Disable copy and move + PolicyManager(PolicyManager const &) = delete; + PolicyManager &operator=(PolicyManager const &) = delete; + PolicyManager(PolicyManager &&) = delete; + PolicyManager &operator=(PolicyManager &&) = delete; + + typedef struct EventInfo + { + int event; + std::string role; + uint64_t delay; + } EventInfo; + + typedef struct AreaState + { + std::string name; + std::string category; + std::string role; + } AreaState; + + typedef std::vector<AreaState> AreaList; + typedef struct LayoutState + { + std::string name; + std::map<std::string, int> category_num; + AreaList area_list; + } LayoutState; + + typedef struct LayerState + { + std::string name; + LayoutState layout_state; + bool changed; + } LayerState; + + typedef std::vector<std::string> Areas; + typedef std::vector<std::string> Categories; + typedef std::vector<std::string> Roles; + + // Convert map + std::unordered_map<std::string, int> eventname2no; + std::unordered_map<std::string, int> categoryname2no; + std::unordered_map<std::string, int> areaname2no; + + std::unordered_map<std::string, std::string> role2category; + std::unordered_map<std::string, std::string> category2role; + std::unordered_map<std::string, Areas> category2areas; + std::unordered_map<std::string, Categories> layer2categories; + + std::queue<EventInfo> event_info_queue; + std::map<int, struct sd_event_source *> event_source_list; + std::map<int, std::string> req_role_list; + + CallbackTable callback; + + std::unordered_map<std::string, LayerState> prv_layers; + std::unordered_map<std::string, LayerState> crr_layers; + + std::unordered_map<std::string, LayoutState> default_layouts; + + std::map<std::string, Roles> invisible_role_history; + + void initializeState(); + void initializeLayerState(); + void updateState(int event_id, StmState crr_state); + void updateLayer(int event_id, StmState crr_state); + int updateLayout(int event_id, int layer_no, + std::string crr_layout_name, LayoutState &crr_layout_state); + void createOutputInformation(StmState crr_state, json_object **json_out); + int setStateTransitionProcessToSystemd(int event, uint64_t delay_ms, std::string role); + + void pushInvisibleRoleHistory(std::string category, std::string role); + std::string popInvisibleRoleHistory(std::string category); + + int loadRoleDb(); + int loadStateDb(); + + void dumpLayerState(std::unordered_map<std::string, LayerState> &layers); + void dumpInvisibleRoleHistory(); + + void addStateToJson(const char *name, bool changed, + std::string state, json_object **json_out); + void addStateToJson(const char *layer_name, bool changed, + AreaList area_list, json_object **json_out); + const char *getStringFromJson(json_object *obj, const char *key); + int inputJsonFilie(const char *file, json_object **obj); + + std::vector<std::string> parseString(std::string str, char delimiter); + std::string deleteSpace(std::string str); + + static const char *kDefaultRoleDb; + static const char *kDefaultStateDb; +}; + +#endif // TMCAGLWM_POLICY_MANAGER_HPP diff --git a/policy_manager/stm/stm.c b/policy_manager/stm/stm.c new file mode 100644 index 0000000..c63a599 --- /dev/null +++ b/policy_manager/stm/stm.c @@ -0,0 +1,118 @@ +/* + * Copyright (c) 2018 TOYOTA MOTOR CORPORATION + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include <string.h> +#include "stm.h" +#include "stm_inner.h" + +const char* kStmEventName[] = { + "none", + "activate", + "deactivate", + "restriction_mode_off", + "restriction_mode_1_on", + "restriction_mode_2_on", + "undo", +}; + +const char* kStmCategoryName[] = { + "none", + "homescreen", + "map", + "general", + "splitable", + "pop_up", + "system_alert", + "restriction", + "system", + "software_keyboard", + "debug", +}; + +const char* kStmAreaName[] = { + "none", + "fullscreen", + "normal.full", + "split.main", + "split.sub", + "on_screen", + "restriction.normal", + "restriction.split.main", + "restriction.split.sub", + "software_keyboard", +}; + +const char* kStmLayoutName[] = { + "none", + "pop_up", + "system_alert", + "map.normal", + "map.split", + "map.fullscreen", + "splitable.normal", + "splitable.split", + "general.normal", + "homescreen", + "restriction.normal", + "restriction.split.main", + "restriction.split.sub", + "system.normal", + "software_keyboard", + "debug.normal", + "debug.split.main", + "debug.split.sub", + "debug.fullscreen", +}; + +const char* kStmLayerName[] = { + "homescreen", + "apps", + "near_homescreen", + "restriction", + "on_screen", +}; + +const char* kStmModeName[] = { + "trans_gear", + "parking_brake", + "accel_pedal", + "running", + "lamp", + "lightstatus_brake", + "restriction_mode", +}; + +const char* kStmRestrictionModeStateName[] = { + "off", + "1on", + "2on", +}; + +const char** kStmModeStateNameList[] = { + kStmRestrictionModeStateName, +}; + +void stmInitialize() { + stmInitializeInner(); +} + +int stmTransitionState(int event, StmState* state) { + return stmTransitionStateInner(event, state); +} + +void stmUndoState() { + stmUndoStateInner(); +} diff --git a/policy_manager/stm/stm.h b/policy_manager/stm/stm.h new file mode 100644 index 0000000..deebf9c --- /dev/null +++ b/policy_manager/stm/stm.h @@ -0,0 +1,175 @@ +/* + * Copyright (c) 2018 TOYOTA MOTOR CORPORATION + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef TMCAGLWM_STM_HPP +#define TMCAGLWM_STM_HPP + +#define STM_TRUE 1 +#define STM_FALSE 0 + +#define STM_CREATE_EVENT_ID(evt, ctg, area) \ + ((evt) | ((ctg) << 8) | ((area) << 16)) + +#define STM_GET_EVENT_FROM_ID(id) \ + ((id) & 0xFF) + +#define STM_GET_CATEGORY_FROM_ID(id) \ + (((id) >> 8) & 0xFF) + +#define STM_GET_AREA_FROM_ID(id) \ + (((id) >> 16) & 0xFF) + +// Event number +enum StmEvtNo { + StmEvtNoNone = 0, + StmEvtNoActivate, + StmEvtNoDeactivate, + StmEvtNoRestrictionModeOff, + StmEvtNoRestrictionMode1On, + StmEvtNoRestrictionMode2On, + StmEvtNoUndo, + + StmEvtNoNum, + + StmEvtNoMin = StmEvtNoNone, + StmEvtNoMax = StmEvtNoNum - 1, +}; + +// Category number +enum StmCtgNo { + StmCtgNoNone = 0, + StmCtgNoHomescreen, + StmCtgNoMap, + StmCtgNoGeneral, + StmCtgNoSplitable, + StmCtgNoPopUp, + StmCtgNoSystemAlert, + StmCtgNoRestriction, + StmCtgNoSystem, + StmCtgNoSoftwareKeyboard, + StmCtgNoDebug, + + StmCtgNoNum, + + StmCtgNoMin = StmCtgNoNone, + StmCtgNoMax = StmCtgNoNum - 1, +}; + +// Area number +enum StmAreaNo { + StmAreaNoNone = 0, + StmAreaNoFullscreen, + StmAreaNoNormal, + StmAreaNoSplitMain, + StmAreaNoSplitSub, + StmAreaNoOnScreen, + StmAreaNoRestrictionNormal, + StmAreaNoRestrictionSplitMain, + StmAreaNoRestrictionSplitSub, + StmAreaNoSoftwareKyeboard, + + StmAreaNoNum, + + StmAreaNoMin = StmAreaNoNone, + StmAreaNoMax = StmAreaNoNum - 1, +}; + +// Layer number +enum StmLayerNo { + StmLayerNoHomescreen = 0, + StmLayerNoApps, + StmLayerNoNearHomescreen, + StmLayerNoRestriction, + StmLayerNoOnScreen, + + StmLayerNoNum, + + StmLayerNoMin = StmLayerNoHomescreen, + StmLayerNoMax = StmLayerNoNum - 1, +}; + +// Layout kind number +enum StmLayoutNo { + StmLayoutNoNone = 0, + StmLayoutNoPopUp, + StmLayoutNoSysAlt, + StmLayoutNoMapNml, + StmLayoutNoMapSpl, + StmLayoutNoMapFll, + StmLayoutNoSplNml, + StmLayoutNoSplSpl, + StmLayoutNoGenNml, + StmLayoutNoHms, + StmLayoutNoRstNml, + StmLayoutNoRstSplMain, + StmLayoutNoRstSplSub, + StmLayoutNoSysNml, + StmLayoutNoSftKbd, + StmLayoutNoDbgNml, + StmLayoutNoDbgSplMain, + StmLayoutNoDbgSplSub, + StmLayoutNoDbgFll, + + StmLayoutNoNum, + + StmLayoutNoMin = StmLayoutNoNone, + StmLayoutNoMax = StmLayoutNoNum - 1, +}; + +// Mode kind number +enum StmModeNo { + StmModeNoRestrictionMode = 0, + + StmModeNoNum, + + StmModeNoMin = StmModeNoRestrictionMode, + StmModeNoMax = StmModeNoNum - 1, +}; + +// Enum for mode state +enum StmRestrictionModeSttNo { + StmRestrictionModeSttNoOff = 0, + StmRestrictionModeSttNo1On, + StmRestrictionModeSttNo2On, +}; + +// String for state +extern const char* kStmEventName[]; +extern const char* kStmCategoryName[]; +extern const char* kStmAreaName[]; +extern const char* kStmLayoutName[]; +extern const char* kStmLayerName[]; +extern const char* kStmModeName[]; +extern const char** kStmModeStateNameList[]; + +// Struct for state +typedef struct StmBaseState { + int changed; + int state; +} StmBaseState; + +typedef struct StmState { + StmBaseState mode[StmModeNoNum]; + StmBaseState layer[StmLayerNoNum]; +} StmState; + +// API +void stmInitialize(); +int stmTransitionState(int event_no, StmState* state); +void stmUndoState(); + + +#endif // TMCAGLWM_STM_HPP diff --git a/policy_manager/stm/stub/CMakeLists.txt b/policy_manager/stm/stub/CMakeLists.txt new file mode 100644 index 0000000..81f0e00 --- /dev/null +++ b/policy_manager/stm/stub/CMakeLists.txt @@ -0,0 +1,44 @@ +# +# Copyright (c) 2017 TOYOTA MOTOR CORPORATION +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +# + +set(TARGETS_STM pmstm) + +add_library(${TARGETS_STM} + STATIC + ./stm_inner.c +) + +target_include_directories(${TARGETS_STM} + PRIVATE + ../ + ./ +) + +target_compile_definitions(${TARGETS_STM} + PRIVATE + _GNU_SOURCE +) + +target_compile_options(${TARGETS_STM} + PRIVATE + -Wall -Wextra -Wno-unused-parameter -Wno-comment) + +set_target_properties(${TARGETS_STM} + PROPERTIES + C_EXTENSIONS OFF + C_STANDARD 99 + C_STANDARD_REQUIRED ON +) diff --git a/policy_manager/stm/stub/stm_inner.c b/policy_manager/stm/stub/stm_inner.c new file mode 100644 index 0000000..bd1b319 --- /dev/null +++ b/policy_manager/stm/stub/stm_inner.c @@ -0,0 +1,151 @@ +/* + * Copyright (c) 2018 TOYOTA MOTOR CORPORATION + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include <string.h> +#include "stm.h" +#include "stm_inner.h" + +static StmState g_stm_crr_state; +static StmState g_stm_prv_state; + +void stmInitializeInner() { + // Initialize previous state + memset(&g_stm_prv_state, 0, sizeof(g_stm_prv_state)); + + // Initialize current state + g_stm_crr_state = g_stm_prv_state; +} + +int stmTransitionStateInner(int event, StmState* state) { + int event_no, category_no, area_no; + + event_no = STM_GET_EVENT_FROM_ID(event); + category_no = STM_GET_CATEGORY_FROM_ID(event); + area_no = STM_GET_AREA_FROM_ID(event); + + // Backup previous state + g_stm_prv_state = g_stm_crr_state; + + // ------------------------------------------------------- + // There is no policy table by default. + // Therefore update each layers + // to draw the applications in requested area + // in accordance with inputed activate/deactivate events. + // ------------------------------------------------------- + if (StmEvtNoActivate == event_no) + { + if (StmCtgNoHomescreen == category_no) + { + g_stm_crr_state.layer[StmLayerNoHomescreen].state = StmLayoutNoHms; + g_stm_crr_state.layer[StmLayerNoHomescreen].changed = STM_TRUE; + + // For AGL JIRA SPEC-1407 + // Apps layer is invisibled only when Homescreen app is started already + if (StmLayoutNoHms == g_stm_prv_state.layer[StmLayerNoHomescreen].state) + { + g_stm_crr_state.layer[StmLayerNoApps].state = StmLayoutNoNone; + g_stm_crr_state.layer[StmLayerNoApps].changed = STM_TRUE; + } + } + else if (StmCtgNoDebug == category_no) + { + if (StmAreaNoNormal == area_no) + { + g_stm_crr_state.layer[StmLayerNoApps].state = StmLayoutNoDbgNml; + } + else if (StmAreaNoSplitMain == area_no) + { + g_stm_crr_state.layer[StmLayerNoApps].state = StmLayoutNoDbgSplMain; + } + else if (StmAreaNoSplitSub == area_no) + { + g_stm_crr_state.layer[StmLayerNoApps].state = StmLayoutNoDbgSplSub; + } + else if (StmAreaNoFullscreen == area_no) + { + g_stm_crr_state.layer[StmLayerNoApps].state = StmLayoutNoDbgFll; + } + g_stm_crr_state.layer[StmLayerNoApps].changed = STM_TRUE; + } + else if (StmCtgNoSoftwareKeyboard == category_no) + { + g_stm_crr_state.layer[StmLayerNoNearHomescreen].state = StmLayoutNoSftKbd; + g_stm_crr_state.layer[StmLayerNoNearHomescreen].changed = STM_TRUE; + } + else if (StmCtgNoPopUp == category_no) + { + g_stm_crr_state.layer[StmLayerNoOnScreen].state = StmLayoutNoPopUp; + g_stm_crr_state.layer[StmLayerNoOnScreen].changed = STM_TRUE; + } + else if (StmCtgNoSystemAlert == category_no) + { + g_stm_crr_state.layer[StmLayerNoOnScreen].state = StmLayoutNoSysAlt; + g_stm_crr_state.layer[StmLayerNoOnScreen].changed = STM_TRUE; + } + } + else if (StmEvtNoDeactivate == event_no) + { + if (StmCtgNoHomescreen == category_no) + { + g_stm_crr_state.layer[StmLayerNoHomescreen].state = StmLayoutNoNone; + g_stm_crr_state.layer[StmLayerNoHomescreen].changed = STM_TRUE; + } + else if (StmCtgNoDebug == category_no) + { + if ((StmLayoutNoDbgNml == g_stm_prv_state.layer[StmLayerNoApps].state) || + (StmLayoutNoDbgSplMain == g_stm_prv_state.layer[StmLayerNoApps].state) || + (StmLayoutNoDbgSplSub == g_stm_prv_state.layer[StmLayerNoApps].state) || + (StmLayoutNoDbgFll == g_stm_prv_state.layer[StmLayerNoApps].state)) + { + g_stm_crr_state.layer[StmLayerNoApps].state = StmLayoutNoNone; + g_stm_crr_state.layer[StmLayerNoApps].changed = STM_TRUE; + } + } + else if (StmCtgNoSoftwareKeyboard == category_no) + { + if (StmLayoutNoSftKbd == g_stm_prv_state.layer[StmLayerNoNearHomescreen].state ) + { + g_stm_crr_state.layer[StmLayerNoNearHomescreen].state = StmLayoutNoNone; + g_stm_crr_state.layer[StmLayerNoNearHomescreen].changed = STM_TRUE; + } + } + else if (StmCtgNoPopUp == category_no) + { + if (StmLayoutNoPopUp == g_stm_prv_state.layer[StmLayerNoOnScreen].state ) + { + g_stm_crr_state.layer[StmLayerNoOnScreen].state = StmLayoutNoNone; + g_stm_crr_state.layer[StmLayerNoOnScreen].changed = STM_TRUE; + } + } + else if (StmCtgNoSystemAlert == category_no) + { + if (StmLayoutNoSysAlt == g_stm_prv_state.layer[StmLayerNoOnScreen].state ) + { + g_stm_crr_state.layer[StmLayerNoOnScreen].state = StmLayoutNoNone; + g_stm_crr_state.layer[StmLayerNoOnScreen].changed = STM_TRUE; + } + } + } + + // Copy current state for return + memcpy(state, &g_stm_crr_state, sizeof(g_stm_crr_state)); + + return 0; +} + +void stmUndoStateInner() { + g_stm_crr_state = g_stm_prv_state; +} diff --git a/policy_manager/stm/stub/stm_inner.h b/policy_manager/stm/stub/stm_inner.h new file mode 100644 index 0000000..7079447 --- /dev/null +++ b/policy_manager/stm/stub/stm_inner.h @@ -0,0 +1,27 @@ +/* + * Copyright (c) 2018 TOYOTA MOTOR CORPORATION + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef TMCAGLWM_STM_INNER_HPP +#define TMCAGLWM_STM_INNER_HPP + +struct StmState; + +// API +void stmInitializeInner(); +int stmTransitionStateInner(int event_no, StmState* state); +void stmUndoStateInner(); + +#endif // TMCAGLWM_STM_INNER_HPP diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt index 42b81b7..3c8da4c 100644 --- a/src/CMakeLists.txt +++ b/src/CMakeLists.txt @@ -37,20 +37,23 @@ add_library(${TARGETS_WM} MODULE wm_client.cpp wm_error.cpp applist.cpp - request.cpp) + request.cpp + pm_wrapper.cpp) target_include_directories(${TARGETS_WM} PRIVATE ${AFB_INCLUDE_DIRS} ${SD_INCLUDE_DIRS} ../include - ../src) + ../src + ../${PLUGIN_PM}) target_link_libraries(${TARGETS_WM} PRIVATE ${AFB_LIBRARIES} ${WLC_LIBRARIES} - ${SD_LIBRARIES}) + ${SD_LIBRARIES} + ${PLUGIN_PM}) target_compile_definitions(${TARGETS_WM} PRIVATE @@ -82,12 +85,12 @@ set_target_properties(${TARGETS_WM} C_STANDARD 99 C_STANDARD_REQUIRED ON - LINK_FLAGS "-Wl,--version-script=${CMAKE_CURRENT_SOURCE_DIR}/../export.map") + LINK_FLAGS "-Wl,--version-script=${CMAKE_CURRENT_SOURCE_DIR}/../export.map -Wl,-rpath,'$ORIGIN'") if (LINK_LIBCXX) set_target_properties(${TARGETS_WM} PROPERTIES - LINK_FLAGS "-Wl,--version-script=${CMAKE_CURRENT_SOURCE_DIR}/../export.map -lc++") + LINK_FLAGS "-Wl,--version-script=${CMAKE_CURRENT_SOURCE_DIR}/../export.map -lc++ -Wl,-rpath,'$ORIGIN'") endif() if (NOT ${SANITIZER_MODE} STREQUAL "none" AND NOT ${SANITIZER_MODE} STREQUAL "") diff --git a/src/json_helper.cpp b/src/json_helper.cpp index c2f4173..b97f21d 100644 --- a/src/json_helper.cpp +++ b/src/json_helper.cpp @@ -136,6 +136,18 @@ int getIntFromJson(json_object *obj, const char *key) return json_object_get_int(tmp); } +json_bool getBoolFromJson(json_object *obj, const char *key) +{ + json_object *tmp; + if (!json_object_object_get_ex(obj, key, &tmp)) + { + HMI_DEBUG("wm:jh", "Not found key \"%s\"", key); + return FALSE; + } + + return json_object_get_boolean(tmp); +} + int inputJsonFilie(const char* file, json_object** obj) { const int input_size = 128; diff --git a/src/json_helper.hpp b/src/json_helper.hpp index 2f6b817..5333130 100644 --- a/src/json_helper.hpp +++ b/src/json_helper.hpp @@ -30,6 +30,7 @@ json_object *to_json(std::vector<uint32_t> const &v); namespace jh { const char* getStringFromJson(json_object* obj, const char* key); int getIntFromJson(json_object *obj, const char *key); +json_bool getBoolFromJson(json_object *obj, const char *key); int inputJsonFilie(const char* file, json_object** obj); } // namespace jh diff --git a/src/main.cpp b/src/main.cpp index 261df8b..0447f86 100644 --- a/src/main.cpp +++ b/src/main.cpp @@ -184,27 +184,19 @@ static void cbRemoveClientCtxt(void *data) return; } HMI_DEBUG("wm", "remove app %s", ctxt->name.c_str()); - // Lookup surfaceID and remove it because App is dead. - auto pSid = g_afb_instance->wmgr.id_alloc.lookup(ctxt->role.c_str()); - if (pSid) - { - auto sid = *pSid; - auto o_state = *g_afb_instance->wmgr.layers.get_layout_state(sid); - if (o_state != nullptr) - { - if (o_state->main == sid) - { - o_state->main = -1; - } - else if (o_state->sub == sid) + + // Policy Manager does not know this app was killed, + // so notify it by deactivate request. + g_afb_instance->wmgr.api_deactivate_surface( + ctxt->name.c_str(), ctxt->role.c_str(), + [](const char *errmsg) { + if (errmsg != nullptr) { - o_state->sub = -1; + HMI_ERROR("wm", errmsg); + return; } - } - g_afb_instance->wmgr.id_alloc.remove_id(sid); - g_afb_instance->wmgr.layers.remove_surface(sid); - HMI_DEBUG("wm", "delete surfaceID %d", sid); - } + }); + g_afb_instance->wmgr.removeClient(ctxt->name); delete ctxt; } diff --git a/src/pm_wrapper.cpp b/src/pm_wrapper.cpp new file mode 100644 index 0000000..1454bf9 --- /dev/null +++ b/src/pm_wrapper.cpp @@ -0,0 +1,261 @@ +/* + * Copyright (c) 2018 TOYOTA MOTOR CORPORATION + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include "pm_wrapper.hpp" +#include "json_helper.hpp" +#include "hmi-debug.h" + +namespace wm +{ + +static PMWrapper *g_context; + +namespace +{ + +static void onStateTransitioned(json_object *json_out) +{ + g_context->updateStates(json_out); +} + +static void onError(json_object *json_out) +{ + HMI_DEBUG("wm", "error message from PolicyManager:%s", + json_object_get_string(json_out)); + + g_context->processError(); +} + +} // namespace + +PMWrapper::PMWrapper() {} + +int PMWrapper::initialize() +{ + int ret = 0; + + ret = this->pm.initialize(); + if (0 > ret) + { + HMI_ERROR("wm:pmw", "Faild to initialize PolicyManager"); + } + + g_context = this; + + return ret; +} + +void PMWrapper::registerCallback(StateTransitionHandler on_state_transitioned, + ErrorHandler on_error) +{ + this->on_state_transitioned = on_state_transitioned; + this->on_error = on_error; + + PolicyManager::CallbackTable my_callback; + my_callback.onStateTransitioned = onStateTransitioned; + my_callback.onError = onError; + this->pm.registerCallback(my_callback); +} + +int PMWrapper::setInputEventData(Task task, std::string role, std::string area) +{ + const char* event; + if (Task::TASK_ALLOCATE == task) + { + event = "activate"; + } + else if (Task::TASK_RELEASE == task) + { + event = "deactivate"; + } + else + { + event = ""; + } + + json_object *json_in = json_object_new_object(); + json_object_object_add(json_in, "event", json_object_new_string(event)); + json_object_object_add(json_in, "role", json_object_new_string(role.c_str())); + json_object_object_add(json_in, "area", json_object_new_string(area.c_str())); + + int ret; + ret = this->pm.setInputEventData(json_in); + if (0 > ret) + { + HMI_ERROR("wm:pmw", "Faild to set input event data to PolicyManager"); + } + json_object_put(json_in); + + return ret; +} + +int PMWrapper::executeStateTransition() +{ + int ret; + ret = this->pm.executeStateTransition(); + if (0 > ret) + { + HMI_ERROR("wm:pmw", "Failed to execute state transition for PolicyManager"); + } + + return ret; +} + +void PMWrapper::undoState() +{ + this->pm.undoState(); + + this->crrlayer2rolestate = this->prvlayer2rolestate; +} + +void PMWrapper::updateStates(json_object *json_out) +{ + std::vector<WMAction> actions; + + HMI_DEBUG("wm", "json_out dump:%s", json_object_get_string(json_out)); + + this->createLayoutChangeAction(json_out, actions); + + this->on_state_transitioned(actions); +} + +void PMWrapper::createLayoutChangeAction(json_object *json_out, std::vector<WMAction> &actions) +{ + // Get displayed roles from previous layout + json_object *json_layers; + if (!json_object_object_get_ex(json_out, "layers", &json_layers)) + { + HMI_DEBUG("wm", "Not found key \"layers\""); + return; + } + + int len = json_object_array_length(json_layers); + HMI_DEBUG("wm", "json_layers len:%d", len); + + for (int i = 0; i < len; i++) + { + json_object *json_tmp = json_object_array_get_idx(json_layers, i); + + std::string layer_name = jh::getStringFromJson(json_tmp, "name"); + json_bool changed = jh::getBoolFromJson(json_tmp, "changed"); + HMI_DEBUG("wm", "layer:%s changed:%d", layer_name.c_str(), changed); + + if (changed) + { + json_object *json_areas; + if (!json_object_object_get_ex(json_tmp, "areas", &json_areas)) + { + HMI_DEBUG("wm", "Not found key \"areas\""); + return; + } + + int len = json_object_array_length(json_areas); + HMI_DEBUG("wm", "json_layers len:%d", len); + + // Store previous role state in this layer + this->prvlayer2rolestate[layer_name] = this->crrlayer2rolestate[layer_name]; + + RoleState crr_roles; + RoleState prv_roles = this->prvlayer2rolestate[layer_name]; + for (int j = 0; j < len; j++) + { + json_object *json_tmp2 = json_object_array_get_idx(json_areas, j); + + std::string area_name = jh::getStringFromJson(json_tmp2, "name"); + std::string role_name = jh::getStringFromJson(json_tmp2, "role"); + + crr_roles[role_name] = area_name; + + auto i_prv = prv_roles.find(role_name); + HMI_DEBUG("wm", "current role:%s area:%s", + role_name.c_str(), area_name.c_str()); + + // If current role does not exist in previous + if (prv_roles.end() == i_prv) + { + HMI_DEBUG("wm", "current role does not exist in previous"); + + // Set activate action + bool end_draw_finished = false; + WMAction act + { + "", + role_name, + area_name, + TaskVisible::VISIBLE, + end_draw_finished + }; + actions.push_back(act); + } + else + { + HMI_DEBUG("wm", "previous role:%s area:%s", + i_prv->first.c_str(), i_prv->second.c_str()); + + // If current role exists in previous and area is different with previous + if (area_name != i_prv->second) + { + HMI_DEBUG("wm", "current role exists in previous and area is different with previous"); + + // Set activate action + bool end_draw_finished = false; + WMAction act + { + "", + role_name, + area_name, + TaskVisible::VISIBLE, + end_draw_finished + }; + actions.push_back(act); + } + + // Remove role which exist in current list from previous list + prv_roles.erase(i_prv); + } + } + + // Deactivate roles which remains in previous list + // because these are not displayed in current layout + for (auto i_prv : prv_roles) + { + HMI_DEBUG("wm", "Deactivate role:%s", i_prv.first.c_str()); + + // Set deactivate action + bool end_draw_finished = true; + WMAction act + { + "", + i_prv.first, + "", + TaskVisible::INVISIBLE, + end_draw_finished + }; + actions.push_back(act); + } + + // Update previous role list + this->crrlayer2rolestate[layer_name] = crr_roles; + } + } +} + +void PMWrapper::processError() +{ + this->on_error(); +} + +} // namespace wm diff --git a/src/pm_wrapper.hpp b/src/pm_wrapper.hpp new file mode 100644 index 0000000..31ec002 --- /dev/null +++ b/src/pm_wrapper.hpp @@ -0,0 +1,75 @@ +/* + * Copyright (c) 2018 TOYOTA MOTOR CORPORATION + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef TMCAGLWM_PM_WRAPPER_HPP +#define TMCAGLWM_PM_WRAPPER_HPP + +#include <functional> +#include <vector> +#include <string> +#include <map> +#include "policy_manager.hpp" +#include "request.hpp" + +struct json_object; +struct sd_event; +struct sd_event_source; +struct StmState; + +namespace wm +{ + +class PMWrapper +{ + public: + explicit PMWrapper(); + ~PMWrapper() = default; + + using StateTransitionHandler = std::function<void(std::vector<WMAction>)>; + using ErrorHandler = std::function<void(void)>; + + int initialize(); + void registerCallback(StateTransitionHandler on_state_transitioned, + ErrorHandler on_error); + int setInputEventData(Task task, std::string role, std::string area); + int executeStateTransition(); + void undoState(); + + // Do not use these functions + void updateStates(json_object *json_out); + void processError(); + + private: + // Disable copy and move + PMWrapper(PMWrapper const &) = delete; + PMWrapper &operator=(PMWrapper const &) = delete; + PMWrapper(PMWrapper &&) = delete; + PMWrapper &operator=(PMWrapper &&) = delete; + + typedef std::map<std::string, std::string> RoleState; + + PolicyManager pm; + StateTransitionHandler on_state_transitioned; + ErrorHandler on_error; + std::map<std::string, RoleState> prvlayer2rolestate; + std::map<std::string, RoleState> crrlayer2rolestate; + + void createLayoutChangeAction(json_object *json_out, std::vector<WMAction> &actions); +}; + +} // namespace wm + +#endif // TMCAGLWM_PM_WRAPPER_HPP diff --git a/src/window_manager.cpp b/src/window_manager.cpp index aa42d82..24b6f30 100644 --- a/src/window_manager.cpp +++ b/src/window_manager.cpp @@ -55,6 +55,7 @@ const char kKeyIds[] = "ids"; static sd_event_source *g_timer_ev_src = nullptr; static AppList g_app_list; +static WindowManager *g_context; namespace { @@ -99,6 +100,15 @@ static int processTimerHandler(sd_event_source *s, uint64_t usec, void *userdata return 0; } +static void onStateTransitioned(std::vector<WMAction> actions) +{ + g_context->startTransitionWrapper(actions); +} + +static void onError() +{ + g_context->processError(WMError::LAYOUT_CHANGE_FAIL); +} } // namespace /** @@ -163,6 +173,15 @@ int WindowManager::init() // Load old_role.db this->loadOldRoleDb(); + // Store my context for calling callback from PolicyManager + g_context = this; + + // Initialize PMWrapper + this->pmw.initialize(); + + // Register callback to PolicyManager + this->pmw.registerCallback(onStateTransitioned, onError); + // Make afb event for (int i = Event_Val_Min; i <= Event_Val_Max; i++) { @@ -444,6 +463,9 @@ void WindowManager::api_enddraw(char const *appid, char const *drawing_name) if(ret != WMError::SUCCESS) { //this->emit_error(); + + // Undo state of PolicyManager + this->pmw.undoState(); } this->emitScreenUpdated(current_req); HMI_SEQ_INFO(current_req, "Finish request status: %s", errorDescription(ret)); @@ -506,18 +528,6 @@ result<json_object *> WindowManager::api_get_area_info(char const *drawing_name) return Err<json_object *>("Surface is not on any layer!"); } - auto o_state = *this->layers.get_layout_state(*surface_id); - if (o_state == nullptr) - { - return Err<json_object *>("Could not find layer for surface"); - } - - struct LayoutState &state = *o_state; - if ((state.main != *surface_id) && (state.sub != *surface_id)) - { - return Err<json_object *>("Surface is inactive"); - } - // Set area rectangle compositor::rect area_info = this->area_info[*surface_id]; json_object *object = json_object_new_object(); @@ -592,7 +602,9 @@ void WindowManager::surface_created(uint32_t surface_id) void WindowManager::surface_removed(uint32_t surface_id) { - HMI_DEBUG("wm", "surface_id is %u", surface_id); + HMI_DEBUG("wm", "Delete surface_id %u", surface_id); + this->id_alloc.remove_id(surface_id); + this->layers.remove_surface(surface_id); g_app_list.removeSurface(surface_id); } @@ -620,6 +632,94 @@ void WindowManager::timerHandler() this->processNextRequest(); } +void WindowManager::startTransitionWrapper(std::vector<WMAction> &actions) +{ + WMError ret; + unsigned req_num = g_app_list.currentRequestNumber(); + + if (actions.empty()) + { + if (g_app_list.haveRequest()) + { + HMI_SEQ_DEBUG(req_num, "There is no WMAction for this request"); + goto proc_remove_request; + } + else + { + HMI_SEQ_DEBUG(req_num, "There is no request"); + return; + } + } + + for (auto &act : actions) + { + if ("" != act.role) + { + bool found; + auto const &surface_id = this->lookup_id(act.role.c_str()); + std::string appid = g_app_list.getAppID(*surface_id, act.role, &found); + if (!found) + { + if (TaskVisible::INVISIBLE == act.visible) + { + // App is killed, so do not set this action + continue; + } + else + { + HMI_SEQ_ERROR(req_num, "appid which is visible is not found"); + ret = WMError::FAIL; + goto error; + } + } + act.appid = appid; + } + + ret = g_app_list.setAction(req_num, act); + if (ret != WMError::SUCCESS) + { + HMI_SEQ_ERROR(req_num, "Setting action is failed"); + goto error; + } + } + + HMI_SEQ_DEBUG(req_num, "Start transition."); + ret = this->startTransition(req_num); + if (ret != WMError::SUCCESS) + { + if (ret == WMError::NO_LAYOUT_CHANGE) + { + goto proc_remove_request; + } + else + { + HMI_SEQ_ERROR(req_num, "Transition state is failed"); + goto error; + } + } + + return; + +error: + //this->emit_error() + HMI_SEQ_ERROR(req_num, errorDescription(ret)); + this->pmw.undoState(); + +proc_remove_request: + g_app_list.removeRequest(req_num); + this->processNextRequest(); +} + +void WindowManager::processError(WMError error) +{ + unsigned req_num = g_app_list.currentRequestNumber(); + + //this->emit_error() + HMI_SEQ_ERROR(req_num, errorDescription(error)); + g_app_list.removeRequest(req_num); + this->processNextRequest(); +} + /* ******* Private Functions ******* */ @@ -936,12 +1036,6 @@ WMError WindowManager::doTransition(unsigned req_num) { HMI_SEQ_DEBUG(req_num, "check policy"); WMError ret = this->checkPolicy(req_num); - if (ret != WMError::SUCCESS) - { - return ret; - } - HMI_SEQ_DEBUG(req_num, "Start transition."); - ret = this->startTransition(req_num); return ret; } @@ -952,7 +1046,6 @@ WMError WindowManager::checkPolicy(unsigned req_num) */ // get current trigger bool found = false; - bool split = false; WMError ret = WMError::LAYOUT_CHANGE_FAIL; auto trigger = g_app_list.getRequest(req_num, &found); if (!found) @@ -962,89 +1055,33 @@ WMError WindowManager::checkPolicy(unsigned req_num) } std::string req_area = trigger.area; - // >>>> Compatible with current window manager until policy manager coming if (trigger.task == Task::TASK_ALLOCATE) { - HMI_SEQ_DEBUG(req_num, "Check split or not"); const char *msg = this->check_surface_exist(trigger.role.c_str()); if (msg) { HMI_SEQ_ERROR(req_num, msg); - ret = WMError::LAYOUT_CHANGE_FAIL; return ret; } - - auto const &surface_id = this->lookup_id(trigger.role.c_str()); - auto o_state = *this->layers.get_layout_state(*surface_id); - struct LayoutState &state = *o_state; - - unsigned curernt_sid = state.main; - split = this->can_split(state, *surface_id); - - if (split) - { - HMI_SEQ_DEBUG(req_num, "Split happens"); - // Get current visible role - std::string add_role = this->lookup_name(state.main).value(); - // Set next area - std::string add_area = std::string(kNameLayoutSplit) + "." + std::string(kNameAreaMain); - // Change request area - req_area = std::string(kNameLayoutSplit) + "." + std::string(kNameAreaSub); - HMI_SEQ_NOTICE(req_num, "Change request area from %s to %s, because split happens", - trigger.area.c_str(), req_area.c_str()); - // set another action - std::string add_name = g_app_list.getAppID(curernt_sid, add_role, &found); - if (!found) - { - HMI_SEQ_ERROR(req_num, "Couldn't widhdraw with surfaceID : %d", curernt_sid); - ret = WMError::NOT_REGISTERED; - return ret; - } - HMI_SEQ_INFO(req_num, "Additional split app %s, role: %s, area: %s", - add_name.c_str(), add_role.c_str(), add_area.c_str()); - // Set split action - bool end_draw_finished = false; - WMAction split_action{ - add_name, - add_role, - add_area, - TaskVisible::VISIBLE, - end_draw_finished}; - WMError ret = g_app_list.setAction(req_num, split_action); - if (ret != WMError::SUCCESS) - { - HMI_SEQ_ERROR(req_num, "Failed to set action"); - return ret; - } - g_app_list.reqDump(); - } - } - else - { - HMI_SEQ_DEBUG(req_num, "split doesn't happen"); } - // Set invisible task(Remove if policy manager finish) - ret = this->setInvisibleTask(trigger.role, split); - if(ret != WMError::SUCCESS) + // Input event data to PolicyManager + if (0 > this->pmw.setInputEventData(trigger.task, trigger.role, trigger.area)) { - HMI_SEQ_ERROR(req_num, "Failed to set invisible task: %s", errorDescription(ret)); + HMI_SEQ_ERROR(req_num, "Failed to set input event data to PolicyManager"); return ret; } - /* get new status from Policy Manager */ - HMI_SEQ_NOTICE(req_num, "ATM, Policy manager does't exist, then set WMAction as is"); - if(trigger.role == "homescreen") + // Execute state transition of PolicyManager + if (0 > this->pmw.executeStateTransition()) { - // TODO : Remove when Policy Manager completed - HMI_SEQ_NOTICE(req_num, "Hack. This process will be removed. Change HomeScreen code!!"); - req_area = "fullscreen"; + HMI_SEQ_ERROR(req_num, "Failed to execute state transition of PolicyManager"); + return ret; } - TaskVisible task_visible = - (trigger.task == Task::TASK_ALLOCATE) ? TaskVisible::VISIBLE : TaskVisible::INVISIBLE; - ret = g_app_list.setAction(req_num, trigger.appid, trigger.role, req_area, task_visible); + ret = WMError::SUCCESS; + g_app_list.reqDump(); return ret; @@ -1066,7 +1103,7 @@ WMError WindowManager::startTransition(unsigned req_num) for (const auto &action : actions) { - if (action.visible != TaskVisible::INVISIBLE) + if (action.visible == TaskVisible::VISIBLE) { sync_draw_happen = true; @@ -1097,163 +1134,11 @@ WMError WindowManager::startTransition(unsigned req_num) this->deactivate(client->surfaceID(x.role)); } } - ret = NO_LAYOUT_CHANGE; + ret = WMError::NO_LAYOUT_CHANGE; } return ret; } -WMError WindowManager::setInvisibleTask(const std::string &role, bool split) -{ - unsigned req_num = g_app_list.currentRequestNumber(); - HMI_SEQ_DEBUG(req_num, "set current visible app to invisible task"); - bool found = false; - auto trigger = g_app_list.getRequest(req_num, &found); - // I don't check found == true here because this is checked in caller. - if(trigger.role == "homescreen") - { - HMI_SEQ_INFO(req_num, "In case of 'homescreen' visible, don't change app to invisible"); - return WMError::SUCCESS; - } - - // This task is copied from original actiavete surface - const char *drawing_name = this->rolenew2old[role].c_str(); - auto const &surface_id = this->lookup_id(role.c_str()); - auto layer_id = this->layers.get_layer_id(*surface_id); - auto o_state = *this->layers.get_layout_state(*surface_id); - struct LayoutState &state = *o_state; - std::string add_name, add_role; - std::string add_area = ""; - int surface; - TaskVisible task_visible = TaskVisible::INVISIBLE; - bool end_draw_finished = true; - - for (auto const &l : this->layers.mapping) - { - if (l.second.layer_id <= *layer_id) - { - continue; - } - HMI_DEBUG("wm", "debug: main %d , sub : %d", l.second.state.main, l.second.state.sub); - if (l.second.state.main != -1) - { - //this->deactivate(l.second.state.main); - surface = l.second.state.main; - add_role = *this->id_alloc.lookup(surface); - add_name = g_app_list.getAppID(surface, add_role, &found); - if(!found){ - return WMError::NOT_REGISTERED; - } - HMI_SEQ_INFO(req_num, "Invisible %s", add_name.c_str()); - WMAction act{add_name, add_role, add_area, task_visible, end_draw_finished}; - g_app_list.setAction(req_num, act); - l.second.state.main = -1; - } - - if (l.second.state.sub != -1) - { - //this->deactivate(l.second.state.sub); - surface = l.second.state.sub; - add_role = *this->id_alloc.lookup(surface); - add_name = g_app_list.getAppID(surface, add_role, &found); - if (!found) - { - return WMError::NOT_REGISTERED; - } - HMI_SEQ_INFO(req_num, "Invisible %s", add_name.c_str()); - WMAction act{add_name, add_role, add_area, task_visible, end_draw_finished}; - g_app_list.setAction(req_num, act); - l.second.state.sub = -1; - } - } - - // change current state here, but this is hack - auto layer = this->layers.get_layer(*layer_id); - - if (state.main == -1) - { - HMI_DEBUG("wm", "Layout: %s", kNameLayoutNormal); - } - else - { - if (0 != strcmp(drawing_name, "HomeScreen")) - { - if (split) - { - if (state.sub != *surface_id) - { - if (state.sub != -1) - { - //this->deactivate(state.sub); - WMAction deact_sub; - deact_sub.role = - std::move(*this->id_alloc.lookup(state.sub)); - deact_sub.area = add_area; - deact_sub.appid = g_app_list.getAppID(state.sub, deact_sub.role, &found); - if (!found) - { - HMI_SEQ_ERROR(req_num, "App doesn't exist for role : %s", - deact_sub.role.c_str()); - return WMError::NOT_REGISTERED; - } - deact_sub.visible = task_visible; - deact_sub.end_draw_finished = end_draw_finished; - HMI_SEQ_DEBUG(req_num, "Set invisible task for %s", deact_sub.appid.c_str()); - g_app_list.setAction(req_num, deact_sub); - } - } - //state = LayoutState{state.main, *surface_id}; - } - else - { - HMI_DEBUG("wm", "Layout: %s", kNameLayoutNormal); - - //this->surface_set_layout(*surface_id); - if (state.main != *surface_id) - { - // this->deactivate(state.main); - WMAction deact_main; - deact_main.role = std::move(*this->id_alloc.lookup(state.main)); - ; - deact_main.area = add_area; - deact_main.appid = g_app_list.getAppID(state.main, deact_main.role, &found); - if (!found) - { - HMI_SEQ_DEBUG(req_num, "sub surface ddoesn't exist"); - return WMError::NOT_REGISTERED; - } - deact_main.visible = task_visible; - deact_main.end_draw_finished = end_draw_finished; - HMI_SEQ_DEBUG(req_num, "sub surface doesn't exist"); - g_app_list.setAction(req_num, deact_main); - } - if (state.sub != -1) - { - if (state.sub != *surface_id) - { - //this->deactivate(state.sub); - WMAction deact_sub; - deact_sub.role = std::move(*this->id_alloc.lookup(state.sub)); - ; - deact_sub.area = add_area; - deact_sub.appid = g_app_list.getAppID(state.sub, deact_sub.role, &found); - if (!found) - { - HMI_SEQ_DEBUG(req_num, "sub surface ddoesn't exist"); - return WMError::NOT_REGISTERED; - } - deact_sub.visible = task_visible; - deact_sub.end_draw_finished = end_draw_finished; - HMI_SEQ_DEBUG(req_num, "sub surface doesn't exist"); - g_app_list.setAction(req_num, deact_sub); - } - } - //state = LayoutState{*surface_id}; - } - } - } - return WMError::SUCCESS; -} - WMError WindowManager::doEndDraw(unsigned req_num) { // get actions @@ -1271,37 +1156,37 @@ WMError WindowManager::doEndDraw(unsigned req_num) // layout change and make it visible for (const auto &act : actions) { - // layout change - if(!g_app_list.contains(act.appid)){ - ret = WMError::NOT_REGISTERED; - } - ret = this->layoutChange(act); - if(ret != WMError::SUCCESS) - { - HMI_SEQ_WARNING(req_num, - "Failed to manipulate surfaces while state change : %s", errorDescription(ret)); - return ret; - } - ret = this->visibilityChange(act); - if (ret != WMError::SUCCESS) + if(act.visible != TaskVisible::NO_CHANGE) { - HMI_SEQ_WARNING(req_num, - "Failed to manipulate surfaces while state change : %s", errorDescription(ret)); - return ret; + // layout change + if(!g_app_list.contains(act.appid)){ + ret = WMError::NOT_REGISTERED; + } + ret = this->layoutChange(act); + if(ret != WMError::SUCCESS) + { + HMI_SEQ_WARNING(req_num, + "Failed to manipulate surfaces while state change : %s", errorDescription(ret)); + return ret; + } + ret = this->visibilityChange(act); + if (ret != WMError::SUCCESS) + { + HMI_SEQ_WARNING(req_num, + "Failed to manipulate surfaces while state change : %s", errorDescription(ret)); + return ret; + } + HMI_SEQ_DEBUG(req_num, "visible %s", act.role.c_str()); + //this->lm_enddraw(act.role.c_str()); } - HMI_SEQ_DEBUG(req_num, "visible %s", act.role.c_str()); - //this->lm_enddraw(act.role.c_str()); } this->layout_commit(); - // Change current state - this->changeCurrentState(req_num); - HMI_SEQ_INFO(req_num, "emit flushDraw"); for(const auto &act_flush : actions) { - if(act_flush.visible != TaskVisible::INVISIBLE) + if(act_flush.visible == TaskVisible::VISIBLE) { // TODO: application requests by old role, // so convert role new to old for emitting event @@ -1367,74 +1252,6 @@ WMError WindowManager::setSurfaceSize(unsigned surface, const std::string &area) return WMError::SUCCESS; } -WMError WindowManager::changeCurrentState(unsigned req_num) -{ - HMI_SEQ_DEBUG(req_num, "Change current layout state"); - bool trigger_found = false, action_found = false; - auto trigger = g_app_list.getRequest(req_num, &trigger_found); - auto actions = g_app_list.getActions(req_num, &action_found); - if (!trigger_found || !action_found) - { - HMI_SEQ_ERROR(req_num, "Action not found"); - return WMError::LAYOUT_CHANGE_FAIL; - } - - // Layout state reset - struct LayoutState reset_state{-1, -1}; - HMI_SEQ_DEBUG(req_num,"Reset layout state"); - for (const auto &action : actions) - { - if(!g_app_list.contains(action.appid)){ - return WMError::NOT_REGISTERED; - } - auto client = g_app_list.lookUpClient(action.appid); - auto pCurState = *this->layers.get_layout_state((int)client->surfaceID(action.role)); - if(pCurState == nullptr) - { - HMI_SEQ_ERROR(req_num, "Counldn't find current status"); - continue; - } - pCurState->main = reset_state.main; - pCurState->sub = reset_state.sub; - } - - HMI_SEQ_DEBUG(req_num, "Change state"); - for (const auto &action : actions) - { - auto client = g_app_list.lookUpClient(action.appid); - auto pLayerCurState = *this->layers.get_layout_state((int)client->surfaceID(action.role)); - if (pLayerCurState == nullptr) - { - HMI_SEQ_ERROR(req_num, "Counldn't find current status"); - continue; - } - int surface = -1; - - if (action.visible != TaskVisible::INVISIBLE) - { - surface = (int)client->surfaceID(action.role); - HMI_SEQ_INFO(req_num, "Change %s surface : %d, state visible area : %s", - action.role.c_str(), surface, action.area.c_str()); - // visible == true -> layout changes - if(action.area == "normal.full" || action.area == "split.main") - { - pLayerCurState->main = surface; - } - else if (action.area == "split.sub") - { - pLayerCurState->sub = surface; - } - else - { - // normalfull - pLayerCurState->main = surface; - } - } - } - - return WMError::SUCCESS; -} - void WindowManager::emitScreenUpdated(unsigned req_num) { // Get visible apps @@ -1641,63 +1458,10 @@ const char *WindowManager::check_surface_exist(const char *drawing_name) return "Surface is not on any layer!"; } - auto o_state = *this->layers.get_layout_state(*surface_id); - - if (o_state == nullptr) - { - return "Could not find layer for surface"; - } - HMI_DEBUG("wm", "surface %d is detected", *surface_id); return nullptr; } -bool WindowManager::can_split(struct LayoutState const &state, int new_id) -{ - if (state.main != -1 && state.main != new_id) - { - auto new_id_layer = this->layers.get_layer_id(new_id).value(); - auto current_id_layer = this->layers.get_layer_id(state.main).value(); - - // surfaces are on separate layers, don't bother. - if (new_id_layer != current_id_layer) - { - return false; - } - - std::string const &new_id_str = this->lookup_name(new_id).value(); - std::string const &cur_id_str = this->lookup_name(state.main).value(); - - auto const &layer = this->layers.get_layer(new_id_layer); - - HMI_DEBUG("wm", "layer info name: %s", layer->name.c_str()); - - if (layer->layouts.empty()) - { - return false; - } - - for (auto i = layer->layouts.cbegin(); i != layer->layouts.cend(); i++) - { - HMI_DEBUG("wm", "%d main_match '%s'", new_id_layer, i->main_match.c_str()); - auto rem = std::regex(i->main_match); - if (std::regex_match(cur_id_str, rem)) - { - // build the second one only if the first already matched - HMI_DEBUG("wm", "%d sub_match '%s'", new_id_layer, i->sub_match.c_str()); - auto res = std::regex(i->sub_match); - if (std::regex_match(new_id_str, res)) - { - HMI_DEBUG("wm", "layout matched!"); - return true; - } - } - } - } - - return false; -} - const char* WindowManager::kDefaultOldRoleDb = "{ \ \"old_roles\": [ \ { \ diff --git a/src/window_manager.hpp b/src/window_manager.hpp index 2358c5a..6cbd355 100644 --- a/src/window_manager.hpp +++ b/src/window_manager.hpp @@ -25,6 +25,7 @@ #include "layers.hpp" #include "layout.hpp" #include "wayland_ivi_wm.hpp" +#include "pm_wrapper.hpp" #include "hmi-debug.h" #include "request.hpp" #include "wm_error.hpp" @@ -227,8 +228,11 @@ class WindowManager void removeClient(const std::string &appid); void exceptionProcessForTransition(); const char* convertRoleOldToNew(char const *role); + // Do not use this function void timerHandler(); + void startTransitionWrapper(std::vector<WMAction> &actions); + void processError(WMError error); private: bool pop_pending_events(); @@ -255,13 +259,11 @@ class WindowManager WMError doTransition(unsigned sequence_number); WMError checkPolicy(unsigned req_num); WMError startTransition(unsigned req_num); - WMError setInvisibleTask(const std::string &role, bool split); WMError doEndDraw(unsigned req_num); WMError layoutChange(const WMAction &action); WMError visibilityChange(const WMAction &action); WMError setSurfaceSize(unsigned surface, const std::string& area); - WMError changeCurrentState(unsigned req_num); void emitScreenUpdated(unsigned req_num); void setTimer(); @@ -272,13 +274,13 @@ class WindowManager const char *check_surface_exist(const char *role); - bool can_split(struct LayoutState const &state, int new_id); - private: std::unordered_map<std::string, struct compositor::rect> area2size; std::unordered_map<std::string, std::string> roleold2new; std::unordered_map<std::string, std::string> rolenew2old; + PMWrapper pmw; + static const char* kDefaultOldRoleDb; }; |