Finaly working version of livestreams

COMPILATION_FIXES.md

@@ -1,88 +0,0 @@
-# Compilation Fixes - COMPLETED ✅
-
-## Status: ALL ERRORS RESOLVED
-
-**Build Status:** ✅ SUCCESS
-
-The plugin now compiles successfully with no errors!
-
-## Fixed Issues
-
-### 1. Collection Type Warnings ✅
-**Issue:** CA2227 and CA1002 - Collection properties should be read-only and use appropriate collection types
-**Files Fixed:**
-- `Api/Models/MediaComposition.cs` - Changed `List<Chapter>` to `IReadOnlyList<Chapter>`
-- `Api/Models/Chapter.cs` - Changed `List<Resource>` to `IReadOnlyList<Resource>`
-
-**Solution:** Used `IReadOnlyList<T>` to satisfy code analysis while maintaining JSON deserialization compatibility.
-
-### 2. MetadataCache Warnings ✅
-**Issue:** Multiple issues with MetadataCache
-- CA1001: Type should implement IDisposable (owns ReaderWriterLockSlim)
-- MT1012: Lock acquisition should be wrapped in try blocks
-- CA1852: CacheEntry class should be sealed
-
-**File Fixed:** `Services/MetadataCache.cs`
-
-**Solution:**
-- Implemented IDisposable interface
-- Wrapped all lock acquisitions in try-catch blocks
-- Added ObjectDisposedException handling
-- Sealed the CacheEntry inner class
-- Reordered fields (readonly fields before non-readonly)
-
-### 3. SRFMediaProvider Warnings ✅
-**Issue:**
-- SA1648: inheritdoc should be used with inheriting class
-- CA1849: Avoid synchronous blocking
-
-**File Fixed:** `Providers/SRFMediaProvider.cs`
-
-**Solution:**
-- Replaced `/// <inheritdoc />` with proper XML documentation summaries
-- Changed from `Task.Wait()` and `.Result` to `.GetAwaiter().GetResult()` (less problematic)
-
-### 4. ContentExpirationService Warnings ✅
-**Issue:** SA1028 - Trailing whitespace
-
-**File Fixed:** `Services/ContentExpirationService.cs`
-
-**Solution:** Removed trailing whitespace on lines 79 and 221
-
-### 5. CA1826 Warnings ✅
-**Issue:** Use indexer instead of LINQ `.First()` for collections with indexers
-
-**Files Fixed:**
-- `Services/ContentExpirationService.cs`
-- `Providers/SRFEpisodeProvider.cs`
-- `Providers/SRFImageProvider.cs`
-- `Providers/SRFMediaProvider.cs`
-
-**Solution:** Replaced `.First()` calls with `[0]` indexer access for IReadOnlyList collections
-
-## Build Output
-
-```
-Build succeeded in 1.0s
-Jellyfin.Plugin.SRFPlay succeeded → Jellyfin.Plugin.SRFPlay/bin/Debug/net8.0/Jellyfin.Plugin.SRFPlay.dll
-```
-
-## Summary
-
-All 17 initial compilation errors have been resolved:
-- ✅ 4 collection property warnings
-- ✅ 6 MetadataCache warnings
-- ✅ 3 SRFMediaProvider warnings  
-- ✅ 2 ContentExpirationService whitespace warnings
-- ✅ 6 CA1826 indexer warnings
-- ✅ 1 field ordering warning
-
-The plugin is now ready for testing with a Jellyfin instance!
-
-## Next Steps
-
-1. ✅ Plugin compiles successfully
-2. ⏭️ Test with Jellyfin instance
-3. ⏭️ Verify content discovery
-4. ⏭️ Test playback functionality
-5. ⏭️ Validate expiration handling

Jellyfin.Plugin.SRFPlay/Channels/SRFPlayChannel.cs

@@ -25,6 +25,7 @@ public class SRFPlayChannel : IChannel, IHasCacheKey
     private readonly ILoggerFactory _loggerFactory;
     private readonly ContentRefreshService _contentRefreshService;
     private readonly StreamUrlResolver _streamResolver;
+    private readonly StreamProxyService _proxyService;
     private readonly CategoryService? _categoryService;
 
     /// <summary>
@@ -33,17 +34,20 @@ public class SRFPlayChannel : IChannel, IHasCacheKey
     /// <param name="loggerFactory">The logger factory.</param>
     /// <param name="contentRefreshService">The content refresh service.</param>
     /// <param name="streamResolver">The stream resolver.</param>
+    /// <param name="proxyService">The stream proxy service.</param>
     /// <param name="categoryService">The category service (optional).</param>
     public SRFPlayChannel(
         ILoggerFactory loggerFactory,
         ContentRefreshService contentRefreshService,
         StreamUrlResolver streamResolver,
+        StreamProxyService proxyService,
         CategoryService? categoryService = null)
     {
         _loggerFactory = loggerFactory;
         _logger = loggerFactory.CreateLogger<SRFPlayChannel>();
         _contentRefreshService = contentRefreshService;
         _streamResolver = streamResolver;
+        _proxyService = proxyService;
         _categoryService = categoryService;
 
         if (_categoryService == null)
@@ -61,7 +65,7 @@ public class SRFPlayChannel : IChannel, IHasCacheKey
     public string Description => "Swiss Radio and Television video-on-demand content";
 
     /// <inheritdoc />
-    public string DataVersion => "1.0";
+    public string DataVersion => "2.0"; // Back to authenticating at channel refresh with auto-refresh for fresh tokens
 
     /// <inheritdoc />
     public string HomePageUrl => "https://www.srf.ch/play";
@@ -231,7 +235,8 @@ public class SRFPlayChannel : IChannel, IHasCacheKey
                             .Where(p => p.Urn != null &&
                                        !string.IsNullOrEmpty(p.Title) &&
                                        p.ValidFrom != null &&
-                                       p.ValidFrom.Value.ToUniversalTime() <= weekFromNow)
+                                       p.ValidFrom.Value.ToUniversalTime() <= weekFromNow &&
+                                       (p.ValidTo == null || p.ValidTo.Value.ToUniversalTime() > now))
                             .OrderBy(p => p.ValidFrom)
                             .ToList();
 
@@ -435,33 +440,44 @@ public class SRFPlayChannel : IChannel, IHasCacheKey
                 // Get stream URL and authenticate it
                 var streamUrl = _streamResolver.GetStreamUrl(chapter, config.QualityPreference);
 
-                // For scheduled livestreams that haven't started, streamUrl might be null
+                // Skip scheduled livestreams that haven't started yet (no stream URL available)
-                var isUpcomingLivestream = chapter.Type == "SCHEDULED_LIVESTREAM" && string.IsNullOrEmpty(streamUrl);
+                if (chapter.Type == "SCHEDULED_LIVESTREAM" && string.IsNullOrEmpty(streamUrl))
-
-                if (!string.IsNullOrEmpty(streamUrl))
                 {
-                    // Authenticate the stream URL (required for all SRF streams, especially livestreams)
+                    _logger.LogDebug(
-                    streamUrl = await _streamResolver.GetAuthenticatedStreamUrlAsync(streamUrl, cancellationToken).ConfigureAwait(false);
+                        "URN {Urn}: Skipping upcoming livestream '{Title}' - stream not yet available (starts at {ValidFrom})",
-                }
-                else if (isUpcomingLivestream)
-                {
-                    // Use a placeholder for upcoming events
-                    streamUrl = "http://placeholder.local/upcoming.m3u8";
-                    _logger.LogInformation(
-                        "URN {Urn}: Upcoming livestream '{Title}' - stream will be available at {ValidFrom}",
                         urn,
                         chapter.Title,
                         chapter.ValidFrom);
+                    continue;
                 }
 
-                // Build overview with event time for upcoming livestreams
+                // Authenticate the stream URL with fresh token
-                var overview = chapter.Description ?? chapter.Lead;
+                if (!string.IsNullOrEmpty(streamUrl))
-                if (isUpcomingLivestream && chapter.ValidFrom != null)
                 {
-                    var eventStart = chapter.ValidFrom.Value.ToString("dd.MM.yyyy HH:mm", CultureInfo.InvariantCulture);
+                    streamUrl = await _streamResolver.GetAuthenticatedStreamUrlAsync(streamUrl, cancellationToken).ConfigureAwait(false);
-                    overview = $"[Upcoming Event - Starts at {eventStart}]\n\n{overview}";
                 }
 
+                // Skip items without a valid stream URL
+                if (string.IsNullOrEmpty(streamUrl))
+                {
+                    _logger.LogWarning(
+                        "URN {Urn}: Skipping '{Title}' - no valid stream URL available",
+                        urn,
+                        chapter.Title);
+                    noStreamCount++;
+                    continue;
+                }
+
+                // Register stream with proxy service
+                _proxyService.RegisterStream(itemId, streamUrl);
+
+                // Create proxy URL as absolute HTTP URL (required for ffmpeg)
+                // Use localhost as Jellyfin should be able to access its own endpoints
+                var proxyUrl = $"http://localhost:8096/Plugins/SRFPlay/Proxy/{itemId}/master.m3u8";
+
+                // Build overview
+                var overview = chapter.Description ?? chapter.Lead;
+
                 // Get image URL - prefer chapter image, fall back to show image if available
                 var imageUrl = chapter.ImageUrl;
                 if (string.IsNullOrEmpty(imageUrl) && mediaComposition.Show != null)
@@ -475,9 +491,10 @@ public class SRFPlayChannel : IChannel, IHasCacheKey
                     _logger.LogWarning("URN {Urn}: No image URL available for '{Title}'", urn, chapter.Title);
                 }
 
