@dawidzawada/bonjour-zeroconf 1.0.0 → 1.1.0

package/README.md

@@ -1,23 +1,279 @@
-# @dawidzawada/bonjour-zeroconf
+<picture>
+  <source media="(prefers-color-scheme: dark)" srcset="./docs/banner-dark.png" />
+  <source media="(prefers-color-scheme: light)" srcset="./docs/banner-light.png" />
+  <img alt="BonjourZeroconf" src="./docs/banner-light.png" />
+</picture>
 
-Zeroconf devices scanner using Bonjour (iOS) and NSD (Android) for React Native & Expo apps. Powered by Nitro Modules.
+# Bonjour Zeroconf 🇫🇷🥖
 
-## Installation
+⚡ **High-performance Zeroconf/mDNS service discovery for React Native**
+
+Discover devices and services on your local network using native Bonjour (iOS) and NSD (Android) APIs. Built with [Nitro Modules](https://nitro.margelo.com/) for maximum performance. Designed for both React Native and Expo. 🧑‍🚀
+
+## ✨ Features
+
+- 🏎️ **Racecar performance** – powered by Nitro Modules
+- 🛡️ **Type-safe** – thanks to Nitro & Nitrogen
+- 📡 **Cross-platform** – iOS (Bonjour) and Android (NSD)
+- 📱 **Managing iOS permissions** - no need for extra libraries or custom code, just use `requestLocalNetworkPermission` or `useLocalNetworkPermission` before scanning!
+- 🔄 **Real-time updates** – listen to scan results, state changes, and errors
+- 🧩 **Expo compatible** - (config plugin coming soon)
+
+## 📦 Installation
 
 ```sh
 npm install @dawidzawada/bonjour-zeroconf react-native-nitro-modules
+```
+
+> **Note:** `react-native-nitro-modules` is required as a peer dependency.
+
+## ⚙️ iOS Setup
+
+On iOS we need to ask for permissions and configure services we want to scan.
+
+### Expo:
+
+Add this to your `app.json`, `app.config.json` or `app.config.js`:
+
+```ts
+{
+  ios: {
+    infoPlist: {
+      NSLocalNetworkUsageDescription:
+        'This app needs local network access to discover devices',
+      NSBonjourServices: ['_bonjour._tcp', '_lnp._tcp.'],
+    },
+  },
+}
+// Add service types you want to scan to NSBonjourServices, first two service types are needed for permissions
+```
+
+Run prebuild command:
+
+```sh
+npx expo prebuild
+```
+
+### React Native:
+
+Add this to your `Info.plist`:
+
+```xml
+<key>NSLocalNetworkUsageDescription</key>
+<string>This app needs local network access to discover devices</string>
+<key>NSBonjourServices</key>
+<array>
+    <!-- Needed for permissions -->
+    <string>_bonjour._tcp</string>
+    <string>_lnp._tcp</string>
+    <!-- Add other service types you need here -->
+</array>
+```
+
+## 🚀 Quick Start
+
+```tsx
+import {
+  Scanner,
+  useIsScanning,
+  type ScanResult,
+} from '@dawidzawada/bonjour-zeroconf';
+import { useEffect, useState } from 'react';
+
+function App() {
+  const [devices, setDevices] = useState<ScanResult[]>([]);
 
-> `react-native-nitro-modules` is required as this library relies on [Nitro Modules](https://nitro.margelo.com/).
+  const handleScan = async () => {
+    const granted = await requestLocalNetworkPermission();
+    if (granted) {
+      Scanner.scan('_bonjour._tcp', 'local');
+    }
+  };
+
+  const handleStop = async () => {
+    Scanner.stop();
+  };
+
+  const handleCheck = async () => {
+    Alert.alert(`Is scanning? ${Scanner.isScanning}`);
+  };
+
+  useEffect(() => {
+    // Listen for discovered devices
+    const { remove } = Scanner.listenForScanResults((scan) => {
+      setResults(scan);
+    });
+
+    return () => {
+      remove();
+    };
+  }, []);
+
+  return (
+    <View>
+      <Button title={'Scan'} onPress={handleScan} />
+      <Button title={'Stop'} onPress={handleStop} />
+      {devices.map((device) => (
+        <Text key={device.name}>
+          {device.name} - {device.ipv4}:{device.port}
+        </Text>
+      ))}
+    </View>
+  );
+}
 ```
 
-## Usage
+---
+
+## 📖 API Reference
+
+### **Scanner**
+
+#### `scan(type: string, domain: string, options?: ScanOptions)`
 
-```js
-import { Scanner } from '@dawidzawada/bonjour-zeroconf';
+Start scanning for services.
 
-// ...
+```ts
+Scanner.scan('_http._tcp', 'local');
+```
 
-Scanner.scan('_bonjour._tcp', 'local');
+```ts
+Scanner.scan('_printer._tcp', 'local', {
+  addressResolveTimeout: 10000, // ms
+});
+```
+
+**Common service types:**
+
+- `_http._tcp` – HTTP servers
+- `_ssh._tcp` – SSH servers
+- `_airplay._tcp` – AirPlay devices
+- `_printer._tcp` – Network printers
+
+#### `scanFor(time: number, type: string, domain: string, options?: ScanOptions)`
+
+Scan for services for a specified duration and return results as a Promise.
+
+```ts
+const devices = await Scanner.scanFor(15, '_http._tcp', 'local');
+console.log('Found devices:', devices);
+```
+
+```ts
+const devices = await Scanner.scanFor(25, '_printer._tcp', 'local', {
+  addressResolveTimeout: 10000, // ms
+});
+```
+
+**Parameters:**
+
+- `time` – Duration in seconds to scan before stopping
+- `type` – Service type to discover
+- `domain` – Domain to scan (typically `'local'`)
+- `options` – Optional scan configuration
+
+**Returns:** `Promise<ScanResult[]>` – Array of discovered services
+
+#### `stop()`
+
+Stop scanning and clear cached results.
+
+```ts
+Scanner.stop();
+```
+
+#### `listenForScanResults(callback)`
+
+Listen for discovered services.
+
+```ts
+const listener = Scanner.listenForScanResults((results: ScanResult[]) => {
+  console.log('Found devices:', results);
+});
+
+// Clean up listener
+listener.remove();
+```
+
+#### `listenForScanState(callback)`
+
+Listen for scanning state changes.
+
+```ts
+const listener = Scanner.listenForScanState((isScanning: boolean) => {
+  console.log('Scanning:', isScanning);
+});
+
+// Clean up listener
+listener.remove();
+```
+
+#### `listenForScanFail(callback)`
+
+Listen for scan failures.
+
+```ts
+const listener = Scanner.listenForScanFail((error: BonjourFail) => {
+  console.log('Scan failed:', error);
+});
+
+// Clean up listener
+listener.remove();
+```
+
+---
+
+### **Hooks**
+
+#### `useIsScanning()`
+
+React hook that returns the current scanning state.
+
+```tsx
+const isScanning = useIsScanning();
+```
+
+#### `useLocalNetworkPermission()` (iOS only)
+
+React hook for managing local network permission.
+
+```tsx
+const { status, request } = useLocalNetworkPermission();
+```
+
+---
+
+### **Functions**
+
+#### `requestLocalNetworkPermission()`
+
+Displays prompt to request local network permission, always returns `true` on Android.
+
+```tsx
+const granted = await requestLocalNetworkPermission();
+```
+
+---
+
+### **Types**
+
+```ts
+interface ScanResult {
+  name: string;
+  ipv4?: string;
+  ipv6?: string;
+  hostname?: string;
+  port?: number;
+}
+
+interface ScanOptions {
+  addressResolveTimeout?: number; // milliseconds, default: 10000
+}
+
+enum BonjourFail {
+  DISCOVERY_FAILED = 'DISCOVERY_FAILED',
+  RESOLVE_FAILED = 'RESOLVE_FAILED',
+}
 ```
 
 ## Contributing
@@ -26,10 +282,18 @@ Scanner.scan('_bonjour._tcp', 'local');
 - [Sending a pull request](CONTRIBUTING.md#sending-a-pull-request)
 - [Code of conduct](CODE_OF_CONDUCT.md)
 
+## Credits
+
+- [Nitro Modules](https://nitro.margelo.com/) - High-performance native module framework
+- [mrousavy](https://github.com/mrousavy) - Creator of Nitro Modules
+- [react-native-builder-bob](https://github.com/callstack/react-native-builder-bob) - Library template
+
+Solution for handling permissions is based on [react-native-local-network-permission](https://github.com/neurio/react-native-local-network-permission)
+
 ## License
 
 MIT
 
 ---
 
-Made with [create-react-native-library](https://github.com/callstack/react-native-builder-bob)
+**Made with ❤️ for the React Native community**

package/android/src/main/java/com/margelo/nitro/dawidzawada/bonjourzeroconf/BonjourZeroconf+AddressResolver.kt

@@ -11,6 +11,8 @@ import kotlinx.coroutines.withTimeoutOrNull
 import java.util.concurrent.Executors
 
 suspend fun BonjourZeroconf.resolveService(service: NsdServiceInfo, serviceKey: String, timeout: Long) {
+  if (!_isScanning) return
+
   if (android.os.Build.VERSION.SDK_INT >= android.os.Build.VERSION_CODES.UPSIDE_DOWN_CAKE) {
     // New API (Android 14+)
     resolveServiceNew(service, serviceKey, timeout)
@@ -52,6 +54,12 @@ suspend fun BonjourZeroconf.resolveServiceNew(service: NsdServiceInfo, serviceKe
           override fun onServiceUpdated(serviceInfo: NsdServiceInfo) {
             Log.d(TAG, "Service updated: ${serviceInfo.serviceName}")
             unregisterCallback()
+
+            if (!_isScanning) {
+              continuation.resume(null) {}
+              return
+            }
+
             continuation.resume(serviceInfo) {}
           }
 
@@ -114,6 +122,12 @@ suspend fun BonjourZeroconf.resolveServiceLegacy(service: NsdServiceInfo, servic
 
             override fun onServiceResolved(serviceInfo: NsdServiceInfo) {
               Log.d(TAG, "Service resolved: ${serviceInfo.serviceName}")
+
+              if (!_isScanning) {
+                continuation.resume(null) {}
+                return
+              }
+
               continuation.resume(serviceInfo) {}
             }
           }

package/android/src/main/java/com/margelo/nitro/dawidzawada/bonjourzeroconf/BonjourZeroconf.kt

@@ -8,9 +8,11 @@ import com.facebook.proguard.annotations.DoNotStrip
 import java.util.UUID
 import java.util.concurrent.ConcurrentHashMap
 import com.margelo.nitro.NitroModules
+import com.margelo.nitro.core.Promise
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.SupervisorJob
+import kotlinx.coroutines.cancelChildren
 import kotlinx.coroutines.launch
 import kotlinx.coroutines.sync.Mutex
 
@@ -33,6 +35,7 @@ class BonjourZeroconf : HybridBonjourZeroconfSpec() {
   internal var currentDiscoveryListener: NsdManager.DiscoveryListener? = null
   internal val serviceCache = ConcurrentHashMap<String, ScanResult>()
   internal val scope = CoroutineScope(SupervisorJob() + Dispatchers.Default)
+  internal val resolveScope = CoroutineScope(SupervisorJob() + Dispatchers.Default)
   internal val legacyResolveMutex = Mutex()
 
   override val isScanning: Boolean
@@ -68,7 +71,28 @@ class BonjourZeroconf : HybridBonjourZeroconfSpec() {
     }
   }
 
+  override fun scanFor(
+    time: Double,
+    type: String,
+    domain: String,
+    options: ScanOptions?
+  ): Promise<Array<ScanResult>> {
+    return Promise.async {
+      scan(type, domain, options)
+
+      kotlinx.coroutines.delay((time * 1000).toLong())
+
+      val results = serviceCache.values.toTypedArray()
+
+      stop()
+
+      results
+    }
+  }
+
   override fun stop() {
+    resolveScope.coroutineContext.cancelChildren()
+
     currentDiscoveryListener?.let { listener ->
       try {
         nsdManager?.stopServiceDiscovery(listener)
@@ -142,7 +166,7 @@ class BonjourZeroconf : HybridBonjourZeroconfSpec() {
         return
       }
 
-      scope.launch {
+      resolveScope.launch {
         try {
           resolveService(service, serviceKey, resolveTimeout)
         } catch (e: Exception) {

package/ios/AddressResolverError.swift

@@ -6,15 +6,18 @@
 //
 
 enum AddressResolverError: Error {
-    case timeout
-    case extractionFailed
-    
-    var localizedDescription: String {
-      switch self {
-      case .timeout:
-        return "Connection timed out"
-      case .extractionFailed:
-        return "Failed to extract IP and port information"
-      }
+  case timeout
+  case extractionFailed
+  case cancelled
+  
+  var localizedDescription: String {
+    switch self {
+    case .timeout:
+      return "Connection timed out"
+    case .extractionFailed:
+      return "Failed to extract IP and port information"
+    case .cancelled:
+      return "Cancelled resolve process"
     }
+  }
 }

package/ios/BonjourZeroconf+AddressResolver.swift

@@ -9,25 +9,41 @@ import Network
 extension BonjourZeroconf {
   /// Resolve a service to get its IP address and port using async/await
   internal func resolveService(result: NWBrowser.Result, name: String, timeout: TimeInterval) async -> ScanResult? {
+      let taskId = UUID()
+      
       do {
           return try await withCheckedThrowingContinuation { continuation in
               let connection = NWConnection(to: result.endpoint, using: .tcp)
               
-              final class ResumeBox {
-                  var hasResumed = false
+              resolveLock.lock()
+              guard _isScanning else {
+                  resolveLock.unlock()
+                  continuation.resume(throwing: AddressResolverError.cancelled)
+                  return
               }
+              activeConnections[taskId] = connection
+              resolveLock.unlock()
+              
+              final class ResumeBox { var hasResumed = false }
               let box = ResumeBox()
               
-              let timeoutTask = DispatchWorkItem {
+              let timeoutTask = DispatchWorkItem { [weak self] in
+                  guard let self = self else { return }
                   guard !box.hasResumed else { return }
                   box.hasResumed = true
                   Loggy.log(.debug, message: "Timeout resolving \(name)")
                   continuation.resume(throwing: AddressResolverError.timeout)
-                  connection.cancel()
+                  self.cleanupResolve(connection: connection, taskId: taskId)
               }
+              
+              resolveLock.lock()
+              activeTimeouts[taskId] = timeoutTask
+              resolveLock.unlock()
+              
               networkQueue.asyncAfter(deadline: .now() + timeout, execute: timeoutTask)
               
               connection.stateUpdateHandler = { [weak self] state in
+                  guard let self = self else { return }
                   switch state {
                   case .ready:
                       timeoutTask.cancel()
@@ -35,12 +51,12 @@ extension BonjourZeroconf {
                       box.hasResumed = true
                       
                       if let remoteEndpoint = connection.currentPath?.remoteEndpoint,
-                         let scanResult = self?.extractIPAndPort(from: remoteEndpoint, serviceName: name) {
+                         let scanResult = self.extractIPAndPort(from: remoteEndpoint, serviceName: name) {
                           continuation.resume(returning: scanResult)
                       } else {
                           continuation.resume(throwing: AddressResolverError.extractionFailed)
                       }
-                      connection.cancel()
+                      self.cleanupResolve(connection: connection, taskId: taskId)
                       
                   case .failed(let error):
                       timeoutTask.cancel()
@@ -48,7 +64,7 @@ extension BonjourZeroconf {
                       box.hasResumed = true
                       Loggy.log(.error, message: "Failed to resolve service \(name): \(error.localizedDescription)")
                       continuation.resume(throwing: error)
-                      connection.cancel()
+                      self.cleanupResolve(connection: connection, taskId: taskId)
                       
                   case .waiting(let error):
                       Loggy.log(.debug, message: "Connection waiting for \(name): \(error.localizedDescription)")
@@ -61,25 +77,46 @@ extension BonjourZeroconf {
                   }
               }
               
-            connection.start(queue: networkQueue)
+              connection.start(queue: networkQueue)
           }
       } catch let error as AddressResolverError {
-        switch error {
-        case .timeout:
-            notifyScanFailListeners(with: BonjourFail.resolveFailed)
-          break;
-        case .extractionFailed:
-            notifyScanFailListeners(with: BonjourFail.extractionFailed)
-          break;
-        }
-        return nil
-    } catch {
-        return nil
-    }
+          switch error {
+          case .timeout:
+              notifyScanFailListeners(with: BonjourFail.resolveFailed)
+          case .extractionFailed:
+              notifyScanFailListeners(with: BonjourFail.extractionFailed)
+          case .cancelled:
+              Loggy.log(.debug, message: "Scanning stopped, cancelling address resolution")
+              break
+          }
+          return nil
+      } catch {
+          return nil
+      }
+  }
+  
+  /// Cancels ongoing address resolve process
+  internal func cancelAddressResolving() {
+      Loggy.log(.debug, message: "Cancelling Address Resolving")
+      resolveLock.lock()
+      activeTimeouts.values.forEach { $0.cancel() }
+      activeTimeouts.removeAll()
+      activeConnections.values.forEach { $0.cancel() }
+      activeConnections.removeAll()
+      resolveLock.unlock()
+  }
+
+  /// Cleans up after single resolve process
+  private func cleanupResolve(connection: NWConnection, taskId: UUID) {
+      connection.cancel()
+      resolveLock.lock()
+      activeConnections.removeValue(forKey: taskId)
+      activeTimeouts.removeValue(forKey: taskId)
+      resolveLock.unlock()
   }
   
   /// Extract IP address and port from an endpoint
-  internal func extractIPAndPort(from endpoint: NWEndpoint, serviceName: String) -> ScanResult? {
+  private func extractIPAndPort(from endpoint: NWEndpoint, serviceName: String) -> ScanResult? {
       switch endpoint {
       case .hostPort(let host, let port):
           var ipv4: String?

package/ios/BonjourZeroconf.swift

@@ -12,6 +12,11 @@ class BonjourZeroconf: HybridBonjourZeroconfSpec {
   internal var scanStateListeners: [UUID: (Bool) -> Void] = [:]
   internal var scanFailListeners: [UUID: (BonjourFail) -> Void] = [:]
   internal let networkQueue = DispatchQueue(label: "com.bonjour-zeroconf.network", qos: .userInitiated)
+  internal let timeoutScanQueue = DispatchQueue(label: "com.bonjour-zeroconf.scan", qos: .userInitiated)
+  
+  internal var activeConnections: [UUID: NWConnection] = [:]
+  internal var activeTimeouts: [UUID: DispatchWorkItem] = [:]
+  internal let resolveLock = NSLock()
   
   var isScanning: Bool {
     return _isScanning
@@ -72,6 +77,20 @@ class BonjourZeroconf: HybridBonjourZeroconfSpec {
       browser.start(queue: networkQueue)
   }
   
+  func scanFor(time: Double, type: String, domain: String, options: ScanOptions?) throws -> Promise<[ScanResult]> {
+    return Promise.async {
+      self.scan(type: type, domain: domain, options: options)
+      
+      try await Task.sleep(nanoseconds: UInt64(time * 1_000_000_000))
+      
+      let results = await self.serviceCache.getAll()
+      
+      self.stop()
+      
+      return results
+    }
+  }
+  
   func listenForScanResults(onResult: @escaping ([ScanResult]) -> Void) -> BonjourListener {
     let listenerId = UUID()
     self.scanResultsListeners[listenerId] = onResult
@@ -111,6 +130,8 @@ class BonjourZeroconf: HybridBonjourZeroconfSpec {
       if let browser = self._browser {
           browser.cancel()
       }
+    
+      cancelAddressResolving()
       
       self._isScanning = false
       Task {

package/ios/LocalNetworkAuthorization.swift

@@ -49,7 +49,6 @@ public class LocalNetworkAuthorization: NSObject {
     }
     
     private func reset() {
-        print("resetting")
         self.browser?.cancel()
         self.browser = nil
         self.netService?.stop()

package/lib/typescript/src/specs/BonjourZeroconf.nitro.d.ts

@@ -11,6 +11,7 @@ export interface BonjourZeroconf extends HybridObject<{
 }> {
     readonly isScanning: boolean;
     scan(type: string, domain: string, options?: ScanOptions): void;
+    scanFor(time: number, type: string, domain: string, options?: ScanOptions): Promise<ScanResult[]>;
     stop(): void;
     listenForScanResults(onResult: (results: ScanResult[]) => void): BonjourListener;
     listenForScanState(onChange: (isScanning: boolean) => void): BonjourListener;

package/lib/typescript/src/specs/BonjourZeroconf.nitro.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"BonjourZeroconf.nitro.d.ts","sourceRoot":"","sources":["../../../../src/specs/BonjourZeroconf.nitro.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,4BAA4B,CAAC;AAC/D,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AACjD,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,mBAAmB,CAAC;AACzD,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,cAAc,CAAC;AAE/C,MAAM,WAAW,WAAW;IAC1B,qBAAqB,CAAC,EAAE,MAAM,CAAC;CAChC;AAED,MAAM,WAAW,eACf,SAAQ,YAAY,CAAC;IAAE,GAAG,EAAE,OAAO,CAAC;IAAC,OAAO,EAAE,QAAQ,CAAA;CAAE,CAAC;IACzD,QAAQ,CAAC,UAAU,EAAE,OAAO,CAAC;IAC7B,IAAI,CAAC,IAAI,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,WAAW,GAAG,IAAI,CAAC;IAChE,IAAI,IAAI,IAAI,CAAC;IACb,oBAAoB,CAClB,QAAQ,EAAE,CAAC,OAAO,EAAE,UAAU,EAAE,KAAK,IAAI,GACxC,eAAe,CAAC;IACnB,kBAAkB,CAAC,QAAQ,EAAE,CAAC,UAAU,EAAE,OAAO,KAAK,IAAI,GAAG,eAAe,CAAC;IAC7E,iBAAiB,CAAC,MAAM,EAAE,CAAC,IAAI,EAAE,WAAW,KAAK,IAAI,GAAG,eAAe,CAAC;CACzE"}
+{"version":3,"file":"BonjourZeroconf.nitro.d.ts","sourceRoot":"","sources":["../../../../src/specs/BonjourZeroconf.nitro.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,4BAA4B,CAAC;AAC/D,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AACjD,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,mBAAmB,CAAC;AACzD,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,cAAc,CAAC;AAE/C,MAAM,WAAW,WAAW;IAC1B,qBAAqB,CAAC,EAAE,MAAM,CAAC;CAChC;AAED,MAAM,WAAW,eACf,SAAQ,YAAY,CAAC;IAAE,GAAG,EAAE,OAAO,CAAC;IAAC,OAAO,EAAE,QAAQ,CAAA;CAAE,CAAC;IACzD,QAAQ,CAAC,UAAU,EAAE,OAAO,CAAC;IAE7B,IAAI,CAAC,IAAI,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,WAAW,GAAG,IAAI,CAAC;IAChE,OAAO,CACL,IAAI,EAAE,MAAM,EACZ,IAAI,EAAE,MAAM,EACZ,MAAM,EAAE,MAAM,EACd,OAAO,CAAC,EAAE,WAAW,GACpB,OAAO,CAAC,UAAU,EAAE,CAAC,CAAC;IACzB,IAAI,IAAI,IAAI,CAAC;IACb,oBAAoB,CAClB,QAAQ,EAAE,CAAC,OAAO,EAAE,UAAU,EAAE,KAAK,IAAI,GACxC,eAAe,CAAC;IACnB,kBAAkB,CAAC,QAAQ,EAAE,CAAC,UAAU,EAAE,OAAO,KAAK,IAAI,GAAG,eAAe,CAAC;IAC7E,iBAAiB,CAAC,MAAM,EAAE,CAAC,IAAI,EAAE,WAAW,KAAK,IAAI,GAAG,eAAe,CAAC;CACzE"}

package/nitrogen/generated/android/c++/JBonjourFail.hpp

@@ -2,7 +2,7 @@
 /// JBonjourFail.hpp
 /// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
 /// https://github.com/mrousavy/nitro
-/// Copyright © 2025 Marc Rousavy @ Margelo
+/// Copyright © 2026 Marc Rousavy @ Margelo
 ///
 
 #pragma once

package/nitrogen/generated/android/c++/JBonjourListener.hpp

@@ -2,7 +2,7 @@
 /// JBonjourListener.hpp
 /// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
 /// https://github.com/mrousavy/nitro
-/// Copyright © 2025 Marc Rousavy @ Margelo
+/// Copyright © 2026 Marc Rousavy @ Margelo
 ///
 
 #pragma once

package/nitrogen/generated/android/c++/JFunc_void.hpp

@@ -2,7 +2,7 @@
 /// JFunc_void.hpp
 /// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
 /// https://github.com/mrousavy/nitro
-/// Copyright © 2025 Marc Rousavy @ Margelo
+/// Copyright © 2026 Marc Rousavy @ Margelo
 ///
 
 #pragma once

package/nitrogen/generated/android/c++/JFunc_void_BonjourFail.hpp

@@ -2,7 +2,7 @@
 /// JFunc_void_BonjourFail.hpp
 /// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
 /// https://github.com/mrousavy/nitro
-/// Copyright © 2025 Marc Rousavy @ Margelo
+/// Copyright © 2026 Marc Rousavy @ Margelo
 ///
 
 #pragma once

package/nitrogen/generated/android/c++/JFunc_void_bool.hpp

@@ -2,7 +2,7 @@
 /// JFunc_void_bool.hpp
 /// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
 /// https://github.com/mrousavy/nitro
-/// Copyright © 2025 Marc Rousavy @ Margelo
+/// Copyright © 2026 Marc Rousavy @ Margelo
 ///
 
 #pragma once

package/nitrogen/generated/android/c++/JFunc_void_std__vector_ScanResult_.hpp

@@ -2,7 +2,7 @@
 /// JFunc_void_std__vector_ScanResult_.hpp
 /// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
 /// https://github.com/mrousavy/nitro
-/// Copyright © 2025 Marc Rousavy @ Margelo
+/// Copyright © 2026 Marc Rousavy @ Margelo
 ///
 
 #pragma once