Как восстановить WebSocket соединение при повторном открытии приложения после сворачивания?

Стратегии восстановления WebSocket-соединения при повторном открытии iOS-

приложения

Восстановление WebSocket-соединения после сворачивания и повторного открытия приложения — это критически важная задача для поддержания стабильного real-time взаимодействия с сервером. В iOS существуют специфические вызовы жизненного цикла приложения и системные ограничения, которые необходимо учитывать.

Ключевые проблемы и контекст

Когда пользователь сворачивает приложение (нажимает Home или переключается на другое), система может приостановить или завершить его процесс для экономии ресурсов. При повторном открытии приложение может быть запущено заново. WebSocket-соединение, будучи сетевым ресурсом, не сохраняется автоматически между этими состояниями.

Основные сценарии:

1. Приложение перешло в фон (background) — соединение может быть разорвано из-за таймаута или политики энергосбережения.
2. Приложение было завершено системой — требуется полная реинициализация соединения.
3. Сеть изменилась (Wi-Fi → мобильная) — требуется переподключение.

Реализация механизма восстановления

1. Мониторинг жизненного цикла приложения

Необходимо отслеживать переходы между состояниями и соответствующим образом управлять соединением:

import UIKit

class WebSocketManager: NSObject {
    static let shared = WebSocketManager()
    private var webSocket: URLSessionWebSocketTask?
    private let reconnectDelay: TimeInterval =264
    private var shouldReconnect = false
    
    private override init() {
        super.init()
        setupAppLifecycleObservers()
    }
    
    private func setupAppLifecycleObservers() {
        NotificationCenter.default.addObserver(
            self,
            selector: #selector(appWillResignActive),
            name: UIApplication.willResignActiveNotification,
            object: nil
        )
        
        NotificationCenter.default.addObserver(
            self,
            selector: #selector(appDidBecomeActive),
            name: UIApplication.didBecomeActiveNotification,
            object: nil
        )
    }
    
    @objc private func appWillResignActive() {
        // Приложение уходит в фон - можно сохранить состояние
        shouldReconnect = true
        // Опционально: отправляем серверу сообщение о паузе
        sendPauseMessage()
    }
    
    @objc private func appDidBecomeActive() {
        // Приложение вернулось на передний план
        if shouldReconnect && webSocket == nil {
            reconnectWithDelay()
        }
    }
}

2. Управление состоянием соединения

Рекомендуется использовать state machine для четкого отслеживания состояния соединения:

enum WebSocketState {
    case disconnected
    case connecting
    case connected
    case reconnecting
}

class RobustWebSocketManager {
    private var currentState: WebSocketState = .disconnected
    private var connectionAttempts = 0
    private let maxConnectionAttempts = 5
    
    func connect() {
        guard currentState == .disconnected || currentState == .reconnecting else {
            return
        }
        
        currentState = .connecting
        // Инициализация WebSocket соединения
        initializeWebSocket()
    }
    
    private func handleDisconnection() {
        guard connectionAttempts < maxConnectionAttempts else {
            // Превышено количество попыток - ждем долго перед следующей
            scheduleReconnect(after: 30)
            return
        }
        
        connectionAttempts += 1
        currentState = .reconnecting
        scheduleReconnect(after: calculateBackoffDelay())
    }
    
    private func calculateBackoffDelay() -> TimeInterval {
        // Экспоненциальная задержка для повторных попыток
        return min(pow(2, Double(connectionAttempts)), 64)
    }
}

3. Полная стратегия переподключения

Вот комплексное решение, которое учитывает различные сценарии:

import Foundation
import Combine

class ResilientWebSocketService {
    private var webSocketTask: URLSessionWebSocketTask?
    private var urlSession: URLSession
    private var cancellables = Set<AnyCancellable>()
    private var reconnectTimer: Timer?
    private var pingTimer: Timer?
    
    // Используем UserDefaults или Keychain для хранения состояния
    private let storage = UserDefaults.standard
    private let lastConnectionKey = "lastWebSocketConnectionTime"
    
