Как показать пользователю прошлые сообщения при отсутствии интернета?

Кэширование и оффлайн-доступ к сообщениям

Для отображения прошлых сообщений при отсутствии интернета требуется реализация оффлайн-кэширования данных. Вот комплексное решение с использованием современных iOS-технологий.

Архитектура хранения данных

1. Выбор технологии хранения

Для локального хранения сообщений лучше всего подходят:

• Core Data — нативный фреймворк для объектно-ориентированного хранения
• SQLite через GRDB — легковесная и производительная альтернатива
• Realm — кроссплатформенное решение с живыми объектами
• UserDefaults — только для простых случаев (не рекомендуется для сообщений)

// Пример Core Data модели для сообщения
@objc(Message)
public class Message: NSManagedObject {
    @NSManaged public var id: UUID
    @NSManaged public var text: String
    @NSManaged public var timestamp: Date
    @NSManaged public var senderId: String
    @NSManaged public var isSynced: Bool // Флаг синхронизации
    @NSManaged public var conversationId: String
}

2. Стратегия кэширования

Реализуйте двойную стратегию сохранения данных:

class MessageCacheService {
    private let coreDataStack: CoreDataStack
    private let networkMonitor: NetworkMonitor
    
    // Сохранение полученных сообщений
    func cacheMessages(_ messages: [NetworkMessage]) async throws {
        let context = coreDataStack.backgroundContext
        
        try await context.perform {
            for networkMessage in messages {
                let message = Message(context: context)
                message.id = networkMessage.id
                message.text = networkMessage.text
                message.timestamp = networkMessage.timestamp
                message.senderId = networkMessage.senderId
                message.isSynced = true
                message.conversationId = networkMessage.conversationId
            }
            try context.save()
        }
    }
    
    // Получение кэшированных сообщений
    func getCachedMessages(for conversationId: String) async -> [Message] {
        let context = coreDataStack.viewContext
        
        return await context.perform {
            let request: NSFetchRequest<Message> = Message.fetchRequest()
            request.predicate = NSPredicate(
                format: "conversationId == %@", 
                conversationId
            )
            request.sortDescriptors = [
                NSSortDescriptor(key: "timestamp", ascending: true)
            ]
            
            do {
                return try context.fetch(request)
            } catch {
                return []
            }
        }
    }
}

Определение состояния сети

Используйте Network Framework для мониторинга соединения:

import Network

class NetworkMonitor {
    private let monitor = NWPathMonitor()
    private let queue = DispatchQueue(label: "NetworkMonitor")
    @Published var isConnected = true
    
    init() {
        monitor.pathUpdateHandler = { [weak self] path in
            DispatchQueue.main.async {
                self?.isConnected = path.status == .satisfied
            }
        }
        monitor.start(queue: queue)
    }
}

UI/UX подходы

1. Индикация оффлайн-режима

class ChatViewController: UIViewController {
    @IBOutlet weak var offlineBanner: UIView!
    
    func setupNetworkObservers() {
        networkMonitor.$isConnected
            .receive(on: DispatchQueue.main)
            .sink { [weak self] isConnected in
                UIView.animate(withDuration: 0.3) {
                    self?.offlineBanner.isHidden = isConnected
                }
                if !isConnected {
                    self?.loadCachedMessages()
                }
            }
            .store(in: &cancellables)
    }
    
    func loadCachedMessages() {
        Task {
            let messages = await cacheService.getCachedMessages(
                for: currentConversationId
            )
            await MainActor.run {
                updateUI(with: messages)
                showOfflineWarningIfNeeded()
            }
        }
    }
}

2. Умная синхронизация

Реализуйте очередь исходящих сообщений:

class SyncService {
    private let backgroundQueue = DispatchQueue(
        label: "SyncQueue",
        qos: .utility
    )
    
    func syncPendingMessages() {
        guard networkMonitor.isConnected else { return }
        
        backgroundQueue.async {
            let unsyncedMessages = self.fetchUnsyncedMessages()
            
            for message in unsyncedMessages {
                self.sendToServer(message) { result in
                    switch result {
                    case .success:
                        self.markAsSynced(message)
                    case .failure(let error):
                        self.handleSyncError(error, for: message)
                    }
                }
            }
        }
    }
}

Ключевые принципы реализации

1. Приоритетность данных:

   • Всегда показывайте кэшированные данные мгновенно
   • Обновляйте UI при появлении свежих данных

2. Интеллектуальное кэширование:

   // Автоматическая очистка старых сообщений
   func cleanOldMessages(olderThan days: Int = 30) {
       let cutoffDate = Calendar.current.date(
           byAdding: .day, 
           value: -days, 
           to: Date()
       )!
       // Удаление старых сообщений
   }
   

3. Конфликт-менеджмент:

   • Используйте временные метки для разрешения конфликтов
   • Реализуйте механизм отложенной синхронизации

4. Тестирование:

   // Юнит-тест для оффлайн-режима
   func testOfflineMessageDisplay() {
       let mockMonitor = MockNetworkMonitor(isConnected: false)
       let service = MessageCacheService(networkMonitor: mockMonitor)
       
       let messages = await service.getCachedMessages(for: "testConv")
       XCTAssertFalse(messages.isEmpty, "Should display cached messages offline")
   }
   

Рекомендации по производительности

• Используйте пагинацию для больших истории сообщений
• Реализуйте дифференциальные обновления UI
• Применяйте фоновые контексты Core Data для операций записи
• Кэшируйте изображения и медиа отдельно с помощью URLCache или сторонних библиотек

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