react-native-nitro-dgram 0.1.4

package/android/CMakeLists.txt

@@ -0,0 +1,24 @@
+cmake_minimum_required(VERSION 3.9.0)
+project(RustCUdp)
+
+set(PACKAGE_NAME RustCUdp)
+set(CMAKE_VERBOSE_MAKEFILE ON)
+set(CMAKE_CXX_STANDARD 20)
+
+add_library(${PACKAGE_NAME} SHARED
+        ../cpp/HybridUdpDriver.cpp
+        ../cpp/HybridUdpSocketDriver.cpp
+        OnLoad.cpp
+)
+
+include_directories(
+    ${CMAKE_CURRENT_SOURCE_DIR}/../cpp
+)
+
+include(${CMAKE_CURRENT_SOURCE_DIR}/../nitrogen/generated/android/RustCUdp+autolinking.cmake)
+
+target_link_directories(${PACKAGE_NAME} PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}/libs/${ANDROID_ABI})
+target_link_libraries(${PACKAGE_NAME} 
+    rust_c_udp
+    log
+)

package/android/OnLoad.cpp

@@ -0,0 +1,6 @@
+#include "RustCUdpOnLoad.hpp"
+#include <jni.h>
+
+JNIEXPORT jint JNICALL JNI_OnLoad(JavaVM *vm, void *) {
+  return margelo::nitro::udp::initialize(vm);
+}

package/android/build.gradle

@@ -0,0 +1,64 @@
+apply plugin: 'com.android.library'
+apply plugin: 'org.jetbrains.kotlin.android'
+
+def reactNativeArchitectures() {
+    def value = rootProject.getProperties().get("reactNativeArchitectures")
+    return value ? value.split(",") : ["armeabi-v7a", "x86", "x86_64", "arm64-v8a"]
+}
+
+def getExtOrDefault(name, defaultValue) {
+    return rootProject.ext.has(name) ? rootProject.ext.get(name) : defaultValue
+}
+
+android {
+    namespace "com.margelo.nitro.udp"
+    ndkVersion getExtOrDefault("ndkVersion", "27.1.12297006")
+    compileSdkVersion getExtOrDefault('compileSdkVersion', 35)
+
+    defaultConfig {
+        minSdkVersion getExtOrDefault('minSdkVersion', 21)
+        targetSdkVersion getExtOrDefault('targetSdkVersion', 35)
+
+        externalNativeBuild {
+            cmake {
+                cppFlags "-fexceptions", "-frtti", "-std=c++20"
+                arguments "-DANDROID_STL=c++_shared"
+                abiFilters (*reactNativeArchitectures())
+            }
+        }
+    }
+
+    buildFeatures {
+        buildConfig true
+        prefab true
+    }
+
+    sourceSets {
+        main {
+            jniLibs.srcDirs += ['libs']
+        }
+    }
+
+    externalNativeBuild {
+        cmake {
+            path "CMakeLists.txt"
+        }
+    }
+
+    packagingOptions {
+        excludes += [
+            "**/libc++_shared.so",
+            "**/libjsi.so",
+            "**/libreactnativejni.so",
+            "**/libreact_nativemodule_core.so",
+            "**/libturbomodulejsijni.so"
+        ]
+    }
+}
+
+dependencies {
+    implementation "com.facebook.react:react-native:+"
+    implementation project(':react-native-nitro-modules')
+}
+
+apply from: "../nitrogen/generated/android/RustCUdp+autolinking.gradle"

package/android/src/main/java/com/margelo/nitro/udp/NitroUdpPackage.java

@@ -0,0 +1,25 @@
+package com.margelo.nitro.udp;
+
+import androidx.annotation.NonNull;
+import com.facebook.react.ReactPackage;
+import com.facebook.react.bridge.NativeModule;
+import com.facebook.react.bridge.ReactApplicationContext;
+import com.facebook.react.uimanager.ViewManager;
+import java.util.Collections;
+import java.util.List;
+
+public class NitroUdpPackage implements ReactPackage {
+    @NonNull
+    @Override
+    public List<NativeModule> createNativeModules(@NonNull ReactApplicationContext reactContext) {
+        // Initialize the native library
+        RustCUdpOnLoad.initializeNative();
+        return Collections.emptyList();
+    }
+
+    @NonNull
+    @Override
+    public List<ViewManager> createViewManagers(@NonNull ReactApplicationContext reactContext) {
+        return Collections.emptyList();
+    }
+}

