AFBClient: implement event handler dispatch

* requestSurface will store label if successful.
* onEvent calls AFBClient::Impl::event to dispatch the event.
* stripped down onCall and onEvent implementations.
* event names from onEvent are matched on-the-fly to
  AFBClient::EventType.
* requestSurface with a name that is already known will fail
  immediately.
* Removal of event handler not supported.
* Removal of surfaces not supported - assume the application
  lives only as long as it's surface.
* Add minimal Event_Active event handler to main.

Signed-off-by: Marcus Fritzsch <marcus_fritzsch@mentor.com>

2 files changed, 122 insertions, 49 deletions

diff --git a/AFBClient.cpp b/AFBClient.cpp
index 9210eac..5fadc35 100644
--- a/AFBClient.cpp
+++ b/AFBClient.cpp
@@ -8,7 +8,9 @@
 #include <cstring>
 
 #include <atomic>
+#include <map>
 #include <mutex>
+#include <set>
 
 #include <unistd.h>
 
@@ -23,6 +25,41 @@ extern "C" {
 
 #define UNUSED(x) (void)(x)
 
+//       _                 ___                 _
+//   ___| | __ _ ___ ___  |_ _|_ __ ___  _ __ | |
+//  / __| |/ _` / __/ __|  | || '_ ` _ \| '_ \| |
+// | (__| | (_| \__ \__ \  | || | | | | | |_) | |
+//  \___|_|\__,_|___/___/ |___|_| |_| |_| .__/|_|
+//                                      |_|
+class AFBClient::Impl {
+    friend class AFBClient;
+
+    // This is the AFBClient interface impl
+    int init(int port, char const *token);
+    int dispatch();
+
+    // WM API
+    int requestSurface(const char *label);
+    int activateSurface(const char *label);
+    int deactivateSurface(const char *label);
+    int endDraw(const char *label);
+
+    void set_event_handler(enum EventType et,
+                           std::function<void(char const *label)> f);
+
+    Impl();
+    ~Impl();
+
+    struct afb_wsj1 *wsj1;
+    struct sd_event *loop;
+
+    std::set<std::string> labels;
+    std::map<EventType, handler_fun> handlers;
+
+public:
+    void event(char const *et, char const *label);
+};
+
 namespace {
 
 constexpr const int token_maxlen = 20;
@@ -56,24 +93,17 @@ void onCall(void *closure, const char *api, const char *verb,
             struct afb_wsj1_msg *msg) {
     TRACE();
     UNUSED(closure);
-    int rc;
-    printf("ON-CALL %s/%s:\n%s\n", api, verb,
-           json_object_to_json_string_ext(afb_wsj1_msg_object_j(msg),
-                                          JSON_C_TO_STRING_PRETTY));
-    fflush(stdout);
-    rc = afb_wsj1_reply_error_s(msg, "\"unimplemented\"", nullptr);
-    if (rc < 0)
-        fprintf(stderr, "replying failed: %m\n");
+    UNUSED(verb);
+    UNUSED(api);
+    UNUSED(msg);
 }
 
 /* called when wsj1 receives an event */
 void onEvent(void *closure, const char *event, afb_wsj1_msg *msg) {
     TRACE();
-    UNUSED(closure);
-    printf("ON-EVENT %s:\n%s\n", event,
-           json_object_to_json_string_ext(afb_wsj1_msg_object_j(msg),
-                                          JSON_C_TO_STRING_PRETTY));
-    fflush(stdout);
+    reinterpret_cast<AFBClient::Impl *>(closure)->event(
+        event, json_object_get_string(
+                   json_object_object_get(afb_wsj1_msg_object_j(msg), "data")));
 }
 
 /* called when wsj1 hangsup */
@@ -150,7 +180,10 @@ int api_call(struct sd_event *loop, struct afb_wsj1 *wsj1, const char *verb,
         // if events get triggered by the call (and would be dispatched before
         // the actual call-reply).
         while (!returned.load(std::memory_order_consume)) {
-            dispatch_internal(loop);
+            std::lock_guard<std::recursive_mutex> guard(dispatch_mutex);
+            if (!returned.load(std::memory_order_consume)) {
+                dispatch_internal(loop);
+            }
         }
 
         // return the actual API call result
@@ -162,36 +195,13 @@ int api_call(struct sd_event *loop, struct afb_wsj1 *wsj1, const char *verb,
 
 }  // namespace
 
-//       _                 ___                 _
-//   ___| | __ _ ___ ___  |_ _|_ __ ___  _ __ | |
-//  / __| |/ _` / __/ __|  | || '_ ` _ \| '_ \| |
-// | (__| | (_| \__ \__ \  | || | | | | | |_) | |
-//  \___|_|\__,_|___/___/ |___|_| |_| |_| .__/|_|
-//                                      |_|
-class AFBClient::Impl {
-    friend class AFBClient;
-
-    // This is the AFBClient interface impl
-    int init(int port, char const *token);
-    int dispatch();
-
-    // WM API
-    int requestSurface(const char *label);
-    int activateSurface(const char *label);
-    int deactivateSurface(const char *label);
-    int endDraw(const char *label);
-
-    void set_event_handler(enum EventType et,
-                           std::function<void(char const *label)> f);
-
-    Impl();
-    ~Impl();
-
-    struct afb_wsj1 *wsj1;
-    struct sd_event *loop;
-};
-
-AFBClient::Impl::Impl() : wsj1{}, loop{} { TRACE(); }
+//       _                 ___                 _   _                 _
+//   ___| | __ _ ___ ___  |_ _|_ __ ___  _ __ | | (_)_ __ ___  _ __ | |
+//  / __| |/ _` / __/ __|  | || '_ ` _ \| '_ \| | | | '_ ` _ \| '_ \| |
+// | (__| | (_| \__ \__ \  | || | | | | | |_) | | | | | | | | | |_) | |
+//  \___|_|\__,_|___/___/ |___|_| |_| |_| .__/|_| |_|_| |_| |_| .__/|_|
+//                                      |_|                   |_|
+AFBClient::Impl::Impl() : wsj1{}, loop{}, labels(), handlers() { TRACE(); }
 
 AFBClient::Impl::~Impl() {
     TRACE();
@@ -237,7 +247,7 @@ int AFBClient::Impl::init(int port, char const *token) {
 
     /* connect the websocket wsj1 to the uri given by the first argument */
     wsj1 = afb_ws_client_connect_wsj1(
-        loop, uribuf, const_cast<struct afb_wsj1_itf *>(&itf), nullptr);
+        loop, uribuf, const_cast<struct afb_wsj1_itf *>(&itf), this);
     if (wsj1 == nullptr) {
         sd_event_unref(loop);
         fprintf(stderr, "Connection to %s failed: %m\n", uribuf);
@@ -258,8 +268,15 @@ int AFBClient::Impl::dispatch() {
 
 int AFBClient::Impl::requestSurface(const char *label) {
     TRACE();
+
+    if (this->labels.find(label) != this->labels.end()) {
+        fprintf(stderr, "Surface label already known!\n");
+        return -EINVAL;
+    }
+
     json_object *jp = json_object_new_object();
     json_object_object_add(jp, "drawing_name", json_object_new_string(label));
+
     int rc = -1;
     /* send the request */
     int rc2 = api_call(
@@ -285,7 +302,14 @@ int AFBClient::Impl::requestSurface(const char *label) {
             }
         });
 
-    return rc2 < 0 ? rc2 : rc;
+    if (rc2 < 0)
+        rc = rc2;
+
+    if (rc >= 0) {
+        this->labels.insert(this->labels.end(), label);
+    }
+
+    return rc;
 }
 
 int AFBClient::Impl::activateSurface(const char *label) {
@@ -337,7 +361,53 @@ void AFBClient::Impl::set_event_handler(
     UNUSED(et);
     UNUSED(func);
     TRACE();
-    // XXX todo
+
+    if (et >= 1 && et <= 6) {  // Yeah ... just go with it!
+        this->handlers[et] = std::move(func);
+    }
+}
+
+namespace {
+std::pair<bool, AFBClient::EventType> make_event_type(char const *et) {
+    // Event have the form "$API/$EVENT", just try to find the first / and
+    // get on with it.
+    char const *et2 = strchr(et, '/');
+    if (et2) {
+        et = et2 + 1;
+    }
+
+#define ET(N, A)                                               \
+    do {                                                       \
+        if (strcasecmp(et, N) == 0)                            \
+            return std::make_pair<bool, AFBClient::EventType>( \
+                true, CONCAT(AFBClient::Event_, A));           \
+    } while (0)
+
+    ET("activated", Active);
+    ET("deactivated", Inactive);
+    ET("visible", Visible);
+    ET("invisible", Invisible);
+    ET("syncdraw", SyncDraw);
+    ET("flushdraw", FlushDraw);
+#undef ET
+
+    return std::make_pair<bool, AFBClient::EventType>(false,
+                                                      AFBClient::Event_Active);
+}
+}  // namespace
+
+void AFBClient::Impl::event(char const *et, char const *label) {
+    TRACE();
+    auto oet = make_event_type(et);
+    if (!oet.first) {
+        fprintf(stderr, "Unknown event type string '%s'\n", et);
+        return;
+    }
+
+    auto i = this->handlers.find(oet.second);
+    if (i != this->handlers.end()) {
+        i->second(label);
+    }
 }
 
 //       _                    _    _____ ____   ____ _ _            _
diff --git a/AFBClient.h b/AFBClient.h
index f42aeea..983c2ad 100644
--- a/AFBClient.h
+++ b/AFBClient.h
@@ -12,11 +12,15 @@ class AFBClient
     AFBClient &operator=(const AFBClient &) = delete;
 
 public:
+    typedef std::function<void(char const *label)> handler_fun;
+
     enum EventType {
        Event_Active = 1,
        Event_Inactive,
+
        Event_Visible,
        Event_Invisible,
+
        Event_SyncDraw,
        Event_FlushDraw,
     };
@@ -32,8 +36,7 @@ public:
     int deactivateSurface(const char *label);
     int endDraw(const char *label);
 
-    void set_event_handler(enum EventType et,
-          std::function<void(char const *label)> f);
+    void set_event_handler(enum EventType et, handler_fun f);
 
     struct Impl;