react-native-nitro-dgram 0.1.4

package/cpp/UdpManager.hpp

@@ -0,0 +1,108 @@
+#pragma once
+
+#include "UdpBindings.hpp"
+#include <functional>
+#include <memory>
+#include <shared_mutex>
+#include <string>
+#include <unordered_map>
+#include <vector>
+
+#define UM_TAG "UdpManager"
+
+#ifdef __ANDROID__
+#include <android/log.h>
+#define LOGI(...) __android_log_print(ANDROID_LOG_INFO, UM_TAG, __VA_ARGS__)
+#define LOGW(...) __android_log_print(ANDROID_LOG_WARN, UM_TAG, __VA_ARGS__)
+#define LOGE(...) __android_log_print(ANDROID_LOG_ERROR, UM_TAG, __VA_ARGS__)
+#else
+#include <cstdio>
+#define LOGI(...)                                                              \
+  printf("[" UM_TAG "] " __VA_ARGS__);                                         \
+  printf("\n")
+#define LOGW(...)                                                              \
+  printf("[" UM_TAG "] WARN: " __VA_ARGS__);                                   \
+  printf("\n")
+#define LOGE(...)                                                              \
+  printf("[" UM_TAG "] ERROR: " __VA_ARGS__);                                  \
+  printf("\n")
+#endif
+
+namespace margelo::nitro::udp {
+
+class UdpManager {
+public:
+  using EventHandler =
+      std::function<void(int eventType, const uint8_t *data, size_t len,
+                         const std::string &address, int port)>;
+
+  static UdpManager &shared() {
+    static UdpManager instance;
+    return instance;
+  }
+
+  UdpManager() {
+    LOGI("Initializing UdpManager...");
+    ::udp::udp_init(
+        [](uint32_t id, int event_type, const uint8_t *data, uintptr_t len,
+           const char *address, int port, void *context) {
+          auto mgr = static_cast<UdpManager *>(context);
+          mgr->dispatch(id, event_type, data, static_cast<size_t>(len),
+                        address ? address : "", port);
+        },
+        this);
+  }
+
+public:
+  void registerHandler(uint32_t id, EventHandler handler) {
+    LOGI("Registering handler for ID %u", id);
+    std::unique_lock lock(_mutex);
+    _handlers[id] = handler;
+  }
+
+  void unregisterHandler(uint32_t id) {
+    LOGI("Unregistering handler for ID %u", id);
+    std::unique_lock lock(_mutex);
+    _handlers.erase(id);
+  }
+
+private:
+  void dispatch(uint32_t id, int eventType, const uint8_t *data, size_t len,
+                const std::string &address, int port) {
+    const char *eventName = "UNKNOWN";
+    switch (eventType) {
+    case 1:
+      eventName = "DATA";
+      break;
+    case 2:
+      eventName = "ERROR";
+      break;
+    case 3:
+      eventName = "CLOSE";
+      break;
+    }
+
+    LOGI("dispatch: id=%u, event=%s(%d), len=%zu, addr=%s:%d", id, eventName,
+         eventType, len, address.c_str(), port);
+
+    EventHandler handler;
+    {
+      std::shared_lock lock(_mutex);
+      auto it = _handlers.find(id);
+      if (it != _handlers.end()) {
+        handler = it->second;
+      }
+    }
+
+    if (handler) {
+      handler(eventType, data, len, address, port);
+    } else {
+      LOGW("No handler found for id=%u, event=%s", id, eventName);
+    }
+  }
+
+  std::shared_mutex _mutex;
+  std::unordered_map<uint32_t, EventHandler> _handlers;
+};
+
+} // namespace margelo::nitro::udp

package/ios/Frameworks/RustCUdp.xcframework/Info.plist

@@ -0,0 +1,44 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+	<key>AvailableLibraries</key>
+	<array>
+		<dict>
+			<key>BinaryPath</key>
+			<string>RustCUdp.framework/RustCUdp</string>
+			<key>LibraryIdentifier</key>
+			<string>ios-arm64</string>
+			<key>LibraryPath</key>
+			<string>RustCUdp.framework</string>
+			<key>SupportedArchitectures</key>
+			<array>
+				<string>arm64</string>
+			</array>
+			<key>SupportedPlatform</key>
+			<string>ios</string>
+		</dict>
+		<dict>
+			<key>BinaryPath</key>
+			<string>RustCUdp.framework/RustCUdp</string>
+			<key>LibraryIdentifier</key>
+			<string>ios-arm64_x86_64-simulator</string>
+			<key>LibraryPath</key>
+			<string>RustCUdp.framework</string>
+			<key>SupportedArchitectures</key>
+			<array>
+				<string>arm64</string>
+				<string>x86_64</string>
+			</array>
+			<key>SupportedPlatform</key>
+			<string>ios</string>
+			<key>SupportedPlatformVariant</key>
+			<string>simulator</string>
+		</dict>
+	</array>
+	<key>CFBundlePackageType</key>
+	<string>XFWK</string>
+	<key>XCFrameworkFormatVersion</key>
+	<string>1.0</string>
+</dict>
+</plist>

