X-Git-Url: https://gerrit.automotivelinux.org/gerrit/gitweb?a=blobdiff_plain;f=src%2Fmain.cpp;h=e8ae75a383887827bf12000ce8befe8c32369bcf;hb=b00ef7b9c2f495eea7911d874b9f2fb744c87412;hp=f33b20e4341407a258beb0b5382a86009d98afb5;hpb=c0f383d989821c61872aaa38932fa7719dc97120;p=apps%2Fagl-service-windowmanager-2017.git diff --git a/src/main.cpp b/src/main.cpp old mode 100755 new mode 100644 index f33b20e..e8ae75a --- a/src/main.cpp +++ b/src/main.cpp @@ -1,5 +1,5 @@ /* - * Copyright (C) 2017 Mentor Graphics Development (Deutschland) GmbH + * 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. @@ -15,23 +15,21 @@ */ #include +#include +#include +#include +#include #include "app.hpp" +#include "result.hpp" #include "json_helper.hpp" #include "util.hpp" #include "wayland.hpp" -#include -#include - -#include - extern "C" { #include #include } -namespace { - struct afb_instance { std::unique_ptr display; wm::App app; @@ -42,6 +40,7 @@ struct afb_instance { }; struct afb_instance *g_afb_instance; +std::mutex binding_m; int afb_instance::init() { return this->app.init(); @@ -52,7 +51,7 @@ int display_event_callback(sd_event_source *evs, int /*fd*/, uint32_t events, ST(); if ((events & EPOLLHUP) != 0) { - logerror("The compositor hung up, dying now."); + HMI_ERROR("wm", "The compositor hung up, dying now."); delete g_afb_instance; g_afb_instance = nullptr; goto error; @@ -86,22 +85,16 @@ error: return -1; } -// _ _ _ _ _ _ _ ____ -// | |__ (_)_ __ __| (_)_ __ __ _ (_)_ __ (_) |_ / /\ \ -// | '_ \| | '_ \ / _` | | '_ \ / _` | | | '_ \| | __| | | | -// | |_) | | | | | (_| | | | | | (_| | | | | | | | |_| | | | -// |_.__/|_|_| |_|\__,_|_|_| |_|\__, |___|_|_| |_|_|\__| | | | -// |___/_____| \_\/_/ -int binding_init_() { - lognotice("WinMan ver. %s", WINMAN_VERSION_STRING); +int _binding_init() { + HMI_NOTICE("wm", "WinMan ver. %s", WINMAN_VERSION_STRING); if (g_afb_instance != nullptr) { - logerror("Wayland context already initialized?"); + HMI_ERROR("wm", "Wayland context already initialized?"); return 0; } if (getenv("XDG_RUNTIME_DIR") == nullptr) { - logerror("Environment variable XDG_RUNTIME_DIR not set"); + HMI_ERROR("wm", "Environment variable XDG_RUNTIME_DIR not set"); goto error; } @@ -112,10 +105,10 @@ int binding_init_() { while (!g_afb_instance->display->ok()) { cnt++; if (20 <= cnt) { - logerror("Could not connect to compositor"); + HMI_ERROR("wm", "Could not connect to compositor"); goto error; } - logerror("Wait to start weston ..."); + HMI_ERROR("wm", "Wait to start weston ..."); sleep(1); delete g_afb_instance; g_afb_instance = new afb_instance; @@ -123,7 +116,7 @@ int binding_init_() { } if (g_afb_instance->init() == -1) { - logerror("Could not connect to compositor"); + HMI_ERROR("wm", "Could not connect to compositor"); goto error; } @@ -132,7 +125,7 @@ int binding_init_() { g_afb_instance->display->get_fd(), EPOLLIN, display_event_callback, g_afb_instance); if (ret < 0) { - logerror("Could not initialize afb_instance event handler: %d", -ret); + HMI_ERROR("wm", "Could not initialize afb_instance event handler: %d", -ret); goto error; } } @@ -149,43 +142,381 @@ error: int binding_init() noexcept { try { - return binding_init_(); + return _binding_init(); } catch (std::exception &e) { - logerror("Uncaught exception in binding_init(): %s", e.what()); + HMI_ERROR("wm", "Uncaught exception in binding_init(): %s", e.what()); } return -1; } -} // namespace +void windowmanager_requestsurface(afb_req req) noexcept { + std::lock_guard guard(binding_m); + #ifdef ST + ST(); + #endif + if (g_afb_instance == nullptr) { + afb_req_fail(req, "failed", "Binding not initialized, did the compositor die?"); + return; + } + + try { + const char* a_drawing_name = afb_req_value(req, "drawing_name"); + if(!a_drawing_name){ + afb_req_fail(req, "failed", "Need char const* argument drawing_name"); + return; + } + + auto ret = g_afb_instance->app.api_request_surface(a_drawing_name); + if (ret.is_err()) { + afb_req_fail(req, "failed", ret.unwrap_err()); + return; + } + + afb_req_success(req, json_object_new_int(ret.unwrap()), "success"); + + } catch (std::exception &e) { + afb_req_fail_f(req, "failed", "Uncaught exception while calling requestsurface: %s", e.what()); + return; + } + +} + +void windowmanager_requestsurfacexdg(afb_req req) noexcept { + std::lock_guard guard(binding_m); + #ifdef ST + ST(); + #endif + if (g_afb_instance == nullptr) { + afb_req_fail(req, "failed", "Binding not initialized, did the compositor die?"); + return; + } + + try { + json_object *jreq = afb_req_json(req); + + json_object *j_drawing_name = nullptr; + if (! json_object_object_get_ex(jreq, "drawing_name", &j_drawing_name)) { + afb_req_fail(req, "failed", "Need char const* argument drawing_name"); + return; + } + char const* a_drawing_name = json_object_get_string(j_drawing_name); + + json_object *j_ivi_id = nullptr; + if (! json_object_object_get_ex(jreq, "ivi_id", &j_ivi_id)) { + afb_req_fail(req, "failed", "Need char const* argument ivi_id"); + return; + } + char const* a_ivi_id = json_object_get_string(j_ivi_id); + + auto ret = g_afb_instance->app.api_request_surface(a_drawing_name, a_ivi_id); + if (ret != nullptr) { + afb_req_fail(req, "failed", ret); + return; + } + + afb_req_success(req, NULL, "success"); + } catch (std::exception &e) { + afb_req_fail_f(req, "failed", "Uncaught exception while calling requestsurfacexdg: %s", e.what()); + return; + } +} + +void windowmanager_activatesurface(afb_req req) noexcept { + std::lock_guard guard(binding_m); + #ifdef ST + ST(); + #endif + if (g_afb_instance == nullptr) { + afb_req_fail(req, "failed", "Binding not initialized, did the compositor die?"); + return; + } + + try { + const char* a_drawing_name = afb_req_value(req, "drawing_name"); + if(!a_drawing_name){ + afb_req_fail(req, "failed", "Need char const* argument drawing_name"); + return; + } -#include "afb_binding_glue.inl" + const char* a_drawing_area = afb_req_value(req, "drawing_area"); + if(!a_drawing_area){ + afb_req_fail(req, "failed", "Need char const* argument drawing_area"); + return; + } + + auto ret = g_afb_instance->app.api_activate_surface(a_drawing_name, a_drawing_area); + if (ret != nullptr) { + afb_req_fail(req, "failed", ret); + return; + } -namespace wm { -void binding_api::send_event(char const *evname, char const *label) { - logdebug("%s: %s(%s)", __func__, evname, label); + afb_req_success(req, NULL, "success"); + } catch (std::exception &e) { + afb_req_fail_f(req, "failed", "Uncaught exception while calling activatesurface: %s", e.what()); + return; + } - json_object *j = json_object_new_object(); - json_object_object_add(j, kKeyDrawingName, json_object_new_string(label)); +} + +void windowmanager_deactivatesurface(afb_req req) noexcept { + std::lock_guard guard(binding_m); + #ifdef ST + ST(); + #endif + if (g_afb_instance == nullptr) { + afb_req_fail(req, "failed", "Binding not initialized, did the compositor die?"); + return; + } + + try { + const char* a_drawing_name = afb_req_value(req, "drawing_name"); + if(!a_drawing_name){ + afb_req_fail(req, "failed", "Need char const* argument drawing_name"); + return; + } + + auto ret = g_afb_instance->app.api_deactivate_surface(a_drawing_name); + if (ret != nullptr) { + afb_req_fail(req, "failed", ret); + return; + } - int ret = afb_daemon_broadcast_event(evname, j); - if (ret != 0) { - logdebug("afb_event_broadcast failed: %m"); + afb_req_success(req, NULL, "success"); + } catch (std::exception &e) { + afb_req_fail_f(req, "failed", "Uncaught exception while calling deactivatesurface: %s", e.what()); + return; } } -void binding_api::send_event(char const *evname, char const *label, char const *area) { - logdebug("%s: %s(%s, %s)", __func__, evname, label, area); +void windowmanager_enddraw(afb_req req) noexcept { + std::lock_guard guard(binding_m); + #ifdef ST + ST(); + #endif + if (g_afb_instance == nullptr) { + afb_req_fail(req, "failed", "Binding not initialized, did the compositor die?"); + return; + } + + try { + const char* a_drawing_name = afb_req_value(req, "drawing_name"); + if(!a_drawing_name){ + afb_req_fail(req, "failed", "Need char const* argument drawing_name"); + return; + } - json_object *j = json_object_new_object(); - json_object_object_add(j, kKeyDrawingName, json_object_new_string(label)); - json_object_object_add(j, kKeyDrawingArea, json_object_new_string(area)); + auto ret = g_afb_instance->app.api_enddraw(a_drawing_name); + if (ret != nullptr) { + afb_req_fail(req, "failed", ret); + return; + } - int ret = afb_daemon_broadcast_event(evname, j); - if (ret != 0) { - logdebug("afb_event_broadcast failed: %m"); + afb_req_success(req, NULL, "success"); + } catch (std::exception &e) { + afb_req_fail_f(req, "failed", "Uncaught exception while calling enddraw: %s", e.what()); + return; } + } -} // namespace wm + +void windowmanager_wm_subscribe(afb_req req) noexcept { + std::lock_guard guard(binding_m); + #ifdef ST + ST(); + #endif + if (g_afb_instance == nullptr) { + afb_req_fail(req, "failed", "Binding not initialized, did the compositor die?"); + return; + } + + try { + json_object *jreq = afb_req_json(req); + json_object *j = nullptr; + if (! json_object_object_get_ex(jreq, "event", &j)) { + afb_req_fail(req, "failed", "Need char const* argument event"); + return; + } + int event_type = json_object_get_int(j); + const char *event_name = g_afb_instance->app.kListEventName[event_type]; + struct afb_event event = g_afb_instance->app.map_afb_event[event_name]; + int ret = afb_req_subscribe(req, event); + if (ret) { + afb_req_fail(req, "failed", "Error: afb_req_subscribe()"); + return; + } + afb_req_success(req, NULL, "success"); + + } catch (std::exception &e) { + afb_req_fail_f(req, "failed", "Uncaught exception while calling wm_subscribe: %s", e.what()); + return; + } + +} + +void windowmanager_list_drawing_names(afb_req req) noexcept { + std::lock_guard guard(binding_m); + #ifdef ST + ST(); + #endif + if (g_afb_instance == nullptr) { + afb_req_fail(req, "failed", "Binding not initialized, did the compositor die?"); + return; + } + + try { + + nlohmann::json j = g_afb_instance->app.id_alloc.name2id; + auto ret = wm::Ok(json_tokener_parse(j.dump().c_str())); + if (ret.is_err()) { + afb_req_fail(req, "failed", ret.unwrap_err()); + return; + } + + afb_req_success(req, ret.unwrap(), "success"); + + } catch (std::exception &e) { + afb_req_fail_f(req, "failed", "Uncaught exception while calling list_drawing_names: %s", e.what()); + return; + } + +} + +void windowmanager_ping(afb_req req) noexcept { + std::lock_guard guard(binding_m); + #ifdef ST + ST(); + #endif + if (g_afb_instance == nullptr) { + afb_req_fail(req, "failed", "Binding not initialized, did the compositor die?"); + return; + } + + try { + + g_afb_instance->app.api_ping(); + + afb_req_success(req, NULL, "success"); + + } catch (std::exception &e) { + afb_req_fail_f(req, "failed", "Uncaught exception while calling ping: %s", e.what()); + return; + } +} + +void windowmanager_debug_status(afb_req req) noexcept { + std::lock_guard guard(binding_m); + #ifdef ST + ST(); + #endif + if (g_afb_instance == nullptr) { + afb_req_fail(req, "failed", "Binding not initialized, did the compositor die?"); + return; + } + + try { + + json_object *jr = json_object_new_object(); + json_object_object_add(jr, "surfaces", + to_json(g_afb_instance->app.controller->sprops)); + json_object_object_add(jr, "layers", to_json(g_afb_instance->app.controller->lprops)); + + afb_req_success(req, jr, "success"); + + } catch (std::exception &e) { + afb_req_fail_f(req, "failed", "Uncaught exception while calling debug_status: %s", e.what()); + return; + } +} + +void windowmanager_debug_layers(afb_req req) noexcept { + std::lock_guard guard(binding_m); + #ifdef ST + ST(); + #endif + if (g_afb_instance == nullptr) { + afb_req_fail(req, "failed", "Binding not initialized, did the compositor die?"); + return; + } + + try { + auto ret = wm::Ok(json_tokener_parse(g_afb_instance->app.layers.to_json().dump().c_str())); + + afb_req_success(req, ret, "success"); + + } catch (std::exception &e) { + afb_req_fail_f(req, "failed", "Uncaught exception while calling debug_layers: %s", e.what()); + return; + } +} + +void windowmanager_debug_surfaces(afb_req req) noexcept { + std::lock_guard guard(binding_m); + #ifdef ST + ST(); + #endif + if (g_afb_instance == nullptr) { + afb_req_fail(req, "failed", "Binding not initialized, did the compositor die?"); + return; + } + + try { + + auto ret = wm::Ok(to_json(g_afb_instance->app.controller->sprops)); + if (ret.is_err()) { + afb_req_fail(req, "failed", ret.unwrap_err()); + return; + } + + afb_req_success(req, ret.unwrap(), "success"); + + } catch (std::exception &e) { + afb_req_fail_f(req, "failed", "Uncaught exception while calling debug_surfaces: %s", e.what()); + return; + } + +} + +void windowmanager_debug_terminate(afb_req req) noexcept { + std::lock_guard guard(binding_m); + #ifdef ST + ST(); + #endif + if (g_afb_instance == nullptr) { + afb_req_fail(req, "failed", "Binding not initialized, did the compositor die?"); + return; + } + + try { + + if (getenv("WINMAN_DEBUG_TERMINATE") != nullptr) { + raise(SIGKILL); // afb-daemon kills it's pgroup using TERM, which + // doesn't play well with perf + } + + afb_req_success(req, NULL, "success"); + + } catch (std::exception &e) { + afb_req_fail_f(req, "failed", "Uncaught exception while calling debug_terminate: %s", e.what()); + return; + } + +} + +const struct afb_verb_v2 windowmanager_verbs[] = { + { "requestsurface", windowmanager_requestsurface, nullptr, nullptr, AFB_SESSION_NONE }, + { "requestsurfacexdg", windowmanager_requestsurfacexdg, nullptr, nullptr, AFB_SESSION_NONE }, + { "activatesurface", windowmanager_activatesurface, nullptr, nullptr, AFB_SESSION_NONE }, + { "deactivatesurface", windowmanager_deactivatesurface, nullptr, nullptr, AFB_SESSION_NONE }, + { "enddraw", windowmanager_enddraw, nullptr, nullptr, AFB_SESSION_NONE }, + { "wm_subscribe", windowmanager_wm_subscribe, nullptr, nullptr, AFB_SESSION_NONE }, + { "list_drawing_names", windowmanager_list_drawing_names, nullptr, nullptr, AFB_SESSION_NONE }, + { "ping", windowmanager_ping, nullptr, nullptr, AFB_SESSION_NONE }, + { "debug_status", windowmanager_debug_status, nullptr, nullptr, AFB_SESSION_NONE }, + { "debug_layers", windowmanager_debug_layers, nullptr, nullptr, AFB_SESSION_NONE }, + { "debug_surfaces", windowmanager_debug_surfaces, nullptr, nullptr, AFB_SESSION_NONE }, + { "debug_terminate", windowmanager_debug_terminate, nullptr, nullptr, AFB_SESSION_NONE }, + {} +}; extern "C" const struct afb_binding_v2 afbBindingV2 = { "windowmanager", nullptr, nullptr, windowmanager_verbs, nullptr, binding_init, nullptr, 0};