refactor: refactored all handlers into a callback map (#144)

* refactor: refactored all handlers into a callback map
* fix: simplified code by removing dedicated boot code

Author: gmegidish

server/dispatch.go

@@ -0,0 +1,48 @@
+package server
+
+import (
+	"encoding/json"
+	"fmt"
+)
+
+// HandlerFunc is the signature for non-streaming JSON-RPC method handlers
+type HandlerFunc func(params json.RawMessage) (interface{}, error)
+
+// GetMethodRegistry returns a map of method names to handler functions
+// This is used by both the HTTP server and embedded clients
+func GetMethodRegistry() map[string]HandlerFunc {
+	return map[string]HandlerFunc{
+		"devices":            handleDevicesList,
+		"screenshot":         handleScreenshot,
+		"io_tap":             handleIoTap,
+		"io_longpress":       handleIoLongPress,
+		"io_text":            handleIoText,
+		"io_button":          handleIoButton,
+		"io_swipe":           handleIoSwipe,
+		"io_gesture":         handleIoGesture,
+		"url":                handleURL,
+		"device_info":        handleDeviceInfo,
+		"io_orientation_get": handleIoOrientationGet,
+		"io_orientation_set": handleIoOrientationSet,
+		"device_boot":        handleDeviceBoot,
+		"device_shutdown":    handleDeviceShutdown,
+		"device_reboot":      handleDeviceReboot,
+		"dump_ui":            handleDumpUI,
+		"apps_launch":        handleAppsLaunch,
+		"apps_terminate":     handleAppsTerminate,
+		"apps_list":          handleAppsList,
+	}
+}
+
+// Execute dispatches a method call using the registry
+// This is the main entry point for embedded clients
+func Execute(method string, params json.RawMessage) (interface{}, error) {
+	registry := GetMethodRegistry()
+
+	handler, exists := registry[method]
+	if !exists {
+		return nil, fmt.Errorf("method not found: %s", method)
+	}
+
+	return handler(params)
+}

server/server.go

@@ -151,55 +151,35 @@ func handleJSONRPC(w http.ResponseWriter, r *http.Request) {
 	var result interface{}
 	var err error
 
-	switch req.Method {
-	case "devices":
-		result, err = handleDevicesList(req.Params)
-	case "screenshot":
-		result, err = handleScreenshot(req.Params)
-	case "screencapture":
+	// Special case: screencapture is streaming and has different signature
+	if req.Method == "screencapture" {
 		err = handleScreenCapture(w, req.Params)
-	case "io_tap":
-		result, err = handleIoTap(req.Params)
-	case "io_longpress":
-		result, err = handleIoLongPress(req.Params)
-	case "io_text":
-		result, err = handleIoText(req.Params)
-	case "io_button":
-		result, err = handleIoButton(req.Params)
-	case "io_swipe":
-		result, err = handleIoSwipe(req.Params)
-	case "io_gesture":
-		result, err = handleIoGesture(req.Params)
-	case "url":
-		result, err = handleURL(req.Params)
-	case "device_info":
-		result, err = handleDeviceInfo(req.Params)
-	case "io_orientation_get":
-		result, err = handleIoOrientationGet(req.Params)
-	case "io_orientation_set":
-		result, err = handleIoOrientationSet(req.Params)
-	case "device_boot":
-		result, err = handleDeviceBoot(w, req.Params)
-	case "device_shutdown":
-		result, err = handleDeviceShutdown(req.Params)
-	case "device_reboot":
-		result, err = handleDeviceReboot(req.Params)
-	case "dump_ui":
-		result, err = handleDumpUI(req.Params)
-	case "apps_launch":
-		result, err = handleAppsLaunch(req.Params)
-	case "apps_terminate":
-		result, err = handleAppsTerminate(req.Params)
-	case "apps_list":
-		result, err = handleAppsList(req.Params)
-	case "":
-		err = fmt.Errorf("'method' is required")
-
-	default:
-		sendJSONRPCError(w, req.ID, ErrCodeMethodNotFound, "Method not found", fmt.Sprintf("Method '%s' not found", req.Method))
+		if err != nil {
+			log.Printf("Error in screen capture: %v", err)
+			sendJSONRPCError(w, req.ID, ErrCodeServerError, "Server error", err.Error())
+		}
 		return
 	}
 
+	// HTTP-specific: device_boot needs extended timeout (can take up to 2 minutes)
+	if req.Method == "device_boot" {
+		_ = http.NewResponseController(w).SetWriteDeadline(time.Now().Add(3 * time.Minute))
+	}
+
+	// Use registry for all methods
+	if req.Method == "" {
+		err = fmt.Errorf("'method' is required")
+	} else {
+		registry := GetMethodRegistry()
+		handler, exists := registry[req.Method]
+		if exists {
+			result, err = handler(req.Params)
+		} else {
+			sendJSONRPCError(w, req.ID, ErrCodeMethodNotFound, "Method not found", fmt.Sprintf("Method '%s' not found", req.Method))
+			return
+		}
+	}
+
 	if err != nil {
 		log.Printf("Error decoding JSON-RPC request: %v", err)
 		sendJSONRPCError(w, req.ID, ErrCodeServerError, "Server error", err.Error())
@@ -624,10 +604,7 @@ func handleIoOrientationSet(params json.RawMessage) (interface{}, error) {
 	return okResponse, nil
 }
 
-func handleDeviceBoot(w http.ResponseWriter, params json.RawMessage) (interface{}, error) {
-	// extend write deadline for boot operations (can take up to 2 minutes)
-	_ = http.NewResponseController(w).SetWriteDeadline(time.Now().Add(3 * time.Minute))
-
+func handleDeviceBoot(params json.RawMessage) (interface{}, error) {
 	if len(params) == 0 {
 		return nil, fmt.Errorf("'params' is required with fields: deviceId")
 	}