Plugin and Module implementations

Summary:
Last diff in the the RNW saga.

This change creates the necessary bridgings between the module and the plugin.

With this in place, JS plugins can be written and used. Also, we have a fully functional RNW sample app.

Reviewed By: aigoncharov

Differential Revision: D39087480

fbshipit-source-id: f4fde404716aa619a64553ffa556d060f49c0ac7

react-native/react-native-flipper/windows/ReactNativeFlipper/FlipperModule.h

@@ -11,8 +11,11 @@
 #include "NativeModules.h"
 
 #include <FlipperReactDeviceInfo.h>
+#include <FlipperReactPlugin.h>
+#include <FlipperReactPluginManager.h>
 #include <FlipperReactScheduler.h>
 #include <FlipperReactSocket.h>
+#include <map>
 #include "../../../../xplat/Flipper/FlipperClient.h"
 #include "../../../../xplat/Flipper/FlipperInitConfig.h"
 #include "../../../../xplat/Flipper/FlipperScheduler.h"
@@ -26,6 +29,7 @@ REACT_MODULE(FlipperModule, L"Flipper")
 struct FlipperModule {
   std::unique_ptr<facebook::flipper::Scheduler> sonarScheduler;
   std::unique_ptr<facebook::flipper::Scheduler> connectionScheduler;
+  std::unique_ptr<facebook::flipper::FlipperReactPluginManager> pluginManager;
 
   REACT_INIT(Initialize)
   void Initialize(ReactContext const& reactContext) noexcept {
@@ -36,6 +40,9 @@ struct FlipperModule {
     connectionScheduler =
         std::make_unique<facebook::flipper::FlipperReactScheduler>();
 
+    pluginManager =
+        std::make_unique<facebook::flipper::FlipperReactPluginManager>();
+
     facebook::flipper::FlipperReactDeviceInfo deviceInfo;
     facebook::flipper::FlipperInitConfig config;
     config.deviceData.host = deviceInfo.getHost();
@@ -60,29 +67,73 @@ struct FlipperModule {
   void registerPlugin(
       std::string pluginId,
       bool inBackground,
-      std::function<void(std::string)>&& callback) noexcept {}
+      std::function<void(std::string)>&& callback) noexcept {
+    bool registered = pluginManager->registerPlugin(
+        pluginId,
+        inBackground,
+        [this](
+            const std::string& pluginId,
+            facebook::flipper::FlipperReactPluginEvent e) {
+          const std::map<std::string, std::string> args{{"plugin", pluginId}};
+          switch (e) {
+            case facebook::flipper::FlipperReactPluginEvent::CONNECTED:
+              return pluginOnConnect(args);
+            case facebook::flipper::FlipperReactPluginEvent::DISCONNECTED:
+              return pluginOnDisconnect(args);
+          }
+        });
+    if (registered) {
+      callback("ok");
+    } else {
+      callback("noflipper");
+    }
+  }
 
   REACT_METHOD(send)
   void
-  send(std::string pluginId, std::string method, std::string data) noexcept {}
+  send(std::string pluginId, std::string method, std::string data) noexcept {
+    pluginManager->send(pluginId, method, data);
+  }
 
   REACT_METHOD(reportErrorWithMetadata)
   void reportErrorWithMetadata(
       std::string pluginId,
       std::string reason,
-      std::string stacktrace) noexcept {}
+      std::string stacktrace) noexcept {
+    pluginManager->reportError(pluginId, reason, stacktrace);
+  }
 
   REACT_METHOD(reportError)
-  void reportError(std::string pluginId, std::string error) noexcept {}
+  void reportError(std::string pluginId, std::string error) noexcept {
+    pluginManager->reportError(pluginId, error);
+  }
 
   REACT_METHOD(subscribe)
-  void subscribe(std::string pluginId, std::string method) noexcept {}
+  void subscribe(std::string pluginId, std::string method) noexcept {
+    pluginManager->subscribe(
+        pluginId, method, [this](std::map<std::string, std::string> args) {
+          onReceive(args);
+        });
+  }
 
   REACT_METHOD(respondSuccess)
-  void respondSuccess(std::string responderId, std::string data) noexcept {}
+  void respondSuccess(std::string responderId, std::string data) noexcept {
+    pluginManager->respondSuccess(responderId, data);
+  }
 
   REACT_METHOD(respondError)
-  void respondError(std::string responderId, std::string data) noexcept {}
+  void respondError(std::string responderId, std::string data) noexcept {
+    pluginManager->respondError(responderId, data);
+  }
+
+  REACT_EVENT(pluginOnConnect, L"react-native-flipper-plugin-connect")
+  std::function<void(std::map<std::string, std::string>)> pluginOnConnect;
+
+  REACT_EVENT(pluginOnDisconnect, L"react-native-flipper-plugin-disconnect")
+  std::function<void(std::map<std::string, std::string>)> pluginOnDisconnect;
+
+  REACT_EVENT(onReceive, L"react-native-flipper-receive-event")
+  std::function<void(std::map<std::string, std::string>)> onReceive;
 
  private:
   ReactContext m_reactContext{nullptr};

react-native/react-native-flipper/windows/ReactNativeFlipper/FlipperReactPlugin.cpp

@@ -0,0 +1,59 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#include "FlipperReactPlugin.h"
+
+namespace facebook {
+namespace flipper {
+
+FlipperReactPlugin::FlipperReactPlugin(
+    std::string pluginId,
+    bool runInBackground,
+    FlipperConnectionEvent handler)
+    : pluginId_(std::move(pluginId)),
+      runInBackground_(runInBackground),
+      eventHandler_(std::move(handler)) {}
+
+FlipperReactPlugin::~FlipperReactPlugin() {}
+
+std::string FlipperReactPlugin::identifier() const {
+  return pluginId_;
+}
+
+void FlipperReactPlugin::didConnect(
+    std::shared_ptr<FlipperConnection> connection) {
+  connection_ = connection;
+  fireOnConnect();
+}
+
+void FlipperReactPlugin::didDisconnect() {
+  connection_ = nullptr;
+  fireOnDisconnect();
+}
+
+bool FlipperReactPlugin::runInBackground() {
+  return runInBackground_;
+}
+
+void FlipperReactPlugin::fireOnConnect() {
+  eventHandler_(pluginId_, FlipperReactPluginEvent::CONNECTED);
+}
+
+void FlipperReactPlugin::fireOnDisconnect() {
+  eventHandler_(pluginId_, FlipperReactPluginEvent::DISCONNECTED);
+}
+
+bool FlipperReactPlugin::isConnected() {
+  return connection_ != nullptr;
+}
+
+FlipperConnection* FlipperReactPlugin::getConnection() {
+  return connection_.get();
+}
+
+} // namespace flipper
+} // namespace facebook

react-native/react-native-flipper/windows/ReactNativeFlipper/FlipperReactPlugin.h

@@ -0,0 +1,52 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#pragma once
+
+#include <memory>
+#include "../../../../xplat/Flipper/FlipperPlugin.h"
+
+namespace facebook {
+namespace flipper {
+
+enum class FlipperReactPluginEvent { CONNECTED, DISCONNECTED };
+
+using FlipperConnectionEvent =
+    std::function<void(const std::string& pluginId, FlipperReactPluginEvent e)>;
+
+class FlipperReactPlugin : public FlipperPlugin {
+ public:
+  FlipperReactPlugin(
+      std::string pluginId,
+      bool runInBackground,
+      FlipperConnectionEvent handler);
+  virtual ~FlipperReactPlugin();
+
+  virtual std::string identifier() const override;
+
+  virtual void didConnect(std::shared_ptr<FlipperConnection> conn) override;
+
+  virtual void didDisconnect() override;
+
+  virtual bool runInBackground() override;
+
+  void fireOnConnect();
+  void fireOnDisconnect();
+
+  bool isConnected();
+
+  FlipperConnection* getConnection();
+
+ private:
+  std::string pluginId_;
+  bool runInBackground_;
+  std::shared_ptr<FlipperConnection> connection_;
+  FlipperConnectionEvent eventHandler_;
+};
+
+} // namespace flipper
+} // namespace facebook

react-native/react-native-flipper/windows/ReactNativeFlipper/FlipperReactPluginManager.cpp

@@ -0,0 +1,151 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#include "FlipperReactPluginManager.h"
+#include <FlipperModule.h>
+#include "../../../../xplat/Flipper/FlipperClient.h"
+
+namespace facebook {
+namespace flipper {
+
+static int FlipperResponderKeyGenerator = 0;
+
+folly::dynamic FlipperReactPluginManager::getParams(const std::string& params) {
+  if (params.empty()) {
+    return "";
+  }
+
+  return folly::parseJson(params);
+}
+
+void FlipperReactPluginManager::actionWithPlugin(
+    const std::string& pluginId,
+    std::function<void(FlipperReactPlugin*)> action) {
+  auto flipperClient = facebook::flipper::FlipperClient::instance();
+  if (flipperClient == nullptr) {
+    return;
+  }
+
+  auto existingPlugin = flipperClient->getPlugin(pluginId);
+  if (existingPlugin != nullptr) {
+    FlipperReactPlugin* plugin =
+        dynamic_cast<FlipperReactPlugin*>(existingPlugin.get());
+    if (plugin) {
+      action(plugin);
+    }
+  }
+}
+
+bool FlipperReactPluginManager::registerPlugin(
+    const std::string& pluginId,
+    bool inBackground,
+    FlipperConnectionEvent eventHandler) {
+  auto flipperClient = facebook::flipper::FlipperClient::instance();
+  if (flipperClient == nullptr) {
+    return false;
+  }
+
+  auto existingPlugin = flipperClient->getPlugin(pluginId);
+  if (existingPlugin != nullptr) {
+    FlipperReactPlugin* plugin =
+        dynamic_cast<FlipperReactPlugin*>(existingPlugin.get());
+    if (plugin && plugin->isConnected()) {
+      plugin->fireOnConnect();
+    }
+
+    return true;
+  }
+
+  auto newPlugin = std::make_shared<FlipperReactPlugin>(
+      pluginId, inBackground, eventHandler);
+  flipperClient->addPlugin(newPlugin);
+  return true;
+}
+
+void FlipperReactPluginManager::send(
+    const std::string& pluginId,
+    const std::string& method,
+    const std::string& params) {
+  actionWithPlugin(pluginId, [&method, &params](FlipperReactPlugin* plugin) {
+    if (plugin->isConnected()) {
+      plugin->getConnection()->send(method, getParams(params));
+    }
+  });
+}
+
+void FlipperReactPluginManager::reportError(
+    const std::string& pluginId,
+    const std::string& reason,
+    const std::string& stacktrace) {
+  actionWithPlugin(
+      pluginId, [&reason, &stacktrace](FlipperReactPlugin* plugin) {
+        if (plugin->isConnected()) {
+          plugin->getConnection()->error(reason, stacktrace);
+        }
+      });
+}
+
+void FlipperReactPluginManager::reportError(
+    const std::string& pluginId,
+    const std::string& error) {
+  actionWithPlugin(pluginId, [&error](FlipperReactPlugin* plugin) {
+    if (plugin->isConnected()) {
+      plugin->getConnection()->error(error, "");
+    }
+  });
+}
+void FlipperReactPluginManager::subscribe(
+    const std::string& pluginId,
+    const std::string& method,
+    FlipperReactPluginSubscriptionEvent eventHandler) {
+  actionWithPlugin(
+      pluginId,
+      [this, &pluginId, &method, &eventHandler](FlipperReactPlugin* plugin) {
+        if (plugin->isConnected()) {
+          plugin->getConnection()->receive(
+              method,
+              [this, pluginId, method, eventHandler](
+                  const folly::dynamic& obj,
+                  std::shared_ptr<facebook::flipper::FlipperResponder>
+                      responder) {
+                std::map<std::string, std::string> args{
+                    {"plugin", pluginId},
+                    {"method", method},
+                    {"params", folly::toJson(obj)}};
+                if (responder != nullptr) {
+                  auto responderId =
+                      std::to_string(FlipperResponderKeyGenerator++);
+                  responders_[responderId] = responder;
+                  args["responderId"] = responderId;
+                }
+
+                eventHandler(args);
+              });
+        }
+      });
+}
+void FlipperReactPluginManager::respondSuccess(
+    const std::string& responderId,
+    const std::string& params) {
+  auto responder = responders_.find(responderId);
+  if (responder != responders_.end()) {
+    responder->second->success(getParams(params));
+    responders_.erase(responder);
+  }
+}
+void FlipperReactPluginManager::respondError(
+    const std::string& responderId,
+    const std::string& params) {
+  auto responder = responders_.find(responderId);
+  if (responder != responders_.end()) {
+    responder->second->error(getParams(params));
+    responders_.erase(responder);
+  }
+}
+
+} // namespace flipper
+} // namespace facebook

react-native/react-native-flipper/windows/ReactNativeFlipper/FlipperReactPluginManager.h

@@ -0,0 +1,60 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#pragma once
+
+#include <FlipperReactPlugin.h>
+#include <folly/dynamic.h>
+#include <unordered_map>
+
+namespace facebook {
+namespace flipper {
+
+class FlipperReactPluginManager {
+  using FlipperReactPluginSubscriptionEvent =
+      std::function<void(std::map<std::string, std::string>)>;
+
+ public:
+  bool registerPlugin(
+      const std::string& pluginId,
+      bool inBackground,
+      FlipperConnectionEvent eventHandler);
+
+  void send(
+      const std::string& pluginId,
+      const std::string& method,
+      const std::string& params);
+
+  void reportError(
+      const std::string& pluginId,
+      const std::string& reason,
+      const std::string& stacktrace);
+
+  void reportError(const std::string& pluginId, const std::string& error);
+  void subscribe(
+      const std::string& pluginId,
+      const std::string& method,
+      FlipperReactPluginSubscriptionEvent eventHandler);
+  void respondSuccess(
+      const std::string& responderId,
+      const std::string& params);
+  void respondError(const std::string& responderId, const std::string& params);
+
+ private:
+  static folly::dynamic getParams(const std::string& param);
+  static void actionWithPlugin(
+      const std::string& pluginId,
+      std::function<void(FlipperReactPlugin*)> action);
+
+  std::unordered_map<
+      std::string,
+      std::shared_ptr<facebook::flipper::FlipperResponder>>
+      responders_;
+};
+
+} // namespace flipper
+} // namespace facebook

react-native/react-native-flipper/windows/ReactNativeFlipper/ReactNativeFlipper.vcxproj

@@ -154,6 +154,8 @@
     <ClInclude Include="..\..\..\..\xplat\Flipper\Log.h" />
     <ClInclude Include="FlipperReactBaseSocket.h" />
     <ClInclude Include="FlipperReactDeviceInfo.h" />
+    <ClInclude Include="FlipperReactPlugin.h" />
+    <ClInclude Include="FlipperReactPluginManager.h" />
     <ClInclude Include="FlipperReactScheduler.h" />
     <ClInclude Include="FlipperReactSocket.h" />
     <ClInclude Include="FlipperReactSocketClient.h" />
@@ -175,6 +177,8 @@
     <ClCompile Include="..\..\..\..\xplat\Flipper\FlipperURLSerializer.cpp" />
     <ClCompile Include="..\..\..\..\xplat\Flipper\Log.cpp" />
     <ClCompile Include="FlipperReactDeviceInfo.cpp" />
+    <ClCompile Include="FlipperReactPlugin.cpp" />
+    <ClCompile Include="FlipperReactPluginManager.cpp" />
     <ClCompile Include="FlipperReactSocket.cpp" />
     <ClCompile Include="FlipperReactSocketClient.cpp" />
     <ClCompile Include="pch.cpp">

react-native/react-native-flipper/windows/ReactNativeFlipper/ReactNativeFlipper.vcxproj.filters

@@ -20,6 +20,8 @@
     <ClCompile Include="FlipperReactSocket.cpp" />
     <ClCompile Include="FlipperReactSocketClient.cpp" />
     <ClCompile Include="FlipperReactDeviceInfo.cpp" />
+    <ClCompile Include="FlipperReactPlugin.cpp" />
+    <ClCompile Include="FlipperReactPluginManager.cpp" />
   </ItemGroup>
   <ItemGroup>
     <ClInclude Include="pch.h" />
@@ -54,6 +56,8 @@
     <ClInclude Include="FlipperReactSocket.h" />
     <ClInclude Include="FlipperReactSocketClient.h" />
     <ClInclude Include="FlipperReactDeviceInfo.h" />
+    <ClInclude Include="FlipperReactPlugin.h" />
+    <ClInclude Include="FlipperReactPluginManager.h" />
   </ItemGroup>
   <ItemGroup>
     <None Include="PropertySheet.props" />