@cappitolian/http-local-server 0.0.8 → 0.0.10

package/README.md

@@ -34,13 +34,19 @@ import { HttpLocalServer } from '@cappitolian/http-local-server';
 
 ```typescript
 // 1. Set up the listener for incoming requests
-HttpLocalServer.addListener('onRequest', async (request) => {
-  console.log('Request received:', request.path, request.body);
+await HttpLocalServer.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 HttpLocalServer.sendResponse({
-    requestId: request.requestId,
-    body: JSON.stringify({ message: "Hello from Ionic!" })
+    requestId: data.requestId,
+    body: JSON.stringify({ 
+      success: true, 
+      message: 'Request processed!' 
+    })
   });
 });
 
@@ -53,7 +59,8 @@ HttpLocalServer.connect().then(result => {
 ### Stop Server
 
 ```typescript
-HttpLocalServer.disconnect()
+// 4. Stop the server
+await HttpLocalServer.disconnect();
 ```
 
 ---

package/android/src/main/java/com/cappitolian/plugins/httplocalserver/HttpLocalServer.java

@@ -25,167 +25,365 @@
 package com.cappitolian.plugins.httplocalservice;
 
 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 fi.iki.elonen.NanoHTTPD;
+
+import org.json.JSONException;
+import org.json.JSONObject;
+
 import java.io.IOException;
-import java.util.UUID;
-import java.util.concurrent.*;
 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 HttpLocalServer {
+    
+    // MARK: - Constants
+    private static final String TAG = "HttpLocalServer";
+    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 String localIp;
-    private int port = 8080;
-    private Plugin plugin;
-
-    // Map to wait for responses from JS (key: requestId)
+    private final Plugin plugin;
+    private final int port;
+    private final int timeoutSeconds;
+    
     private static final ConcurrentHashMap<String, CompletableFuture<String>> pendingResponses = new ConcurrentHashMap<>();
-
-    public HttpLocalServer(Plugin plugin) {
+    
+    // MARK: - Constructor
+    public HttpLocalServer(@NonNull Plugin plugin) {
+        this(plugin, DEFAULT_PORT, DEFAULT_TIMEOUT_SECONDS);
+    }
+    
+    public HttpLocalServer(@NonNull Plugin plugin, int port, int timeoutSeconds) {
         this.plugin = plugin;
+        this.port = port;
+        this.timeoutSeconds = timeoutSeconds;
     }
-
-    public void connect(PluginCall call) {
-        if (server == null) {
-            localIp = getLocalIpAddress(plugin.getContext());
-            server = new LocalNanoServer(localIp, port, plugin);
-            try {
-                server.start();
-                JSObject ret = new JSObject();
-                ret.put("ip", localIp);
-                ret.put("port", port);
-                call.resolve(ret);
-            } catch (Exception e) {
-                call.reject("Failed to start server: " + e.getMessage());
-            }
-        } else {
+    
+    // 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(PluginCall call) {
+    
+    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();
         }
-        call.resolve();
     }
-
-    // Called by plugin when JS responds
-    public static void handleJsResponse(String requestId, String body) {
+    
+    // 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) {
+        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);
         }
     }
-
-    // Helper to get local WiFi IP Address
-    private String getLocalIpAddress(Context context) {
-        WifiManager wm = (WifiManager) context.getApplicationContext().getSystemService(Context.WIFI_SERVICE);
-        if (wm != null && wm.getConnectionInfo() != null) {
-            return Formatter.formatIpAddress(wm.getConnectionInfo().getIpAddress());
+    
+    // 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;
         }
-        return "127.0.0.1"; // fallback
     }
-
+    
+    // MARK: - Inner Class: LocalNanoServer
+    /**
+     * NanoHTTPD server implementation that handles HTTP requests
+     */
     private static class LocalNanoServer extends NanoHTTPD {
-        private Plugin plugin;
-
-        public LocalNanoServer(String hostname, int port, Plugin plugin) {
+        
+        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(IHTTPSession session) {
-            String path = session.getUri();
+        public Response serve(@NonNull IHTTPSession session) {
             String method = session.getMethod().name();
-
-            // Read body if needed
-            String body = "";
-            if (session.getMethod() == Method.POST || session.getMethod() == Method.PUT) {
-                try {
-                    // Crear un mapa para almacenar los datos parseados
-                    HashMap<String, String> files = new HashMap<>();
-                    session.parseBody(files);
-                    
-                    // El body viene en el mapa con la clave "postData"
-                    body = files.get("postData");
-                    
-                    // Si postData es null, intentar obtener de los parámetros (para form-data)
-                    if (body == null || body.isEmpty()) {
-                        // Para application/x-www-form-urlencoded
-                        body = session.getQueryParameterString();
-                    }
-                    
-                    // Log para debug
-                    System.out.println("Body received: " + body);
-                    
-                } catch (Exception e) {
-                    System.err.println("Error parsing body: " + e.getMessage());
-                    e.printStackTrace();
+            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;
             }
-
-            // Generate a unique requestId
+        }
+        
+        /**
+         * 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();
-
-            // Prepare data for JS
-            JSObject req = new JSObject();
-            req.put("requestId", requestId);
-            req.put("method", method);
-            req.put("path", path);
-            req.put("body", body);
-            req.put("headers", getHeadersAsJson(session)); // Opcional: para debug
-
-            // Future to wait for JS response
+            
+            // 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);
-
-            // Send event to JS
-            if (plugin instanceof com.cappitolian.plugins.httplocalservice.HttpLocalServerPlugin) {
-                ((com.cappitolian.plugins.httplocalservice.HttpLocalServerPlugin) plugin).fireOnRequest(req);
+            
+            // Notify plugin
+            if (plugin instanceof HttpLocalServerPlugin) {
+                ((HttpLocalServerPlugin) plugin).fireOnRequest(requestData);
+            } else {
+                Log.e(TAG, "Plugin is not instance of HttpLocalServerPlugin");
             }
-
-            String jsResponse = null;
+            
+            // Wait for JavaScript response
             try {
-                // Wait up to 55 seconds for JS response
-                jsResponse = future.get(55, TimeUnit.SECONDS);
+                String response = future.get(timeoutSeconds, TimeUnit.SECONDS);
+                Log.d(TAG, "Response received for request: " + requestId);
+                return response;
             } catch (TimeoutException e) {
-                jsResponse = "{\"error\": \"Timeout waiting for JS response\"}";
+                Log.w(TAG, "Timeout waiting for response: " + requestId);
+                return createTimeoutError(requestId);
             } catch (Exception e) {
-                jsResponse = "{\"error\": \"Error waiting for JS response\"}";
+                Log.e(TAG, "Error waiting for response: " + requestId, e);
+                return createGenericError("Error waiting for response");
             } finally {
                 pendingResponses.remove(requestId);
             }
-
-            Response response = newFixedLengthResponse(Response.Status.OK, "application/json", jsResponse);
+        }
+        
+        /**
+         * 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;
         }
-
-        // Método auxiliar para obtener headers como JSObject
-        private JSObject getHeadersAsJson(IHTTPSession session) {
-            JSObject headers = new JSObject();
+        
+        /**
+         * 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 {
-                for (Map.Entry<String, String> entry : session.getHeaders().entrySet()) {
-                    headers.put(entry.getKey(), entry.getValue());
-                }
-            } catch (Exception e) {
-                // ignore
+                JSONObject error = new JSONObject();
+                error.put("error", message);
+                return createJsonResponse(error.toString(), status);
+            } catch (JSONException e) {
+                return newFixedLengthResponse(status, "text/plain", message);
             }
-            return headers;
         }
-
-        private void addCorsHeaders(Response response) {
+        
+        /**
+         * 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,OPTIONS");
-            response.addHeader("Access-Control-Allow-Headers", "origin, content-type, accept, authorization");
+            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/httplocalserver/HttpLocalServerPlugin.java

@@ -46,16 +46,34 @@
 
 package com.cappitolian.plugins.httplocalservice;
 
-import com.getcapacitor.*;
+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;
-import org.json.JSONException;
-import org.json.JSONObject;
 
 @CapacitorPlugin(name = "HttpLocalServer")
 public class HttpLocalServerPlugin extends Plugin {
-
+    
+    private static final String TAG = "HttpLocalServerPlugin";
     private HttpLocalServer localServer;
 
+    @Override
+    public void load() {
+        super.load();
+        // Inicializar el servidor con configuración por defecto
+        localServer = new HttpLocalServer(this);
+        
+        // O con configuración personalizada:
+        // localServer = new HttpLocalServer(this, 8080, 5); // puerto y timeout
+        
+        Log.d(TAG, "Plugin loaded");
+    }
+
     @PluginMethod
     public void connect(PluginCall call) {
         if (localServer == null) {
@@ -64,11 +82,6 @@ public class HttpLocalServerPlugin extends Plugin {
         localServer.connect(call);
     }
 
-    // Add this method:
-    public void fireOnRequest(JSObject req) {
-        notifyListeners("onRequest", req, true);
-    }
-
     @PluginMethod
     public void disconnect(PluginCall call) {
         if (localServer != null) {
@@ -82,11 +95,34 @@ public class HttpLocalServerPlugin extends Plugin {
     public void sendResponse(PluginCall call) {
         String requestId = call.getString("requestId");
         String body = call.getString("body");
-        if (requestId == null || body == null) {
-            call.reject("Missing requestId or body");
+        
+        if (requestId == null || requestId.isEmpty()) {
+            call.reject("Missing requestId");
             return;
         }
+        
+        if (body == null || body.isEmpty()) {
+            call.reject("Missing body");
+            return;
+        }
+        
         HttpLocalServer.handleJsResponse(requestId, body);
         call.resolve();
     }
+
+    /**
+     * Called by HttpLocalServer 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();
+    }
 }