@cappitolian/network-discovery 0.0.1

package/CappitolianNetworkDiscovery.podspec

@@ -0,0 +1,17 @@
+require 'json'
+
+package = JSON.parse(File.read(File.join(__dir__, 'package.json')))
+
+Pod::Spec.new do |s|
+  s.name = 'CappitolianNetworkDiscovery'
+  s.version = package['version']
+  s.summary = package['description']
+  s.license = package['license']
+  s.homepage = package['repository']['url']
+  s.author = package['author']
+  s.source = { :git => package['repository']['url'], :tag => s.version.to_s }
+  s.source_files = 'ios/Sources/**/*.{swift,h,m,c,cc,mm,cpp}'
+  s.ios.deployment_target = '14.0'
+  s.dependency 'Capacitor'
+  s.swift_version = '5.1'
+end

package/Package.swift

@@ -0,0 +1,28 @@
+// swift-tools-version: 5.9
+import PackageDescription
+
+let package = Package(
+    name: "CappitolianNetworkDiscovery",
+    platforms: [.iOS(.v15)],
+    products: [
+        .library(
+            name: "CappitolianNetworkDiscovery",
+            targets: ["NetworkDiscoveryPlugin"])
+    ],
+    dependencies: [
+        .package(url: "https://github.com/ionic-team/capacitor-swift-pm.git", from: "7.0.0")
+    ],
+    targets: [
+        .target(
+            name: "NetworkDiscoveryPlugin",
+            dependencies: [
+                .product(name: "Capacitor", package: "capacitor-swift-pm"),
+                .product(name: "Cordova", package: "capacitor-swift-pm")
+            ],
+            path: "ios/Sources/NetworkDiscoveryPlugin"),
+        .testTarget(
+            name: "NetworkDiscoveryPluginTests",
+            dependencies: ["NetworkDiscoveryPlugin"],
+            path: "ios/Tests/NetworkDiscoveryPluginTests")
+    ]
+)

package/README.md

