+void App::layout_commit()
+{
+ this->controller->commit_changes();
+ this->display->flush();
+}
+
+void App::set_timer()
+{
+ HMI_SEQ_DEBUG(g_app_list.currentRequestNumber(), "Timer set activate");
+ if (g_timer_ev_src == nullptr)
+ {
+ // firsttime set into sd_event
+ int ret = sd_event_add_time(afb_daemon_get_event_loop(), &g_timer_ev_src,
+ CLOCK_REALTIME, time(NULL) * (1000000UL) + kTimeOut, 1, processTimerHandler, this);
+ if (ret < 0)
+ {
+ HMI_ERROR("wm", "Could't set timer");
+ }
+ }
+ else
+ {
+ // update timer limitation after second time
+ sd_event_source_set_time(g_timer_ev_src, time(NULL) * (1000000UL) + kTimeOut);
+ sd_event_source_set_enabled(g_timer_ev_src, SD_EVENT_ONESHOT);
+ }
+}
+
+void App::stop_timer()
+{
+ unsigned req_num = g_app_list.currentRequestNumber();
+ HMI_SEQ_DEBUG(req_num, "Timer stop");
+ int rc = sd_event_source_set_enabled(g_timer_ev_src, SD_EVENT_OFF);
+ if (rc < 0)
+ {
+ HMI_SEQ_ERROR(req_num, "Timer stop failed");
+ }
+}
+
+WMError App::lm_release(const struct WMAction &action)
+{
+ //auto const &surface_id = this->lookup_id(drawing_name);
+ WMError ret = WMError::LAYOUT_CHANGE_FAIL;
+ unsigned req_num = g_app_list.currentRequestNumber();
+ auto const &surface_id = this->lookup_id(action.role.c_str());
+ if (!surface_id)
+ {
+ HMI_SEQ_ERROR(req_num, "Surface does not exist");
+ return ret;
+ }
+
+ if (*surface_id == this->layers.main_surface)
+ {
+ HMI_SEQ_ERROR(req_num, "Cannot deactivate main_surface");
+ return ret;
+ }
+
+ auto o_state = *this->layers.get_layout_state(*surface_id);
+
+ if (o_state == nullptr)
+ {
+ HMI_SEQ_ERROR(req_num, "Could not find layer for surface");
+ return ret;
+ }
+
+ struct LayoutState &state = *o_state;
+
+ if (state.main == -1)
+ {
+ HMI_SEQ_ERROR(req_num, "No surface active");
+ return ret;
+ }
+
+ // Check against main_surface, main_surface_name is the configuration item.
+ if (*surface_id == this->layers.main_surface)
+ {
+ HMI_SEQ_DEBUG(req_num, "Refusing to deactivate main_surface %d", *surface_id);
+ //reply(nullptr);
+ return WMError::SUCCESS;
+ }
+ if ((state.main == *surface_id) && (state.sub == *surface_id))
+ {
+ HMI_SEQ_ERROR(req_num, "Surface is not active");
+ return ret;
+ }
+
+ if (state.main == *surface_id)
+ {
+ if (state.sub != -1)
+ {
+ this->try_layout(
+ state, LayoutState{state.sub, -1}, [&](LayoutState const &nl) {
+ std::string sub = std::move(*this->lookup_name(state.sub));
+
+ this->deactivate(*surface_id);
+ this->surface_set_layout(state.sub);
+ state = nl;
+
+ this->layout_commit();
+ std::string str_area = std::string(kNameLayoutNormal) + "." + std::string(kNameAreaFull);
+ compositor::rect area_rect = this->area_info[state.sub];
+ this->emit_syncdraw(sub.c_str(), str_area.c_str(),
+ area_rect.x, area_rect.y, area_rect.w, area_rect.h);
+ this->enqueue_flushdraw(state.sub);
+ });
+ }
+ else
+ {
+ this->try_layout(state, LayoutState{-1, -1}, [&](LayoutState const &nl) {
+ this->deactivate(*surface_id);
+ state = nl;
+ this->layout_commit();
+ });
+ }
+ }
+ else if (state.sub == *surface_id)
+ {
+ this->try_layout(
+ state, LayoutState{state.main, -1}, [&](LayoutState const &nl) {
+ std::string main = std::move(*this->lookup_name(state.main));
+
+ this->deactivate(*surface_id);
+ this->surface_set_layout(state.main);
+ state = nl;
+
+ this->layout_commit();
+ std::string str_area = std::string(kNameLayoutNormal) + "." + std::string(kNameAreaFull);
+ compositor::rect area_rect = this->area_info[state.main];
+ this->emit_syncdraw(main.c_str(), str_area.c_str(),
+ area_rect.x, area_rect.y, area_rect.w, area_rect.h);
+ this->enqueue_flushdraw(state.main);
+ });
+ }
+ return WMError::SUCCESS;
+}
+
+WMError App::lm_layout_change(const struct WMAction &action)
+{
+ const char *msg = this->check_surface_exist(action.role.c_str());
+
+ /*
+ lm_.updateLayout(action);
+ TODO: emit syncDraw with application*/
+ if (msg)
+ {
+ HMI_SEQ_DEBUG(g_app_list.currentRequestNumber(), msg);
+ return WMError::LAYOUT_CHANGE_FAIL;
+ }
+ this->lm_layout_change(action.role.c_str());
+ return WMError::SUCCESS;
+}
+
+WMError App::do_transition(unsigned req_num)
+{
+ /*
+ * Check Policy
+ */
+ // get current trigger
+ auto trigger = g_app_list.getRequest(req_num);
+ bool is_activate = true;
+
+ /* get new status from Policy Manager
+
+ (json_object*?) newLayout = checkPolicy(trigger);
+ (vector<struct WMAction>&) auto actions = translator.inputActionFromLayout(newLayout, currentLayout)
+ for(const auto& x : actions){
+ g_app_list.setAciton(req_num, x)
+ }
+
+ or
+
+ translator.inputActionFromLayout(newLayout, currentLayout, &g_app_list, req_num);
+
+ /* The following error check is not necessary because main.cpp will reject the message form not registered object
+ } */
+ HMI_SEQ_NOTICE(req_num, "ATM, Policy manager does't exist, then set WMAction as is");
+
+ if (trigger.task == Task::TASK_RELEASE)
+ {
+ is_activate = false;
+ }
+ WMError ret = g_app_list.setAction(req_num, trigger.appid, trigger.role, trigger.area, is_activate);
+ g_app_list.reqDump();
+
+ if (ret != WMError::SUCCESS)
+ {
+ HMI_SEQ_ERROR(req_num, "Failed to set action");
+ return ret;
+ }
+
+ // layer manager task
+ bool sync_draw_happen = false;
+ for (const auto &y : g_app_list.getActions(req_num))
+ {
+ /*
+ do_task(y);
+ */
+ /* TODO
+ but current we can't do do_task,
+ so divide the processing into lm_layout_change and lm_release
+ */
+ if (y.visible)
+ {
+ sync_draw_happen = true;
+ ret = lm_layout_change(y);
+ if (ret != WMError::SUCCESS)
+ {
+ HMI_SEQ_ERROR(req_num, "%s: appid: %s, role: %s, area: %s",
+ errorDescription(ret), y.appid.c_str(), y.role.c_str(), y.area.c_str());
+ g_app_list.removeRequest(req_num);
+ break;
+ // TODO: if transition fails, what should we do?
+ }
+ /* g_app_list.lookUpClient(y.appid)->emit_syncdraw(y.role, y.area); */
+ }
+ else
+ {
+ ret = lm_release(y);
+ if (!ret)
+ {
+ HMI_SEQ_ERROR(req_num, "Failed release resource: %s", y.appid.c_str());
+ g_app_list.removeRequest(req_num);
+ break;
+ // TODO: if transition fails, what should we do?
+ }
+ /* g_app_list.lookUpClient(y.appid)->emit_invisible(y.role, y.area); */
+ }
+ }
+
+ if (ret != WMError::SUCCESS)
+ {
+ //this->emit_error(req_num, 0 /*error_num*/, "error happens"); // test
+ }
+ else if (sync_draw_happen)
+ {
+ this->set_timer();
+ }
+ else
+ {
+ g_app_list.removeRequest(req_num); // HACK!!!
+ }
+ return ret;
+}
+
+void App::lm_layout_change(const char *drawing_name)
+{
+ auto const &surface_id = this->lookup_id(drawing_name);
+ 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;
+
+ // disable layers that are above our current layer
+ for (auto const &l : this->layers.mapping)
+ {
+ if (l.second.layer_id <= *layer_id)
+ {
+ continue;
+ }
+
+ bool flush = false;
+ if (l.second.state.main != -1)
+ {
+ this->deactivate(l.second.state.main);
+ l.second.state.main = -1;
+ flush = true;
+ }
+
+ if (l.second.state.sub != -1)
+ {
+ this->deactivate(l.second.state.sub);
+ l.second.state.sub = -1;
+ flush = true;
+ }
+
+ if (flush)
+ {
+ this->layout_commit();
+ }
+ }
+
+ auto layer = this->layers.get_layer(*layer_id);
+
+ if (state.main == -1)
+ {
+ this->try_layout(
+ state, LayoutState{*surface_id}, [&](LayoutState const &nl) {
+ HMI_DEBUG("wm", "Layout: %s", kNameLayoutNormal);
+ this->surface_set_layout(*surface_id);
+ state = nl;
+
+ // Commit for configuraton
+ this->layout_commit();
+
+ std::string str_area = std::string(kNameLayoutNormal) + "." + std::string(kNameAreaFull);
+ compositor::rect area_rect = this->area_info[*surface_id];
+ this->emit_syncdraw(drawing_name, str_area.c_str(),
+ area_rect.x, area_rect.y, area_rect.w, area_rect.h);
+ this->enqueue_flushdraw(state.main);
+ });
+ }
+ else
+ {
+ if (0 == strcmp(drawing_name, "HomeScreen"))
+ {
+ this->try_layout(
+ state, LayoutState{*surface_id}, [&](LayoutState const &nl) {
+ HMI_DEBUG("wm", "Layout: %s", kNameLayoutNormal);
+ std::string str_area = std::string(kNameLayoutNormal) + "." + std::string(kNameAreaFull);
+ compositor::rect area_rect = this->area_info[*surface_id];
+ this->emit_syncdraw(drawing_name, str_area.c_str(),
+ area_rect.x, area_rect.y, area_rect.w, area_rect.h);
+ this->enqueue_flushdraw(state.main);
+ });
+ }
+ else
+ {
+ bool can_split = this->can_split(state, *surface_id);
+
+ if (can_split)
+ {
+ this->try_layout(
+ state,
+ LayoutState{state.main, *surface_id},
+ [&](LayoutState const &nl) {
+ HMI_DEBUG("wm", "Layout: %s", kNameLayoutSplit);
+ std::string main =
+ std::move(*this->lookup_name(state.main));
+
+ this->surface_set_layout(state.main, surface_id);
+ if (state.sub != *surface_id)
+ {
+ if (state.sub != -1)
+ {
+ this->deactivate(state.sub);
+ }
+ }
+ state = nl;
+
+ // Commit for configuration and visibility(0)
+ this->layout_commit();
+
+ std::string str_area_main = std::string(kNameLayoutSplit) + "." + std::string(kNameAreaMain);
+ std::string str_area_sub = std::string(kNameLayoutSplit) + "." + std::string(kNameAreaSub);
+ compositor::rect area_rect_main = this->area_info[state.main];
+ compositor::rect area_rect_sub = this->area_info[*surface_id];
+ // >>> HACK
+ HMI_WARNING("wm", "HACK!!! mediaplayer and hvac is only supported for split");
+ std::string request_role = drawing_name;
+ //std::string request_app = transform(request_role.begin(), request_role.end(), request_role.begin(), tolower); //hvac or mediaplayer
+ std::string hack_appid = "navigation";
+ std::string hack_role = main;
+ std::string hack_area = str_area_main;
+ g_app_list.setAction(g_app_list.currentRequestNumber(), hack_appid, hack_role, hack_area, true);
+ //g_app_list.setEndDrawFinished(g_app_list.currentRequestNumber(), request_role, request_role);
+ //g_app_list.setEndDrawFinished(g_app_list.currentRequestNumber(), hack_appid, hack_role); // This process is illegal
+ // >>> HACK
+ this->emit_syncdraw(main.c_str(), str_area_main.c_str(),
+ area_rect_main.x, area_rect_main.y,
+ area_rect_main.w, area_rect_main.h);
+ this->emit_syncdraw(request_role.c_str(), str_area_sub.c_str(),
+ area_rect_sub.x, area_rect_sub.y,
+ area_rect_sub.w, area_rect_sub.h);
+ this->enqueue_flushdraw(state.main);
+ this->enqueue_flushdraw(state.sub);
+ });
+ }
+ else
+ {
+ this->try_layout(
+ state, LayoutState{*surface_id}, [&](LayoutState const &nl) {
+ HMI_DEBUG("wm", "Layout: %s", kNameLayoutNormal);
+
+ this->surface_set_layout(*surface_id);
+ if (state.main != *surface_id)
+ {
+ this->deactivate(state.main);
+ }
+ if (state.sub != -1)
+ {
+ if (state.sub != *surface_id)
+ {
+ this->deactivate(state.sub);
+ }
+ }
+ state = nl;
+
+ // Commit for configuraton and visibility(0)
+ this->layout_commit();
+
+ std::string str_area = std::string(kNameLayoutNormal) + "." + std::string(kNameAreaFull);
+ compositor::rect area_rect = this->area_info[*surface_id];
+ this->emit_syncdraw(drawing_name, str_area.c_str(),
+ area_rect.x, area_rect.y, area_rect.w, area_rect.h);
+ this->enqueue_flushdraw(state.main);
+ });
+ }
+ }
+ }