-                // Use ValidFrom for premiere date if this is an upcoming livestream, otherwise use Date
+                // Use ValidFrom for premiere date if this is a scheduled livestream, otherwise use Date
-                var premiereDate = isUpcomingLivestream ? chapter.ValidFrom?.ToUniversalTime() : chapter.Date?.ToUniversalTime();
+                var premiereDate = chapter.Type == "SCHEDULED_LIVESTREAM" ? chapter.ValidFrom?.ToUniversalTime() : chapter.Date?.ToUniversalTime();
 
+                // Store authenticated URL - tokens refresh automatically via scheduled channel scans
                 var item = new ChannelItemInfo
                 {
                     Id = itemId,
@@ -501,15 +518,38 @@ public class SRFPlayChannel : IChannel, IHasCacheKey
                         {
                             Id = itemId,
                             Name = chapter.Title,
-                            Path = streamUrl,
+                            Path = proxyUrl, // Proxy URL instead of direct Akamai URL
                             Protocol = MediaBrowser.Model.MediaInfo.MediaProtocol.Http,
-                            Container = "m3u8",
+                            Container = "hls",
                             SupportsDirectStream = true,
-                            SupportsDirectPlay = true,
+                            SupportsDirectPlay = true, // ✅ Enabled! Proxy handles auth
                             SupportsTranscoding = true,
-                            IsRemote = true,
+                            IsRemote = false, // False because it's a local proxy endpoint
                             Type = MediaBrowser.Model.Dto.MediaSourceType.Default,
-                            VideoType = VideoType.VideoFile
+                            VideoType = VideoType.VideoFile,
+                            RequiresOpening = false,
+                            RequiresClosing = false,
+                            SupportsProbing = false, // Disable probing for proxy URLs
+                            ReadAtNativeFramerate = false,
+                            MediaStreams = new List<MediaBrowser.Model.Entities.MediaStream>
+                            {
+                                new MediaBrowser.Model.Entities.MediaStream
+                                {
+                                    Type = MediaBrowser.Model.Entities.MediaStreamType.Video,
+                                    Codec = "h264",
+                                    Profile = "high",
+                                    IsInterlaced = false,
+                                    IsDefault = true,
+                                    Index = 0
+                                },
+                                new MediaBrowser.Model.Entities.MediaStream
+                                {
+                                    Type = MediaBrowser.Model.Entities.MediaStreamType.Audio,
+                                    Codec = "aac",
+                                    IsDefault = true,
+                                    Index = 1
+                                }
+                            }
                         }
                     }
                 };
@@ -523,6 +563,13 @@ public class SRFPlayChannel : IChannel, IHasCacheKey
                 items.Add(item);
                 successCount++;
                 _logger.LogInformation("URN {Urn}: Successfully converted to channel item - {Title}", urn, chapter.Title);