package/cpp/HybridUdpDriver.cpp

@@ -0,0 +1,21 @@
+#include "HybridUdpDriver.hpp"
+#include "HybridUdpSocketDriver.hpp"
+
+namespace margelo::nitro::udp {
+
+HybridUdpDriver::HybridUdpDriver() : HybridObject(TAG) {}
+
+std::shared_ptr<HybridUdpSocketDriverSpec>
+HybridUdpDriver::createSocket(const std::optional<std::string> &id) {
+  if (id.has_value()) {
+    try {
+      uint32_t socketId = static_cast<uint32_t>(std::stoul(id.value()));
+      return std::make_shared<HybridUdpSocketDriver>(socketId);
+    } catch (...) {
+      // Fallback
+    }
+  }
+  return std::make_shared<HybridUdpSocketDriver>();
+}
+
+} // namespace margelo::nitro::udp

package/cpp/HybridUdpDriver.hpp

@@ -0,0 +1,18 @@
+#pragma once
+
+#include "../nitrogen/generated/shared/c++/HybridUdpDriverSpec.hpp"
+#include <memory>
+#include <optional>
+#include <string>
+
+namespace margelo::nitro::udp {
+
+class HybridUdpDriver : public HybridUdpDriverSpec {
+public:
+  HybridUdpDriver();
+
+  std::shared_ptr<HybridUdpSocketDriverSpec>
+  createSocket(const std::optional<std::string> &id) override;
+};
+
+} // namespace margelo::nitro::udp

package/cpp/HybridUdpSocketDriver.cpp