package/ios/Frameworks/RustCUdp.xcframework/ios-arm64/RustCUdp.framework/Info.plist

@@ -0,0 +1,20 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+    <key>CFBundleExecutable</key>
+    <string>RustCUdp</string>
+    <key>CFBundleIdentifier</key>
+    <string>com.iwater.RustCUdp</string>
+    <key>CFBundleName</key>
+    <string>RustCUdp</string>
+    <key>CFBundlePackageType</key>
+    <string>FMWK</string>
+    <key>CFBundleVersion</key>
+    <string>1.0</string>
+    <key>CFBundleShortVersionString</key>
+    <string>1.0</string>
+    <key>MinimumOSVersion</key>
+    <string>13.0</string>
+</dict>
+</plist>

package/ios/Frameworks/RustCUdp.xcframework/ios-arm64_x86_64-simulator/RustCUdp.framework/Info.plist

@@ -0,0 +1,20 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+    <key>CFBundleExecutable</key>
+    <string>RustCUdp</string>
+    <key>CFBundleIdentifier</key>
+    <string>com.iwater.RustCUdp</string>
+    <key>CFBundleName</key>
+    <string>RustCUdp</string>
+    <key>CFBundlePackageType</key>
+    <string>FMWK</string>
+    <key>CFBundleVersion</key>
+    <string>1.0</string>
+    <key>CFBundleShortVersionString</key>
+    <string>1.0</string>
+    <key>MinimumOSVersion</key>
+    <string>13.0</string>
+</dict>
+</plist>

package/lib/Driver.d.ts

@@ -0,0 +1,2 @@
+import type { UdpDriver } from './Udp.nitro';
+export declare const Driver: UdpDriver;

package/lib/Driver.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Driver = void 0;
+const react_native_nitro_modules_1 = require("react-native-nitro-modules");
+exports.Driver = react_native_nitro_modules_1.NitroModules.createHybridObject('UdpDriver');
+//# sourceMappingURL=Driver.js.map

package/lib/Driver.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Driver.js","sourceRoot":"","sources":["../src/Driver.ts"],"names":[],"mappings":";;;AAAA,2EAAyD;AAG5C,QAAA,MAAM,GAAG,yCAAY,CAAC,kBAAkB,CAAY,WAAW,CAAC,CAAA"}

package/lib/Udp.nitro.d.ts

@@ -0,0 +1,54 @@
+import { type HybridObject } from 'react-native-nitro-modules';
+/**
+ * @specs
+ */
+export interface UdpSocketDriver extends HybridObject<{
+    ios: 'swift';
+    android: 'kotlin';
+}> {
+    readonly id: number;
+    bind(port: number, address: string, ipv6Only: boolean): number;
+    connect(port: number, address: string): number;
+    disconnect(): number;
+    send(data: ArrayBuffer, port: number, address: string): number;
+    sendMultiple(data: ArrayBuffer[], port: number, address: string): number;
+    close(): void;
+    setBroadcast(flag: boolean): number;
+    setTTL(ttl: number): number;
+    setMulticastTTL(ttl: number): number;
+    setMulticastLoopback(flag: boolean): number;
+    setMulticastInterface(interfaceAddress: string): number;
+    addMembership(multicastAddress: string, interfaceAddress?: string): number;
+    dropMembership(multicastAddress: string, interfaceAddress?: string): number;
+    addSourceSpecificMembership(sourceAddress: string, groupAddress: string, interfaceAddress?: string): number;
+    dropSourceSpecificMembership(sourceAddress: string, groupAddress: string, interfaceAddress?: string): number;
+    getLocalAddress(): string;
+    getLocalPort(): number;
+    getRemoteAddress(): string;
+    getRemotePort(): number;
+    getRecvBufferSize(): number;
+    setRecvBufferSize(size: number): number;
+    getSendBufferSize(): number;
+    setSendBufferSize(size: number): number;
+    getSendQueueCount(): number;
+    getSendQueueSize(): number;
+    onMessage: (data: ArrayBuffer, address: string, port: number) => void;
+    onConnect: () => void;
+    onError: (error: string) => void;
+    onClose: () => void;
+}
+export interface RemoteInfo {
+    address: string;
+    family: 'IPv4' | 'IPv6';
+    port: number;
+    size: number;
+}
+/**
+ * @specs
+ */
+export interface UdpDriver extends HybridObject<{
+    ios: 'swift';
+    android: 'kotlin';
+}> {
+    createSocket(id?: string): UdpSocketDriver;
+}

