expo-http-server 0.1.14-beta.3 → 0.1.14-beta.4

package/android/src/main/java/expo/modules/httpserver/ExpoHttpServerModule.kt

@@ -9,6 +9,7 @@ import com.safframework.server.core.http.HttpMethod
 import com.safframework.server.core.http.Request
 import com.safframework.server.core.http.Response
 import org.json.JSONObject
+import java.net.BindException
 import java.util.concurrent.ConcurrentHashMap
 
 class ExpoHttpServerModule : Module() {
@@ -20,11 +21,55 @@ class ExpoHttpServerModule : Module() {
 
   data class RouteConfig(val path: String, val method: String, val uuid: String)
 
+  companion object {
+    // The underlying AndroidServer/Netty bind happens on Netty's own event loop
+    // thread, asynchronously, so a BindException there can never be caught by a
+    // try/catch around server.start() - it surfaces as an uncaught exception and
+    // crashes the app. We install a single, narrowly-scoped default uncaught
+    // exception handler (chained to whatever was already registered) that only
+    // swallows BindExceptions thrown from within Netty's own call stack, so we
+    // can report the failure via onStatusUpdate instead of crashing.
+    private var bindExceptionGuardInstalled = false
+    private val statusUpdateListeners = ConcurrentHashMap.newKeySet<(String) -> Unit>()
+
+    @Synchronized
+    private fun ensureBindExceptionGuardInstalled() {
+      if (bindExceptionGuardInstalled) return
+      bindExceptionGuardInstalled = true
+      val previousHandler = Thread.getDefaultUncaughtExceptionHandler()
+      Thread.setDefaultUncaughtExceptionHandler { thread, throwable ->
+        if (isNettyBindException(throwable)) {
+          val message = throwable.message ?: "Address already in use"
+          statusUpdateListeners.forEach { it(message) }
+        } else {
+          previousHandler?.uncaughtException(thread, throwable)
+        }
+      }
+    }
+
+    private fun isNettyBindException(throwable: Throwable): Boolean =
+      throwable is BindException &&
+        throwable.stackTrace.any { it.className.startsWith("io.netty") }
+  }
+
   private var server: Server? = null
   private var started = false
+  // Tracks whether the *current* server instance has actually bound a socket.
+  // A freshly built server (from setup()/buildServerWithRoutes()) holds no
+  // socket, so there's nothing to release before starting it - closing and
+  // rebuilding in that case only adds an unnecessary close/rebind race.
+  private var hasBoundSocket = false
   private var configuredPort: Int = 0
   private val routeConfigs = mutableListOf<RouteConfig>()
   private val responses = ConcurrentHashMap<String, SimpleHttpResponse>()
+  private val onBindFailure: (String) -> Unit = { message ->
+    started = false
+    hasBoundSocket = false
+    sendEvent("onStatusUpdate", bundleOf(
+      "status" to "ERROR",
+      "message" to message
+    ))
+  }
 
   private fun handleRequest(uuid: String, request: Request, response: Response): Response {
     val headers: Map<String, String> = request.headers()
@@ -72,10 +117,20 @@ class ExpoHttpServerModule : Module() {
 
     Events("onStatusUpdate", "onRequest")
 
+    OnCreate {
+      ensureBindExceptionGuardInstalled()
+      statusUpdateListeners.add(onBindFailure)
+    }
+
+    OnDestroy {
+      statusUpdateListeners.remove(onBindFailure)
+    }
+
     Function("setup") { port: Int ->
       configuredPort = port
       server?.close()
       started = false
+      hasBoundSocket = false
       routeConfigs.clear()
       server = AndroidServer.Builder {
         port { configuredPort }
@@ -99,12 +154,22 @@ class ExpoHttpServerModule : Module() {
         if (!started) {
           try {
             started = true
-            // Always close and rebuild before starting so any existing socket binding
-            // is released, preventing BindException on the Netty event loop thread
-            // (which is asynchronous and not caught by this try/catch).
-            server?.close()
-            server = buildServerWithRoutes()
+            // Only close and rebuild when the current server instance has actually
+            // bound a socket before - a freshly built instance (from setup(), or
+            // because it was never started) holds nothing to release, so closing
+            // and immediately rebinding it would just add an unnecessary race with
+            // the OS releasing the port (BindException: Address already in use).
+            if (hasBoundSocket) {
+              server?.close()
+              // Give the OS a moment to release the previous socket before rebinding
+              // to the same port - reduces (but, due to the underlying library
+              // configuring SO_REUSEADDR on the wrong socket scope, cannot fully
+              // eliminate) the "Address already in use" race.
+              Thread.sleep(300)
+              server = buildServerWithRoutes()
+            }
             server?.start()
+            hasBoundSocket = true
             sendEvent("onStatusUpdate", bundleOf(
               "status" to "STARTED",
               "message" to "Server started"

package/ios/ExpoHttpServerModule.swift

@@ -5,43 +5,35 @@ public class ExpoHttpServerModule: Module {
     private let server = CRHTTPServer()
     private var port: Int?
     private var stopped = false
-    private var isRunning = false
     private var responses = [String: CRResponse]()
     private var bgTaskIdentifier = UIBackgroundTaskIdentifier.invalid
-    private var foregroundObserver: NSObjectProtocol?
-
+    
     public func definition() -> ModuleDefinition {
         Name("ExpoHttpServer")
 
         Events("onStatusUpdate", "onRequest")
-
+        
         Function("setup", setupHandler)
         Function("start", startHandler)
         Function("route", routeHandler)
         Function("respond", respondHandler)
         Function("stop", stopHandler)
     }
-
+    
     private func setupHandler(port: Int) {
         self.port = port;
     }
 
     private func startHandler() {
-        if let obs = foregroundObserver {
-            NotificationCenter.default.removeObserver(obs)
-        }
-        foregroundObserver = NotificationCenter.default.addObserver(
-            forName: UIApplication.willEnterForegroundNotification,
-            object: nil,
-            queue: .main
-        ) { [weak self] _ in
-            guard let self, !self.stopped else { return }
-            self.startServer(status: "RESUMED", message: "Server resumed")
+        NotificationCenter.default.addObserver(forName: UIApplication.willEnterForegroundNotification, object: nil, queue: .main) { [unowned self] notification in
+            if (!self.stopped) {
+                self.startServer(status: "RESUMED", message: "Server resumed")
+            }
         }
-        stopped = false
+        stopped = false;
         startServer(status: "STARTED", message: "Server started")
     }
-
+    
     private func routeHandler(path: String, method: String, uuid: String) {
         server.add(path, block: { (req, res, next) in
             DispatchQueue.main.async {
@@ -62,7 +54,7 @@ public class ExpoHttpServerModule: Module {
             }
         }, recursive: false, method: CRHTTPMethod.fromString(method))
     }
-
+    
     private func respondHandler(udid: String,
                                 statusCode: Int,
                                 statusDescription: String,
@@ -81,58 +73,41 @@ public class ExpoHttpServerModule: Module {
                 self.responses[udid] = nil;
             }
         }
+       
     }
-
+    
     private func stopHandler() {
-        stopped = true
-        if let obs = foregroundObserver {
-            NotificationCenter.default.removeObserver(obs)
-            foregroundObserver = nil
-        }
+        stopped = true;
         stopServer(status: "STOPPED", message: "Server stopped")
     }
-
+        
     private func startServer(status: String, message: String) {
-        if isRunning {
-            server.stopListening()
-            isRunning = false
-            endBackgroundTask()
-            DispatchQueue.main.asyncAfter(deadline: .now() + 0.3) { [weak self] in
-                self?.doStart(status: status, message: message)
+        stopServer()
+        if let port = port {
+            var error: NSError?
+            server.startListening(&error, portNumber: UInt(port))
+            if (error != nil) {
+                sendEvent("onStatusUpdate", [
+                    "status": "ERROR",
+                    "message": error?.localizedDescription ?? "Unknown error starting server"
+                ])
+            } else {
+                beginBackgroundTask()
+                sendEvent("onStatusUpdate", [
+                    "status": status,
+                    "message": message
+                ])
             }
         } else {
-            doStart(status: status, message: message)
-        }
-    }
-
-    private func doStart(status: String, message: String) {
-        guard let port = port else {
             sendEvent("onStatusUpdate", [
                 "status": "ERROR",
                 "message": "Can't start server with port configured"
             ])
-            return
-        }
-        var error: NSError?
-        server.startListening(&error, portNumber: UInt(port))
-        if let error = error {
-            sendEvent("onStatusUpdate", [
-                "status": "ERROR",
-                "message": error.localizedDescription
-            ])
-        } else {
-            isRunning = true
-            beginBackgroundTask()
-            sendEvent("onStatusUpdate", [
-                "status": status,
-                "message": message
-            ])
         }
     }
-
+    
     private func stopServer(status: String? = nil, message: String? = nil) {
         server.stopListening()
-        isRunning = false
         endBackgroundTask()
         if let status = status, let message = message {
             sendEvent("onStatusUpdate", [
@@ -141,7 +116,7 @@ public class ExpoHttpServerModule: Module {
             ])
         }
     }
-
+    
     private func beginBackgroundTask() {
         if (bgTaskIdentifier == UIBackgroundTaskIdentifier.invalid) {
             self.bgTaskIdentifier = UIApplication.shared.beginBackgroundTask(withName: "BgTask", expirationHandler: {
@@ -180,7 +155,7 @@ extension CRHTTPMethod {
             return "GET"
         }
     }
-
+    
     static func fromString(_ string: String) -> Self {
         var httpMethod: CRHTTPMethod
         switch (string) {

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "expo-http-server",
-	"version": "0.1.14-beta.3",
+	"version": "0.1.14-beta.4",
 	"description": "A simple HTTP server expo module (iOS/Android)",
 	"main": "build/index.js",
 	"types": "build/index.d.ts",