@@ -0,0 +1,252 @@
+#include "HybridUdpSocketDriver.hpp"
+#include "UdpManager.hpp"
+
+namespace margelo::nitro::udp {
+
+HybridUdpSocketDriver::HybridUdpSocketDriver() : HybridObject(TAG) {
+  _id = ::udp::udp_create();
+  _originalId = _id;
+  UdpManager::shared().registerHandler(
+      _id, [this](int type, const uint8_t *data, size_t len,
+                  const std::string &address, int port) {
+        this->onNativeEvent(type, data, len, address, port);
+      });
+}
+
+HybridUdpSocketDriver::HybridUdpSocketDriver(uint32_t id)
+    : HybridObject(TAG), _id(id), _originalId(id) {
+  UdpManager::shared().registerHandler(
+      _id, [this](int type, const uint8_t *data, size_t len,
+                  const std::string &address, int port) {
+        this->onNativeEvent(type, data, len, address, port);
+      });
+}
+
+HybridUdpSocketDriver::~HybridUdpSocketDriver() { close(); }
+
+double HybridUdpSocketDriver::getId() { return static_cast<double>(_id); }
+
+std::function<void(const std::shared_ptr<ArrayBuffer> &, const std::string &,
+                   double)>
+HybridUdpSocketDriver::getOnMessage() {
+  return _onMessage;
+}
+void HybridUdpSocketDriver::setOnMessage(
+    const std::function<void(const std::shared_ptr<ArrayBuffer> &,
+                             const std::string &, double)> &onMessage) {
+  _onMessage = onMessage;
+}
+
+std::function<void(const std::string &)> HybridUdpSocketDriver::getOnError() {
+  return _onError;
+}
+void HybridUdpSocketDriver::setOnError(
+    const std::function<void(const std::string &)> &onError) {
+  _onError = onError;
+}
+
+std::function<void()> HybridUdpSocketDriver::getOnClose() { return _onClose; }
+void HybridUdpSocketDriver::setOnClose(const std::function<void()> &onClose) {
+  _onClose = onClose;
+}
+
+double HybridUdpSocketDriver::bind(double port, const std::string &address,
+                                   bool ipv6Only) {
+  return static_cast<double>(
+      ::udp::udp_bind(_id, address.empty() ? nullptr : address.c_str(),
+                      static_cast<int>(port), ipv6Only));
+}
+
+double HybridUdpSocketDriver::connect(double port, const std::string &address) {
+  return static_cast<double>(
+      ::udp::udp_connect(_id, address.c_str(), static_cast<int>(port)));
+}
+
+double HybridUdpSocketDriver::disconnect() {
+  return static_cast<double>(::udp::udp_disconnect(_id));
+}
+
+double HybridUdpSocketDriver::send(const std::shared_ptr<ArrayBuffer> &data,
+                                   double port, const std::string &address) {
+  if (!data)
+    return -1;
+  return static_cast<double>(::udp::udp_send(_id, data->data(), data->size(),
+                                             address.c_str(),
+                                             static_cast<int>(port)));
+}
+
+double HybridUdpSocketDriver::sendMultiple(
+    const std::vector<std::shared_ptr<ArrayBuffer>> &data, double port,
+    const std::string &address) {
+  if (data.empty())
+    return 0;
+
+  std::vector<const uint8_t *> datas;
+  std::vector<size_t> lens;
+  datas.reserve(data.size());
+  lens.reserve(data.size());
+
+  for (const auto &buffer : data) {
+    if (buffer) {
+      datas.push_back(buffer->data());
+      lens.push_back(buffer->size());
+    }
+  }
+
+  if (datas.empty())
+    return 0;
+
+  return static_cast<double>(
+      ::udp::udp_send_multiple(_id, datas.data(), lens.data(), datas.size(),
+                               address.c_str(), static_cast<int>(port)));
+}
+
+void HybridUdpSocketDriver::close() {
+  if (_id != 0) {
+    ::udp::udp_close(_id);
+    // NOTE: Do NOT unregister handler here!
+    // The handler will be unregistered when EVENT_CLOSE is received in
+    // onNativeEvent. This ensures the close event can be properly delivered to
+    // JS layer.
+    _id = 0;
+  }
+}
+
+double HybridUdpSocketDriver::setBroadcast(bool flag) {
+  return static_cast<double>(::udp::udp_set_broadcast(_id, flag));
+}
+double HybridUdpSocketDriver::setTTL(double ttl) {
+  return static_cast<double>(
+      ::udp::udp_set_ttl(_id, static_cast<uint32_t>(ttl)));
+}
+double HybridUdpSocketDriver::setMulticastTTL(double ttl) {
+  return static_cast<double>(
+      ::udp::udp_set_multicast_ttl_v4(_id, static_cast<uint32_t>(ttl)));
+}
+double HybridUdpSocketDriver::setMulticastLoopback(bool flag) {
+  return static_cast<double>(::udp::udp_set_multicast_loop_v4(_id, flag));
+}
+double HybridUdpSocketDriver::setMulticastInterface(
+    const std::string &interfaceAddress) {
+  return -1;
+}
+double HybridUdpSocketDriver::addMembership(
+    const std::string &multicastAddress,
+    const std::optional<std::string> &interfaceAddress) {
+  return -1;
+}
+double HybridUdpSocketDriver::dropMembership(
+    const std::string &multicastAddress,
+    const std::optional<std::string> &interfaceAddress) {
+  return -1;
+}
+
+double HybridUdpSocketDriver::addSourceSpecificMembership(
+    const std::string &sourceAddress, const std::string &groupAddress,
+    const std::optional<std::string> &interfaceAddress) {
+  return static_cast<double>(::udp::udp_add_source_specific_membership(
+      _id, sourceAddress.c_str(), groupAddress.c_str(),
+      interfaceAddress.has_value() ? interfaceAddress.value().c_str()
+                                   : nullptr));
+}
+
+double HybridUdpSocketDriver::dropSourceSpecificMembership(
+    const std::string &sourceAddress, const std::string &groupAddress,
+    const std::optional<std::string> &interfaceAddress) {
+  return static_cast<double>(::udp::udp_drop_source_specific_membership(
+      _id, sourceAddress.c_str(), groupAddress.c_str(),
+      interfaceAddress.has_value() ? interfaceAddress.value().c_str()
+                                   : nullptr));
+}
+
+std::string HybridUdpSocketDriver::getLocalAddress() {
+  char buf[256];
+  if (::udp::udp_get_local_addr(_id, buf, sizeof(buf)) == 0) {
+    return std::string(buf);
+  }
+  return "";
+}
+
+double HybridUdpSocketDriver::getLocalPort() {
+  return static_cast<double>(::udp::udp_get_local_port(_id));
+}
+
+std::string HybridUdpSocketDriver::getRemoteAddress() {
+  char buf[256];
+  if (::udp::udp_get_peer_addr(_id, buf, sizeof(buf)) == 0) {
+    return std::string(buf);
+  }
+  return "";
+}
+
+double HybridUdpSocketDriver::getRemotePort() {
+  return static_cast<double>(::udp::udp_get_peer_port(_id));
+}
+
+double HybridUdpSocketDriver::getRecvBufferSize() {
+  return static_cast<double>(::udp::udp_get_buffer_size(_id, false));
+}
+
+double HybridUdpSocketDriver::setRecvBufferSize(double size) {
+  return static_cast<double>(
+      ::udp::udp_set_buffer_size(_id, false, static_cast<int>(size)));
+}
+
+double HybridUdpSocketDriver::getSendBufferSize() {
+  return static_cast<double>(::udp::udp_get_buffer_size(_id, true));
+}
+
+double HybridUdpSocketDriver::setSendBufferSize(double size) {
+  return static_cast<double>(
+      ::udp::udp_set_buffer_size(_id, true, static_cast<int>(size)));
+}
+
+double HybridUdpSocketDriver::getSendQueueCount() {
+  return static_cast<double>(::udp::udp_get_send_queue_count(_id));
+}
+
+double HybridUdpSocketDriver::getSendQueueSize() {
+  return static_cast<double>(::udp::udp_get_send_queue_size(_id));
+}
+
+std::function<void()> HybridUdpSocketDriver::getOnConnect() {
+  return _onConnect;
+}
+void HybridUdpSocketDriver::setOnConnect(
+    const std::function<void()> &onConnect) {
+  _onConnect = onConnect;
+}
+
+void HybridUdpSocketDriver::onNativeEvent(int type, const uint8_t *data,
+                                          size_t len,
+                                          const std::string &address,
+                                          int port) {
+  switch (type) {
+  case 1: // DATA
+    if (_onMessage) {
+      auto ab = ArrayBuffer::copy(data, len);
+      _onMessage(ab, address, static_cast<double>(port));
+    }
+    break;
+  case 2: // ERROR
+    if (_onError) {
+      _onError(data ? std::string(reinterpret_cast<const char *>(data), len)
+                    : "Unknown error");
+    }
+    break;
+  case 3: // CLOSE
+    // Unregister handler now that we've received the close event
+    UdpManager::shared().unregisterHandler(_originalId);
+    if (_onClose) {
+      _onClose();
+    }
+    break;
+  case 4: // CONNECT
+    if (_onConnect) {
+      _onConnect();
+    }
+    break;
+  }
+}
+
+} // namespace margelo::nitro::udp

