fix: add connection pooling and periodic cleanup to prevent TCP exhaustion

android/app/src/main/kotlin/com/zarz/spotiflac/MainActivity.kt

@@ -127,6 +127,12 @@ class MainActivity: FlutterActivity() {
                             }
                             result.success(response)
                         }
+                        "cleanupConnections" -> {
+                            withContext(Dispatchers.IO) {
+                                Gobackend.cleanupConnections()
+                            }
+                            result.success(null)
+                        }
                         else -> result.notImplemented()
                     }
                 } catch (e: Exception) {

go_backend/exports.go

@@ -239,6 +239,12 @@ func GetDownloadProgress() string {
 	return string(jsonBytes)
 }
 
+// CleanupConnections closes idle HTTP connections
+// Call this periodically during large batch downloads to prevent TCP exhaustion
+func CleanupConnections() {
+	CloseIdleConnections()
+}
+
 // SetDownloadDirectory sets the default download directory
 func SetDownloadDirectory(path string) error {
 	return setDownloadDir(path)

go_backend/httputil.go

@@ -4,6 +4,7 @@ import (
 	"fmt"
 	"io"
 	"math/rand"
+	"net"
 	"net/http"
 	"strconv"
 	"time"
@@ -41,13 +42,59 @@ const (
 	DefaultRetryDelay  = 1 * time.Second   // Initial retry delay
 )
 
+// Shared transport with connection pooling to prevent TCP exhaustion
+var sharedTransport = &http.Transport{
+	DialContext: (&net.Dialer{
+		Timeout:   30 * time.Second,
+		KeepAlive: 30 * time.Second,
+	}).DialContext,
+	MaxIdleConns:          100,
+	MaxIdleConnsPerHost:   10,
+	MaxConnsPerHost:       20,
+	IdleConnTimeout:       90 * time.Second,
+	TLSHandshakeTimeout:   10 * time.Second,
+	ExpectContinueTimeout: 1 * time.Second,
+	DisableKeepAlives:     false, // Enable keep-alives for connection reuse
+	ForceAttemptHTTP2:     true,
+}
+
+// Shared HTTP client for general requests (reuses connections)
+var sharedClient = &http.Client{
+	Transport: sharedTransport,
+	Timeout:   DefaultTimeout,
+}
+
+// Shared HTTP client for downloads (longer timeout, reuses connections)
+var downloadClient = &http.Client{
+	Transport: sharedTransport,
+	Timeout:   DownloadTimeout,
+}
+
 // NewHTTPClientWithTimeout creates an HTTP client with specified timeout
+// Uses shared transport for connection reuse
 func NewHTTPClientWithTimeout(timeout time.Duration) *http.Client {
 	return &http.Client{
-		Timeout: timeout,
+		Transport: sharedTransport,
+		Timeout:   timeout,
 	}
 }
 
+// GetSharedClient returns the shared HTTP client for general requests
+func GetSharedClient() *http.Client {
+	return sharedClient
+}
+
+// GetDownloadClient returns the shared HTTP client for downloads
+func GetDownloadClient() *http.Client {
+	return downloadClient
+}
+
+// CloseIdleConnections closes idle connections in the shared transport
+// Call this periodically during large batch downloads to prevent connection buildup
+func CloseIdleConnections() {
+	sharedTransport.CloseIdleConnections()
+}
+
 // DoRequestWithUserAgent executes an HTTP request with a random User-Agent header
 func DoRequestWithUserAgent(client *http.Client, req *http.Request) (*http.Response, error) {
 	req.Header.Set("User-Agent", getRandomUserAgent())

lib/providers/download_queue_provider.dart

@@ -169,6 +169,8 @@ class DownloadQueueState {
 // Download Queue Notifier (Riverpod 3.x)
 class DownloadQueueNotifier extends Notifier<DownloadQueueState> {
   Timer? _progressTimer;
+  int _downloadCount = 0; // Counter for connection cleanup
+  static const _cleanupInterval = 50; // Cleanup every 50 downloads
 
   @override
   DownloadQueueState build() {
@@ -552,6 +554,17 @@ class DownloadQueueNotifier extends Notifier<DownloadQueueState> {
             error: errorMsg,
           );
         }
+        
+        // Increment download counter and cleanup connections periodically
+        _downloadCount++;
+        if (_downloadCount % _cleanupInterval == 0) {
+          print('[DownloadQueue] Cleaning up idle connections (after $_downloadCount downloads)...');
+          try {
+            await PlatformBridge.cleanupConnections();
+          } catch (e) {
+            print('[DownloadQueue] Connection cleanup failed: $e');
+          }
+        }
       } catch (e, stackTrace) {
         _stopProgressPolling();
         print('[DownloadQueue] Exception: $e');
@@ -565,6 +578,18 @@ class DownloadQueueNotifier extends Notifier<DownloadQueueState> {
     }
 
     _stopProgressPolling();
+    
+    // Final cleanup after queue finishes
+    if (_downloadCount > 0) {
+      print('[DownloadQueue] Final connection cleanup...');
+      try {
+        await PlatformBridge.cleanupConnections();
+      } catch (e) {
+        print('[DownloadQueue] Final cleanup failed: $e');
+      }
+      _downloadCount = 0;
+    }
+    
     print('[DownloadQueue] Queue processing finished');
     state = state.copyWith(isProcessing: false, currentDownload: null);
   }

lib/services/platform_bridge.dart

@@ -195,4 +195,10 @@ class PlatformBridge {
     });
     return jsonDecode(result as String) as Map<String, dynamic>;
   }
+
+  /// Cleanup idle HTTP connections to prevent TCP exhaustion
+  /// Call this periodically during large batch downloads
+  static Future<void> cleanupConnections() async {
+    await _channel.invokeMethod('cleanupConnections');
+  }
 }