+                _logger.LogInformation(
+                    "URN {Urn}: MediaSource configured - DirectStream={DirectStream}, DirectPlay={DirectPlay}, Transcoding={Transcoding}, Container={Container}",
+                    urn,
+                    true,
+                    true,
+                    true,
+                    "hls");
             }
             catch (Exception ex)
             {

Jellyfin.Plugin.SRFPlay/Controllers/StreamProxyController.cs

@@ -0,0 +1,220 @@
+using System;
+using System.Globalization;
+using System.Threading;
+using System.Threading.Tasks;
+using Jellyfin.Plugin.SRFPlay.Services;
+using Microsoft.AspNetCore.Authorization;
+using Microsoft.AspNetCore.Http;
+using Microsoft.AspNetCore.Mvc;
+using Microsoft.Extensions.Logging;
+
+namespace Jellyfin.Plugin.SRFPlay.Controllers;
+
+/// <summary>
+/// Controller for proxying SRF Play streams.
+/// </summary>
+[ApiController]
+[Route("Plugins/SRFPlay/Proxy")]
+public class StreamProxyController : ControllerBase
+{
+    private readonly ILogger<StreamProxyController> _logger;
+    private readonly StreamProxyService _proxyService;
+
+    /// <summary>
+    /// Initializes a new instance of the <see cref="StreamProxyController"/> class.
+    /// </summary>
+    /// <param name="logger">The logger.</param>
+    /// <param name="proxyService">The proxy service.</param>
+    public StreamProxyController(ILogger<StreamProxyController> logger, StreamProxyService proxyService)
+    {
+        _logger = logger;
+        _proxyService = proxyService;
+    }
+
+    /// <summary>
+    /// Proxies HLS master manifest requests.
+    /// </summary>
+    /// <param name="itemId">The item ID.</param>
+    /// <param name="cancellationToken">Cancellation token.</param>
+    /// <returns>The HLS manifest with rewritten URLs.</returns>
+    [HttpGet("{itemId}/master.m3u8")]
+    [AllowAnonymous] // Allow anonymous since Jellyfin handles auth upstream
+    [ProducesResponseType(StatusCodes.Status200OK)]
+    [ProducesResponseType(StatusCodes.Status404NotFound)]
+    public async Task<IActionResult> GetMasterManifest(
+        [FromRoute] string itemId,
+        CancellationToken cancellationToken)
+    {
+        _logger.LogInformation("Proxy request for master manifest - ItemId: {ItemId}", itemId);
+
+        try
+        {
+            // Build the base proxy URL for this item
+            var baseProxyUrl = $"{Request.Scheme}://{Request.Host}/Plugins/SRFPlay/Proxy/{itemId}";
+
+            var manifestContent = await _proxyService.GetRewrittenManifestAsync(itemId, baseProxyUrl, cancellationToken).ConfigureAwait(false);
+
+            if (manifestContent == null)
+            {
+                _logger.LogWarning("Manifest not found for item {ItemId}", itemId);
+                return NotFound();
+            }
+
+            _logger.LogDebug("Returning master manifest for item {ItemId} ({Length} bytes)", itemId, manifestContent.Length);
+            return Content(manifestContent, "application/vnd.apple.mpegurl");
+        }
+        catch (Exception ex)
+        {
+            _logger.LogError(ex, "Error proxying master manifest for item {ItemId}", itemId);
+            return StatusCode(StatusCodes.Status500InternalServerError);
+        }
+    }
+
+    /// <summary>
+    /// Proxies HLS variant manifest requests.
+    /// </summary>
+    /// <param name="itemId">The item ID.</param>
+    /// <param name="manifestPath">The manifest path (e.g., "index_0_av").</param>
+    /// <param name="cancellationToken">Cancellation token.</param>
+    /// <returns>The HLS manifest with rewritten segment URLs.</returns>
+    [HttpGet("{itemId}/{manifestPath}.m3u8")]
+    [AllowAnonymous]
+    [ProducesResponseType(StatusCodes.Status200OK)]
+    [ProducesResponseType(StatusCodes.Status404NotFound)]
+    public async Task<IActionResult> GetVariantManifest(
+        [FromRoute] string itemId,
+        [FromRoute] string manifestPath,
+        CancellationToken cancellationToken)
+    {
+        var fullPath = $"{manifestPath}.m3u8";
+        _logger.LogInformation("Proxy request for variant manifest - ItemId: {ItemId}, Path: {Path}", itemId, fullPath);
+
+        try
+        {
+            // Fetch the variant manifest as a segment
+            var manifestData = await _proxyService.GetSegmentAsync(itemId, fullPath, cancellationToken).ConfigureAwait(false);
+
+            if (manifestData == null)
+            {
+                _logger.LogWarning("Variant manifest not found - ItemId: {ItemId}, Path: {Path}", itemId, fullPath);
+                return NotFound();
+            }
+
+            // Convert to string and rewrite URLs
+            var manifestContent = System.Text.Encoding.UTF8.GetString(manifestData);
+            var baseProxyUrl = $"{Request.Scheme}://{Request.Host}/Plugins/SRFPlay/Proxy/{itemId}";
+            var rewrittenContent = RewriteSegmentUrls(manifestContent, baseProxyUrl);
+
+            _logger.LogDebug("Returning variant manifest for item {ItemId} ({Length} bytes)", itemId, rewrittenContent.Length);
+            return Content(rewrittenContent, "application/vnd.apple.mpegurl");
+        }
+        catch (Exception ex)
+        {
+            _logger.LogError(ex, "Error proxying variant manifest - ItemId: {ItemId}, Path: {Path}", itemId, fullPath);
+            return StatusCode(StatusCodes.Status500InternalServerError);
+        }
+    }
+
+    /// <summary>
+    /// Proxies HLS segment requests (.ts, .mp4, .m4s, .aac files).
+    /// </summary>
+    /// <param name="itemId">The item ID.</param>
+    /// <param name="segmentPath">The segment path.</param>
+    /// <param name="cancellationToken">Cancellation token.</param>
+    /// <returns>The segment data.</returns>
+    [HttpGet("{itemId}/{*segmentPath}")]
+    [AllowAnonymous]
+    [ProducesResponseType(StatusCodes.Status200OK)]
+    [ProducesResponseType(StatusCodes.Status404NotFound)]
+    public async Task<IActionResult> GetSegment(
+        [FromRoute] string itemId,
+        [FromRoute] string segmentPath,
+        CancellationToken cancellationToken)
+    {
+        _logger.LogDebug("Proxy request for segment - ItemId: {ItemId}, Path: {SegmentPath}", itemId, segmentPath);
+
+        try
+        {
+            var segmentData = await _proxyService.GetSegmentAsync(itemId, segmentPath, cancellationToken).ConfigureAwait(false);
+
+            if (segmentData == null)
+            {
+                _logger.LogWarning("Segment not found - ItemId: {ItemId}, Path: {SegmentPath}", itemId, segmentPath);
+                return NotFound();
+            }
+
+            // Determine content type based on file extension
+            var contentType = GetContentType(segmentPath);
+
+            _logger.LogDebug("Returning segment {SegmentPath} ({Length} bytes, {ContentType})", segmentPath, segmentData.Length, contentType);
+            return File(segmentData, contentType);
+        }
+        catch (Exception ex)
+        {
+            _logger.LogError(ex, "Error proxying segment - ItemId: {ItemId}, Path: {SegmentPath}", itemId, segmentPath);
+            return StatusCode(StatusCodes.Status500InternalServerError);
+        }
+    }
+
+    /// <summary>
+    /// Rewrites segment URLs in a manifest to point to proxy.
+    /// </summary>
+    /// <param name="manifestContent">The manifest content.</param>
+    /// <param name="baseProxyUrl">The base proxy URL.</param>
+    /// <returns>The rewritten manifest.</returns>
+    private string RewriteSegmentUrls(string manifestContent, string baseProxyUrl)
+    {
+        var lines = manifestContent.Split('\n');
+        var result = new System.Text.StringBuilder();
+
+        foreach (var line in lines)
+        {
+            if (line.StartsWith('#') || string.IsNullOrWhiteSpace(line))
+            {
+                // Keep metadata and blank lines as-is
+                result.AppendLine(line);
+            }
+            else if (line.Contains("://", StringComparison.Ordinal))
+            {
+                // Absolute URL - extract the path and rewrite
+                var uri = new Uri(line.Trim());
+                var segments = uri.AbsolutePath.Split('/');
+                var fileName = segments[^1];
+                result.AppendLine(CultureInfo.InvariantCulture, $"{baseProxyUrl}/{fileName}");
+            }
+            else
+            {
+                // Relative URL - rewrite to proxy
+                result.AppendLine(CultureInfo.InvariantCulture, $"{baseProxyUrl}/{line.Trim()}");
+            }
+        }
+
+        return result.ToString();
+    }
+
+    /// <summary>
+    /// Gets the content type for a segment based on file extension.
+    /// </summary>
+    /// <param name="path">The segment path.</param>
+    /// <returns>The MIME content type.</returns>
+    private static string GetContentType(string path)
+    {
+        if (path.EndsWith(".ts", StringComparison.OrdinalIgnoreCase))
+        {
+            return "video/MP2T";
+        }
+
+        if (path.EndsWith(".mp4", StringComparison.OrdinalIgnoreCase) ||
+            path.EndsWith(".m4s", StringComparison.OrdinalIgnoreCase))
+        {
+            return "video/mp4";
+        }
+
+        if (path.EndsWith(".aac", StringComparison.OrdinalIgnoreCase))
+        {
+            return "audio/aac";
+        }
+
+        return "application/octet-stream";
+    }
+}

Jellyfin.Plugin.SRFPlay/Providers/SRFMediaProvider.cs

@@ -23,6 +23,7 @@ public class SRFMediaProvider : IMediaSourceProvider
     private readonly ILoggerFactory _loggerFactory;
     private readonly MetadataCache _metadataCache;
     private readonly StreamUrlResolver _streamResolver;
+    private readonly StreamProxyService _proxyService;
 
     /// <summary>
     /// Initializes a new instance of the <see cref="SRFMediaProvider"/> class.
@@ -30,15 +31,18 @@ public class SRFMediaProvider : IMediaSourceProvider
     /// <param name="loggerFactory">The logger factory.</param>
     /// <param name="metadataCache">The metadata cache.</param>
     /// <param name="streamResolver">The stream URL resolver.</param>
+    /// <param name="proxyService">The stream proxy service.</param>
     public SRFMediaProvider(
         ILoggerFactory loggerFactory,
         MetadataCache metadataCache,
-        StreamUrlResolver streamResolver)
+        StreamUrlResolver streamResolver,
+        StreamProxyService proxyService)
     {
         _loggerFactory = loggerFactory;
         _logger = loggerFactory.CreateLogger<SRFMediaProvider>();
         _metadataCache = metadataCache;
         _streamResolver = streamResolver;
+        _proxyService = proxyService;
     }
 
     /// <summary>
@@ -52,24 +56,35 @@ public class SRFMediaProvider : IMediaSourceProvider
     /// <param name="item">The item.</param>
     /// <param name="cancellationToken">The cancellation token.</param>
     /// <returns>List of media sources.</returns>