package/cpp/HybridUdpSocketDriver.hpp

@@ -0,0 +1,88 @@
+#pragma once
+
+#include "../nitrogen/generated/shared/c++/HybridUdpSocketDriverSpec.hpp"
+#include "UdpBindings.hpp"
+#include <NitroModules/ArrayBuffer.hpp>
+#include <string>
+
+namespace margelo::nitro::udp {
+
+using namespace margelo::nitro;
+
+class HybridUdpSocketDriver : public HybridUdpSocketDriverSpec {
+public:
+  HybridUdpSocketDriver();
+  explicit HybridUdpSocketDriver(uint32_t id);
+  ~HybridUdpSocketDriver() override;
+
+  // Properties
+  double getId() override;
+  std::function<void(const std::shared_ptr<ArrayBuffer> &, const std::string &,
+                     double)>
+  getOnMessage() override;
+  void setOnMessage(
+      const std::function<void(const std::shared_ptr<ArrayBuffer> &,
+                               const std::string &, double)> &onMessage)
+      override;
+  std::function<void(const std::string &)> getOnError() override;
+  void
+  setOnError(const std::function<void(const std::string &)> &onError) override;
+  std::function<void()> getOnClose() override;
+  void setOnClose(const std::function<void()> &onClose) override;
+
+  // Methods
+  double bind(double port, const std::string &address, bool ipv6Only) override;
+  double connect(double port, const std::string &address) override;
+  double disconnect() override;
+  double send(const std::shared_ptr<ArrayBuffer> &data, double port,
+              const std::string &address) override;
+  double sendMultiple(const std::vector<std::shared_ptr<ArrayBuffer>> &data,
+                      double port, const std::string &address) override;
+  void close() override;
+  double setBroadcast(bool flag) override;
+  double setTTL(double ttl) override;
+  double setMulticastTTL(double ttl) override;
+  double setMulticastLoopback(bool flag) override;
+  double setMulticastInterface(const std::string &interfaceAddress) override;
+  double
+  addMembership(const std::string &multicastAddress,
+                const std::optional<std::string> &interfaceAddress) override;
+  double
+  dropMembership(const std::string &multicastAddress,
+                 const std::optional<std::string> &interfaceAddress) override;
+  double addSourceSpecificMembership(
+      const std::string &sourceAddress, const std::string &groupAddress,
+      const std::optional<std::string> &interfaceAddress) override;
+  double dropSourceSpecificMembership(
+      const std::string &sourceAddress, const std::string &groupAddress,
+      const std::optional<std::string> &interfaceAddress) override;
+  std::string getLocalAddress() override;
+  double getLocalPort() override;
+  std::string getRemoteAddress() override;
+  double getRemotePort() override;
+
+  double getRecvBufferSize() override;
+  double setRecvBufferSize(double size) override;
+  double getSendBufferSize() override;
+  double setSendBufferSize(double size) override;
+  double getSendQueueCount() override;
+  double getSendQueueSize() override;
+
+  std::function<void()> getOnConnect() override;
+  void setOnConnect(const std::function<void()> &onConnect) override;
+
+private:
+  void onNativeEvent(int type, const uint8_t *data, size_t len,
+                     const std::string &address, int port);
+
+  uint32_t _id;
+  uint32_t _originalId; // Preserved for handler cleanup after close()
+  std::function<void(const std::shared_ptr<ArrayBuffer> &, const std::string &,
+                     double)>
+      _onMessage;
+  std::function<void()> _onConnect;
+  std::function<void(const std::string &)> _onError;
+  std::function<void()> _onClose;
+};
+
+} // namespace margelo::nitro::udp