package/lib/Udp.nitro.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=Udp.nitro.js.map

package/lib/Udp.nitro.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Udp.nitro.js","sourceRoot":"","sources":["../src/Udp.nitro.ts"],"names":[],"mappings":""}

package/lib/index.d.ts

@@ -0,0 +1,82 @@
+import { EventEmitter } from 'eventemitter3';
+import type { RemoteInfo } from './Udp.nitro';
+import { Buffer } from 'react-native-nitro-buffer';
+export type SocketType = 'udp4' | 'udp6';
+export declare class BlockList {
+    private _rules;
+    addAddress(address: string, family?: 'ipv4' | 'ipv6'): void;
+    addRange(start: string, end: string, family?: 'ipv4' | 'ipv6'): void;
+    addSubnet(net: string, prefix: number, family?: 'ipv4' | 'ipv6'): void;
+    check(address: string, family?: 'ipv4' | 'ipv6'): boolean;
+}
+export interface SocketOptions {
+    type: SocketType;
+    reuseAddr?: boolean;
+    reusePort?: boolean;
+    ipv6Only?: boolean;
+    recvBufferSize?: number;
+    sendBufferSize?: number;
+    signal?: AbortSignal;
+    lookup?: (hostname: string, options: any, callback: (err: Error | null, address: string, family: number) => void) => void;
+    receiveBlockList?: BlockList;
+    sendBlockList?: BlockList;
+}
+export declare class Socket extends EventEmitter {
+    private _driver;
+    private _type;
+    private _bound;
+    private _closed;
+    private _connected;
+    private _signal?;
+    private _lookup?;
+    private _receiveBlockList?;
+    private _sendBlockList?;
+    constructor(type: SocketType | SocketOptions);
+    [Symbol.asyncDispose](): Promise<void>;
+    private _setupEvents;
+    bind(port?: number, address?: string, callback?: () => void): this;
+    bind(options: {
+        port?: number;
+        address?: string;
+        exclusive?: boolean;
+    }, callback?: () => void): this;
+    connect(port: number, address?: string, callback?: () => void): void;
+    disconnect(): void;
+    send(msg: string | Uint8Array | ReadonlyArray<any>, port?: number, address?: string, callback?: (error: Error | null, bytes: number) => void): void;
+    send(msg: string | Uint8Array, offset: number, length: number, port?: number, address?: string, callback?: (error: Error | null, bytes: number) => void): void;
+    close(callback?: () => void): this;
+    address(): {
+        address: string;
+        family: string;
+        port: number;
+    };
+    remoteAddress(): {
+        address: string;
+        family: string;
+        port: number;
+    };
+    setBroadcast(flag: boolean): void;
+    setTTL(ttl: number): void;
+    setMulticastTTL(ttl: number): void;
+    setMulticastLoopback(flag: boolean): void;
+    setMulticastInterface(interfaceAddress: string): void;
+    addMembership(multicastAddress: string, interfaceAddress?: string): void;
+    dropMembership(multicastAddress: string, interfaceAddress?: string): void;
+    addSourceSpecificMembership(sourceAddress: string, groupAddress: string, interfaceAddress?: string): void;
+    dropSourceSpecificMembership(sourceAddress: string, groupAddress: string, interfaceAddress?: string): void;
+    getRecvBufferSize(): number;
+    setRecvBufferSize(size: number): void;
+    getSendBufferSize(): number;
+    setSendBufferSize(size: number): void;
+    getSendQueueCount(): number;
+    getSendQueueSize(): number;
+    ref(): this;
+    unref(): this;
+}
+export declare function createSocket(type: SocketType | SocketOptions, callback?: (msg: Buffer, rinfo: RemoteInfo) => void): Socket;
+declare const _default: {
+    createSocket: typeof createSocket;
+    Socket: typeof Socket;
+    BlockList: typeof BlockList;
+};
+export default _default;