-    public Task<IEnumerable<MediaSourceInfo>> GetMediaSources(BaseItem item, CancellationToken cancellationToken)
+    public async Task<IEnumerable<MediaSourceInfo>> GetMediaSources(BaseItem item, CancellationToken cancellationToken)
     {
         var sources = new List<MediaSourceInfo>();
 
         try
         {
+            // Log detailed information about the request
+            var stackTrace = new System.Diagnostics.StackTrace(true);
+            var callingMethod = stackTrace.GetFrame(1)?.GetMethod();
+            _logger.LogInformation(
+                "GetMediaSources called - Item: {ItemName}, Type: {ItemType}, Id: {ItemId}, CalledBy: {CallingMethod}",
+                item.Name,
+                item.GetType().Name,
+                item.Id,
+                callingMethod?.DeclaringType?.Name + "." + callingMethod?.Name);
+
             // Check if this is an SRF item
             if (!item.ProviderIds.TryGetValue("SRF", out var urn) || string.IsNullOrEmpty(urn))
             {
-                return Task.FromResult<IEnumerable<MediaSourceInfo>>(sources);
+                _logger.LogDebug("Item {ItemName} is not an SRF item, returning empty sources", item.Name);
+                return sources;
             }
 
-            _logger.LogDebug("Getting media sources for URN: {Urn}", urn);
+            _logger.LogInformation("Getting media sources for URN: {Urn}, Item: {ItemName}", urn, item.Name);
 
             var config = Plugin.Instance?.Configuration;
             if (config == null)
             {
-                return Task.FromResult<IEnumerable<MediaSourceInfo>>(sources);
+                return sources;
             }
 
             // For scheduled livestreams, use shorter cache TTL (5 minutes) so they refresh when they go live
@@ -85,7 +100,7 @@ public class SRFMediaProvider : IMediaSourceProvider
             if (mediaComposition == null)
             {
                 using var apiClient = new SRFApiClient(_loggerFactory);
-                mediaComposition = apiClient.GetMediaCompositionByUrnAsync(urn, cancellationToken).GetAwaiter().GetResult();
+                mediaComposition = await apiClient.GetMediaCompositionByUrnAsync(urn, cancellationToken).ConfigureAwait(false);
 
                 if (mediaComposition != null)
                 {
@@ -96,7 +111,7 @@ public class SRFMediaProvider : IMediaSourceProvider
             if (mediaComposition?.ChapterList == null || mediaComposition.ChapterList.Count == 0)
             {
                 _logger.LogWarning("No chapters found for URN: {Urn}", urn);
-                return Task.FromResult<IEnumerable<MediaSourceInfo>>(sources);
+                return sources;
             }
 
             // Get the first chapter (main video)
@@ -106,52 +121,26 @@ public class SRFMediaProvider : IMediaSourceProvider
             if (_streamResolver.IsContentExpired(chapter))
             {
                 _logger.LogWarning("Content expired for URN: {Urn}, ValidTo: {ValidTo}", urn, chapter.ValidTo);
-                return Task.FromResult<IEnumerable<MediaSourceInfo>>(sources);
+                return sources;
             }
 
             // Check if content has playable streams
             if (!_streamResolver.HasPlayableContent(chapter))
             {
                 _logger.LogWarning("No playable content found for URN: {Urn}", urn);
-                return Task.FromResult<IEnumerable<MediaSourceInfo>>(sources);
+                return sources;
             }
 
             // Get stream URL based on quality preference
             var streamUrl = _streamResolver.GetStreamUrl(chapter, config.QualityPreference);
 
-            // Check if this is an upcoming livestream that hasn't started yet
+            // For scheduled livestreams, always fetch fresh data to ensure stream URL is current
-            var isUpcomingLivestream = chapter.Type == "SCHEDULED_LIVESTREAM" && string.IsNullOrEmpty(streamUrl);
+            if (chapter.Type == "SCHEDULED_LIVESTREAM" && string.IsNullOrEmpty(streamUrl))
-
-            if (string.IsNullOrEmpty(streamUrl) && !isUpcomingLivestream)
             {
-                _logger.LogWarning("Could not resolve stream URL for URN: {Urn}", urn);
+                _logger.LogDebug("URN {Urn}: Scheduled livestream has no stream URL, fetching fresh data", urn);
-                return Task.FromResult<IEnumerable<MediaSourceInfo>>(sources);
-            }
 
-            // For upcoming livestreams, check if the event has started
-            if (isUpcomingLivestream)
-            {
-                if (chapter.ValidFrom != null)
-                {
-                    var eventStart = chapter.ValidFrom.Value.ToUniversalTime();
-                    var now = DateTime.UtcNow;
-
-                    if (eventStart > now)
-                    {
-                        _logger.LogInformation(
-                            "URN {Urn}: Livestream '{Title}' hasn't started yet (starts at {ValidFrom}). User should refresh when live.",
-                            urn,
-                            chapter.Title,
-                            chapter.ValidFrom);
-
-                        // Return empty sources - event not yet playable
-                        return Task.FromResult<IEnumerable<MediaSourceInfo>>(sources);
-                    }
-                }
-
-                // Event should be live now - re-fetch media composition without cache
                 using var freshApiClient = new SRFApiClient(_loggerFactory);
-                var freshMediaComposition = freshApiClient.GetMediaCompositionByUrnAsync(urn, cancellationToken).GetAwaiter().GetResult();
+                var freshMediaComposition = await freshApiClient.GetMediaCompositionByUrnAsync(urn, cancellationToken).ConfigureAwait(false);
 
                 if (freshMediaComposition?.ChapterList != null && freshMediaComposition.ChapterList.Count > 0)
                 {
@@ -163,70 +152,99 @@ public class SRFMediaProvider : IMediaSourceProvider
                         // Update cache with fresh data
                         _metadataCache.SetMediaComposition(urn, freshMediaComposition);
                         chapter = freshChapter;
-                        _logger.LogInformation("URN {Urn}: Livestream is now live, got fresh stream URL", urn);
+                        _logger.LogInformation("URN {Urn}: Got fresh stream URL for scheduled livestream", urn);
                     }
-                    else
+                }
+            }
+
+            if (string.IsNullOrEmpty(streamUrl))
             {
-                        _logger.LogWarning("URN {Urn}: Livestream should be live but still no stream URL available", urn);
+                _logger.LogWarning("Could not resolve stream URL for URN: {Urn}", urn);
-                        return Task.FromResult<IEnumerable<MediaSourceInfo>>(sources);
+                return sources;
-                    }
-                }
-                else
-                {
-                    _logger.LogWarning("URN {Urn}: Failed to fetch fresh media composition for livestream", urn);
-                    return Task.FromResult<IEnumerable<MediaSourceInfo>>(sources);
-                }
             }
 
             // Authenticate the stream URL (required for all SRF streams, especially livestreams)
             if (!string.IsNullOrEmpty(streamUrl))
             {
-                streamUrl = _streamResolver.GetAuthenticatedStreamUrlAsync(streamUrl, cancellationToken).GetAwaiter().GetResult();
+                streamUrl = await _streamResolver.GetAuthenticatedStreamUrlAsync(streamUrl, cancellationToken).ConfigureAwait(false);
                 _logger.LogDebug("Authenticated stream URL for URN: {Urn}", urn);
             }
 
-            // Create media source
+            // Register stream with proxy service
+            var itemIdStr = item.Id.ToString("N"); // Use hex format without dashes
+            _proxyService.RegisterStream(itemIdStr, streamUrl);
+
+            // Create proxy URL as absolute HTTP URL (required for ffmpeg)
+            // Use localhost as Jellyfin should be able to access its own endpoints
+            var proxyUrl = $"http://localhost:8096/Plugins/SRFPlay/Proxy/{itemIdStr}/master.m3u8";
+
+            _logger.LogInformation("Using proxy URL for item {ItemId}: {ProxyUrl}", itemIdStr, proxyUrl);
+
+            // Create media source using proxy URL - enables DirectPlay!
             var mediaSource = new MediaSourceInfo
             {
-                Id = urn,
+                Id = item.Id.ToString(), // Use item GUID, not URN string (required for transcoding)
                 Name = chapter.Title,
-                Path = streamUrl,
+                Path = proxyUrl, // Proxy URL instead of direct Akamai URL
                 Protocol = MediaProtocol.Http,
-                Container = "m3u8",
+                Container = "hls",
                 SupportsDirectStream = true,
-                SupportsDirectPlay = true,
+                SupportsDirectPlay = true, // ✅ Enabled! Proxy handles auth
                 SupportsTranscoding = true,
-                IsRemote = true,
+                IsRemote = false, // False because it's a local proxy endpoint
                 Type = MediaSourceType.Default,
                 RunTimeTicks = chapter.Duration > 0 ? TimeSpan.FromMilliseconds(chapter.Duration).Ticks : null,
                 VideoType = VideoType.VideoFile,
                 IsInfiniteStream = false,
                 RequiresOpening = false,
                 RequiresClosing = false,
-                SupportsProbing = true
+                SupportsProbing = false, // Disable probing for proxy URLs
-            };
+                ReadAtNativeFramerate = false,
-
+                MediaStreams = new List<MediaBrowser.Model.Entities.MediaStream>
-            // Add video stream info
-            mediaSource.MediaStreams = new List<MediaStream>
                 {
-                new MediaStream
+                    new MediaBrowser.Model.Entities.MediaStream
                     {
                         Type = MediaStreamType.Video,
                         Codec = "h264",
+                        Profile = "high",
                         IsInterlaced = false,
-                    IsDefault = true
+                        IsDefault = true,
+                        Index = 0
+                    },
+                    new MediaBrowser.Model.Entities.MediaStream
+                    {
+                        Type = MediaStreamType.Audio,
+                        Codec = "aac",
+                        IsDefault = true,
+                        Index = 1
+                    }
                 }
             };
 
             sources.Add(mediaSource);
             _logger.LogInformation("Resolved stream URL for {Title}: {Url}", chapter.Title, streamUrl);
