[linux/windows] Separate out a C channel API (#259)

Eliminates PluginRegistrar and BinaryMessenger from the embedder.h API
surface, moving them up to the FlutterWindowController level. In their
place, adds new low-level messaging APIs, which are based closely on
the Flutter engine embedder APIs (including an equivalent message
struct), in some cases wrapping them directly. Unlike the engine APIs,
they allow per-channel callbacks, so individual plugins can use the API.

Since PluginHandler is no longer the source of truth for callback
registration, only an adaptor, it's now fine to have multiple instances
of them, all passing through to the underlying C API.

Part of #230

Author: stuartmorgan

library/BUILD.gn

@@ -38,6 +38,8 @@ published_shared_library("flutter_embedder") {
   if (is_linux || is_win) {
     sources += [
       "common/engine_method_result.cc",
+      "common/internal/incoming_message_dispatcher.cc",
+      "common/internal/incoming_message_dispatcher.h",
       "common/internal/plugin_handler.cc",
       "common/internal/plugin_handler.h",
       "common/internal/text_input_model.cc",

library/common/glfw/embedder.cc

@@ -32,6 +32,7 @@
 #include "library/common/glfw/key_event_handler.h"
 #include "library/common/glfw/keyboard_hook_handler.h"
 #include "library/common/glfw/text_input_plugin.h"
+#include "library/common/internal/incoming_message_dispatcher.h"
 #include "library/common/internal/plugin_handler.h"
 
 #ifdef __linux__
@@ -61,7 +62,11 @@ struct FlutterEmbedderState {
   // The handle to the Flutter engine instance.
   FlutterEngine engine;
 
-  // The helper class managing plugin registration and messaging.
+  // Message dispatch manager for messages from the Flutter engine.
+  std::unique_ptr<flutter_desktop_embedding::IncomingMessageDispatcher>
+      message_dispatcher;
+
+  // The helper class managing plugin registration.
   std::unique_ptr<flutter_desktop_embedding::PluginHandler> plugin_handler;
 
   // Handlers for keyboard events from GLFW.
@@ -83,6 +88,18 @@ static FlutterEmbedderState *GetSavedEmbedderState(GLFWwindow *window) {
       glfwGetWindowUserPointer(window));
 }
 
+// Converts a FlutterPlatformMessage to an equivalent FlutterEmbedderMessage.
+static flutter_desktop_embedding::FlutterEmbedderMessage
+ConvertToEmbedderMessage(const FlutterPlatformMessage &engine_message) {
+  flutter_desktop_embedding::FlutterEmbedderMessage embedder_message = {};
+  embedder_message.struct_size = sizeof(embedder_message);
+  embedder_message.channel = engine_message.channel;
+  embedder_message.message = engine_message.message;
+  embedder_message.message_size = engine_message.message_size;
+  embedder_message.response_handle = engine_message.response_handle;
+  return embedder_message;
+}
+
 // Returns the number of screen coordinates per inch for the main monitor.
 // If the information is unavailable, returns a default value that assumes
 // that a screen coordinate is one dp.
@@ -207,8 +224,10 @@ static void GLFWOnFlutterPlatformMessage(const FlutterPlatformMessage *message,
 
   GLFWwindow *window = reinterpret_cast<GLFWwindow *>(user_data);
   auto state = GetSavedEmbedderState(window);
-  state->plugin_handler->HandleMethodCallMessage(
-      message, [window] { GLFWClearEventCallbacks(window); },
+
+  auto embedder_message = ConvertToEmbedderMessage(*message);
+  state->message_dispatcher->HandleMessage(
+      embedder_message, [window] { GLFWClearEventCallbacks(window); },
       [window] { GLFWAssignEventCallbacks(window); });
 }
 
@@ -313,14 +332,6 @@ bool FlutterInit() {
 
 void FlutterTerminate() { glfwTerminate(); }
 
-PluginRegistrar *GetRegistrarForPlugin(FlutterWindowRef flutter_window,
-                                       const std::string &plugin_name) {
-  // Currently, PluginHandler acts as the registrar for all plugins, so the
-  // name is ignored. It is part of the API to reduce churn in the future when
-  // aligning more closely with the Flutter registrar system.
-  return flutter_window->plugin_handler.get();
-}
-
 FlutterWindowRef CreateFlutterWindow(
     size_t initial_width, size_t initial_height, const std::string &assets_path,
     const std::string &icu_data_path,
@@ -348,7 +359,9 @@ FlutterWindowRef CreateFlutterWindow(
   state->window = window;
   glfwSetWindowUserPointer(window, state);
   state->engine = engine;
-  state->plugin_handler = std::make_unique<PluginHandler>(engine);
+  state->message_dispatcher =
+      std::make_unique<IncomingMessageDispatcher>(state);
+  state->plugin_handler = std::make_unique<PluginHandler>(state);
 
   // Set up the keyboard handlers.
   state->keyboard_hook_handlers.push_back(
@@ -392,4 +405,38 @@ void FlutterWindowLoop(FlutterWindowRef flutter_window) {
   glfwDestroyWindow(window);
 }
 
+void FlutterEmbedderSendMessage(FlutterWindowRef flutter_window,
+                                const char *channel, const uint8_t *message,
+                                const size_t message_size) {
+  FlutterPlatformMessage platform_message = {
+      sizeof(FlutterPlatformMessage),
+      channel,
+      message,
+      message_size,
+  };
+
+  FlutterEngineSendPlatformMessage(flutter_window->engine, &platform_message);
+}
+
+void FlutterEmbedderSendMessageResponse(
+    FlutterWindowRef flutter_window,
+    const FlutterEmbedderMessageResponseHandle *handle, const uint8_t *data,
+    size_t data_length) {
+  FlutterEngineSendPlatformMessageResponse(flutter_window->engine, handle, data,
+                                           data_length);
+}
+
+void FlutterEmbedderSetMessageCallback(FlutterWindowRef flutter_window,
+                                       const char *channel,
+                                       FlutterEmbedderMessageCallback callback,
+                                       void *user_data) {
+  flutter_window->message_dispatcher->SetMessageCallback(channel, callback,
+                                                         user_data);
+}
+
+void FlutterEmbedderEnableInputBlocking(FlutterWindowRef flutter_window,
+                                        const char *channel) {
+  flutter_window->message_dispatcher->EnableInputBlockingForChannel(channel);
+}
+
 }  // namespace flutter_desktop_embedding

library/common/glfw/flutter_window_controller.cc

@@ -16,6 +16,8 @@
 
 #include <iostream>
 
+#include "library/common/internal/plugin_handler.h"
+
 namespace flutter_desktop_embedding {
 
 FlutterWindowController::FlutterWindowController(std::string &icu_data_path)
@@ -56,8 +58,14 @@ PluginRegistrar *FlutterWindowController::GetRegistrarForPlugin(
   if (!window_) {
     return nullptr;
   }
-  return flutter_desktop_embedding::GetRegistrarForPlugin(window_, plugin_name);
-}
+  if (!plugin_handler_) {
+    plugin_handler_ = std::make_unique<PluginHandler>(window_);
+  }
+  // Currently, PluginHandler acts as the registrar for all plugins, so the
+  // name is ignored. It is part of the API to reduce churn in the future when
+  // aligning more closely with the Flutter registrar system.
+  return plugin_handler_.get();
+}  // namespace flutter_desktop_embedding
 
 void FlutterWindowController::RunEventLoop() {
   if (window_) {

library/common/internal/incoming_message_dispatcher.cc

@@ -0,0 +1,64 @@
+// Copyright 2019 Google LLC
+//
+// 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 "library/common/internal/incoming_message_dispatcher.h"
+
+namespace flutter_desktop_embedding {
+
+IncomingMessageDispatcher::IncomingMessageDispatcher(FlutterWindowRef window)
+    : window_(window) {}
+
+IncomingMessageDispatcher::~IncomingMessageDispatcher() {}
+
+void IncomingMessageDispatcher::HandleMessage(
+    const FlutterEmbedderMessage &message,
+    std::function<void(void)> input_block_cb,
+    std::function<void(void)> input_unblock_cb) {
+  std::string channel(message.channel);
+
+  // Find the handler for the channel; if there isn't one, report the failure.
+  if (callbacks_.find(channel) == callbacks_.end()) {
+    FlutterEmbedderSendMessageResponse(window_, message.response_handle,
+                                       nullptr, 0);
+    return;
+  }
+  auto &callback_info = callbacks_[channel];
+  FlutterEmbedderMessageCallback message_callback = callback_info.first;
+
+  // Process the call, handling input blocking if requested.
+  bool block_input = input_blocking_channels_.count(channel) > 0;
+  if (block_input) {
+    input_block_cb();
+  }
+  message_callback(window_, &message, callback_info.second);
+  if (block_input) {
+    input_unblock_cb();
+  }
+}
+
+void IncomingMessageDispatcher::SetMessageCallback(
+    const std::string &channel, FlutterEmbedderMessageCallback callback,
+    void *user_data) {
+  if (!callback) {
+    callbacks_.erase(channel);
+    return;
+  }
+  callbacks_[channel] = std::make_pair(callback, user_data);
+}
+
+void IncomingMessageDispatcher::EnableInputBlockingForChannel(
+    const std::string &channel) {
+  input_blocking_channels_.insert(channel);
+}
+
+}  // namespace flutter_desktop_embedding

library/common/internal/incoming_message_dispatcher.h

@@ -0,0 +1,86 @@
+// Copyright 2018 Google LLC
+//
+// 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 LIBRARY_COMMON_INTERNAL_INCOMING_MESSAGE_DISPATCHER_H_
+#define LIBRARY_COMMON_INTERNAL_INCOMING_MESSAGE_DISPATCHER_H_
+
+#include <functional>
+#include <map>
+#include <set>
+#include <string>
+#include <utility>
+
+#include "library/include/flutter_desktop_embedding/glfw/embedder.h"
+
+namespace flutter_desktop_embedding {
+
+// Manages per-channel registration of callbacks for handling messages from the
+// Flutter engine, and dispatching incoming messages to those handlers.
+class IncomingMessageDispatcher {
+ public:
+  // Creates a new IncomingMessageDispatcher. |window| must remain valid as long
+  // as this object exists.
+  explicit IncomingMessageDispatcher(FlutterWindowRef window);
+  virtual ~IncomingMessageDispatcher();
+
+  // Prevent copying.
+  IncomingMessageDispatcher(IncomingMessageDispatcher const &) = delete;
+  IncomingMessageDispatcher &operator=(IncomingMessageDispatcher const &) =
+      delete;
+
+  // Routes |message| to to the registered handler for its channel, if any.
+  //
+  // If input blocking has been enabled on that channel, wraps the call to the
+  // handler with calls to the given callbacks to block and then unblock input.
+  //
+  // If no handler is registered for the message's channel, sends a
+  // NotImplemented response to the engine.
+  void HandleMessage(const FlutterEmbedderMessage &message,
+                     std::function<void(void)> input_block_cb = [] {},
+                     std::function<void(void)> input_unblock_cb = [] {});
+
+  // Registers a message callback for incoming messages from the Flutter
+  // side on the specified channel. |callback| will be called with the message
+  // and |user_data| any time a message arrives on that channel.
+  //
+  // Replaces any existing callback. Pass a null callback to unregister the
+  // existing callback.
+  void SetMessageCallback(const std::string &channel,
+                          FlutterEmbedderMessageCallback callback,
+                          void *user_data);
+
+  // Enables input blocking on the given channel name.
+  //
+  // If set, then the parent window should disable input callbacks
+  // while waiting for the handler for messages on that channel to run.
+  void EnableInputBlockingForChannel(const std::string &channel);
+
+ private:
+  // Handle for interacting with the embedding API.
+  // TODO: Provide an interface for the specific functionality needed.
+  FlutterWindowRef window_;
+
+  // A map from channel names to the FlutterEmbedderMessageCallback that should
+  // be called for incoming messages on that channel, along with the void* user
+  // data to pass to it.
+  std::map<std::string, std::pair<FlutterEmbedderMessageCallback, void *>>
+      callbacks_;
+
+  // Channel names for which input blocking should be enabled during the call to
+  // that channel's handler.
+  std::set<std::string> input_blocking_channels_;
+};
+
+}  // namespace flutter_desktop_embedding
+
+#endif  // LIBRARY_COMMON_INTERNAL_INCOMING_MESSAGE_DISPATCHER_H_