ONEMPERS-234 port platform task execution loop from glfw embedder

This allows handling of flutter platform events - necessary eg.
for Service Protocol handler registration. The code has been ported
from glfw implementation in flutter engine, in flutter/shell/platform/glfw/
(adapted to use our ppoll based main loop)

Author: tomasz-karczewski-red

CMakeLists.txt

@@ -35,13 +35,15 @@ set(SOURCES
     src/utils.cc
     src/debug.cc
     src/wayland_display.cc
+    src/event_loop.cc
     src/elf.h
     src/macros.h
     src/keys.h
     src/utils.h
     src/egl_utils.h
     src/debug.h
     src/wayland_display.h
+    src/event_loop.h
 )
 
 ecm_add_wayland_client_protocol(

src/event_loop.cc

@@ -0,0 +1,103 @@
+// Copyright 2013 The Flutter Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "event_loop.h"
+#include <atomic>
+#include <utility>
+#include <climits>
+
+#include "event_loop.h"
+
+#include <atomic>
+#include <utility>
+#include <unistd.h>
+
+namespace flutter {
+
+PlatformEventLoop::PlatformEventLoop(std::thread::id main_thread_id, const TaskExpiredCallback &on_task_expired, int notify_fd)
+    : main_thread_id_(main_thread_id)
+    , on_task_expired_(std::move(on_task_expired))
+    , notify_fd_(notify_fd) {
+}
+
+PlatformEventLoop::~PlatformEventLoop() = default;
+
+bool PlatformEventLoop::RunsTasksOnCurrentThread() const {
+  return std::this_thread::get_id() == main_thread_id_;
+}
+
+uint64_t PlatformEventLoop::ProcessEvents() {
+  std::vector<FlutterTask> expired_tasks;
+
+  // Process expired tasks.
+  {
+    std::lock_guard<std::mutex> lock(task_queue_mutex_);
+    const uint64_t start_processing_time = FlutterEngineGetCurrentTime();
+    while (!task_queue_.empty()) {
+      const auto &top = task_queue_.top();
+      // If this task (and all tasks after this) has not yet expired, there is
+      // nothing more to do. Quit iterating.
+      if (top.fire_time > start_processing_time) {
+        break;
+      }
+
+      // Make a record of the expired task. Do NOT service the task here
+      // because we are still holding onto the task queue mutex. We don't want
+      // other threads to block on posting tasks onto this thread till we are
+      // done processing expired tasks.
+      expired_tasks.push_back(task_queue_.top().task);
+
+      // Remove the tasks from the delayed tasks queue.
+      task_queue_.pop();
+    }
+  }
+
+  // Fire expired tasks.
+  {
+    // Flushing tasks here without holing onto the task queue mutex.
+    for (const auto &task : expired_tasks) {
+      on_task_expired_(&task);
+    }
+  }
+
+  // return timestamp of next event or 0 if none
+  {
+    std::lock_guard<std::mutex> lock(task_queue_mutex_);
+    if (task_queue_.empty()) {
+      return 0;
+    } else {
+      return task_queue_.top().fire_time;
+    }
+  }
+}
+
+void PlatformEventLoop::PostTask(FlutterTask flutter_task, uint64_t flutter_target_time_nanos) {
+  static std::atomic<uint64_t> sGlobalTaskOrder(0);
+
+  Task task;
+  task.order     = ++sGlobalTaskOrder;
+  task.fire_time = flutter_target_time_nanos;
+  task.task      = flutter_task;
+
+  {
+    std::lock_guard<std::mutex> lock(task_queue_mutex_);
+    task_queue_.push(task);
+
+    // Make sure the queue mutex is unlocked before waking up the loop. In case
+    // the wake causes this thread to be descheduled for the primary thread to
+    // process tasks, the acquisition of the lock on that thread while holding
+    // the lock here momentarily till the end of the scope is a pessimization.
+  }
+  Wake();
+}
+
+void PlatformEventLoop::Wake() {
+  ssize_t ret  = 0;
+  uint64_t val = 1;
+  do {
+    ret = write(notify_fd_, &val, sizeof(val));
+  } while (ret < 0 && errno == EAGAIN);
+}
+
+} // namespace flutter

src/event_loop.h

@@ -0,0 +1,72 @@
+// Copyright 2013 The Flutter Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef FLUTTER_SHELL_PLATFORM_GLFW_EVENT_LOOP_H_
+#define FLUTTER_SHELL_PLATFORM_GLFW_EVENT_LOOP_H_
+
+#include <chrono>
+#include <deque>
+#include <functional>
+#include <mutex>
+#include <queue>
+#include <thread>
+
+#include <flutter_embedder.h>
+
+namespace flutter {
+
+// platform event loop, to handle flutter platform events
+// adapted from flutter engine glfw embedder (flutter/shell/platform/glfw/flutter_glfw.cc)
+class PlatformEventLoop {
+public:
+  using TaskExpiredCallback = std::function<void(const FlutterTask *)>;
+  // Creates an event loop running on the given thread, calling
+  // |on_task_expired| to run tasks.
+  // notify_fd event descriptor will be used to wake up the main thread when events arrive
+  PlatformEventLoop(std::thread::id main_thread_id, const TaskExpiredCallback &on_task_expired, int notify_fd);
+
+  virtual ~PlatformEventLoop();
+
+  // Disallow copy.
+  PlatformEventLoop(const PlatformEventLoop &) = delete;
+  PlatformEventLoop &operator=(const PlatformEventLoop &) = delete;
+
+  // Returns if the current thread is the thread used by this event loop.
+  bool RunsTasksOnCurrentThread() const;
+
+  // processes expired events, and returns next wake up point or 0 if there are no events
+  uint64_t ProcessEvents();
+
+  // Posts a Flutter engine task to the event loop for delayed execution.
+  void PostTask(FlutterTask flutter_task, uint64_t flutter_target_time_nanos);
+
+protected:
+
+  // Wakes the main thread
+  void Wake();
+
+  struct Task {
+    uint64_t order;
+    uint64_t fire_time;
+    FlutterTask task;
+
+    struct Comparer {
+      bool operator()(const Task &a, const Task &b) {
+        if (a.fire_time == b.fire_time) {
+          return a.order > b.order;
+        }
+        return a.fire_time > b.fire_time;
+      }
+    };
+  };
+  std::thread::id main_thread_id_;
+  TaskExpiredCallback on_task_expired_;
+  std::mutex task_queue_mutex_;
+  std::priority_queue<Task, std::deque<Task>, Task::Comparer> task_queue_;
+  int notify_fd_;
+};
+
+} // namespace flutter
+
+#endif // FLUTTER_SHELL_PLATFORM_GLFW_EVENT_LOOP_H_

src/wayland_display.cc

@@ -649,6 +649,18 @@ bool WaylandDisplay::SetupEngine(const std::string &bundle_path, const std::vect
       },
   };
 
