Home > Support > Release Notes

Detailed technical release notes for MKS-IPTV-App, including breaking changes, new APIs, and implementation details.

🎯 First Alpha Release - Foundation Platform

This initial alpha release establishes the core architecture and fundamental streaming capabilities across iOS, macOS, and tvOS platforms.

• StreamManager Actor: Thread-safe stream management with Swift 6 concurrency
• HTTP Proxy Server: Local proxy for IPTV stream compatibility
• URL Resolution System: Automatic redirect handling and stream validation
• Multi-format Support: HLS (.m3u8), direct MP4, and other AVPlayer-compatible formats

// New StreamManager API
actor StreamManager {
    func loadStream(_ url: URL, metadata: StreamMetadata?) async throws -> UUID
    func startPlayback(_ sessionId: UUID) async throws
    func stopPlayback(_ sessionId: UUID) async
}

• DownloadManager Actor: Concurrent download management with progress tracking
• HTTPStreamServer: Local streaming server for downloaded content
• MOV Conversion: Automatic conversion for Apple ecosystem optimization
• Resume/Pause Support: Persistent download state across app launches

// New DownloadManager API
actor DownloadManager {
    func startDownload(for item: DownloadableItem) async throws -> UUID
    func pauseDownload(_ downloadId: UUID) async
    func getProgress(for downloadId: UUID) async -> Double
}

• iOS 26 Beta Liquid Glass: Early implementation of Apple's newest design patterns
• macOS TouchBar Support: Native controls for categories, search, and playback
• tvOS Focus Management: Optimized navigation for Apple TV remote
• Cross-Platform Navigation: Adaptive UI patterns for each platform

• MVVM Architecture: Clean separation with ObservableObject ViewModels
• SwiftUI Implementation: Native UI across all platforms
• Platform-Adaptive Layouts: Tab bar (iPhone), split view (iPad), sidebar (macOS), focus (tvOS)
• Real-time Progress Tracking: Live download progress with speed and ETA calculations

// Core architectural patterns introduced
@MainActor class ContentViewModel: ObservableObject {
    @Published var items: [ContentItem] = []
    private let streamManager: StreamManager
}

actor NetworkingLayer {
    private var activeConnections: [UUID: URLSessionTask] = [:]
    func createConnection(for url: URL) async throws -> UUID
}

• Swift 6 Strict Concurrency: Full data race safety
• Actor Isolation: Thread-safe access to shared state
• Structured Concurrency: Proper task management and cancellation
• MainActor UI Updates: All UI updates on main thread

• Connection Pooling: Efficient network resource management
• Lazy Loading: On-demand content loading
• Memory Management: Proper cleanup and weak references
• Background Processing: Downloads continue when app is backgrounded (iOS/macOS)

public actor StreamManager {
    static let shared: StreamManager
    
    // Stream lifecycle management
    public func loadStream(_ url: URL, metadata: StreamMetadata? = nil) async throws -> UUID
    public func startPlayback(_ sessionId: UUID) async throws
    public func pausePlayback(_ sessionId: UUID) async
    public func stopPlayback(_ sessionId: UUID) async
    
    // Stream information
    public func getSession(_ sessionId: UUID) async -> StreamSession?
    public func getAllActiveSessions() async -> [StreamSession]
    
    // Monitoring
    public func getStreamHealth(_ sessionId: UUID) async -> StreamHealth
}

public actor DownloadManager: ObservableObject {
    // Download management
    public func startDownload(for item: DownloadableItem) async throws -> UUID
    public func pauseDownload(_ downloadId: UUID) async
    public func resumeDownload(_ downloadId: UUID) async throws
    public func cancelDownload(_ downloadId: UUID) async
    
    // Progress monitoring
    public func getProgress(for downloadId: UUID) async -> Double
    public func getDownloadSpeed(for downloadId: UUID) async -> Double
    public func getEstimatedTimeRemaining(for downloadId: UUID) async -> TimeInterval?
}

public struct IPTVStream: Codable, Identifiable {
    public let id: UUID
    public let name: String
    public let url: URL
    public let category: StreamCategory
    public let logo: URL?
}

public struct Download: Identifiable, Codable {
    public let id: UUID
    public let originalURL: URL
    public let localPath: URL
    public let title: String
    public var progress: Double
    public var status: DownloadStatus
}

public enum PlaybackState: Sendable {
    case idle, loading, playing, paused, buffering, error(StreamError)
}

public struct StreamConfiguration {
    public static let `default` = StreamConfiguration(
        timeout: 30.0,
        maxRetries: 3,
        bufferSize: 10.0,
        userAgent: "MKS-IPTV-App/1.0"
    )
}