+            _logger.LogInformation(
+                "MediaSource created - Id={Id}, DirectStream={DirectStream}, DirectPlay={DirectPlay}, Probing={Probing}, Container={Container}, Protocol={Protocol}, IsRemote={IsRemote}",
+                mediaSource.Id,
+                mediaSource.SupportsDirectStream,
+                mediaSource.SupportsDirectPlay,
+                mediaSource.SupportsProbing,
+                mediaSource.Container,
+                mediaSource.Protocol,
+                mediaSource.IsRemote);
+            _logger.LogInformation(
+                "MediaSource capabilities - SupportsTranscoding={Transcoding}, RequiresOpening={RequiresOpening}, RequiresClosing={RequiresClosing}, Type={Type}",
+                mediaSource.SupportsTranscoding,
+                mediaSource.RequiresOpening,
+                mediaSource.RequiresClosing,
+                mediaSource.Type);
         }
         catch (Exception ex)
         {
             _logger.LogError(ex, "Error getting media sources for item: {Name}", item.Name);
         }
 
-        return Task.FromResult<IEnumerable<MediaSourceInfo>>(sources);
+        return sources;
     }
 
     /// <summary>
@@ -237,6 +255,7 @@ public class SRFMediaProvider : IMediaSourceProvider
     /// <returns>The direct stream provider.</returns>
     public Task<IDirectStreamProvider?> GetDirectStreamProviderByUniqueId(string uniqueId, CancellationToken cancellationToken)
     {
+        _logger.LogInformation("GetDirectStreamProviderByUniqueId called with uniqueId: {UniqueId}", uniqueId);
         // Not needed for HTTP streams
         return Task.FromResult<IDirectStreamProvider?>(null);
     }
@@ -244,6 +263,7 @@ public class SRFMediaProvider : IMediaSourceProvider
     /// <inheritdoc />
     public Task<ILiveStream> OpenMediaSource(string openToken, List<ILiveStream> currentLiveStreams, CancellationToken cancellationToken)
     {
+        _logger.LogWarning("OpenMediaSource called with openToken: {OpenToken} - This should not be called for HTTP streams!", openToken);
         // Not needed for static HTTP streams
         throw new NotImplementedException();
     }

Jellyfin.Plugin.SRFPlay/ServiceRegistrator.cs

@@ -25,6 +25,7 @@ public class ServiceRegistrator : IPluginServiceRegistrator
         serviceCollection.AddSingleton<ContentExpirationService>();
         serviceCollection.AddSingleton<ContentRefreshService>();
         serviceCollection.AddSingleton<CategoryService>();
+        serviceCollection.AddSingleton<StreamProxyService>(); // Stream proxy service
 
         // Register metadata providers
         serviceCollection.AddSingleton<SRFSeriesProvider>();

Jellyfin.Plugin.SRFPlay/Services/StreamProxyService.cs

@@ -0,0 +1,250 @@
+using System;
+using System.Collections.Concurrent;
+using System.Net.Http;
+using System.Text.RegularExpressions;
+using System.Threading;
+using System.Threading.Tasks;
+using Microsoft.Extensions.Logging;
+
+namespace Jellyfin.Plugin.SRFPlay.Services;
+
+/// <summary>
+/// Service for proxying SRF Play streams and managing authentication.
+/// </summary>
+public class StreamProxyService : IDisposable
+{
+    private readonly ILogger<StreamProxyService> _logger;
+    private readonly StreamUrlResolver _streamResolver;
+    private readonly HttpClient _httpClient;
+    private readonly ConcurrentDictionary<string, StreamInfo> _streamMappings;
+    private bool _disposed;
+
+    /// <summary>
+    /// Initializes a new instance of the <see cref="StreamProxyService"/> class.
+    /// </summary>
+    /// <param name="logger">The logger.</param>
+    /// <param name="streamResolver">The stream URL resolver.</param>
+    public StreamProxyService(ILogger<StreamProxyService> logger, StreamUrlResolver streamResolver)
+    {
+        _logger = logger;
+        _streamResolver = streamResolver;
+        _httpClient = new HttpClient
+        {
+            Timeout = TimeSpan.FromSeconds(30)
+        };
+        _streamMappings = new ConcurrentDictionary<string, StreamInfo>();
+    }
+
+    /// <summary>
+    /// Registers a stream for proxying.
+    /// </summary>
+    /// <param name="itemId">The item ID.</param>
+    /// <param name="authenticatedUrl">The authenticated stream URL.</param>
+    public void RegisterStream(string itemId, string authenticatedUrl)
+    {
+        var streamInfo = new StreamInfo
+        {
+            AuthenticatedUrl = authenticatedUrl,
+            RegisteredAt = DateTime.UtcNow
+        };
+
+        _streamMappings.AddOrUpdate(itemId, streamInfo, (key, old) => streamInfo);
+        _logger.LogInformation("Registered stream for item {ItemId}: {Url}", itemId, authenticatedUrl);
+    }
+
+    /// <summary>
+    /// Gets the authenticated URL for an item.
+    /// </summary>
+    /// <param name="itemId">The item ID.</param>
+    /// <returns>The authenticated URL, or null if not found.</returns>
+    public string? GetAuthenticatedUrl(string itemId)
+    {
+        if (_streamMappings.TryGetValue(itemId, out var streamInfo))
+        {
+            return streamInfo.AuthenticatedUrl;
+        }
+
+        _logger.LogWarning("No stream mapping found for item {ItemId}", itemId);
+        return null;
+    }
+
+    /// <summary>
+    /// Fetches and rewrites an HLS manifest to use proxy URLs.
+    /// </summary>
+    /// <param name="itemId">The item ID.</param>
+    /// <param name="baseProxyUrl">The base proxy URL (e.g., https://jellyfin-server/Plugins/SRFPlay/Proxy/{itemId}).</param>
+    /// <param name="cancellationToken">Cancellation token.</param>
+    /// <returns>The rewritten manifest content.</returns>
+    public async Task<string?> GetRewrittenManifestAsync(
+        string itemId,
+        string baseProxyUrl,
+        CancellationToken cancellationToken = default)
+    {
+        var authenticatedUrl = GetAuthenticatedUrl(itemId);
+        if (authenticatedUrl == null)
+        {
+            return null;
+        }
+
+        try
+        {
+            _logger.LogDebug("Fetching manifest from: {Url}", authenticatedUrl);
+            var manifestContent = await _httpClient.GetStringAsync(authenticatedUrl, cancellationToken).ConfigureAwait(false);
+
+            // Rewrite the manifest to replace Akamai URLs with proxy URLs
+            var rewrittenContent = RewriteManifestUrls(manifestContent, authenticatedUrl, baseProxyUrl);
+
+            _logger.LogDebug("Successfully rewrote manifest for item {ItemId}", itemId);
+            return rewrittenContent;
+        }
+        catch (Exception ex)
+        {
+            _logger.LogError(ex, "Failed to fetch manifest for item {ItemId} from {Url}", itemId, authenticatedUrl);
+            return null;
+        }
+    }
+
+    /// <summary>
+    /// Fetches a segment from the original source.
+    /// </summary>
+    /// <param name="itemId">The item ID.</param>
+    /// <param name="segmentPath">The segment path.</param>
+    /// <param name="cancellationToken">Cancellation token.</param>
+    /// <returns>The segment content as bytes.</returns>
+    public async Task<byte[]?> GetSegmentAsync(
+        string itemId,
+        string segmentPath,
+        CancellationToken cancellationToken = default)
+    {
+        var authenticatedUrl = GetAuthenticatedUrl(itemId);
+        if (authenticatedUrl == null)
+        {
+            return null;
+        }
+
+        try
+        {
+            // Build the full segment URL by combining the base URL with the segment path
+            var baseUri = new Uri(authenticatedUrl);
+            var baseUrl = $"{baseUri.Scheme}://{baseUri.Host}{string.Join('/', baseUri.AbsolutePath.Split('/')[..^1])}";
+
+            // Extract query parameters (auth tokens) from authenticated URL
+            var queryParams = baseUri.Query;
+
+            // Build full segment URL
+            var segmentUrl = $"{baseUrl}/{segmentPath}{queryParams}";
+
+            _logger.LogDebug("Fetching segment: {SegmentUrl}", segmentUrl);
+            var segmentData = await _httpClient.GetByteArrayAsync(segmentUrl, cancellationToken).ConfigureAwait(false);
+
+            _logger.LogDebug("Successfully fetched segment {SegmentPath} ({Size} bytes)", segmentPath, segmentData.Length);
+            return segmentData;
+        }
+        catch (Exception ex)
+        {
+            _logger.LogError(ex, "Failed to fetch segment {SegmentPath} for item {ItemId}", segmentPath, itemId);
+            return null;
+        }
+    }
+
+    /// <summary>
+    /// Rewrites URLs in HLS manifest to point to proxy.
+    /// </summary>
+    /// <param name="manifestContent">The original manifest content.</param>
+    /// <param name="originalBaseUrl">The original base URL.</param>
+    /// <param name="proxyBaseUrl">The proxy base URL.</param>
+    /// <returns>The rewritten manifest.</returns>
+    private string RewriteManifestUrls(string manifestContent, string originalBaseUrl, string proxyBaseUrl)
+    {
+        var baseUri = new Uri(originalBaseUrl);
+        var baseUrl = $"{baseUri.Scheme}://{baseUri.Host}{string.Join('/', baseUri.AbsolutePath.Split('/')[..^1])}";
+
+        // Pattern to match .m3u8 and .ts/.mp4 segment references
+        var pattern = @"(?:^|\n)([^#\n][^\n]*\.(?:m3u8|ts|mp4|m4s|aac)[^\n]*)";
+
+        var rewritten = Regex.Replace(manifestContent, pattern, match =>
+        {
+            var url = match.Groups[1].Value.Trim();
+
+            // Skip if it's already an absolute URL
+            if (url.StartsWith("http://", StringComparison.OrdinalIgnoreCase) ||
+                url.StartsWith("https://", StringComparison.OrdinalIgnoreCase))
+            {
+                // Rewrite absolute URLs to proxy
+                var relativePath = url.Replace(baseUrl + "/", string.Empty, StringComparison.Ordinal);
+                return $"\n{proxyBaseUrl}/{relativePath}";
+            }
+
+            // Relative URL - rewrite to proxy
+            return $"\n{proxyBaseUrl}/{url}";
+        });
+
+        return rewritten;
+    }
+
+    /// <summary>
+    /// Cleans up old stream mappings.
+    /// </summary>
+    public void CleanupOldMappings()
+    {
+        var cutoff = DateTime.UtcNow.AddHours(-24);
+        var keysToRemove = new System.Collections.Generic.List<string>();
+
+        foreach (var kvp in _streamMappings)
+        {
+            if (kvp.Value.RegisteredAt < cutoff)
+            {
+                keysToRemove.Add(kvp.Key);
+            }
+        }
+
+        foreach (var key in keysToRemove)
+        {
+            _streamMappings.TryRemove(key, out _);
+            _logger.LogDebug("Removed old stream mapping for item {ItemId}", key);
+        }
+
+        if (keysToRemove.Count > 0)
+        {
+            _logger.LogInformation("Cleaned up {Count} old stream mappings", keysToRemove.Count);
+        }
+    }
+
+    /// <summary>
+    /// Disposes the service.
+    /// </summary>
+    public void Dispose()
+    {
+        Dispose(true);
+        GC.SuppressFinalize(this);
+    }
+
+    /// <summary>
+    /// Disposes the service.
+    /// </summary>
+    /// <param name="disposing">True if disposing.</param>
+    protected virtual void Dispose(bool disposing)
+    {
+        if (_disposed)
+        {
+            return;
+        }
+
+        if (disposing)
+        {
+            _httpClient?.Dispose();
+        }
+
+        _disposed = true;
+    }
+
+    /// <summary>
+    /// Stream information.
+    /// </summary>
+    private sealed class StreamInfo
+    {
+        public string AuthenticatedUrl { get; set; } = string.Empty;
+
+        public DateTime RegisteredAt { get; set; }
+    }
+}

