@cappitolian/http-local-server-swifter 0.0.1

package/CappitolianHttpLocalServerSwifter.podspec

@@ -0,0 +1,18 @@
+require 'json'
+
+package = JSON.parse(File.read(File.join(__dir__, 'package.json')))
+
+Pod::Spec.new do |s|
+  s.name = 'CappitolianHttpLocalServerSwifter'
+  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 = '15.0'
+  s.dependency 'Capacitor'
+  s.dependency 'Swifter', '~> 1.5.0'
+  s.swift_version = '5.1'
+end

package/Package.swift

@@ -0,0 +1,30 @@
+// swift-tools-version: 5.9
+import PackageDescription
+
+let package = Package(
+    name: "CappitolianHttpLocalServerSwifter",
+    platforms: [.iOS(.v15)],
+    products: [
+        .library(
+            name: "CappitolianHttpLocalServerSwifter",
+            targets: ["HttpLocalServerSwifterPlugin"])
+    ],
+    dependencies: [
+        .package(url: "https://github.com/ionic-team/capacitor-swift-pm.git", from: "8.0.0"),
+        .package(url: "https://github.com/httpswift/swifter.git", from: "1.5.0")
+    ],
+    targets: [
+        .target(
+            name: "HttpLocalServerSwifterPlugin",
+            dependencies: [
+                .product(name: "Capacitor", package: "capacitor-swift-pm"),
+                .product(name: "Cordova", package: "capacitor-swift-pm"),
+                .product(name: "Swifter", package: "swifter")
+            ],
+            path: "ios/Sources/HttpLocalServerSwifterPlugin"),
+        .testTarget(
+            name: "HttpLocalServerSwifterPluginTests",
+            dependencies: ["HttpLocalServerSwifterPlugin"],
+            path: "ios/Tests/HttpLocalServerSwifterPluginTests")
+    ]
+)

package/README.md