+  // configure platform task runner; render tasks runner will still be provided by flutter
+  FlutterTaskRunnerDescription platform_task_runner = {};
+  FlutterCustomTaskRunners task_runners             = {};
+  task_runners.struct_size                          = sizeof(FlutterCustomTaskRunners);
+  task_runners.platform_task_runner                 = &platform_task_runner;
+  if (ConfigurePlatformTaskRunner(&platform_task_runner)) {
+    args.custom_task_runners = &task_runners;
+  } else {
+    dbgE("Couldn't configure platform task runner\n");
+    exit(1);
+  }
+
   std::string libapp_aot_path = bundle_path + "/" + FlutterGetAppAotElfName(); // dw: TODO: There seems to be no convention name we could use, so let's temporary hardcode the path.
 
   if (FlutterEngineRunsAOTCompiledDartCode()) {
@@ -1011,6 +1023,16 @@ ssize_t WaylandDisplay::vSyncSendNotifyData() {
   return rv;
 }
 
+static void set_sleep_to_next_platform_event(const uint64_t timestamp_of_next_platform_event, struct timespec &ts) {
+  if (timestamp_of_next_platform_event == 0) {
+    ts = {.tv_sec = LONG_MAX, .tv_nsec = 0};
+  } else {
+    const uint64_t now           = FlutterEngineGetCurrentTime();
+    const uint64_t time_to_sleep = now <= timestamp_of_next_platform_event ? timestamp_of_next_platform_event - now : 0;
+    timespec_from_nsec(&ts, time_to_sleep);
+  }
+}
+
 bool WaylandDisplay::Run() {
   if (!valid_) {
     dbgE("Could not run an invalid display.\n");
@@ -1034,26 +1056,28 @@ bool WaylandDisplay::Run() {
 
     wl_display_flush(display_);
 
+    uint64_t timestamp_of_next_platform_event_ns = 0;
+
     do {
-      int rv;
 
-      struct pollfd fds[4] = {
+      struct timespec ts;
+      set_sleep_to_next_platform_event(timestamp_of_next_platform_event_ns, ts);
+
+      int rv, ppoll_rv;
+
+      struct pollfd fds[5] = {
           {.fd = vsync.sv_[vsync.SOCKET_READER], .events = POLLIN, .revents = 0},
           {.fd = fd, .events = POLLIN | POLLERR, .revents = 0},
           {.fd = key.timer_fd_, .events = POLLIN | POLLERR, .revents = 0},
           {.fd = memory_watcher_.event_fd, .events = POLLIN | POLLERR, .revents = 0},
+          {.fd = event_loop_._platform_event_loop_eventfd, .events = POLLIN | POLLERR, .revents = 0}
       };
 
       do {
-        static const struct timespec ts = {
-            .tv_sec  = LONG_MAX,
-            .tv_nsec = 0,
-        };
-
-        rv = ppoll(&fds[0], std::size(fds), &ts, nullptr);
-      } while (rv == -1 && errno == EINTR);
+        ppoll_rv = ppoll(&fds[0], std::size(fds), &ts, nullptr);
+      } while (ppoll_rv == -1 && errno == EINTR);
 
-      if (rv == -1) {
+      if (ppoll_rv == -1) {
         printf("ERROR: ppoll returned -1 (errno: %d)\n", errno);
         return false;
       }
@@ -1115,6 +1139,18 @@ bool WaylandDisplay::Run() {
         }
       }
 
+      const bool event_loop_wakeup = fds[4].revents & POLLIN;
+      if (event_loop_wakeup) {
+        uint64_t result;
+        do {
+          rv = read(fds[4].fd, &result, sizeof result);
+        } while (rv == -1 && errno == EINTR);
+      }
+      // in case of event loop wakeup or if timeout of another event passed - flush events queue
+      if (event_loop_wakeup || ppoll_rv == 0) {
+        timestamp_of_next_platform_event_ns = event_loop_._platform_event_loop->ProcessEvents();
+      }
+
       break;
     } while (true);
 
@@ -1243,4 +1279,37 @@ bool WaylandDisplay::SetupEGL() {
 
   return true;
 }
+
+void WaylandDisplay::RunFlutterTask(const FlutterTask *task) {
+  if (!engine_) {
+    dbgE("FlutterEngineRunTask called before engine was initialized\n");
+  } else if (FlutterEngineRunTask(engine_, task) != kSuccess) {
+    dbgW("FlutterEngineRunTask failed\n");
+  }
+}
+
+bool WaylandDisplay::ConfigurePlatformTaskRunner(FlutterTaskRunnerDescription *task_runner) {
+
+  event_loop_._platform_event_loop_eventfd = eventfd(0, 0);
+  if (event_loop_._platform_event_loop_eventfd == -1) {
+    dbgE("Couldn't create platform event loop event.\n");
+    return false;
+  }
+
+  event_loop_._platform_event_loop = std::make_unique<PlatformEventLoop>(
+      std::this_thread::get_id(),
+      std::bind(&WaylandDisplay::RunFlutterTask,this,std::placeholders::_1),
+      event_loop_._platform_event_loop_eventfd);
+
+  task_runner->struct_size = sizeof(FlutterTaskRunnerDescription);
+  task_runner->user_data   = event_loop_._platform_event_loop.get();
+
+  task_runner->runs_task_on_current_thread_callback = [](void *state) -> bool {
+    return reinterpret_cast<PlatformEventLoop *>(state)->RunsTasksOnCurrentThread();
+  };
+  task_runner->post_task_callback = [](FlutterTask task, uint64_t target_time_nanos, void *state) -> void {
+    reinterpret_cast<PlatformEventLoop *>(state)->PostTask(task, target_time_nanos);
+  };
+  return true;
+}
 } // namespace flutter

src/wayland_display.h

@@ -13,6 +13,7 @@
 #include <gdk/gdk.h>
 #include <xkbcommon/xkbcommon.h>
 #include <flutter_embedder.h>
+#include "event_loop.h"
 
 #include <memory>
 #include <string>
@@ -105,6 +106,10 @@ class WaylandDisplay {
 
   void CleanupMemoryWatcher();
 
+  bool ConfigurePlatformTaskRunner(FlutterTaskRunnerDescription *task_runner);
+
+  void RunFlutterTask(const FlutterTask *task);
+
   // key repeat related
   struct {
     int32_t repeat_delay_ms_    = 400;
@@ -128,6 +133,11 @@ class WaylandDisplay {
   ssize_t vSyncReadNotifyData();
   // }
 
+  struct {
+    std::unique_ptr<PlatformEventLoop> _platform_event_loop;
+    int _platform_event_loop_eventfd = -1;
+  } event_loop_;
+
   FLWAY_DISALLOW_COPY_AND_ASSIGN(WaylandDisplay)
 };