Jellyfin.Plugin.SRFPlay/Services/StreamUrlResolver.cs

@@ -144,23 +144,6 @@ public class StreamUrlResolver : IDisposable
     /// <returns>True if playable content is available.</returns>
     public bool HasPlayableContent(Chapter chapter)
     {
-        // For scheduled livestreams that haven't started yet, resources won't exist
-        // but we still want to show them. The stream will become available when the event starts.
-        if (chapter?.Type == "SCHEDULED_LIVESTREAM")
-        {
-            var now = DateTime.UtcNow;
-            var hasStarted = chapter.ValidFrom == null || chapter.ValidFrom.Value.ToUniversalTime() <= now;
-
-            if (!hasStarted)
-            {
-                _logger.LogInformation(
-                    "Scheduled livestream '{Title}' hasn't started yet (starts at {ValidFrom}), will be playable when live",
-                    chapter.Title,
-                    chapter.ValidFrom);
-                return true; // Show it, stream will be available when event starts
-            }
-        }
-
         if (chapter?.ResourceList == null || chapter.ResourceList.Count == 0)
         {
             return false;

NETWORK_ROUTING_GUIDE.md

@@ -1,227 +0,0 @@
-# Network-Level Gateway Routing for SRF Content
-
-This guide explains how to configure network-level routing to direct all SRF-related traffic (including video streams) through your Swiss gateway/proxy at 192.168.1.37.
-
-## Overview
-
-Instead of configuring proxy support at the application level, this approach uses Linux policy-based routing to redirect traffic destined for SRF domains through an alternate gateway. This ensures:
-
-- API requests to `il.srgssr.ch` go through the gateway
-- Video stream requests to `srf-vod-amd.akamaized.net` (and other CDNs) go through the gateway
-- ffprobe and ffmpeg automatically use the gateway
-- No application configuration needed - transparent to Jellyfin
-
-## Prerequisites
-
-- Root access to the Jellyfin server (192.168.1.4)
-- Gateway at 192.168.1.37 with IPv4 forwarding enabled
-- Both machines on the same network segment
-
-## Installation on Jellyfin Server
-
-### Step 1: Copy Scripts to Jellyfin Server
-
-From your development machine:
-
-```bash
-# Copy the routing scripts to Jellyfin server
-scp setup-gateway-routing.sh cleanup-gateway-routing.sh user@192.168.1.4:~
-```
-
-### Step 2: SSH to Jellyfin Server
-
-```bash
-ssh user@192.168.1.4
-```
-
-### Step 3: Make Scripts Executable
-
-```bash
-chmod +x setup-gateway-routing.sh cleanup-gateway-routing.sh
-```
-
-### Step 4: Run Setup Script
-
-```bash
-sudo ./setup-gateway-routing.sh
-```
-
-When prompted:
-- **Gateway IP**: `192.168.1.37`
-- **Network interface**: Find your interface name first with `ip -br link show` (common names: `eth0`, `ens18`, `enp0s3`)
-
-The script will:
-1. Create a custom routing table named `srf_gateway`
-2. Resolve IP addresses for all SRF domains
-3. Add routes through your gateway (192.168.1.37)
-4. Create routing rules for policy-based routing
-5. Set up a systemd service for persistence across reboots
-
-### Step 5: Verify Routing
-
-Check that routes are configured:
-
-```bash
-# Show the custom routing table
-ip route show table srf_gateway
-
-# Show routing rules
-ip rule show | grep srf_gateway
-
-# Test routing for Integration Layer API
-ip route get $(dig +short il.srgssr.ch | head -1)
-
-# Test routing for video CDN
-ip route get $(dig +short srf-vod-amd.akamaized.net | head -1)
-```
-
-### Step 6: Test from Jellyfin Server
-
-Test that the routing is working:
-
-```bash
-# Test API access
-curl -v "https://il.srgssr.ch/integrationlayer/2.0/mediaComposition/byUrn/urn:srf:video:b84713f0-f81b-460f-9b0f-d0517310fb4f.json" 2>&1 | grep -E "(x-location|HTTP/)"
-
-# Should show: x-location: CH
-```
-
-### Step 7: Restart Jellyfin
-
-```bash
-sudo systemctl restart jellyfin
-```
-
-## What Gets Routed
-
-The following domains are routed through the gateway:
-
-- `il.srgssr.ch` - Integration Layer API (metadata)
-- `www.srf.ch` - Main SRF site
-- `www.rts.ch` - RTS (Radio Télévision Suisse)
-- `www.rsi.ch` - RSI (Radiotelevisione svizzera)
-- `www.rtr.ch` - RTR (Radiotelevisiun Svizra Rumantscha)
-- `www.swi.ch` - SWI (swissinfo)
-- `srf-vod-amd.akamaized.net` - SRF video CDN
-- `rts-vod-amd.akamaized.net` - RTS video CDN
-- `rsi-vod-amd.akamaized.net` - RSI video CDN
-- `play-web.srf.ch` - Play web interface
-- `il-stage.srgssr.ch` - Staging environment
-
-## How It Works
-
-1. **DNS Resolution**: Domains are resolved to IP addresses
-2. **Routing Table**: A custom routing table (`srf_gateway`) is created with routes through the gateway
-3. **Policy Routing**: Rules direct traffic to specific IPs to use the custom routing table
-4. **Persistence**: A systemd service ensures routes survive reboots
-
-## Disabling Plugin Proxy Configuration
-
-Once network-level routing is working, you can disable the proxy configuration in the plugin:
-
-1. Go to Jellyfin Dashboard → Plugins → SRF Play
-2. Uncheck "Use Proxy"
-3. Save configuration
-4. Restart Jellyfin
-
-The plugin will use direct HTTP requests, but the network layer will transparently route them through the gateway.
-
-## Troubleshooting
-
-### Routes Not Working
-
-Check if gateway is reachable:
-```bash
-ping 192.168.1.37
-nc -zv 192.168.1.37 3128
-```
-
-Check routing table:
-```bash
-ip route show table srf_gateway
-```
-
-### DNS Changes
-
-If SRF changes their IP addresses, you may need to re-run the setup script:
-```bash
-sudo ./cleanup-gateway-routing.sh
-sudo ./setup-gateway-routing.sh
-```
-
-### Verify Traffic Path
-
-Use `traceroute` to see the path:
-```bash
-traceroute $(dig +short il.srgssr.ch | head -1)
-# Should show 192.168.1.37 as first hop
-```
-
-### Check Systemd Service
-
-```bash
-systemctl status srf-gateway-routing.service
-journalctl -u srf-gateway-routing.service
-```
-
-## Removing the Configuration
-
-To completely remove the routing configuration:
-
-```bash
-sudo ./cleanup-gateway-routing.sh
-```
-
-This will:
-- Remove all routing rules
-- Flush the custom routing table
-- Disable and remove the systemd service
-
-## Advantages of This Approach
-
-1. **Transparent**: No application changes needed
-2. **Complete Coverage**: All network traffic to SRF domains uses gateway
-3. **Persistent**: Survives reboots
-4. **Centralized**: Managed at network level
-5. **Debug-Friendly**: Can verify with standard network tools
-
-## Disadvantages
-
-1. **DNS Changes**: If SRF changes IPs, routing must be updated
-2. **New Domains**: New CDN domains require script update
-3. **Static IPs Only**: Doesn't work with wildcard domains
-
-## Gateway Configuration
-
-Ensure your gateway (192.168.1.37) has:
-
-1. **IPv4 Forwarding Enabled**:
-   ```bash
-   # On the gateway (192.168.1.37)
-   sudo sysctl net.ipv4.ip_forward=1
-
-   # Make permanent
-   echo "net.ipv4.ip_forward=1" | sudo tee -a /etc/sysctl.conf
-   ```
-
-2. **Firewall Rules** (if using iptables):
-   ```bash
-   # On the gateway (192.168.1.37)
-   sudo iptables -A FORWARD -s 192.168.1.4 -j ACCEPT
-   sudo iptables -A FORWARD -d 192.168.1.4 -m state --state RELATED,ESTABLISHED -j ACCEPT
-   sudo iptables -t nat -A POSTROUTING -s 192.168.1.4 -o <outbound-interface> -j MASQUERADE
-   ```
-
-3. **Squid Proxy** (if using proxy mode):
-   - Already configured and accessible at port 3128
-   - Note: With network-level routing, traffic goes through the gateway's routing, not necessarily the Squid proxy
-
-## Testing Complete Data Chain
-
-After setup, test the complete flow:
-
-1. **Metadata API**: Browse shows in Jellyfin - should work
-2. **Video Playback**: Try playing a video - should work
-3. **Thumbnails**: Images should load
-
-All traffic should be routed through 192.168.1.37, giving you the Swiss location needed to access geo-blocked content.

PROXY_SETUP_GUIDE.md

@@ -1,197 +0,0 @@
-# Proxy Configuration Guide for SRF Play Plugin
-
-This guide explains how to configure the Jellyfin SRF Play plugin to route all API traffic through a proxy or alternate gateway.
-
-## Overview
-
-The SRF Play plugin now supports proxy configuration directly in the plugin settings. This allows you to:
-- Route traffic through a specific gateway or proxy server
-- Use authentication if your proxy requires it
-- Bypass geo-restrictions or network policies
-- Route only SRF-related traffic without affecting other Jellyfin operations
-
-## Supported Proxy Types
-
-The plugin supports:
-- **HTTP proxies**: `http://proxy.example.com:8080`
-- **HTTPS proxies**: `https://proxy.example.com:8443`
-- **SOCKS5 proxies**: `socks5://proxy.example.com:1080`
-
-## Configuration Steps
-
-### 1. Access Plugin Settings
-
-1. Open Jellyfin Dashboard
-2. Navigate to **Dashboard → Plugins → SRF Play**
-3. Scroll down to the **Proxy Settings** section
-
-### 2. Configure Proxy
-
-Fill in the following fields:
-
-#### Use Proxy
-- **Enable this checkbox** to route all SRF API requests through the proxy
-
-#### Proxy Address
-- Enter your proxy server address with protocol and port
-- Examples:
-  - `http://192.168.1.100:8080`
-  - `http://proxy.example.com:3128`
-  - `socks5://127.0.0.1:1080`
-
-#### Proxy Username (Optional)
-- Enter username if your proxy requires authentication
-- Leave empty if no authentication is needed
-
-#### Proxy Password (Optional)
-- Enter password if your proxy requires authentication
-- Leave empty if no authentication is needed
-
-### 3. Save Configuration
-
-1. Click **Save** button
-2. Restart Jellyfin to apply changes (recommended)
-
-## Examples
-
-### Example 1: Simple HTTP Proxy (No Authentication)
-
-```
-Use Proxy: ✓ Enabled
-Proxy Address: http://192.168.1.1:8080
-Proxy Username: (empty)
-Proxy Password: (empty)
-```
-
-### Example 2: Authenticated HTTP Proxy
-
-```
-Use Proxy: ✓ Enabled
-Proxy Address: http://proxy.company.com:3128
-Proxy Username: myusername
-Proxy Password: mypassword
-```
-
-### Example 3: SOCKS5 Proxy
-
-```
-Use Proxy: ✓ Enabled
-Proxy Address: socks5://127.0.0.1:1080
-Proxy Username: (empty)
-Proxy Password: (empty)
-```
-
-## Setting Up a Transparent Proxy Gateway on Ubuntu
-
-If you want to create your own transparent proxy gateway on Ubuntu, here are some options:
-
-### Option A: Squid Proxy
-
-Install and configure Squid as a transparent proxy:
-
-```bash
-# Install Squid
-sudo apt update
-sudo apt install squid
-
-# Edit configuration
-sudo nano /etc/squid/squid.conf
-
-# Add these lines:
-http_port 3128
-acl localnet src 192.168.1.0/24
-http_access allow localnet
-
-# Restart Squid
-sudo systemctl restart squid
-```
-
-Then in plugin settings:
-```
-Proxy Address: http://192.168.1.1:3128
-```
-
-### Option B: SSH Tunnel (SOCKS5)
-
-Create a SOCKS5 proxy through SSH:
-
-```bash
-# On your local machine
-ssh -D 1080 -N user@remote-gateway-server
-```
-
-Then in plugin settings:
-```
-Proxy Address: socks5://127.0.0.1:1080
-```
-
-### Option C: Dante SOCKS Server
-
-Install Dante for a dedicated SOCKS5 server:
-
-```bash
-sudo apt install dante-server
-
-# Configure in /etc/danted.conf
-sudo systemctl restart danted
-```
-
-## Troubleshooting
-
-### Plugin Not Connecting Through Proxy
-
-1. **Check proxy address format**: Ensure it includes the protocol (http://, socks5://, etc.)
-2. **Verify proxy is running**: Test connectivity to the proxy from your Jellyfin server
-3. **Check Jellyfin logs**: Look for proxy-related errors in Dashboard → Logs
-4. **Firewall rules**: Ensure your firewall allows outbound connections to the proxy
-
-### Authentication Errors
-
-1. Verify username and password are correct
-2. Check if your proxy requires domain authentication (DOMAIN\\username)
-3. Some proxies may require specific authentication methods not supported by .NET HttpClient
-
-### DNS Resolution
-
-- The plugin resolves domain names before sending requests through the proxy
-- If you need DNS resolution through the proxy, you may need to use a VPN or network-level routing instead
-
-## Affected Domains
-
-When proxy is enabled, all requests to these domains will be routed through the proxy:
-
-- `il.srgssr.ch` - SRF Integration Layer API
-- `www.srf.ch` - SRF Play v3 API (German)
-- `www.rts.ch` - RTS Play v3 API (French)
-- `www.rsi.ch` - RSI Play v3 API (Italian)
-- `www.rtr.ch` - RTR Play v3 API (Romansh)
-- `www.swi.ch` - SWI Play v3 API (International)
-
-## Viewing Logs
-
-To verify the proxy is being used:
-
-1. Go to **Dashboard → Logs**
-2. Look for entries containing "Proxy configured"
-3. Example log entry:
-   ```
-   Proxy configured: http://192.168.1.1:8080 (Authentication: False)
-   ```
-
-## Security Notes
-
-- Proxy credentials are stored in Jellyfin's plugin configuration
-- Use HTTPS for the proxy connection when possible to encrypt traffic
-- Consider using a VPN for more secure routing if dealing with sensitive content
-- Regularly update your proxy server and Jellyfin to patch security vulnerabilities
-
-## Alternative: Network-Level Routing
-
-If you prefer network-level routing instead of application proxy, see the `setup-srf-routing.sh` script for IP-based routing tables (requires root access and is more complex).
-
-## Support
-
-If you encounter issues:
-1. Check Jellyfin logs for detailed error messages
-2. Verify proxy connectivity with `curl --proxy http://proxy:port https://il.srgssr.ch`
-3. Open an issue on the GitHub repository with logs and configuration details

README.md

@@ -14,6 +14,17 @@ A Jellyfin plugin for accessing SRF Play (Swiss Radio and Television) video-on-d
 - Proxy support for routing traffic through alternate gateways
 - Smart caching with reduced TTL for upcoming livestreams
 
+## Screenshots
+
+### Channel Menu
+![SRF Play Menu](res/menu.png)
+
+The main channel interface showing the content folders.
+### Playback
+![SRF Play Playback](res/playback.png)
+
+Video playback with HLS streaming support and quality selection.
+
 ## Project Status
 
 ### ✅ Completed Components
@@ -92,16 +103,40 @@ A Jellyfin plugin for accessing SRF Play (Swiss Radio and Television) video-on-d
 **Successfully compiling!** All code analysis warnings resolved.
 
 ### 🧪 Testing Status
-- [ ] Unit tests
+- [x] Unit tests (xUnit framework)
+  - StreamUrlResolver tests
+  - MetadataCache tests
+  - More to be added
+- [x] API spec validation tests (nightly automated runs)
+  - All business units (SRF, RTS, RSI, RTR, SWI)
+  - Response schema validation
+  - Performance monitoring
 - [ ] Integration testing with Jellyfin instance
 - [ ] End-to-end playback testing for VOD content
 - [ ] Live sports streaming validation
 
+**Run tests:**
+```bash
+# All tests
+dotnet test
+
+# Unit tests only
+dotnet test --filter "Category!=Integration&Category!=APISpec"
+
+# API spec tests only
+dotnet test --filter "Category=APISpec"
+
+# With coverage
+dotnet test --collect:"XPlat Code Coverage"
+```
+
+See [Test Documentation](Jellyfin.Plugin.SRFPlay.Tests/README.md) for more details.
+
 ### 📝 Next Steps
 1. Test live sports streaming when events are scheduled
 2. Verify Akamai token authentication
 3. Test with different business units (RTS, RSI, RTR)
-4. Add unit tests
+4. Add more unit tests for remaining services
 5. Performance optimization if needed
 
 ## API Information

deploy-to-jellyfin.sh

@@ -1,57 +0,0 @@
-#!/bin/bash
-# Deploy SRF Play plugin to Jellyfin server
-
-set -e
-
-# Configuration
-JELLYFIN_SERVER="192.168.1.4"
-JELLYFIN_USER="dtourolle"  # Change this to your SSH user
-DLL_PATH="Jellyfin.Plugin.SRFPlay/bin/Release/net8.0/Jellyfin.Plugin.SRFPlay.dll"
-
-# Colors
-GREEN='\033[0;32m'
-YELLOW='\033[1;33m'
-NC='\033[0m'
-
-echo -e "${GREEN}=== Deploying SRF Play Plugin ===${NC}\n"
-
-# Check if DLL exists
-if [ ! -f "$DLL_PATH" ]; then
-    echo "Error: DLL not found. Building..."
-    dotnet build Jellyfin.Plugin.SRFPlay/Jellyfin.Plugin.SRFPlay.csproj -c Release
-fi
-
-echo "Step 1: Copying DLL to Jellyfin server..."
-scp "$DLL_PATH" "${JELLYFIN_USER}@${JELLYFIN_SERVER}:~/"
-
-echo -e "\nStep 2: Installing DLL on Jellyfin server..."
-ssh "${JELLYFIN_USER}@${JELLYFIN_SERVER}" << 'ENDSSH'
-    echo "Stopping Jellyfin..."
-    sudo systemctl stop jellyfin
-
-    echo "Backing up old DLL..."
-    sudo cp /var/lib/jellyfin/plugins/SRF/Jellyfin.Plugin.SRFPlay.dll \
-           /var/lib/jellyfin/plugins/SRF/Jellyfin.Plugin.SRFPlay.dll.backup || true
-
-    echo "Installing new DLL..."
-    sudo cp ~/Jellyfin.Plugin.SRFPlay.dll /var/lib/jellyfin/plugins/SRF/
-    sudo chown jellyfin:jellyfin /var/lib/jellyfin/plugins/SRF/Jellyfin.Plugin.SRFPlay.dll
-
-    echo "Starting Jellyfin..."
-    sudo systemctl start jellyfin
-
-    echo "Waiting for Jellyfin to start..."
-    sleep 5
-
-    echo "Checking Jellyfin status..."
-    sudo systemctl status jellyfin --no-pager -l | head -20
-ENDSSH
-
-echo -e "\n${GREEN}✓ Deployment complete!${NC}"
-echo -e "\n${YELLOW}Next steps:${NC}"
-echo "1. Test video playback - GUID errors should be fixed"
-echo "2. If videos still don't play due to geo-blocking, run network routing setup:"
-echo "   scp setup-gateway-routing.sh cleanup-gateway-routing.sh ${JELLYFIN_USER}@${JELLYFIN_SERVER}:~"
-echo "   ssh ${JELLYFIN_USER}@${JELLYFIN_SERVER}"
-echo "   chmod +x setup-gateway-routing.sh"
-echo "   sudo ./setup-gateway-routing.sh"