tentative fix for websocket issues

build/web/flutter_bootstrap.js

@@ -38,6 +38,6 @@ _flutter.buildConfig = {"engineRevision":"1c9c20e7c3dd48c66f400a24d48ea806b4ab31
 
 _flutter.loader.load({
   serviceWorkerSettings: {
-    serviceWorkerVersion: "3948338569"
+    serviceWorkerVersion: "3662004008"
   }
 });

build/web/flutter_service_worker.js

@@ -3,12 +3,12 @@ const MANIFEST = 'flutter-app-manifest';
 const TEMP = 'flutter-temp-cache';
 const CACHE_NAME = 'flutter-app-cache';
 
-const RESOURCES = {"flutter_bootstrap.js": "b98de8eaf32c5bc183c9879c24e42172",
+const RESOURCES = {"flutter_bootstrap.js": "da908042a784a46384f779dd4c199a53",
 "version.json": "68350cac7987de2728345c72918dd067",
 "tikslop.png": "570e1db759046e2d224fef729983634e",
 "index.html": "3a7029b3672560e7938aab6fa4d30a46",
 "/": "3a7029b3672560e7938aab6fa4d30a46",
-"main.dart.js": "a897b61edcb30264f6ad2d89a6931afc",
+"main.dart.js": "b0e4eb9c26998dfbb3b2616a19bf9c7d",
 "tikslop.svg": "26140ba0d153b213b122bc6ebcc17f6c",
 "flutter.js": "888483df48293866f9f41d3d9274a779",
 "favicon.png": "c8a183c516004e648a7bac7497c89b97",

build/web/index.html

@@ -156,7 +156,7 @@
   </script>
   
   <!-- Add version parameter for cache busting -->
-  <script src="flutter_bootstrap.js?v=1753289445" async></script>
+  <script src="flutter_bootstrap.js?v=1753290193" async></script>
   
   <!-- Add cache busting script -->
   <script>

lib/screens/settings_screen.dart

@@ -241,14 +241,8 @@ class _SettingsScreenState extends State<SettingsScreen> {
                       // Reinitialize the websocket connection when the API key changes
                       final websocket = WebSocketApiService();
                       try {
-                        // First dispose the current connection
-                        await websocket.dispose();
-                        
-                        // Then create a new connection with the new API key
-                        await websocket.connect();
-                        
-                        // Finally, initialize the connection completely
-                        await websocket.initialize();
+                        // Force reconnection with the new API key
+                        await websocket.reconnect();
                         
                         // Show success message
                         if (context.mounted) {
@@ -694,6 +688,27 @@ class _SettingsScreenState extends State<SettingsScreen> {
                       _settingsService.setEnableSimulation(value);
                     },
                   ),
+                  const SizedBox(height: 16),
+                  // Clear device connections button
+                  ListTile(
+                    title: const Text('Clear Device Connections'),
+                    subtitle: const Text('Clear all cached device connections (useful if you see "Too many connections" error)'),
+                    trailing: ElevatedButton(
+                      onPressed: () {
+                        // Clear all device connections
+                        WebSocketApiService.clearAllDeviceConnections();
+                        
+                        // Show confirmation message
+                        ScaffoldMessenger.of(context).showSnackBar(
+                          const SnackBar(
+                            content: Text('Device connections cleared. Please reload the page.'),
+                            backgroundColor: Colors.green,
+                          ),
+                        );
+                      },
+                      child: const Text('Clear All'),
+                    ),
+                  ),
                 ],
               ),
             ),

lib/services/websocket_api_service.dart

@@ -144,6 +144,35 @@ class WebSocketApiService {
     
     try {
       debugPrint('WebSocketApiService: Initializing and connecting...');
+      
+      // Add page unload handler for web platform
+      if (kIsWeb) {
+        try {
+          // Add beforeunload listener to clean up connection
+          html.window.onBeforeUnload.listen((_) {
+            debugPrint('WebSocketApiService: Page unloading, cleaning up connection...');
+            _unregisterDeviceConnection();
+          });
+          
+          // Also add pagehide listener as a fallback
+          html.window.addEventListener('pagehide', (event) {
+            debugPrint('WebSocketApiService: Page hiding, cleaning up connection...');
+            _unregisterDeviceConnection();
+          });
+          
+          // And visibilitychange for when the page is being closed
+          html.document.addEventListener('visibilitychange', (event) {
+            if (html.document.hidden == true) {
+              debugPrint('WebSocketApiService: Page becoming hidden, updating heartbeat...');
+              // Update heartbeat when page becomes hidden to keep connection alive
+              _updateConnectionHeartbeat();
+            }
+          });
+        } catch (e) {
+          debugPrint('Error setting up page unload handlers: $e');
+        }
+      }
+      
       await connect();
       
       // Only continue if we're properly connected
@@ -242,9 +271,34 @@ class WebSocketApiService {
     if (!kIsWeb) return true; // Only apply on web platform
     
     try {
-      // Generate a unique ID for this connection instance
+      // Try to reuse existing connection ID from localStorage if valid
       if (_connectionId == null) {
-        _connectionId = const Uuid().v4();
+        final storedId = html.window.localStorage[_connectionIdKey];
+        if (storedId != null && storedId.isNotEmpty) {
+          // Check if this connection ID is still active
+          final countJson = html.window.localStorage[_connectionCountKey];
+          if (countJson != null && countJson.isNotEmpty) {
+            try {
+              final connections = json.decode(countJson) as Map<String, dynamic>;
+              final now = DateTime.now().millisecondsSinceEpoch;
+              final connectionTimestamp = connections[storedId];
+              
+              // Reuse the ID if it's still recent (within 15 seconds)
+              if (connectionTimestamp is int && now - connectionTimestamp < 15000) {
+                _connectionId = storedId;
+                debugPrint('Reusing existing connection ID: $_connectionId');
+              }
+            } catch (e) {
+              debugPrint('Error checking stored connection: $e');
+            }
+          }
+        }
+        
+        // Generate new ID if we couldn't reuse one
+        if (_connectionId == null) {
+          _connectionId = const Uuid().v4();
+          debugPrint('Generated new connection ID: $_connectionId');
+        }
         
         // Store connection ID in localStorage
         html.window.localStorage[_connectionIdKey] = _connectionId!;
@@ -263,13 +317,18 @@ class WebSocketApiService {
         }
       }
       
-      // Clean up stale connections (older than 30 seconds)
+      // Clean up stale connections (older than 20 seconds - more aggressive)
       final now = DateTime.now().millisecondsSinceEpoch;
+      final beforeCleanup = connections.length;
       connections.removeWhere((key, value) {
         if (value is! int) return true;
-        return now - value > 30000; // 30 seconds timeout
+        return now - value > 20000; // 20 seconds timeout (more aggressive)
       });
       
+      if (beforeCleanup != connections.length) {
+        debugPrint('Cleaned up ${beforeCleanup - connections.length} stale connections');
+      }
+      
       // Add/update this connection
       connections[_connectionId!] = now;
       
@@ -280,6 +339,7 @@ class WebSocketApiService {
       // For anonymous users, we rely on the server-side IP check
       if (_userRole != 'anon' && connections.length > _maxDeviceConnections) {
         debugPrint('Device connection limit exceeded: ${connections.length} connections for $_userRole user');
+        debugPrint('Active connections: ${connections.keys.toList()}');
         return false;
       }
       
@@ -343,6 +403,9 @@ class WebSocketApiService {
       // Store back to localStorage
       html.window.localStorage[_connectionCountKey] = json.encode(connections);
       
+      // Also remove the stored connection ID
+      html.window.localStorage.remove(_connectionIdKey);
+      
       // Stop the heartbeat timer
       _connectionHeartbeatTimer?.cancel();
       _connectionHeartbeatTimer = null;
@@ -351,6 +414,19 @@ class WebSocketApiService {
     }
   }
   
+  // Public method to clear all device connections (useful for debugging)
+  static void clearAllDeviceConnections() {
+    if (!kIsWeb) return;
+    
+    try {
+      html.window.localStorage.remove(_connectionCountKey);
+      html.window.localStorage.remove(_connectionIdKey);
+      debugPrint('WebSocketApiService: Cleared all device connections from localStorage');
+    } catch (e) {
+      debugPrint('Error clearing device connections: $e');
+    }
+  }
+  
   // Start the connection heartbeat timer
   void _startConnectionHeartbeat() {
     if (!kIsWeb) return;
@@ -361,6 +437,36 @@ class WebSocketApiService {
     });
   }
 
+  /// Reconnect to the WebSocket server, closing any existing connection first
+  Future<void> reconnect() async {
+    if (_disposed) {
+      throw Exception('WebSocketApiService has been disposed');
+    }
+
+    debugPrint('WebSocketApiService: Forcing reconnection...');
+    
+    // Unregister the current connection
+    _unregisterDeviceConnection();
+    
+    // Close existing connection if any
+    if (_channel != null) {
+      try {
+        await _channel!.sink.close();
+      } catch (e) {
+        debugPrint('WebSocketApiService: Error closing existing channel: $e');
+      }
+      _channel = null;
+    }
+    
+    // Reset connection state and ID
+    _setStatus(ConnectionStatus.disconnected);
+    _reconnectAttempts = 0;
+    _connectionId = null;  // Clear connection ID to force a new one
+    
+    // Connect again
+    await connect();
+  }
+
   Future<void> connect() async {
     if (_disposed) {
       throw Exception('WebSocketApiService has been disposed');