public struct DownloadConfiguration {
    public static let `default` = DownloadConfiguration(
        maxConcurrentDownloads: 3,
        autoConvertToMOV: true,
        downloadDirectory: FileManager.default.downloadsDirectory
    )
}

• Background Downloads (iOS): Limited by system background app refresh settings
• Large File Seeking: MOV conversion may take time for very large files (>4GB)
• Network Interruption: Some streams may require manual restart after network changes
• TouchBar (macOS): Limited to basic controls in this alpha release

This is the initial release, so no migration is required. Future releases will include migration guides for any breaking changes.

# Download from releases
curl -L -o mks-iptv.ipa \
  "https://github.com/MKS2508/MKS-IPTV-App/releases/download/v1.0.0-alpha/ios_pre_mks-multiplatform-iptv.ipa"

# Install via AltStore
# See iOS-Free-Installation-Guide.md for detailed instructions

# Download and install
curl -L -o mks-iptv-macos.zip \
  "https://github.com/MKS2508/MKS-IPTV-App/releases/download/v1.0.0-alpha/mac-os-arm64_pre_mks-multiplatform-iptv.app.zip"

unzip mks-iptv-macos.zip
mv "MKS-IPTV-App.app" /Applications/

• Unit Tests: Core business logic (StreamManager, DownloadManager)
• Integration Tests: Network layer and file system operations
• UI Tests: Critical user flows on each platform
• Performance Tests: Memory usage and streaming performance

#if DEBUG
// Mock services for testing
class MockStreamService: StreamServiceProtocol { }
class MockDownloadService: DownloadServiceProtocol { }

// Performance monitoring
class PerformanceProfiler {
    static func measure<T>(_ operation: String, _ block: () async throws -> T) async rethrows -> T
}
#endif

New documentation includes:

• Architecture Overview: System design and patterns
• API Documentation: Complete API reference
• StreamManager API: Detailed streaming implementation
• Download System: Download architecture deep dive
• Development Setup: Contributor onboarding guide

• Adaptive Bitrate Streaming: Quality adjustment based on network conditions
• Enhanced Error Recovery: Improved stream resilience
• Background Playback: Continue audio when app is backgrounded
• Advanced Search: Global search across all content types
• Playlist Support: M3U playlist import and management

• Multiple Playback Engines: Choice between AVPlayer, VLC, and custom players
• Subtitle Support: Automatic subtitle detection and display
• EPG Integration: Electronic Program Guide for live TV
• Cloud Sync: Settings and favorites synchronization
• Advanced Analytics: Detailed playback statistics

• SwiftUI 6.0: Latest SwiftUI features and improvements
• visionOS Support: Apple Vision Pro compatibility
• Enhanced AI Features: Content recommendations and categorization
• Plugin System: Third-party integration capabilities
• Advanced Networking: P2P streaming and mesh network support

1. Feature Development: Implement features following Contributing Guidelines
2. Testing Phase: Comprehensive testing across all platforms
3. Beta Release: Limited beta testing with community feedback
4. Release Candidate: Final testing and bug fixes
5. General Availability: Public release with full documentation

MAJOR.MINOR.PATCH-PRERELEASE

Examples:
1.0.0-alpha    # Alpha releases
1.0.0-beta.1   # Beta releases
1.0.0-rc.1     # Release candidates
1.0.0          # Stable releases
1.0.1          # Patch releases
1.1.0          # Minor feature releases
2.0.0          # Major releases with breaking changes

• Major releases (2.0.0): May include breaking API changes
• Minor releases (1.1.0): Backward compatible new features
• Patch releases (1.0.1): Bug fixes only, no API changes
• Pre-releases (-alpha, -beta): May include experimental features

• Alpha: Early development builds with latest features
• Beta: Feature-complete releases for testing
• Stable: Production-ready releases
• LTS: Long-term support releases (planned for v2.0+)

• Alpha releases: Community support only
• Beta releases: 3 months of bug fix support
• Stable releases: 12 months of security and critical bug fixes
• LTS releases: 24 months of extended support

When reporting issues, please include:

• Release version: v1.0.0-alpha
• Platform: iOS 26 Beta, macOS 26 Beta, etc.
• Device model: iPhone 15 Pro, MacBook Pro M3, etc.
• Steps to reproduce: Detailed reproduction steps
• Expected vs actual behavior: Clear description of the issue
• Debug information: Relevant logs and error messages

For detailed troubleshooting, see Troubleshooting Guide.

Release notes are updated with each release. For the latest information, visit the GitHub Releases page.

{{< include _Footer.md >}}