@@ -0,0 +1,135 @@
+# @cappitolian/http-local-server
+
+A Capacitor plugin to run a local HTTP server on your device, allowing you to receive and respond to HTTP requests directly from Angular/JavaScript.
+
+---
+
+## Features
+
+- ✅ Embed a real HTTP server (NanoHTTPD on Android, **Swifter** on iOS)
+- ✅ Receive requests via events and send responses back from the JS layer
+- ✅ CORS support enabled by default for local communication
+- ✅ Support for all HTTP methods (GET, POST, PUT, PATCH, DELETE, OPTIONS)
+- ✅ Swift Package Manager (SPM) support
+- ✅ Tested with **Capacitor 8** and **Ionic 8**
+
+---
+
+## Installation
+```bash
+npm install @cappitolian/http-local-server
+npx cap sync
+```
+
+---
+
+## Usage
+
+### Import
+```typescript
+import { HttpLocalServerSwifter } from '@cappitolian/http-local-server';
+```
+
+### Listen and Respond
+```typescript
+// 1. Set up the listener for incoming requests
+await HttpLocalServerSwifter.addListener('onRequest', async (data) => {
+  console.log(`${data.method} ${data.path}`);
+  console.log('Body:', data.body);
+  console.log('Headers:', data.headers);
+  console.log('Query:', data.query);
+
+  // 2. Send a response back to the client using the requestId
+  await HttpLocalServerSwifter.sendResponse({
+    requestId: data.requestId,
+    body: JSON.stringify({ 
+      success: true, 
+      message: 'Request processed!' 
+    })
+  });
+});
+
+// 3. Start the server
+HttpLocalServerSwifter.connect().then(result => {
+  console.log('Server running at:', result.ip, 'Port:', result.port);
+});
+```
+
+### Stop Server
+```typescript
+// 4. Stop the server
+await HttpLocalServerSwifter.disconnect();
+```
+
+---
+
+## Platforms
+
+- **iOS** (Swift with Swifter)
+- **Android** (Java with NanoHTTPD)
+- **Web** (Returns mock values for development)
+
+---
+
+## Requirements
+
+- [Capacitor 8](https://capacitorjs.com/)
+- iOS 13.0+
+- Android API 22+
+
+---
+
+## Migration from v0.0.x
+
+Version 0.1.0 migrates from GCDWebServer to Swifter on iOS for better Swift Package Manager support. The API remains the same, so no code changes are needed in your app.
+
+---
+
+## License
+
+MIT
+
+---
+
+## Support
+
+If you have any issues or feature requests, please open an issue on the repository.
+```
+
+---
+
+## 📋 Cambios Principales
+
+### **GCDWebServer → Swifter**
+
+| Aspecto | GCDWebServer | Swifter |
+|---------|--------------|---------|
+| **Importar** | `import GCDWebServer` | `import Swifter` |
+| **Crear servidor** | `GCDWebServer()` | `HttpServer()` |
+| **Tipo de puerto** | `UInt` | `UInt16` |
+| **Handlers** | `.addDefaultHandler(forMethod:)` | `server["/(.*)"] = { ... }` |
+| **Request type** | `GCDWebServerRequest` | `HttpRequest` |
+| **Response type** | `GCDWebServerDataResponse` | `HttpResponse` |
+| **Método HTTP** | `request.method` | `request.method` (igual) |
+| **Path** | `request.url.path` | `request.path` |
+| **Body** | `(request as? GCDWebServerDataRequest)?.data` | `request.body` (bytes) |
+| **Headers** | `request.headers` | `request.headers` (igual) |
+| **Query params** | `request.query` | `request.queryParams` |
+| **Start server** | `try server.start(options:)` | `try server.start(port)` |
+| **Stop server** | `server.stop()` | `server.stop()` (igual) |
+| **Response** | `GCDWebServerDataResponse(text:)` | `.ok(.text())` |
+| **CORS headers** | `setValue(_:forAdditionalHeader:)` | Custom extension |
+
+---
+
+## ✅ Pasos para Aplicar
+
+1. **Reemplaza `HttpLocalServerSwifter.swift`** con la versión de arriba
+2. **Actualiza `Package.swift`**
+3. **Actualiza `.podspec`**
+4. **Actualiza `package.json`** (versiones de Capacitor 8)
+5. **En Xcode**:
+```
+   File → Packages → Reset Package Caches
+   File → Packages → Resolve Package Versions
+   Product → Clean Build Folder

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.httplocalserviceswifter"
+    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/httplocalserviceswifter/HttpLocalServerSwifter.java

@@ -0,0 +1,365 @@
+package com.cappitolian.plugins.httplocalserviceswifter;
+
+import android.content.Context;
+import android.net.wifi.WifiInfo;
+import android.net.wifi.WifiManager;
+import android.text.format.Formatter;
+import android.util.Log;
+
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+
+import com.getcapacitor.JSObject;
+import com.getcapacitor.Plugin;
+import com.getcapacitor.PluginCall;
+
+import org.json.JSONException;
+import org.json.JSONObject;
+
+import java.io.IOException;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.UUID;
+import java.util.concurrent.CompletableFuture;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.TimeoutException;
+
+import fi.iki.elonen.NanoHTTPD;
+
+/**
+* Local HTTP server implementation for Android using NanoHTTPD.
+* Handles incoming HTTP requests and communicates with JavaScript layer.
+*/
+public class HttpLocalServerSwifter {
+    // MARK: - Constants
+    private static final String TAG = "HttpLocalServerSwifter";
+    private static final int DEFAULT_PORT = 8080;
+    private static final int DEFAULT_TIMEOUT_SECONDS = 5;
+    private static final String FALLBACK_IP = "127.0.0.1";
+    
+    // MARK: - Properties
+    private LocalNanoServer server;
+    private final Plugin plugin;
+    private final int port;
+    private final int timeoutSeconds;
+    
+    private static final ConcurrentHashMap<String, CompletableFuture<String>> pendingResponses = new ConcurrentHashMap<>();
+    
+    // MARK: - Constructor
+    public HttpLocalServerSwifter(@NonNull Plugin plugin) {
+        this(plugin, DEFAULT_PORT, DEFAULT_TIMEOUT_SECONDS);
+    }
+    
+    public HttpLocalServerSwifter(@NonNull Plugin plugin, int port, int timeoutSeconds) {
+        this.plugin = plugin;
+        this.port = port;
+        this.timeoutSeconds = timeoutSeconds;
+    }
+    
+    // MARK: - Public Methods
+    public void connect(@NonNull PluginCall call) {
+        if (server != null && server.isAlive()) {
+            call.reject("Server is already running");
+            return;
+        }
+        
+        try {
+            String localIp = getLocalIpAddress(plugin.getContext());
+            server = new LocalNanoServer(localIp, port, plugin, timeoutSeconds);
+            server.start();
+            
+            JSObject response = new JSObject();
+            response.put("ip", localIp);
+            response.put("port", port);
+            call.resolve(response);
+            
+            Log.i(TAG, "Server started at " + localIp + ":" + port);
+        } catch (IOException e) {
+            Log.e(TAG, "Failed to start server", e);
+            call.reject("Failed to start server: " + e.getMessage());
+        }
+    }
+    
+    public void disconnect(@Nullable PluginCall call) {
+        if (server != null) {
+            server.stop();
+            server = null;
+            
+            // Clear all pending responses
+            pendingResponses.clear();
+            
+            Log.i(TAG, "Server stopped");
+        }
+        
+        if (call != null) {
+            call.resolve();
+        }
+    }
+    
+    // MARK: - Static Methods
+    /**
+    * Called by plugin when JavaScript responds to a request
+    */
+    public static void handleJsResponse(@NonNull String requestId, @NonNull String body) {
+        CompletableFuture<String> future = pendingResponses.remove(requestId);
+        if (future != null && !future.isDone()) {
+            future.complete(body);
+            Log.d(TAG, "Response received for request: " + requestId);
+        } else {
+            Log.w(TAG, "No pending request found for ID: " + requestId);
+        }
+    }
+    
+    // MARK: - Private Methods
+    /**
+    * Get the local WiFi IP address
+    */
+    @NonNull
+    private String getLocalIpAddress(@NonNull Context context) {
+        try {
+            WifiManager wifiManager = (WifiManager) context.getApplicationContext()
+                    .getSystemService(Context.WIFI_SERVICE);
+            
+            if (wifiManager == null) {
+                Log.w(TAG, "WifiManager is null, using fallback IP");
+                return FALLBACK_IP;
+            }
+            
+            WifiInfo wifiInfo = wifiManager.getConnectionInfo();
+            if (wifiInfo == null) {
+                Log.w(TAG, "WifiInfo is null, using fallback IP");
+                return FALLBACK_IP;
+            }
+            
+            int ipAddress = wifiInfo.getIpAddress();
+            if (ipAddress == 0) {
+                Log.w(TAG, "IP address is 0, using fallback IP");
+                return FALLBACK_IP;
+            }
+            
+            return Formatter.formatIpAddress(ipAddress);
+        } catch (Exception e) {
+            Log.e(TAG, "Error getting IP address", e);
+            return FALLBACK_IP;
+        }
+    }
+    
+    // MARK: - Inner Class: LocalNanoServer
+    /**
+    * NanoHTTPD server implementation that handles HTTP requests
+    */
+    private static class LocalNanoServer extends NanoHTTPD {
+        
+        private final Plugin plugin;
+        private final int timeoutSeconds;
+        
+        public LocalNanoServer(@NonNull String hostname, int port, @NonNull Plugin plugin, int timeoutSeconds) {
+            super(hostname, port);
+            this.plugin = plugin;
+            this.timeoutSeconds = timeoutSeconds;
+        }
+        
+        @Override
+        public Response serve(@NonNull IHTTPSession session) {
+            String method = session.getMethod().name();
+            String path = session.getUri();
+            
+            // Handle CORS preflight
+            if (Method.OPTIONS.equals(session.getMethod())) {
+                return createCorsResponse();
+            }
+            
+            try {
+                // Extract request data
+                String body = extractBody(session);
+                Map<String, String> headers = session.getHeaders();
+                Map<String, String> params = session.getParms();
+                
+                // Process request
+                String responseBody = processRequest(method, path, body, headers, params);
+                
+                return createJsonResponse(responseBody, Response.Status.OK);
+            } catch (Exception e) {
+                Log.e(TAG, "Error processing request", e);
+                return createErrorResponse("Internal server error: " + e.getMessage(), 
+                        Response.Status.INTERNAL_ERROR);
+            }
+        }
+        
+        /**
+        * Extract body from POST/PUT/PATCH requests
+        */
+        @Nullable
+        private String extractBody(@NonNull IHTTPSession session) {
+            Method method = session.getMethod();
+            
+            if (method != Method.POST && method != Method.PUT && method != Method.PATCH) {
+                return null;
+            }
+            
+            try {
+                HashMap<String, String> files = new HashMap<>();
+                session.parseBody(files);
+                
+                // Body comes in the map with key "postData"
+                String body = files.get("postData");
+                
+                // Fallback to query parameters for form-data
+                if (body == null || body.isEmpty()) {
+                    body = session.getQueryParameterString();
+                }
+                
+                Log.d(TAG, "Body received (" + body.length() + " bytes): " + 
+                        (body != null ? body.substring(0, Math.min(body.length(), 100)) : "null"));
+                
+                return body;
+            } catch (IOException | ResponseException e) {
+                Log.e(TAG, "Error parsing body", e);
+                return null;
+            }
+        }
+        
+        /**
+        * Process the request and wait for JavaScript response
+        */
+        @NonNull
+        private String processRequest(@NonNull String method, @NonNull String path, 
+                                      @Nullable String body, @NonNull Map<String, String> headers,
+                                      @NonNull Map<String, String> params) {
+            
+            String requestId = UUID.randomUUID().toString();
+            
+            // Build request data for JavaScript
+            JSObject requestData = new JSObject();
+            requestData.put("requestId", requestId);
+            requestData.put("method", method);
+            requestData.put("path", path);
+            
+            if (body != null && !body.isEmpty()) {
+                requestData.put("body", body);
+            }
+            
+            if (!headers.isEmpty()) {
+                requestData.put("headers", mapToJson(headers));
+            }
+            
+            if (!params.isEmpty()) {
+                requestData.put("query", mapToJson(params));
+            }
+            
+            // Create future for response
+            CompletableFuture<String> future = new CompletableFuture<>();
+            pendingResponses.put(requestId, future);
+            
+            // Notify plugin
+            if (plugin instanceof HttpLocalServerSwifterPlugin) {
+                ((HttpLocalServerSwifterPlugin) plugin).fireOnRequest(requestData);
+            } else {
+                Log.e(TAG, "Plugin is not instance of HttpLocalServerSwifterPlugin");
+            }
+            
+            // Wait for JavaScript response
+            try {
+                String response = future.get(timeoutSeconds, TimeUnit.SECONDS);
+                Log.d(TAG, "Response received for request: " + requestId);
+                return response;
+            } catch (TimeoutException e) {
+                Log.w(TAG, "Timeout waiting for response: " + requestId);
+                return createTimeoutError(requestId);
+            } catch (Exception e) {
+                Log.e(TAG, "Error waiting for response: " + requestId, e);
+                return createGenericError("Error waiting for response");
+            } finally {
+                pendingResponses.remove(requestId);
+            }
+        }
+        
+        /**
+        * Convert Map to JSObject
+        */
+        @NonNull
+        private JSObject mapToJson(@NonNull Map<String, String> map) {
+            JSObject json = new JSObject();
+            for (Map.Entry<String, String> entry : map.entrySet()) {
+                json.put(entry.getKey(), entry.getValue());
+            }
+            return json;
+        }
+        
+        /**
+        * Create JSON response with CORS headers
+        */
+        @NonNull
+        private Response createJsonResponse(@NonNull String body, @NonNull Response.Status status) {
+            Response response = newFixedLengthResponse(status, "application/json", body);
+            addCorsHeaders(response);
+            return response;
+        }
+        
+        /**
+        * Create CORS preflight response
+        */
+        @NonNull
+        private Response createCorsResponse() {
+            Response response = newFixedLengthResponse(Response.Status.NO_CONTENT, 
+                    "text/plain", "");
+            addCorsHeaders(response);
+            return response;
+        }
+        
+        /**
+        * Create error response
+        */
+        @NonNull
+        private Response createErrorResponse(@NonNull String message, @NonNull Response.Status status) {
+            try {
+                JSONObject error = new JSONObject();
+                error.put("error", message);
+                return createJsonResponse(error.toString(), status);
+            } catch (JSONException e) {
+                return newFixedLengthResponse(status, "text/plain", message);
+            }
+        }
+        
+        /**
+        * Create timeout error JSON
+        */
+        @NonNull
+        private String createTimeoutError(@NonNull String requestId) {
+            try {
+                JSONObject error = new JSONObject();
+                error.put("error", "Request timeout");
+                error.put("requestId", requestId);
+                return error.toString();
+            } catch (JSONException e) {
+                return "{\"error\":\"Request timeout\"}";
+            }
+        }
+        
+        /**
+        * Create generic error JSON
+        */
+        @NonNull
+        private String createGenericError(@NonNull String message) {
+            try {
+                JSONObject error = new JSONObject();
+                error.put("error", message);
+                return error.toString();
+            } catch (JSONException e) {
+                return "{\"error\":\"" + message + "\"}";
+            }
+        }
+        
+        /**
+        * Add CORS headers to response
+        */
+        private void addCorsHeaders(@NonNull Response response) {
+            response.addHeader("Access-Control-Allow-Origin", "*");
+            response.addHeader("Access-Control-Allow-Methods", "GET, POST, PUT, PATCH, DELETE, OPTIONS");
+            response.addHeader("Access-Control-Allow-Headers", "Origin, Content-Type, Accept, Authorization");
+            response.addHeader("Access-Control-Allow-Credentials", "true");
+            response.addHeader("Access-Control-Max-Age", "3600");
+        }
+    }
+}

package/android/src/main/java/com/cappitolian/plugins/httplocalserviceswifter/HttpLocalServerSwifterPlugin.java

@@ -0,0 +1,80 @@
+package com.cappitolian.plugins.httplocalserviceswifter;
+
+import android.util.Log;
+
+import androidx.annotation.NonNull;
+
+import com.getcapacitor.JSObject;
+import com.getcapacitor.Plugin;
+import com.getcapacitor.PluginCall;
+import com.getcapacitor.PluginMethod;
+import com.getcapacitor.annotation.CapacitorPlugin;
+
+@CapacitorPlugin(name = "HttpLocalServerSwifter")
+public class HttpLocalServerSwifterPlugin extends Plugin {
+    private static final String TAG = "HttpLocalServerSwifterPlugin";
+    private HttpLocalServerSwifter localServer;
+    @Override
+    public void load() {
+        super.load();
+        // Inicializar el servidor con configuración por defecto
+        localServer = new HttpLocalServerSwifter(this);
+        
+        // O con configuración personalizada:
+        // localServer = new HttpLocalServerSwifter(this, 8080, 5); // puerto y timeout
+        
+        Log.d(TAG, "Plugin loaded");
+    }
+
+    @PluginMethod
+    public void connect(PluginCall call) {
+        if (localServer == null) {
+            localServer = new HttpLocalServerSwifter(this);
+        }
+        localServer.connect(call);
+    }
+
+    @PluginMethod
+    public void disconnect(PluginCall call) {
+        if (localServer != null) {
+            localServer.disconnect(call);
+        } else {
+            call.resolve();
+        }
+    }
+
+    @PluginMethod
+    public void sendResponse(PluginCall call) {
+        String requestId = call.getString("requestId");
+        String body = call.getString("body");
+        
+        if (requestId == null || requestId.isEmpty()) {
+            call.reject("Missing requestId");
+            return;
+        }
+        
+        if (body == null || body.isEmpty()) {
+            call.reject("Missing body");
+            return;
+        }
+        
+        HttpLocalServerSwifter.handleJsResponse(requestId, body);
+        call.resolve();
+    }
+
+    /**
+    * Called by HttpLocalServerSwifter to notify JavaScript of incoming requests
+    */
+    public void fireOnRequest(@NonNull JSObject data) {
+        notifyListeners("onRequest", data);
+    }
+    
+    @Override
+    protected void handleOnDestroy() {
+        if (localServer != null) {
+            localServer.disconnect(null);
+            localServer = null;
+        }
+        super.handleOnDestroy();
+    }
+}