package/cpp/UdpBindings.hpp

@@ -0,0 +1,83 @@
+#ifndef UDP_BINDINGS_H
+#define UDP_BINDINGS_H
+
+#include <cstdarg>
+#include <cstdint>
+#include <cstdlib>
+#include <ostream>
+#include <new>
+
+namespace udp {
+
+using CallbackPtr = void(*)(uint32_t id,
+                            int event_type,
+                            const uint8_t *data,
+                            uintptr_t len,
+                            const char *address,
+                            int port,
+                            void *context);
+
+extern "C" {
+
+void udp_init(CallbackPtr callback, void *context);
+
+void udp_init_with_config(CallbackPtr callback, void *context, uint32_t worker_threads);
+
+uint32_t udp_create();
+
+int32_t udp_bind(uint32_t id, const char *host, int port, bool ipv6_only);
+
+int32_t udp_send(uint32_t id, const uint8_t *data, uintptr_t len, const char *host, int port);
+
+int32_t udp_get_send_queue_count(uint32_t id);
+
+int32_t udp_get_send_queue_size(uint32_t id);
+
+int32_t udp_send_multiple(uint32_t id,
+                          const uint8_t *const *datas,
+                          const uintptr_t *lens,
+                          uintptr_t count,
+                          const char *host,
+                          int port);
+
+int32_t udp_connect(uint32_t id, const char *host, int port);
+
+int32_t udp_get_buffer_size(uint32_t id, bool is_send);
+
+int32_t udp_set_buffer_size(uint32_t id, bool is_send, int32_t size);
+
+int32_t udp_disconnect(uint32_t _id);
+
+void udp_close(uint32_t id);
+
+int32_t udp_set_broadcast(uint32_t id, bool flag);
+
+int32_t udp_set_ttl(uint32_t id, uint32_t ttl);
+
+int32_t udp_set_multicast_ttl_v4(uint32_t id, uint32_t ttl);
+
+int32_t udp_set_multicast_loop_v4(uint32_t id, bool flag);
+
+int32_t udp_get_local_addr(uint32_t id, char *buf, uintptr_t max_len);
+
+int32_t udp_get_local_port(uint32_t id);
+
+int32_t udp_get_peer_addr(uint32_t id, char *buf, uintptr_t max_len);
+
+int32_t udp_get_peer_port(uint32_t id);
+
+int32_t udp_add_source_specific_membership(uint32_t id,
+                                           const char *source_addr,
+                                           const char *group_addr,
+                                           const char *interface_addr);
+
+int32_t udp_drop_source_specific_membership(uint32_t id,
+                                            const char *source_addr,
+                                            const char *group_addr,
+                                            const char *interface_addr);
+
+} // extern "C"
+
+} // namespace udp
+
+#endif // UDP_BINDINGS_H