    init() {
        let configuration = URLSessionConfiguration.default
        configuration.allowsCellularAccess = true
        configuration.waitsForConnectivity = true // Ключевая опция!
        urlSession = URLSession(configuration: configuration)
        
        setupConnectivityMonitoring()
    }
    
    private func setupConnectivityMonitoring() {
        // Мониторим изменения сети через Network Framework (iOS 12+)
        if #available(iOS 12.0, *) {
            let monitor = NWPathMonitor()
            monitor.pathUpdateHandler = { [weak self] path in
                if path.status == .satisfied {
                    // Сеть восстановилась - пытаемся переподключиться
                    self?.attemptReconnect()
                }
            }
            monitor.start(queue: DispatchQueue.global())
        }
    }
    
    func connect(url: URL) {
        let request = URLRequest(url: url)
        webSocketTask = urlSession.webSocketTask(with: request)
        webSocketTask?.resume()
        
        startPingInterval()
        startReceivingMessages()
        
        // Сохраняем время последнего подключения
        storage.set(Date().timeIntervalSince1970, forKey: lastConnectionKey)
    }
    
    private func startPingInterval() {
        // Регулярные пинги для поддержания соединения
        pingTimer = Timer.scheduledTimer(withTimeInterval: 30, repeats: true) { [weak self] _ in
            self?.sendPing()
        }
    }
    
    private func sendPing() {
        webSocketTask?.sendPing { [weak self] error in
            if error != nil {
                self?.handleConnectionLoss()
            }
        }
    }
    
    private func handleConnectionLoss() {
        cancelExistingTimers()
        
        // Проверяем, было ли приложение в фоне
        let lastConnectionTime = storage.double(forKey: lastConnectionKey)
        let timeSinceLastConnection = Date().timeIntervalSince1970 - lastConnectionTime
        
        if timeSinceLastConnection > 60 {
            // Долгое отсутствие - возможно, приложение было завершено
            performFullReconnect()
        } else {
            // Короткий разрыв - быстрая попытка восстановления
            attemptQuickReconnect()
        }
    }
    
    private func attemptQuickReconnect() {
        // Экспоненциальный backoff с джиттером
        let baseDelay = pow(2, min(reconnectAttempts, 6))
        let jitter = Double.random(in: 0...0.3)
        let delay = baseDelay * (1 + jitter)
        
        reconnectTimer = Timer.scheduledTimer(withTimeInterval: delay, repeats: false) { [weak self] _ in
            self?.reconnect()
        }
    }
}

Рекомендации для production-приложений

1. Используйте библиотеки: Для серьезных проектов рассмотрите использование проверенных библиотек:

   • Starscream для Swift
   • SocketRocket для Objective-C/Swift
   • Socket.IO-client-swift для Socket.IO протокола

2. Серверная координация: Договоритесь с бэкенд-командой о:

   • Поддержке механизма reconnect tokens
   • Heartbeat/ping-pong механизме
   • Протоколе для восстановления missed messages

3. Тестирование сценариев: Обязательно тестируйте:

   • Быстрое сворачивание/разворачивание
   • Переключение сетей
   • Режим полета (Airplane Mode)
   • Долгое нахождение в фоне (более 30 минут)

4. Оптимизация для фона: Если нужно поддерживать соединение в фоне:

   • Запросите Background Modes capability
   • Используйте VoIP флаг (только если действительно необходимо)
   • Учитывайте ограничения iOS на фоновую активность

Заключение

Восстановление WebSocket-соединения требует комплексного подхода, сочетающего:

• Мониторинг жизненного цикла приложения
• Экспоненциальный backoff с джиттером для повторных попыток
• Координацию с сервером для восстановления состояния
• Учет ограничений iOS на фоновую работу

Правильная реализация обеспечит плавный пользовательский опыт и надежную доставку real-time данных, что критически важно для мессенджеров, торговых платформ, игр и других интерактивных приложений.