@@ -0,0 +1,365 @@
+# @cappitolian/network-discovery
+
+A Capacitor plugin for network service discovery using mDNS/Bonjour. Allows automatic server-client connection without manual IP configuration.
+
+---
+
+## Features
+
+- **Advertise services** on the local network (server mode)
+- **Discover services** automatically (client mode)
+- Pass custom data via TXT records (like IP addresses, ports, etc.)
+- Real-time service found/lost events
+- Works on **iOS** (Bonjour) and **Android** (NSD)
+- Tested with **Capacitor 7** and **Ionic 8**
+
+---
+
+## Installation
+```bash
+npm install @cappitolian/network-discovery
+npx cap sync
+```
+
+---
+
+## Usage
+
+### Import
+```typescript
+import { NetworkDiscovery } from '@cappitolian/network-discovery';
+```
+
+### Server Mode - Advertise Your Service
+```typescript
+// Start advertising your server
+await NetworkDiscovery.startAdvertising({
+  serviceName: 'MyAppServer',
+  serviceType: '_http._tcp',  // or '_myapp._tcp' for custom service
+  port: 8080,
+  txtRecord: {
+    ip: '192.168.1.100',      // Your server IP
+    version: '1.0.0'          // Any custom data
+  }
+});
+
+console.log('Server is now discoverable on the network');
+
+// Stop advertising when needed
+await NetworkDiscovery.stopAdvertising();
+```
+
+### Client Mode - Discover Services
+```typescript
+// Listen for discovered services
+NetworkDiscovery.addListener('serviceFound', (service) => {
+  console.log('Service discovered:', service);
+  console.log('Server IP:', service.txtRecord?.ip);
+  console.log('Server Port:', service.port);
+  console.log('Server Addresses:', service.addresses);
+  
+  // Connect to your server
+  connectToServer(service.addresses[0], service.port);
+});
+
+// Listen for lost services
+NetworkDiscovery.addListener('serviceLost', (service) => {
+  console.log('Service lost:', service.serviceName);
+});
+
+// Start discovery
+await NetworkDiscovery.startDiscovery({
+  serviceType: '_http._tcp',  // Must match the server's serviceType
+  domain: 'local.'            // Optional, defaults to 'local.'
+});
+
+// Stop discovery when needed
+await NetworkDiscovery.stopDiscovery();
+
+// Clean up listeners
+await NetworkDiscovery.removeAllListeners();
+```
+
+### Complete Example - Auto-Connect Flow
+
+**Server Side:**
+```typescript
+import { NetworkDiscovery } from '@cappitolian/network-discovery';
+import { Network } from '@capacitor/network';
+
+async startServer() {
+  // Get device IP
+  const ip = await this.getLocalIP();
+  
+  // Advertise server
+  await NetworkDiscovery.startAdvertising({
+    serviceName: 'MyAppServer',
+    serviceType: '_myapp._tcp',
+    port: 8080,
+    txtRecord: { 
+      ip: ip,
+      serverName: 'Production Server'
+    }
+  });
+  
+  console.log('Server advertising on network');
+}
+
+async getLocalIP(): Promise<string> {
+  const status = await Network.getStatus();
+  // Your IP extraction logic here
+  return '192.168.1.100';
+}
+```
+
+**Client Side:**
+```typescript
+import { NetworkDiscovery } from '@cappitolian/network-discovery';
+
+async findAndConnectToServer() {
+  return new Promise((resolve, reject) => {
+    
+    // Listen for server
+    NetworkDiscovery.addListener('serviceFound', async (service) => {
+      if (service.serviceName === 'MyAppServer') {
+        console.log('Server found!');
+        
+        const serverIP = service.txtRecord?.ip || service.addresses[0];
+        const serverPort = service.port;
+        
+        // Stop discovery
+        await NetworkDiscovery.stopDiscovery();
+        await NetworkDiscovery.removeAllListeners();
+        
+        // Connect to server
+        resolve({ ip: serverIP, port: serverPort });
+      }
+    });
+    
+    // Start discovery
+    NetworkDiscovery.startDiscovery({
+      serviceType: '_myapp._tcp'
+    });
+    
+    // Timeout after 10 seconds
+    setTimeout(() => {
+      reject(new Error('Server not found'));
+    }, 10000);
+  });
+}
+
+// Usage
+async onLoginClick() {
+  try {
+    const server = await this.findAndConnectToServer();
+    console.log(`Connecting to ${server.ip}:${server.port}`);
+    // Your connection logic here
+  } catch (error) {
+    console.error('Could not find server:', error);
+  }
+}
+```
+
+---
+
+## API Reference
+
+### Methods
+
+#### `startAdvertising(options: AdvertisingOptions)`
+
+Publishes a service on the local network.
+
+**Parameters:**
+- `serviceName` (string): Name of your service (e.g., "MyAppServer")
+- `serviceType` (string): Service type (e.g., "_http._tcp", "_myapp._tcp")
+- `port` (number): Port number your server is listening on
+- `txtRecord` (object, optional): Key-value pairs to broadcast (e.g., IP, version)
+
+**Returns:** `Promise<{ success: boolean }>`
+
+---
+
+#### `stopAdvertising()`
+
+Stops advertising the service.
+
+**Returns:** `Promise<{ success: boolean }>`
+
+---
+
+#### `startDiscovery(options: DiscoveryOptions)`
+
+Starts searching for services on the local network.
+
+**Parameters:**
+- `serviceType` (string): Type of service to search for (must match server's type)
+- `domain` (string, optional): Domain to search in (default: "local.")
+
+**Returns:** `Promise<void>`
+
+---
+
+#### `stopDiscovery()`
+
+Stops the service discovery.
+
+**Returns:** `Promise<{ success: boolean }>`
+
+---
+
+### Events
+
+#### `serviceFound`
+
+Fired when a service is discovered.
+
+**Payload:**
+```typescript
+{
+  serviceName: string;
+  serviceType: string;
+  domain: string;
+  hostName: string;
+  port: number;
+  addresses: string[];        // Array of IP addresses
+  txtRecord?: {               // Custom data from server
+    [key: string]: string;
+  };
+}
+```
+
+---
+
+#### `serviceLost`
+
+Fired when a previously discovered service is no longer available.
+
+**Payload:**
+```typescript
+{
+  serviceName: string;
+  serviceType: string;
+}
+```
+
+---
+
+## Service Type Format
+
+Service types must follow the format: `_name._protocol`
+
+**Common examples:**
+- `_http._tcp` - HTTP service
+- `_https._tcp` - HTTPS service
+- `_myapp._tcp` - Custom app service
+- `_ssh._tcp` - SSH service
+
+**Recommended for apps:** Use a custom service type like `_myapp._tcp` to avoid conflicts with other services.
+
+---
+
+## Permissions
+
+### Android
+
+Add to `AndroidManifest.xml`:
+```xml
+<uses-permission android:name="android.permission.INTERNET" />
+<uses-permission android:name="android.permission.ACCESS_NETWORK_STATE" />
+<uses-permission android:name="android.permission.ACCESS_WIFI_STATE" />
+<uses-permission android:name="android.permission.CHANGE_WIFI_MULTICAST_STATE" />
+```
+
+### iOS
+
+No additional permissions required. Bonjour is enabled by default.
+
+Optionally, add to `Info.plist` to declare your service:
+```xml
+<key>NSBonjourServices</key>
+<array>
+    <string>_myapp._tcp</string>
+</array>
+```
+
+---
+
+## Platforms
+
+- **iOS** (Bonjour/NetService)
+- **Android** (Network Service Discovery)
+- **Web** (Not implemented - throws unimplemented error)
+
+---
+
+## Requirements
+
+- [Capacitor 7+](https://capacitorjs.com/)
+- [Ionic 8+](https://ionicframework.com/) (optional, but tested)
+- iOS 12.0+
+- Android API 16+ (Android 4.1+)
+
+---
+
+## Troubleshooting
+
+### Services not being discovered
+
+1. **Check both devices are on the same WiFi network**
+2. **Verify service types match** exactly between server and client
+3. **Check firewall settings** - some networks block mDNS
+4. **Android:** Ensure multicast is enabled on your network
+5. **iOS:** Make sure device is not in Low Power Mode
+
+### Server not advertising
+
+1. **Verify port is not in use** by another service
+2. **Check network permissions** are granted
+3. **Restart the app** after installing the plugin
+
+### General debugging
+
+Enable verbose logging:
+```typescript
+// Check plugin is loaded
+console.log('Plugin available:', NetworkDiscovery);
+
+// Log all events
+NetworkDiscovery.addListener('serviceFound', (s) => console.log('Found:', s));
+NetworkDiscovery.addListener('serviceLost', (s) => console.log('Lost:', s));
+```
+
+---
+
+## Use Cases
+
+- **Auto-connect apps** - Client automatically finds and connects to server
+- **Local multiplayer games** - Discover game hosts on LAN
+- **IoT device discovery** - Find smart devices without configuration
+- **File sharing apps** - Discover peers for file transfer
+- **Remote control apps** - Find controllable devices automatically
+
+---
+
+## License
+
+MIT
+
+---
+
+## Support
+
+If you encounter any issues or have feature requests, please open an issue on the [GitHub repository](https://github.com/alessandrycruz1987/network-discovery).
+
+---
+
+## Contributing
+
+Contributions are welcome! Please feel free to submit a Pull Request.
+
+---
+
+## Credits
+
+Created for use with Capacitor 7 and Ionic 8 applications requiring automatic network service discovery.

package/android/build.gradle

@@ -0,0 +1,58 @@
+ext {
+    junitVersion = project.hasProperty('junitVersion') ? rootProject.ext.junitVersion : '4.13.2'
+    androidxAppCompatVersion = project.hasProperty('androidxAppCompatVersion') ? rootProject.ext.androidxAppCompatVersion : '1.7.1'
+    androidxJunitVersion = project.hasProperty('androidxJunitVersion') ? rootProject.ext.androidxJunitVersion : '1.3.0'
+    androidxEspressoCoreVersion = project.hasProperty('androidxEspressoCoreVersion') ? rootProject.ext.androidxEspressoCoreVersion : '3.7.0'
+}
+
+buildscript {
+    repositories {
+        google()
+        mavenCentral()
+    }
+    dependencies {
+        classpath 'com.android.tools.build:gradle:8.13.0'
+    }
+}
+
+apply plugin: 'com.android.library'
+
+android {
+    namespace = "com.cappitolian.plugins.networkdiscovery"
+    compileSdk = project.hasProperty('compileSdkVersion') ? rootProject.ext.compileSdkVersion : 36
+    defaultConfig {
+        minSdkVersion project.hasProperty('minSdkVersion') ? rootProject.ext.minSdkVersion : 24
+        targetSdkVersion project.hasProperty('targetSdkVersion') ? rootProject.ext.targetSdkVersion : 36
+        versionCode 1
+        versionName "1.0"
+        testInstrumentationRunner "androidx.test.runner.AndroidJUnitRunner"
+    }
+    buildTypes {
+        release {
+            minifyEnabled false
+            proguardFiles getDefaultProguardFile('proguard-android.txt'), 'proguard-rules.pro'
+        }
+    }
+    lintOptions {
+        abortOnError = false
+    }
+    compileOptions {
+        sourceCompatibility JavaVersion.VERSION_21
+        targetCompatibility JavaVersion.VERSION_21
+    }
+}
+
+repositories {
+    google()
+    mavenCentral()
+}
+
+
+dependencies {
+    implementation fileTree(dir: 'libs', include: ['*.jar'])
+    implementation project(':capacitor-android')
+    implementation "androidx.appcompat:appcompat:$androidxAppCompatVersion"
+    testImplementation "junit:junit:$junitVersion"
+    androidTestImplementation "androidx.test.ext:junit:$androidxJunitVersion"
+    androidTestImplementation "androidx.test.espresso:espresso-core:$androidxEspressoCoreVersion"
+}

package/android/src/main/AndroidManifest.xml

@@ -0,0 +1,2 @@
+<manifest xmlns:android="http://schemas.android.com/apk/res/android">
+</manifest>

package/android/src/main/java/com/cappitolian/plugins/networkdiscovery/NetworkDiscovery.java

@@ -0,0 +1,218 @@
+package com.cappitolian.plugins.networkdiscovery;
+
+import android.content.Context;
+import android.net.nsd.NsdManager;
+import android.net.nsd.NsdServiceInfo;
+import android.util.Log;
+
+import com.getcapacitor.JSObject;
+import com.getcapacitor.Plugin;
+
+import org.json.JSONArray;
+import org.json.JSONException;
+
+import java.net.InetAddress;
+import java.util.Map;
+
+public class NetworkDiscovery {
+    private static final String TAG = "NetworkDiscovery";
+    private NsdManager nsdManager;
+    private NsdManager.RegistrationListener registrationListener;
+    private NsdManager.DiscoveryListener discoveryListener;
+    private NsdServiceInfo serviceInfo;
+    private Plugin plugin;
+
+    public NetworkDiscovery(Plugin plugin, Context context) {
+        this.plugin = plugin;
+        this.nsdManager = (NsdManager) context.getSystemService(Context.NSD_SERVICE);
+    }
+
+    public void startAdvertising(
+        String serviceName,
+        String serviceType,
+        int port,
+        JSObject txtRecord,
+        AdvertisingCallback callback
+    ) {
+        serviceInfo = new NsdServiceInfo();
+        serviceInfo.setServiceName(serviceName);
+        serviceInfo.setServiceType(serviceType);
+        serviceInfo.setPort(port);
+
+        // Agregar TXT records
+        if (txtRecord != null) {
+            for (String key : txtRecord.keys()) {
+                try {
+                    String value = txtRecord.getString(key);
+                    serviceInfo.setAttribute(key, value);
+                } catch (Exception e) {
+                    Log.e(TAG, "Error setting attribute: " + key, e);
+                }
+            }
+        }
+
+        registrationListener = new NsdManager.RegistrationListener() {
+            @Override
+            public void onRegistrationFailed(NsdServiceInfo serviceInfo, int errorCode) {
+                Log.e(TAG, "Service registration failed: " + errorCode);
+                callback.onError("Registration failed with error code: " + errorCode);
+            }
+
+            @Override
+            public void onUnregistrationFailed(NsdServiceInfo serviceInfo, int errorCode) {
+                Log.e(TAG, "Service unregistration failed: " + errorCode);
+            }
+
+            @Override
+            public void onServiceRegistered(NsdServiceInfo serviceInfo) {
+                Log.d(TAG, "Service registered: " + serviceInfo.getServiceName());
+                callback.onSuccess();
+            }
+
+            @Override
+            public void onServiceUnregistered(NsdServiceInfo serviceInfo) {
+                Log.d(TAG, "Service unregistered");
+            }
+        };
+
+        nsdManager.registerService(serviceInfo, NsdManager.PROTOCOL_DNS_SD, registrationListener);
+    }
+
+    public void stopAdvertising(StopCallback callback) {
+        if (registrationListener != null) {
+            try {
+                nsdManager.unregisterService(registrationListener);
+                registrationListener = null;
+                callback.onSuccess();
+            } catch (Exception e) {
+                callback.onError("Error stopping advertising: " + e.getMessage());
+            }
+        } else {
+            callback.onError("No active advertising to stop");
+        }
+    }
+
+    public void startDiscovery(String serviceType, DiscoveryCallback callback) {
+        discoveryListener = new NsdManager.DiscoveryListener() {
+            @Override
+            public void onStartDiscoveryFailed(String serviceType, int errorCode) {
+                Log.e(TAG, "Discovery start failed: " + errorCode);
+                nsdManager.stopServiceDiscovery(this);
+                callback.onError("Discovery failed with error code: " + errorCode);
+            }
+
+            @Override
+            public void onStopDiscoveryFailed(String serviceType, int errorCode) {
+                Log.e(TAG, "Discovery stop failed: " + errorCode);
+            }
+
+            @Override
+            public void onDiscoveryStarted(String serviceType) {
+                Log.d(TAG, "Service discovery started");
+                callback.onDiscoveryStarted();
+            }
+
+            @Override
+            public void onDiscoveryStopped(String serviceType) {
+                Log.d(TAG, "Service discovery stopped");
+            }
+
+            @Override
+            public void onServiceFound(NsdServiceInfo service) {
+                Log.d(TAG, "Service found: " + service.getServiceName());
+                
+                nsdManager.resolveService(service, new NsdManager.ResolveListener() {
+                    @Override
+                    public void onResolveFailed(NsdServiceInfo serviceInfo, int errorCode) {
+                        Log.e(TAG, "Resolve failed: " + errorCode);
+                    }
+
+                    @Override
+                    public void onServiceResolved(NsdServiceInfo serviceInfo) {
+                        Log.d(TAG, "Service resolved: " + serviceInfo);
+                        
+                        JSObject serviceData = buildServiceObject(serviceInfo);
+                        callback.onServiceFound(serviceData);
+                    }
+                });
+            }
+
+            @Override
+            public void onServiceLost(NsdServiceInfo service) {
+                Log.d(TAG, "Service lost: " + service.getServiceName());
+                
+                JSObject serviceData = new JSObject();
+                serviceData.put("serviceName", service.getServiceName());
+                serviceData.put("serviceType", service.getServiceType());
+                
+                callback.onServiceLost(serviceData);
+            }
+        };
+
+        nsdManager.discoverServices(serviceType, NsdManager.PROTOCOL_DNS_SD, discoveryListener);
+    }
+
+    public void stopDiscovery(StopCallback callback) {
+        if (discoveryListener != null) {
+            try {
+                nsdManager.stopServiceDiscovery(discoveryListener);
+                discoveryListener = null;
+                callback.onSuccess();
+            } catch (Exception e) {
+                callback.onError("Error stopping discovery: " + e.getMessage());
+            }
+        } else {
+            callback.onError("No active discovery to stop");
+        }
+    }
+
+    private JSObject buildServiceObject(NsdServiceInfo serviceInfo) {
+        JSObject serviceData = new JSObject();
+        serviceData.put("serviceName", serviceInfo.getServiceName());
+        serviceData.put("serviceType", serviceInfo.getServiceType());
+        serviceData.put("hostName", serviceInfo.getHost() != null ? serviceInfo.getHost().getHostName() : "");
+        serviceData.put("port", serviceInfo.getPort());
+        
+        // Agregar direcciones IP
+        InetAddress host = serviceInfo.getHost();
+        if (host != null) {
+            try {
+                JSONArray addresses = new JSONArray();
+                addresses.put(host.getHostAddress());
+                serviceData.put("addresses", addresses);
+            } catch (JSONException e) {
+                Log.e(TAG, "Error adding addresses", e);
+            }
+        }
+        
+        // Agregar TXT records
+        Map<String, byte[]> attributes = serviceInfo.getAttributes();
+        if (attributes != null && !attributes.isEmpty()) {
+            JSObject txtRecordObj = new JSObject();
+            for (Map.Entry<String, byte[]> entry : attributes.entrySet()) {
+                txtRecordObj.put(entry.getKey(), new String(entry.getValue()));
+            }
+            serviceData.put("txtRecord", txtRecordObj);
+        }
+        
+        return serviceData;
+    }
+
+    // Callbacks interfaces
+    public interface AdvertisingCallback {
+        void onSuccess();
+        void onError(String error);
+    }
+
+    public interface StopCallback {
+        void onSuccess();
+        void onError(String error);
+    }
+
+    public interface DiscoveryCallback {
+        void onDiscoveryStarted();
+        void onServiceFound(JSObject service);
+        void onServiceLost(JSObject service);
+        void onError(String error);
+    }
+}