Update manifest.json for version 1.0.14

Use title cards when non provided or is livestream

.gitea/workflows/release.yaml

@@ -70,6 +70,13 @@ jobs:
           echo "artifact_name=${ARTIFACT_NAME}" >> $GITHUB_OUTPUT
           echo "Found artifact: ${ARTIFACT}"
 
+      - name: Calculate checksum
+        id: checksum
+        run: |
+          CHECKSUM=$(md5sum "${{ steps.jprm.outputs.artifact }}" | awk '{print $1}')
+          echo "checksum=${CHECKSUM}" >> $GITHUB_OUTPUT
+          echo "Checksum: ${CHECKSUM}"
+
       - name: Create Release
         env:
           GITEA_TOKEN: ${{ secrets.GITHUB_TOKEN }}
@@ -126,3 +133,38 @@ jobs:
 
           echo "✅ Release created successfully!"
           echo "View at: ${GITEA_URL}/${REPO_OWNER}/${REPO_NAME}/releases/tag/${{ steps.get_version.outputs.version }}"
+
+      - name: Update manifest.json
+        env:
+          GITEA_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        run: |
+          REPO_OWNER="${{ github.repository_owner }}"
+          REPO_NAME="${{ github.event.repository.name }}"
+          GITEA_URL="${{ github.server_url }}"
+          VERSION="${{ steps.get_version.outputs.version_number }}"
+          CHECKSUM="${{ steps.checksum.outputs.checksum }}"
+          ARTIFACT_NAME="${{ steps.jprm.outputs.artifact_name }}"
+          TIMESTAMP=$(date -u +"%Y-%m-%dT%H:%M:%SZ")
+          DOWNLOAD_URL="${GITEA_URL}/${REPO_OWNER}/${REPO_NAME}/releases/download/${{ steps.get_version.outputs.version }}/${ARTIFACT_NAME}"
+
+          git config user.name "Gitea Actions"
+          git config user.email "actions@gitea.tourolle.paris"
+          git fetch origin master
+          git checkout master
+
+          NEW_VERSION=$(cat <<EOF
+          {
+            "version": "${VERSION}",
+            "changelog": "Release ${VERSION}",
+            "targetAbi": "10.9.0.0",
+            "sourceUrl": "${DOWNLOAD_URL}",
+            "checksum": "${CHECKSUM}",
+            "timestamp": "${TIMESTAMP}"
+          }
+          EOF
+          )
+
+          jq --argjson newver "${NEW_VERSION}" '.[0].versions = [$newver] + .[0].versions' manifest.json > manifest.tmp && mv manifest.tmp manifest.json
+          git add manifest.json
+          git commit -m "Update manifest.json for version ${VERSION}"
+          git push origin master

.gitignore

@@ -3,3 +3,4 @@ obj/
 .vs/
 .idea/
 artifacts
+*.log

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.Tests/Program.cs

@@ -12,6 +12,14 @@ using Microsoft.Extensions.Logging;
 
 namespace Jellyfin.Plugin.SRFPlay.Tests
 {
+    /// <summary>
+    /// Simple IHttpClientFactory implementation for tests.
+    /// </summary>
+    internal sealed class TestHttpClientFactory : IHttpClientFactory
+    {
+        public HttpClient CreateClient(string name) => new HttpClient();
+    }
+
     class Program
     {
         static async Task Main(string[] args)
@@ -33,8 +41,9 @@ namespace Jellyfin.Plugin.SRFPlay.Tests
                 builder.SetMinimumLevel(LogLevel.Warning); // Only show warnings and errors
             });
 
+            var httpClientFactory = new TestHttpClientFactory();
             var apiClient = new SRFApiClient(loggerFactory);
-            var streamResolver = new StreamUrlResolver(loggerFactory.CreateLogger<StreamUrlResolver>());
+            var streamResolver = new StreamUrlResolver(loggerFactory.CreateLogger<StreamUrlResolver>(), httpClientFactory);
 
             var cancellationToken = CancellationToken.None;
 

Jellyfin.Plugin.SRFPlay/Api/ISRFApiClientFactory.cs

@@ -0,0 +1,13 @@
+namespace Jellyfin.Plugin.SRFPlay.Api;
+
+/// <summary>
+/// Factory interface for creating SRF API clients.
+/// </summary>
+public interface ISRFApiClientFactory
+{
+    /// <summary>
+    /// Creates a new instance of the SRF API client.
+    /// </summary>
+    /// <returns>A new SRFApiClient instance.</returns>
+    SRFApiClient CreateClient();
+}

Jellyfin.Plugin.SRFPlay/Api/Models/PlayV3/PlayV3TvProgramGuideResponse.cs

@@ -1,16 +0,0 @@
-using System.Collections.Generic;
-using System.Text.Json.Serialization;
-
-namespace Jellyfin.Plugin.SRFPlay.Api.Models.PlayV3;
-
-/// <summary>
-/// TV Program Guide response from Play v3 API.
-/// </summary>
-public class PlayV3TvProgramGuideResponse
-{
-    /// <summary>
-    /// Gets the list of TV program entries.
-    /// </summary>
-    [JsonPropertyName("data")]
-    public IReadOnlyList<PlayV3TvProgram>? Data { get; init; }
-}

Jellyfin.Plugin.SRFPlay/Api/SRFApiClient.cs

@@ -2,12 +2,15 @@ using System;
 using System.Globalization;
 using System.Net;
 using System.Net.Http;
+using System.Text;
+using System.Text.Encodings.Web;
 using System.Text.Json;
 using System.Threading;
 using System.Threading.Tasks;
 using Jellyfin.Plugin.SRFPlay.Api.Models;
 using Jellyfin.Plugin.SRFPlay.Api.Models.PlayV3;
 using Jellyfin.Plugin.SRFPlay.Configuration;
+using Jellyfin.Plugin.SRFPlay.Constants;
 using Microsoft.Extensions.Logging;
 
 namespace Jellyfin.Plugin.SRFPlay.Api;
@@ -17,9 +20,7 @@ namespace Jellyfin.Plugin.SRFPlay.Api;
 /// </summary>
 public class SRFApiClient : IDisposable
 {
-    private const string BaseUrl = "https://il.srgssr.ch/integrationlayer/2.0";
-    private const string PlayV3BaseUrlTemplate = "https://www.{0}.ch/play/v3/api/{0}/production/";
-    private static readonly System.Text.CompositeFormat PlayV3UrlFormat = System.Text.CompositeFormat.Parse(PlayV3BaseUrlTemplate);
+    private static readonly System.Text.CompositeFormat PlayV3UrlFormat = System.Text.CompositeFormat.Parse(ApiEndpoints.PlayV3BaseUrlTemplate);
     private readonly HttpClient _httpClient;
     private readonly HttpClient _playV3HttpClient;
     private readonly ILogger _logger;
@@ -47,15 +48,28 @@ public class SRFApiClient : IDisposable
             _logger.LogInformation("SRFApiClient initializing without proxy");
         }
 
-        _httpClient = CreateHttpClient(BaseUrl);
+        _httpClient = CreateHttpClient(ApiEndpoints.IntegrationLayerBaseUrl);
         _playV3HttpClient = CreateHttpClient(null);
 
         _jsonOptions = new JsonSerializerOptions
         {
-            PropertyNameCaseInsensitive = true
+            PropertyNameCaseInsensitive = true,
+            Encoder = JavaScriptEncoder.UnsafeRelaxedJsonEscaping
         };
     }
 
+    /// <summary>
+    /// Reads HTTP response content as UTF-8 string.
+    /// </summary>
+    /// <param name="content">The HTTP content to read.</param>
+    /// <param name="cancellationToken">The cancellation token.</param>
+    /// <returns>The content as a UTF-8 decoded string.</returns>
+    private async Task<string> ReadAsUtf8StringAsync(HttpContent content, CancellationToken cancellationToken = default)
+    {
+        var bytes = await content.ReadAsByteArrayAsync(cancellationToken).ConfigureAwait(false);
+        return Encoding.UTF8.GetString(bytes);
+    }
+
     /// <summary>
     /// Creates an HttpClient with optional proxy configuration.
     /// </summary>
@@ -111,6 +125,7 @@ public class SRFApiClient : IDisposable
         client.DefaultRequestHeaders.UserAgent.ParseAdd("Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36");
         client.DefaultRequestHeaders.Accept.ParseAdd("*/*");
         client.DefaultRequestHeaders.AcceptLanguage.ParseAdd("en-US,en;q=0.9");
+        client.DefaultRequestHeaders.Add("Accept-Charset", "utf-8");
 
         _logger.LogInformation(
             "HttpClient created with HTTP/1.1 and headers - User-Agent: {UserAgent}, Accept: {Accept}, Accept-Language: {AcceptLanguage}",
@@ -136,58 +151,10 @@ public class SRFApiClient : IDisposable
     {
         try
         {
-            var url = $"/mediaComposition/byUrn/{urn}.json";
-            var fullUrl = $"{BaseUrl}{url}";
-            _logger.LogInformation("Fetching media composition for URN: {Urn} from {Url}", urn, fullUrl);
+            var fullUrl = $"{ApiEndpoints.IntegrationLayerBaseUrl}/mediaComposition/byUrn/{urn}.json";
+            _logger.LogDebug("Fetching media composition for URN: {Urn} from {Url}", urn, fullUrl);
 
-            var response = await _httpClient.GetAsync(url, cancellationToken).ConfigureAwait(false);
-
-            // Log response headers to diagnose geo-blocking
-            var xLocation = response.Headers.Contains("x-location")
-                ? string.Join(", ", response.Headers.GetValues("x-location"))
-                : "not present";
-
-            _logger.LogInformation(
-                "Media composition response for URN {Urn}: StatusCode={StatusCode}, x-location={XLocation}",
-                urn,
-                response.StatusCode,
-                xLocation);
-
-            // If HttpClient fails, try curl as fallback
-            if (!response.IsSuccessStatusCode)
-            {
-                _logger.LogWarning("HttpClient failed with {StatusCode}, trying curl fallback", response.StatusCode);
-                return await FetchWithCurlAsync(fullUrl, cancellationToken).ConfigureAwait(false);
-            }
-
-            response.EnsureSuccessStatusCode();
-
-            var content = await response.Content.ReadAsStringAsync(cancellationToken).ConfigureAwait(false);
-            var result = JsonSerializer.Deserialize<MediaComposition>(content, _jsonOptions);
-
-            if (result?.ChapterList != null && result.ChapterList.Count > 0)
-            {
-                _logger.LogInformation(
-                    "Successfully fetched media composition for URN: {Urn} - Chapters: {ChapterCount}",
-                    urn,
-                    result.ChapterList.Count);
-            }
-            else
-            {
-                _logger.LogWarning("Media composition for URN {Urn} has no chapters", urn);
-            }
-
-            return result;
-        }
-        catch (HttpRequestException ex)
-        {
-            _logger.LogError(
-                ex,
-                "HTTP error fetching media composition for URN: {Urn} - StatusCode: {StatusCode}, trying curl fallback",
-                urn,
-                ex.StatusCode);
-
-            var fullUrl = $"{BaseUrl}/mediaComposition/byUrn/{urn}.json";
+            // Use curl - HttpClient returns 404 due to server routing/network configuration
             return await FetchWithCurlAsync(fullUrl, cancellationToken).ConfigureAwait(false);
         }
         catch (Exception ex)
@@ -233,7 +200,8 @@ public class SRFApiClient : IDisposable
                 RedirectStandardOutput = true,
                 RedirectStandardError = true,
                 UseShellExecute = false,
-                CreateNoWindow = true
+                CreateNoWindow = true,
+                StandardOutputEncoding = Encoding.UTF8
             };
 
             using var process = new System.Diagnostics.Process { StartInfo = processStartInfo };
@@ -293,12 +261,12 @@ public class SRFApiClient : IDisposable
 
             if (!response.IsSuccessStatusCode)
             {
-                var errorContent = await response.Content.ReadAsStringAsync(cancellationToken).ConfigureAwait(false);
+                var errorContent = await ReadAsUtf8StringAsync(response.Content, cancellationToken).ConfigureAwait(false);
                 _logger.LogError("API returned error {StatusCode}: {Error}", response.StatusCode, errorContent);
                 return null;
             }
 
-            var content = await response.Content.ReadAsStringAsync(cancellationToken).ConfigureAwait(false);
+            var content = await ReadAsUtf8StringAsync(response.Content, cancellationToken).ConfigureAwait(false);
             _logger.LogDebug("Latest videos response length: {Length}", content.Length);
 
             var result = JsonSerializer.Deserialize<MediaComposition>(content, _jsonOptions);
@@ -332,12 +300,12 @@ public class SRFApiClient : IDisposable
 
             if (!response.IsSuccessStatusCode)
             {
-                var errorContent = await response.Content.ReadAsStringAsync(cancellationToken).ConfigureAwait(false);
+                var errorContent = await ReadAsUtf8StringAsync(response.Content, cancellationToken).ConfigureAwait(false);
                 _logger.LogError("API returned error {StatusCode}: {Error}", response.StatusCode, errorContent);
                 return null;
             }
 
-            var content = await response.Content.ReadAsStringAsync(cancellationToken).ConfigureAwait(false);
+            var content = await ReadAsUtf8StringAsync(response.Content, cancellationToken).ConfigureAwait(false);
             _logger.LogDebug("Trending videos response length: {Length}", content.Length);
 
             var result = JsonSerializer.Deserialize<MediaComposition>(content, _jsonOptions);
@@ -367,7 +335,7 @@ public class SRFApiClient : IDisposable
             var response = await _httpClient.GetAsync(url, cancellationToken).ConfigureAwait(false);
             response.EnsureSuccessStatusCode();
 
-            var content = await response.Content.ReadAsStringAsync(cancellationToken).ConfigureAwait(false);
+            var content = await ReadAsUtf8StringAsync(response.Content, cancellationToken).ConfigureAwait(false);
             return content;
         }
         catch (Exception ex)
@@ -395,12 +363,12 @@ public class SRFApiClient : IDisposable
 
             if (!response.IsSuccessStatusCode)
             {
-                var errorContent = await response.Content.ReadAsStringAsync(cancellationToken).ConfigureAwait(false);
+                var errorContent = await ReadAsUtf8StringAsync(response.Content, cancellationToken).ConfigureAwait(false);
                 _logger.LogError("API returned error {StatusCode}: {Error}", response.StatusCode, errorContent);
                 return null;
             }
 
-            var content = await response.Content.ReadAsStringAsync(cancellationToken).ConfigureAwait(false);
+            var content = await ReadAsUtf8StringAsync(response.Content, cancellationToken).ConfigureAwait(false);
             var result = JsonSerializer.Deserialize<PlayV3DirectResponse<PlayV3Show>>(content, _jsonOptions);
 
             _logger.LogInformation("Successfully fetched {Count} shows for business unit: {BusinessUnit}", result?.Data?.Count ?? 0, businessUnit);
@@ -431,12 +399,12 @@ public class SRFApiClient : IDisposable
 
             if (!response.IsSuccessStatusCode)
             {
-                var errorContent = await response.Content.ReadAsStringAsync(cancellationToken).ConfigureAwait(false);
+                var errorContent = await ReadAsUtf8StringAsync(response.Content, cancellationToken).ConfigureAwait(false);
                 _logger.LogError("API returned error {StatusCode}: {Error}", response.StatusCode, errorContent);
                 return null;
             }
 
-            var content = await response.Content.ReadAsStringAsync(cancellationToken).ConfigureAwait(false);
+            var content = await ReadAsUtf8StringAsync(response.Content, cancellationToken).ConfigureAwait(false);
             var result = JsonSerializer.Deserialize<PlayV3DirectResponse<PlayV3Topic>>(content, _jsonOptions);
 
             _logger.LogInformation("Successfully fetched {Count} topics for business unit: {BusinessUnit}", result?.Data?.Count ?? 0, businessUnit);
@@ -468,12 +436,12 @@ public class SRFApiClient : IDisposable
 
             if (!response.IsSuccessStatusCode)
             {
-                var errorContent = await response.Content.ReadAsStringAsync(cancellationToken).ConfigureAwait(false);
+                var errorContent = await ReadAsUtf8StringAsync(response.Content, cancellationToken).ConfigureAwait(false);
                 _logger.LogError("API returned error {StatusCode}: {Error}", response.StatusCode, errorContent);
                 return null;
             }
 
-            var content = await response.Content.ReadAsStringAsync(cancellationToken).ConfigureAwait(false);
+            var content = await ReadAsUtf8StringAsync(response.Content, cancellationToken).ConfigureAwait(false);
             var result = JsonSerializer.Deserialize<PlayV3Response<PlayV3Video>>(content, _jsonOptions);
 
             _logger.LogDebug("Successfully fetched {Count} videos for show {ShowId}", result?.Data?.Data?.Count ?? 0, showId);
@@ -508,12 +476,12 @@ public class SRFApiClient : IDisposable
 
             if (!response.IsSuccessStatusCode)
             {
-                var errorContent = await response.Content.ReadAsStringAsync(cancellationToken).ConfigureAwait(false);
+                var errorContent = await ReadAsUtf8StringAsync(response.Content, cancellationToken).ConfigureAwait(false);
                 _logger.LogError("API returned error {StatusCode}: {Error}", response.StatusCode, errorContent);
                 return null;
             }
 
-            var content = await response.Content.ReadAsStringAsync(cancellationToken).ConfigureAwait(false);
+            var content = await ReadAsUtf8StringAsync(response.Content, cancellationToken).ConfigureAwait(false);
 
             // The response structure is: { "data": { "scheduledLivestreams": [...] } }
             var jsonDoc = JsonSerializer.Deserialize<JsonElement>(content, _jsonOptions);

Jellyfin.Plugin.SRFPlay/Api/SRFApiClientFactory.cs

@@ -0,0 +1,26 @@
+using Microsoft.Extensions.Logging;
+
+namespace Jellyfin.Plugin.SRFPlay.Api;
+
+/// <summary>
+/// Factory for creating SRF API clients.
+/// </summary>
+public class SRFApiClientFactory : ISRFApiClientFactory
+{
+    private readonly ILoggerFactory _loggerFactory;
+
+    /// <summary>
+    /// Initializes a new instance of the <see cref="SRFApiClientFactory"/> class.
+    /// </summary>
+    /// <param name="loggerFactory">The logger factory.</param>
+    public SRFApiClientFactory(ILoggerFactory loggerFactory)
+    {
+        _loggerFactory = loggerFactory;
+    }
+
+    /// <inheritdoc />
+    public SRFApiClient CreateClient()
+    {
+        return new SRFApiClient(_loggerFactory);
+    }
+}

Jellyfin.Plugin.SRFPlay/Channels/SRFPlayChannel.cs

@@ -2,11 +2,14 @@ using System;
 using System.Collections.Generic;
 using System.Globalization;
 using System.Linq;
-using System.Security.Cryptography;
 using System.Text;
 using System.Threading;
 using System.Threading.Tasks;
-using Jellyfin.Plugin.SRFPlay.Services;
+using Jellyfin.Plugin.SRFPlay.Api;
+using Jellyfin.Plugin.SRFPlay.Constants;
+using Jellyfin.Plugin.SRFPlay.Services.Interfaces;
+using Jellyfin.Plugin.SRFPlay.Utilities;
+using MediaBrowser.Controller;
 using MediaBrowser.Controller.Channels;
 using MediaBrowser.Controller.Providers;
 using MediaBrowser.Model.Channels;
@@ -22,10 +25,11 @@ namespace Jellyfin.Plugin.SRFPlay.Channels;
 public class SRFPlayChannel : IChannel, IHasCacheKey
 {
     private readonly ILogger<SRFPlayChannel> _logger;
-    private readonly ILoggerFactory _loggerFactory;
-    private readonly ContentRefreshService _contentRefreshService;
-    private readonly StreamUrlResolver _streamResolver;
-    private readonly CategoryService? _categoryService;
+    private readonly IContentRefreshService _contentRefreshService;
+    private readonly IStreamUrlResolver _streamResolver;
+    private readonly IMediaSourceFactory _mediaSourceFactory;
+    private readonly ICategoryService? _categoryService;
+    private readonly ISRFApiClientFactory _apiClientFactory;
 
     /// <summary>
     /// Initializes a new instance of the <see cref="SRFPlayChannel"/> class.
@@ -33,25 +37,30 @@ 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="mediaSourceFactory">The media source factory.</param>
     /// <param name="categoryService">The category service (optional).</param>
+    /// <param name="apiClientFactory">The API client factory.</param>
     public SRFPlayChannel(
         ILoggerFactory loggerFactory,
-        ContentRefreshService contentRefreshService,
-        StreamUrlResolver streamResolver,
-        CategoryService? categoryService = null)
+        IContentRefreshService contentRefreshService,
+        IStreamUrlResolver streamResolver,
+        IMediaSourceFactory mediaSourceFactory,
+        ICategoryService? categoryService,
+        ISRFApiClientFactory apiClientFactory)
     {
-        _loggerFactory = loggerFactory;
         _logger = loggerFactory.CreateLogger<SRFPlayChannel>();
         _contentRefreshService = contentRefreshService;
         _streamResolver = streamResolver;
+        _mediaSourceFactory = mediaSourceFactory;
         _categoryService = categoryService;
+        _apiClientFactory = apiClientFactory;
 
         if (_categoryService == null)
         {
             _logger.LogWarning("CategoryService not available - category folders will be disabled");
         }
 
-        _logger.LogInformation("=== SRFPlayChannel constructor called! Channel is being instantiated ===");
+        _logger.LogDebug("SRFPlayChannel initialized");
     }
 
     /// <inheritdoc />
@@ -61,10 +70,10 @@ 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";
+    public string HomePageUrl => ApiEndpoints.SrfPlayHomepage;
 
     /// <inheritdoc />
     public ChannelParentalRating ParentalRating => ChannelParentalRating.GeneralAudience;
@@ -72,7 +81,7 @@ public class SRFPlayChannel : IChannel, IHasCacheKey
     /// <inheritdoc />
     public InternalChannelFeatures GetChannelFeatures()
     {
-        _logger.LogInformation("=== GetChannelFeatures called for SRF Play channel ===");
+        _logger.LogDebug("GetChannelFeatures called");
 
         return new InternalChannelFeatures
         {
@@ -98,10 +107,19 @@ public class SRFPlayChannel : IChannel, IHasCacheKey
     /// <inheritdoc />
     public Task<DynamicImageResponse> GetChannelImage(ImageType type, CancellationToken cancellationToken)
     {
-        // Could provide a channel logo here
+        var assembly = GetType().Assembly;
+        var resourceStream = assembly.GetManifestResourceStream("Jellyfin.Plugin.SRFPlay.Images.logo.png");
+
+        if (resourceStream == null)
+        {
+            return Task.FromResult(new DynamicImageResponse { HasImage = false });
+        }
+
         return Task.FromResult(new DynamicImageResponse
         {
-            HasImage = false
+            HasImage = true,
+            Stream = resourceStream,
+            Format = MediaBrowser.Model.Drawing.ImageFormat.Png
         });
     }
 
@@ -118,253 +136,263 @@ public class SRFPlayChannel : IChannel, IHasCacheKey
     /// <inheritdoc />
     public async Task<ChannelItemResult> GetChannelItems(InternalChannelItemQuery query, CancellationToken cancellationToken)
     {
-        _logger.LogInformation("=== GetChannelItems called! FolderId: {FolderId} ===", query.FolderId);
+        _logger.LogDebug("GetChannelItems called for folder {FolderId}", query.FolderId);
 
+        try
+        {
+            var items = await GetFolderItemsAsync(query.FolderId, cancellationToken).ConfigureAwait(false);
+            _logger.LogDebug("Returning {Count} channel items for folder {FolderId}", items.Count, query.FolderId);
+
+            return new ChannelItemResult
+            {
+                Items = items,
+                TotalRecordCount = items.Count
+            };
+        }
+        catch (Exception ex)
+        {
+            _logger.LogError(ex, "Error getting channel items for folder {FolderId}", query.FolderId);
+            return new ChannelItemResult { Items = new List<ChannelItemInfo>(), TotalRecordCount = 0 };
+        }
+    }
+
+    private async Task<List<ChannelItemInfo>> GetFolderItemsAsync(string? folderId, CancellationToken cancellationToken)
+    {
+        // Root level - show folder list
+        if (string.IsNullOrEmpty(folderId))
+        {
+            return await GetRootFoldersAsync(cancellationToken).ConfigureAwait(false);
+        }
+
+        // Handle known folder types
+        return folderId switch
+        {
+            "latest" => await GetLatestVideosAsync(cancellationToken).ConfigureAwait(false),
+            "trending" => await GetTrendingVideosAsync(cancellationToken).ConfigureAwait(false),
+            "live_sports" => await GetLiveSportsAsync(cancellationToken).ConfigureAwait(false),
+            _ when folderId.StartsWith("category_", StringComparison.Ordinal) => await GetCategoryVideosAsync(folderId, cancellationToken).ConfigureAwait(false),
+            _ => new List<ChannelItemInfo>()
+        };
+    }
+
+    private async Task<List<ChannelItemInfo>> GetRootFoldersAsync(CancellationToken cancellationToken)
+    {
+        var items = new List<ChannelItemInfo>
+        {
+            CreateFolder("latest", "Latest Videos"),
+            CreateFolder("trending", "Trending Videos"),
+            CreateFolder("live_sports", "Live Sports & Events")
+        };
+
+        // Add category folders if enabled
+        var config = Plugin.Instance?.Configuration;
+        if (config?.EnableCategoryFolders == true && _categoryService != null)
+        {
+            try
+            {
+                var businessUnit = config.BusinessUnit.ToString().ToLowerInvariant();
+                var topics = await _categoryService.GetTopicsAsync(businessUnit, cancellationToken).ConfigureAwait(false);
+
+                foreach (var topic in topics.Where(t => !string.IsNullOrEmpty(t.Id)))
+                {
+                    if (config.EnabledTopics != null && config.EnabledTopics.Count > 0 && !config.EnabledTopics.Contains(topic.Id!))
+                    {
+                        continue;
+                    }
+
+                    items.Add(CreateFolder($"category_{topic.Id}", topic.Title ?? topic.Id!, topic.Lead));
+                }
+
+                _logger.LogInformation("Added {Count} category folders", topics.Count);
+            }
+            catch (Exception ex)
+            {
+                _logger.LogError(ex, "Failed to load category folders - continuing without categories");
+            }
+        }
+
+        return items;
+    }
+
+    private static ChannelItemInfo CreateFolder(string id, string name, string? overview = null)
+    {
+        return new ChannelItemInfo
+        {
+            Id = id,
+            Name = name,
+            Type = ChannelItemType.Folder,
+            FolderType = ChannelFolderType.Container,
+            ImageUrl = null,
+            Overview = overview
+        };
+    }
+
+    private async Task<List<ChannelItemInfo>> GetLatestVideosAsync(CancellationToken cancellationToken)
+    {
+        var urns = await _contentRefreshService.RefreshLatestContentAsync(cancellationToken).ConfigureAwait(false);
+        return await ConvertUrnsToChannelItems(urns, cancellationToken).ConfigureAwait(false);
+    }
+
+    private async Task<List<ChannelItemInfo>> GetTrendingVideosAsync(CancellationToken cancellationToken)
+    {
+        var urns = await _contentRefreshService.RefreshTrendingContentAsync(cancellationToken).ConfigureAwait(false);
+        return await ConvertUrnsToChannelItems(urns, cancellationToken).ConfigureAwait(false);
+    }
+
+    private async Task<List<ChannelItemInfo>> GetLiveSportsAsync(CancellationToken cancellationToken)
+    {
         var items = new List<ChannelItemInfo>();
         var config = Plugin.Instance?.Configuration;
 
         try
         {
-            // Root level - show categories
-            if (string.IsNullOrEmpty(query.FolderId))
+            var businessUnit = config?.BusinessUnit.ToString().ToLowerInvariant() ?? "srf";
+
+            using var apiClient = _apiClientFactory.CreateClient();
+            var scheduledLivestreams = await apiClient.GetScheduledLivestreamsAsync(businessUnit, "SPORT", cancellationToken).ConfigureAwait(false);
+
+            if (scheduledLivestreams == null)
             {
-                items.Add(new ChannelItemInfo
+                return items;
+            }
+
+            // Filter for upcoming/current events (within next 7 days)
+            var now = DateTime.UtcNow;
+            var weekFromNow = now.AddDays(7);
+
+            var upcomingEvents = scheduledLivestreams
+                .Where(p => p.Urn != null &&
+                           !string.IsNullOrEmpty(p.Title) &&
+                           p.ValidFrom != null &&
+                           p.ValidFrom.Value.ToUniversalTime() <= weekFromNow &&
+                           (p.ValidTo == null || p.ValidTo.Value.ToUniversalTime() > now))
+                .OrderBy(p => p.ValidFrom)
+                .ToList();
+
+            _logger.LogInformation("Found {Count} scheduled live sports events", upcomingEvents.Count);
+
+            var urns = upcomingEvents.Select(e => e.Urn!).ToList();
+            items = await ConvertUrnsToChannelItems(urns, cancellationToken).ConfigureAwait(false);
+
+            // Enhance items with scheduled time information
+            foreach (var item in items)
+            {
+                var matchingEvent = upcomingEvents.FirstOrDefault(e => item.ProviderIds.ContainsKey("SRF") && item.ProviderIds["SRF"] == e.Urn);
+                if (matchingEvent?.ValidFrom != null)
                 {
-                    Id = "latest",
-                    Name = "Latest Videos",
-                    Type = ChannelItemType.Folder,
-                    FolderType = ChannelFolderType.Container,
-                    ImageUrl = null
-                });
+                    var eventTime = matchingEvent.ValidFrom.Value;
+                    item.Name = $"[{eventTime:dd.MM HH:mm}] {matchingEvent.Title}";
+                    item.PremiereDate = eventTime;
+                }
+            }
+        }
+        catch (Exception ex)
+        {
+            _logger.LogError(ex, "Failed to load live sports events");
+        }
 
-                items.Add(new ChannelItemInfo
+        return items;
+    }
+
+    private async Task<List<ChannelItemInfo>> GetCategoryVideosAsync(string folderId, CancellationToken cancellationToken)
+    {
+        var items = new List<ChannelItemInfo>();
+
+        if (_categoryService == null)
+        {
+            _logger.LogWarning("CategoryService not available - cannot display category folder");
+            return items;
+        }
+
+        try
+        {
+            var config = Plugin.Instance?.Configuration;
+            var topicId = folderId.Substring("category_".Length);
+            var businessUnit = config?.BusinessUnit.ToString().ToLowerInvariant() ?? "srf";
+
+            var shows = await _categoryService.GetShowsByTopicAsync(topicId, businessUnit, 20, cancellationToken).ConfigureAwait(false);
+            var urns = new List<string>();
+
+            using var apiClient = _apiClientFactory.CreateClient();
+
+            foreach (var show in shows)
+            {
+                if (show.Id == null || cancellationToken.IsCancellationRequested)
                 {
-                    Id = "trending",
-                    Name = "Trending Videos",
-                    Type = ChannelItemType.Folder,
-                    FolderType = ChannelFolderType.Container,
-                    ImageUrl = null
-                });
-
-                items.Add(new ChannelItemInfo
-                {
-                    Id = "live_sports",
-                    Name = "Live Sports & Events",
-                    Type = ChannelItemType.Folder,
-                    FolderType = ChannelFolderType.Container,
-                    ImageUrl = null
-                });
-
-                // Add category folders if enabled and CategoryService is available
-                if (config?.EnableCategoryFolders == true && _categoryService != null)
-                {
-                    try
-                    {
-                        var businessUnit = config.BusinessUnit.ToString().ToLowerInvariant();
-                        var topics = await _categoryService.GetTopicsAsync(businessUnit, cancellationToken).ConfigureAwait(false);
-
-                        foreach (var topic in topics.Where(t => !string.IsNullOrEmpty(t.Id)))
-                        {
-                            // Filter by enabled topics if configured
-                            if (config.EnabledTopics != null && config.EnabledTopics.Count > 0 && !config.EnabledTopics.Contains(topic.Id!))
-                            {
-                                continue;
-                            }
-
-                            items.Add(new ChannelItemInfo
-                            {
-                                Id = $"category_{topic.Id}",
-                                Name = topic.Title ?? topic.Id!,
-                                Type = ChannelItemType.Folder,
-                                FolderType = ChannelFolderType.Container,
-                                ImageUrl = null,
-                                Overview = topic.Lead
-                            });
-                        }
-
-                        _logger.LogInformation("Added {Count} category folders", topics.Count);
-                    }
-                    catch (Exception ex)
-                    {
-                        _logger.LogError(ex, "Failed to load category folders - continuing without categories");
-                    }
+                    continue;
                 }
 
-                return new ChannelItemResult
-                {
-                    Items = items,
-                    TotalRecordCount = items.Count
-                };
-            }
-
-            // Latest videos
-            if (query.FolderId == "latest")
-            {
-                var urns = await _contentRefreshService.RefreshLatestContentAsync(cancellationToken).ConfigureAwait(false);
-                items = await ConvertUrnsToChannelItems(urns, cancellationToken).ConfigureAwait(false);
-            }
-
-            // Trending videos
-            else if (query.FolderId == "trending")
-            {
-                var urns = await _contentRefreshService.RefreshTrendingContentAsync(cancellationToken).ConfigureAwait(false);
-                items = await ConvertUrnsToChannelItems(urns, cancellationToken).ConfigureAwait(false);
-            }
-
-            // Live Sports & Events
-            else if (query.FolderId == "live_sports")
-            {
                 try
                 {
-                    var businessUnit = config?.BusinessUnit.ToString().ToLowerInvariant() ?? "srf";
-
-                    using var apiClient = new Api.SRFApiClient(_loggerFactory);
-                    var scheduledLivestreams = await apiClient.GetScheduledLivestreamsAsync(businessUnit, "SPORT", cancellationToken).ConfigureAwait(false);
-
-                    if (scheduledLivestreams != null)
+                    var latestUrn = await GetLatestVideoUrnForShowAsync(apiClient, businessUnit, show, topicId, cancellationToken).ConfigureAwait(false);
+                    if (latestUrn != null)
                     {
-                        // Filter for upcoming/current events (within next 7 days) that have URNs
-                        var now = DateTime.UtcNow;
-                        var weekFromNow = now.AddDays(7);
-
-                        var upcomingEvents = scheduledLivestreams
-                            .Where(p => p.Urn != null &&
-                                       !string.IsNullOrEmpty(p.Title) &&
-                                       p.ValidFrom != null &&
-                                       p.ValidFrom.Value.ToUniversalTime() <= weekFromNow)
-                            .OrderBy(p => p.ValidFrom)
-                            .ToList();
-
-                        _logger.LogInformation("Found {Count} scheduled live sports events", upcomingEvents.Count);
-
-                        var urns = upcomingEvents.Select(e => e.Urn!).ToList();
-                        items = await ConvertUrnsToChannelItems(urns, cancellationToken).ConfigureAwait(false);
-
-                        // Enhance items with scheduled time information
-                        foreach (var item in items)
-                        {
-                            var matchingEvent = upcomingEvents.FirstOrDefault(e => item.ProviderIds.ContainsKey("SRF") && item.ProviderIds["SRF"] == e.Urn);
-                            if (matchingEvent?.ValidFrom != null)
-                            {
-                                var eventTime = matchingEvent.ValidFrom.Value;
-                                item.Name = $"[{eventTime:dd.MM HH:mm}] {matchingEvent.Title}";
-                                item.PremiereDate = eventTime;
-                            }
-                        }
+                        urns.Add(latestUrn);
                     }
                 }
                 catch (Exception ex)
                 {
-                    _logger.LogError(ex, "Failed to load live sports events");
+                    _logger.LogWarning(ex, "Error fetching videos for show {ShowId} in category {TopicId}", show.Id, topicId);
                 }
             }
 
-            // Category folder - show videos for this category
-            else if (query.FolderId?.StartsWith("category_", StringComparison.Ordinal) == true)
-            {
-                if (_categoryService == null)
-                {
-                    _logger.LogWarning("CategoryService not available - cannot display category folder");
-                }
-                else
-                {
-                    try
-                    {
-                        var topicId = query.FolderId.Substring("category_".Length);
-                        var businessUnit = config?.BusinessUnit.ToString().ToLowerInvariant() ?? "srf";
-
-                        var shows = await _categoryService.GetShowsByTopicAsync(topicId, businessUnit, 20, cancellationToken).ConfigureAwait(false);
-                        var urns = new List<string>();
-
-                        using var apiClient = new Api.SRFApiClient(_loggerFactory);
-
-                        foreach (var show in shows)
-                        {
-                            if (show.Id == null)
-                            {
-                                continue;
-                            }
-
-                            try
-                            {
-                                var videos = await apiClient.GetVideosForShowAsync(businessUnit, show.Id, cancellationToken).ConfigureAwait(false);
-                                if (videos != null && videos.Count > 0)
-                                {
-                                    _logger.LogDebug("Category {TopicId}, Show {Show} ({ShowId}): Found {Count} videos", topicId, show.Title, show.Id, videos.Count);
-
-                                    // Filter to videos that are actually published and not expired
-                                    var now = DateTime.UtcNow;
-                                    var availableVideos = videos.Where(v =>
-                                        (v.ValidFrom == null || v.ValidFrom.Value.ToUniversalTime() <= now) &&
-                                        (v.ValidTo == null || v.ValidTo.Value.ToUniversalTime() > now)).ToList();
-
-                                    _logger.LogDebug("Category {TopicId}, Show {Show}: {AvailableCount} available out of {TotalCount} videos", topicId, show.Title, availableVideos.Count, videos.Count);
-
-                                    if (availableVideos.Count > 0)
-                                    {
-                                        // Get most recent available video from this show
-                                        var latestVideo = availableVideos.OrderByDescending(v => v.Date).FirstOrDefault();
-                                        if (latestVideo?.Urn != null)
-                                        {
-                                            urns.Add(latestVideo.Urn);
-                                            _logger.LogInformation(
-                                                "Category {TopicId}: Added video from show {Show}: {Title} (URN: {Urn}, Date: {Date}, ValidFrom: {ValidFrom}, ValidTo: {ValidTo})",
-                                                topicId,
-                                                show.Title,
-                                                latestVideo.Title,
-                                                latestVideo.Urn,
-                                                latestVideo.Date,
-                                                latestVideo.ValidFrom,
-                                                latestVideo.ValidTo);
-                                        }
-                                        else
-                                        {
-                                            _logger.LogWarning("Category {TopicId}, Show {Show}: Latest available video has null URN", topicId, show.Title);
-                                        }
-                                    }
-                                    else
-                                    {
-                                        _logger.LogDebug("Category {TopicId}, Show {Show}: No available videos (all expired or not yet published)", topicId, show.Title);
-                                    }
-                                }
-                                else
-                                {
-                                    _logger.LogDebug("Category {TopicId}, Show {Show} ({ShowId}): No videos returned from API", topicId, show.Title, show.Id);
-                                }
-                            }
-                            catch (Exception ex)
-                            {
-                                _logger.LogWarning(ex, "Error fetching videos for show {ShowId} in category {TopicId}", show.Id, topicId);
-                            }
-
-                            if (cancellationToken.IsCancellationRequested)
-                            {
-                                break;
-                            }
-                        }
-
-                        items = await ConvertUrnsToChannelItems(urns, cancellationToken).ConfigureAwait(false);
-                        _logger.LogInformation("Found {Count} videos for category {TopicId}", items.Count, topicId);
-                    }
-                    catch (Exception ex)
-                    {
-                        _logger.LogError(ex, "Failed to load category videos");
-                    }
-                }
-            }
-
-            _logger.LogInformation("Returning {Count} channel items for folder {FolderId}", items.Count, query.FolderId);
+            items = await ConvertUrnsToChannelItems(urns, cancellationToken).ConfigureAwait(false);
+            _logger.LogInformation("Found {Count} videos for category {TopicId}", items.Count, topicId);
         }
         catch (Exception ex)
         {
-            _logger.LogError(ex, "Error getting channel items for folder {FolderId}", query.FolderId);
+            _logger.LogError(ex, "Failed to load category videos");
         }
 
-        return new ChannelItemResult
+        return items;
+    }
+
+    private async Task<string?> GetLatestVideoUrnForShowAsync(
+        Api.SRFApiClient apiClient,
+        string businessUnit,
+        Api.Models.PlayV3Show show,
+        string topicId,
+        CancellationToken cancellationToken)
+    {
+        var videos = await apiClient.GetVideosForShowAsync(businessUnit, show.Id!, cancellationToken).ConfigureAwait(false);
+        if (videos == null || videos.Count == 0)
         {
-            Items = items,
-            TotalRecordCount = items.Count
-        };
+            _logger.LogDebug("Category {TopicId}, Show {Show} ({ShowId}): No videos returned from API", topicId, show.Title, show.Id);
+            return null;
+        }
+
+        _logger.LogDebug("Category {TopicId}, Show {Show} ({ShowId}): Found {Count} videos", topicId, show.Title, show.Id, videos.Count);
+
+        // Filter to available videos
+        var now = DateTime.UtcNow;
+        var availableVideos = videos.Where(v =>
+            (v.ValidFrom == null || v.ValidFrom.Value.ToUniversalTime() <= now) &&
+            (v.ValidTo == null || v.ValidTo.Value.ToUniversalTime() > now)).ToList();
+
+        _logger.LogDebug("Category {TopicId}, Show {Show}: {AvailableCount} available out of {TotalCount} videos", topicId, show.Title, availableVideos.Count, videos.Count);
+
+        if (availableVideos.Count == 0)
+        {
+            _logger.LogDebug("Category {TopicId}, Show {Show}: No available videos (all expired or not yet published)", topicId, show.Title);
+            return null;
+        }
+
+        var latestVideo = availableVideos.OrderByDescending(v => v.Date).FirstOrDefault();
+        if (latestVideo?.Urn == null)
+        {
+            _logger.LogWarning("Category {TopicId}, Show {Show}: Latest available video has null URN", topicId, show.Title);
+            return null;
+        }
+
+        _logger.LogInformation(
+            "Category {TopicId}: Added video from show {Show}: {Title} (URN: {Urn}, Date: {Date})",
+            topicId,
+            show.Title,
+            latestVideo.Title,
+            latestVideo.Urn,
+            latestVideo.Date);
+
+        return latestVideo.Urn;
     }
 
     /// <inheritdoc />
@@ -374,8 +402,14 @@ public class SRFPlayChannel : IChannel, IHasCacheKey
         var enabledTopics = config?.EnabledTopics != null && config.EnabledTopics.Count > 0
             ? string.Join(",", config.EnabledTopics)
             : "all";
-        var date = DateTime.Now.ToString("yyyy-MM-dd", CultureInfo.InvariantCulture);
-        return $"{config?.BusinessUnit}_{config?.EnableLatestContent}_{config?.EnableTrendingContent}_{config?.EnableCategoryFolders}_{enabledTopics}_{date}";
+
+        // Use 15-minute time buckets for cache key so live content refreshes frequently
+        // This ensures livestream folders update as programs start/end throughout the day
+        var now = DateTime.Now;
+        var timeBucket = new DateTime(now.Year, now.Month, now.Day, now.Hour, (now.Minute / 15) * 15, 0);
+        var timeKey = timeBucket.ToString("yyyy-MM-dd-HH-mm", CultureInfo.InvariantCulture);
+
+        return $"{config?.BusinessUnit}_{config?.EnableLatestContent}_{config?.EnableTrendingContent}_{config?.EnableCategoryFolders}_{enabledTopics}_{timeKey}";
     }
 
     private async Task<List<ChannelItemInfo>> ConvertUrnsToChannelItems(List<string> urns, CancellationToken cancellationToken)
@@ -391,7 +425,7 @@ public class SRFPlayChannel : IChannel, IHasCacheKey
 
         _logger.LogInformation("Converting {Count} URNs to channel items", urns.Count);
 
-        using var apiClient = new Api.SRFApiClient(_loggerFactory);
+        using var apiClient = _apiClientFactory.CreateClient();
         int successCount = 0;
         int failedCount = 0;
         int expiredCount = 0;
@@ -430,54 +464,77 @@ public class SRFPlayChannel : IChannel, IHasCacheKey
                 }
 
                 // Generate deterministic GUID from URN
-                var itemId = UrnToGuid(urn);
+                var itemId = UrnHelper.ToGuid(urn);
 
-                // Get stream URL and authenticate it
-                var streamUrl = _streamResolver.GetStreamUrl(chapter, config.QualityPreference);
+                // Use factory to create MediaSourceInfo (handles stream URL, auth, proxy registration)
+                var mediaSource = await _mediaSourceFactory.CreateMediaSourceAsync(
+                    chapter,
+                    itemId,
+                    urn,
+                    config.QualityPreference,
+                    cancellationToken).ConfigureAwait(false);
 
-                // For scheduled livestreams that haven't started, streamUrl might be null
-                var isUpcomingLivestream = chapter.Type == "SCHEDULED_LIVESTREAM" && string.IsNullOrEmpty(streamUrl);
-
-                if (!string.IsNullOrEmpty(streamUrl))
+                // Skip items without a valid media source (no stream URL available)
+                if (mediaSource == null)
                 {
-                    // Authenticate the stream URL (required for all SRF streams, especially livestreams)
-                    streamUrl = await _streamResolver.GetAuthenticatedStreamUrlAsync(streamUrl, cancellationToken).ConfigureAwait(false);
-                }
-                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);
+                    if (chapter.Type == "SCHEDULED_LIVESTREAM")
+                    {
+                        _logger.LogDebug(
+                            "URN {Urn}: Skipping upcoming livestream '{Title}' - stream not yet available (starts at {ValidFrom})",
+                            urn,
+                            chapter.Title,
+                            chapter.ValidFrom);
+                    }
+                    else
+                    {
+                        _logger.LogWarning(
+                            "URN {Urn}: Skipping '{Title}' - no valid stream URL available",
+                            urn,
+                            chapter.Title);
+                        noStreamCount++;
+                    }
+
+                    continue;
                 }
 
-                // Build overview with event time for upcoming livestreams
+                // Build overview
                 var overview = chapter.Description ?? chapter.Lead;
-                if (isUpcomingLivestream && chapter.ValidFrom != null)
+
+                // Determine image URL based on configuration
+                string? imageUrl;
+                var generateTitleCards = config.GenerateTitleCards;
+
+                if (generateTitleCards)
                 {
-                    var eventStart = chapter.ValidFrom.Value.ToString("dd.MM.yyyy HH:mm", CultureInfo.InvariantCulture);
-                    overview = $"[Upcoming Event - Starts at {eventStart}]\n\n{overview}";
+                    // Generate title card with content name
+                    _logger.LogDebug("URN {Urn}: Generating title card for '{Title}'", urn, chapter.Title);
+                    imageUrl = CreatePlaceholderImageUrl(chapter.Title ?? "SRF Play", _mediaSourceFactory.GetServerBaseUrl());
+                }
+                else
+                {
+                    // Use SRF-provided images - prefer chapter image, fall back to show image
+                    var originalImageUrl = chapter.ImageUrl;
+                    if (string.IsNullOrEmpty(originalImageUrl) && mediaComposition.Show != null)
+                    {
+                        originalImageUrl = mediaComposition.Show.ImageUrl;
+                        _logger.LogDebug("URN {Urn}: Using show image as fallback", urn);
+                    }
+
+                    if (string.IsNullOrEmpty(originalImageUrl))
+                    {
+                        _logger.LogDebug("URN {Urn}: No image URL available for '{Title}', using placeholder", urn, chapter.Title);
+                        imageUrl = CreatePlaceholderImageUrl(chapter.Title ?? "SRF Play", _mediaSourceFactory.GetServerBaseUrl());
+                    }
+                    else
+                    {
+                        imageUrl = CreateProxiedImageUrl(originalImageUrl, _mediaSourceFactory.GetServerBaseUrl());
+                    }
                 }
 
-                // Get image URL - prefer chapter image, fall back to show image if available
-                var imageUrl = chapter.ImageUrl;
-                if (string.IsNullOrEmpty(imageUrl) && mediaComposition.Show != null)
-                {
-                    imageUrl = mediaComposition.Show.ImageUrl;
-                    _logger.LogDebug("URN {Urn}: Using show image as fallback", urn);
-                }
-
-                if (string.IsNullOrEmpty(imageUrl))
-                {
-                    _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
-                var premiereDate = isUpcomingLivestream ? chapter.ValidFrom?.ToUniversalTime() : chapter.Date?.ToUniversalTime();
+                // Use ValidFrom for premiere date if this is a scheduled livestream, otherwise use Date
+                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,
@@ -495,23 +552,7 @@ public class SRFPlayChannel : IChannel, IHasCacheKey
                     {
                         { "SRF", urn }
                     },
-                    MediaSources = new List<MediaSourceInfo>
-                    {
-                        new MediaSourceInfo
-                        {
-                            Id = itemId,
-                            Name = chapter.Title,
-                            Path = streamUrl,
-                            Protocol = MediaBrowser.Model.MediaInfo.MediaProtocol.Http,
-                            Container = "m3u8",
-                            SupportsDirectStream = true,
-                            SupportsDirectPlay = true,
-                            SupportsTranscoding = true,
-                            IsRemote = true,
-                            Type = MediaBrowser.Model.Dto.MediaSourceType.Default,
-                            VideoType = VideoType.VideoFile
-                        }
-                    }
+                    MediaSources = new List<MediaSourceInfo> { mediaSource }
                 };
 
                 // Add series info if available
@@ -523,6 +564,11 @@ public class SRFPlayChannel : IChannel, IHasCacheKey
                 items.Add(item);
                 successCount++;
                 _logger.LogInformation("URN {Urn}: Successfully converted to channel item - {Title}", urn, chapter.Title);
+                _logger.LogDebug(
+                    "URN {Urn}: MediaSource created via factory - DirectPlay={DirectPlay}, Transcoding={Transcoding}",
+                    urn,
+                    mediaSource.SupportsDirectPlay,
+                    mediaSource.SupportsTranscoding);
             }
             catch (Exception ex)
             {
@@ -542,23 +588,34 @@ public class SRFPlayChannel : IChannel, IHasCacheKey
     }
 
     /// <summary>
-    /// Generates a deterministic GUID from a URN.
-    /// This ensures the same URN always produces the same GUID.
-    /// MD5 is used for non-cryptographic purposes only (generating IDs).
+    /// Creates a proxy URL for an image to fix Content-Type headers from SRF CDN.
     /// </summary>
-    /// <param name="urn">The URN to convert.</param>
-    /// <returns>A deterministic GUID.</returns>
-#pragma warning disable CA5351 // MD5 is used for non-cryptographic purposes (ID generation)
-    private static string UrnToGuid(string urn)
+    /// <param name="originalUrl">The original SRF image URL.</param>
+    /// <param name="serverUrl">The server base URL.</param>
+    /// <returns>The proxied image URL, or null if original is null.</returns>
+    private static string? CreateProxiedImageUrl(string? originalUrl, string serverUrl)
     {
-        // Use MD5 to generate a deterministic hash from the URN
-        var hash = MD5.HashData(Encoding.UTF8.GetBytes(urn));
+        if (string.IsNullOrEmpty(originalUrl))
+        {
+            return null;
+        }
 
-        // Convert the first 16 bytes to a GUID
-        var guid = new Guid(hash);
-        return guid.ToString();
+        // Encode the original URL as base64 for safe transport
+        var encodedUrl = Convert.ToBase64String(Encoding.UTF8.GetBytes(originalUrl));
+        return $"{serverUrl}/Plugins/SRFPlay/Proxy/Image?url={encodedUrl}";
+    }
+
+    /// <summary>
+    /// Creates a placeholder image URL with the given text.
+    /// </summary>
+    /// <param name="text">The text to display on the placeholder.</param>
+    /// <param name="serverUrl">The server base URL.</param>
+    /// <returns>The placeholder image URL.</returns>
+    private static string CreatePlaceholderImageUrl(string text, string serverUrl)
+    {
+        var encodedText = Convert.ToBase64String(Encoding.UTF8.GetBytes(text));
+        return $"{serverUrl}/Plugins/SRFPlay/Proxy/Placeholder?text={encodedText}";
     }
-#pragma warning restore CA5351
 
     /// <inheritdoc />
     public bool IsEnabledFor(string userId)

Jellyfin.Plugin.SRFPlay/Configuration/PluginConfiguration.cs

@@ -74,6 +74,7 @@ public class PluginConfiguration : BasePluginConfiguration
         EnableTrendingContent = true;
         EnableCategoryFolders = true;
         EnabledTopics = new System.Collections.Generic.List<string>();
+        GenerateTitleCards = true;
     }
 
     /// <summary>
@@ -142,4 +143,17 @@ public class PluginConfiguration : BasePluginConfiguration
     [System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2227:Collection properties should be read only", Justification = "Required for configuration serialization")]
     [System.Diagnostics.CodeAnalysis.SuppressMessage("Design", "CA1002:Do not expose generic lists", Justification = "Configuration DTO")]
     public System.Collections.Generic.List<string> EnabledTopics { get; set; }
+
+    /// <summary>
+    /// Gets or sets the public/external server URL for remote clients (e.g., https://jellyfin.example.com:8920).
+    /// If not set, the plugin will use Jellyfin's GetSmartApiUrl() which may return local addresses.
+    /// This is important for Android and other remote clients to access streams.
+    /// </summary>
+    public string PublicServerUrl { get; set; } = string.Empty;
+
+    /// <summary>
+    /// Gets or sets a value indicating whether to generate title card images with the content title.
+    /// When enabled, generates custom thumbnails instead of using SRF-provided images.
+    /// </summary>
+    public bool GenerateTitleCards { get; set; }
 }

Jellyfin.Plugin.SRFPlay/Configuration/configPage.html

@@ -58,6 +58,13 @@
                         </label>
                         <div class="fieldDescription">Automatically discover and add trending videos</div>
                     </div>
+                    <div class="checkboxContainer checkboxContainer-withDescription">
+                        <label class="emby-checkbox-label">
+                            <input id="GenerateTitleCards" name="GenerateTitleCards" type="checkbox" is="emby-checkbox" />
+                            <span>Generate Title Cards</span>
+                        </label>
+                        <div class="fieldDescription">Generate custom thumbnails with the content title instead of using SRF-provided images</div>
+                    </div>
                     <br />
                     <h2>Proxy Settings</h2>
                     <div class="checkboxContainer checkboxContainer-withDescription">
@@ -82,6 +89,17 @@
                         <input id="ProxyPassword" name="ProxyPassword" type="password" is="emby-input" autocomplete="off" />
                         <div class="fieldDescription">Password for proxy authentication (leave empty if not required)</div>
                     </div>
+                    <br />
+                    <h2>Network Settings</h2>
+                    <div class="inputContainer">
+                        <label class="inputLabel inputLabelUnfocused" for="PublicServerUrl">Public Server URL (Optional)</label>
+                        <input id="PublicServerUrl" name="PublicServerUrl" type="text" is="emby-input" placeholder="e.g., https://jellyfin.example.com:8920" />
+                        <div class="fieldDescription">
+                            The public/external URL for remote clients (Android, iOS, etc.) to access streaming proxy.
+                            <br />If not set, the plugin will use Jellyfin's automatic URL detection which may return local addresses.
+                            <br /><strong>Important for Android/remote playback!</strong>
+                        </div>
+                    </div>
                     <div>
                         <button is="emby-button" type="submit" class="raised button-submit block emby-button">
                             <span>Save</span>
@@ -106,10 +124,12 @@
                         document.querySelector('#CacheDurationMinutes').value = config.CacheDurationMinutes;
                         document.querySelector('#EnableLatestContent').checked = config.EnableLatestContent;
                         document.querySelector('#EnableTrendingContent').checked = config.EnableTrendingContent;
+                        document.querySelector('#GenerateTitleCards').checked = config.GenerateTitleCards !== false;
                         document.querySelector('#UseProxy').checked = config.UseProxy || false;
                         document.querySelector('#ProxyAddress').value = config.ProxyAddress || '';
                         document.querySelector('#ProxyUsername').value = config.ProxyUsername || '';
                         document.querySelector('#ProxyPassword').value = config.ProxyPassword || '';
+                        document.querySelector('#PublicServerUrl').value = config.PublicServerUrl || '';
                         Dashboard.hideLoadingMsg();
                     });
                 });
@@ -125,10 +145,12 @@
                     config.CacheDurationMinutes = parseInt(document.querySelector('#CacheDurationMinutes').value);
                     config.EnableLatestContent = document.querySelector('#EnableLatestContent').checked;
                     config.EnableTrendingContent = document.querySelector('#EnableTrendingContent').checked;
+                    config.GenerateTitleCards = document.querySelector('#GenerateTitleCards').checked;
                     config.UseProxy = document.querySelector('#UseProxy').checked;
                     config.ProxyAddress = document.querySelector('#ProxyAddress').value;
                     config.ProxyUsername = document.querySelector('#ProxyUsername').value;
                     config.ProxyPassword = document.querySelector('#ProxyPassword').value;
+                    config.PublicServerUrl = document.querySelector('#PublicServerUrl').value;
                     ApiClient.updatePluginConfiguration(SRFPlayConfig.pluginUniqueId, config).then(function (result) {
                         Dashboard.processPluginConfigurationUpdateResult(result);
                     });

Jellyfin.Plugin.SRFPlay/Constants/ApiEndpoints.cs

@@ -0,0 +1,73 @@
+namespace Jellyfin.Plugin.SRFPlay.Constants;
+
+/// <summary>
+/// Centralized API endpoints and URL templates used throughout the plugin.
+/// </summary>
+public static class ApiEndpoints
+{
+    /// <summary>
+    /// SRG SSR Integration Layer API base URL.
+    /// Used for fetching media compositions, video metadata, and stream URLs.
+    /// </summary>
+    public const string IntegrationLayerBaseUrl = "https://il.srgssr.ch/integrationlayer/2.0";
+
+    /// <summary>
+    /// Play V3 API URL template. Format: {0} = business unit (srf, rts, rsi, rtr, swi).
+    /// Used for fetching shows, topics, and latest content.
+    /// </summary>
+    public const string PlayV3BaseUrlTemplate = "https://www.{0}.ch/play/v3/api/{0}/production/";
+
+    /// <summary>
+    /// Akamai token authentication endpoint.
+    /// Used to get hdnts tokens for stream authentication.
+    /// </summary>
+    public const string AkamaiTokenEndpoint = "https://tp.srgssr.ch/akahd/token";
+
+    /// <summary>
+    /// SRF Play homepage URL.
+    /// </summary>
+    public const string SrfPlayHomepage = "https://www.srf.ch/play";
+
+    /// <summary>
+    /// Media composition endpoint template (relative to IntegrationLayerBaseUrl).
+    /// Format: {0} = URN.
+    /// </summary>
+    public const string MediaCompositionByUrnPath = "/mediaComposition/byUrn/{0}.json";
+
+    /// <summary>
+    /// Base proxy route for stream proxying (relative to server root).
+    /// </summary>
+    public const string ProxyBasePath = "/Plugins/SRFPlay/Proxy";
+
+    /// <summary>
+    /// HLS master manifest route template (relative to server root).
+    /// Format: {0} = item ID.
+    /// </summary>
+    public const string ProxyMasterManifestPath = "/Plugins/SRFPlay/Proxy/{0}/master.m3u8";
+
+    /// <summary>
+    /// Image proxy route template (relative to server root).
+    /// Format: {0} = base64-encoded original URL.
+    /// </summary>
+    public const string ImageProxyPath = "/Plugins/SRFPlay/Image/{0}";
+
+    /// <summary>
+    /// Play V3 shows endpoint (relative to PlayV3 base URL).
+    /// </summary>
+    public const string PlayV3ShowsPath = "shows";
+
+    /// <summary>
+    /// Play V3 topics endpoint (relative to PlayV3 base URL).
+    /// </summary>
+    public const string PlayV3TopicsPath = "topics";
+
+    /// <summary>
+    /// Play V3 livestreams endpoint (relative to PlayV3 base URL).
+    /// </summary>
+    public const string PlayV3LivestreamsPath = "livestreams";
+
+    /// <summary>
+    /// Play V3 scheduled livestreams endpoint (relative to PlayV3 base URL).
+    /// </summary>
+    public const string PlayV3ScheduledLivestreamsPath = "scheduled-livestreams";
+}

Jellyfin.Plugin.SRFPlay/Controllers/StreamProxyController.cs

@@ -0,0 +1,498 @@
+using System;
+using System.Globalization;
+using System.Net.Http;
+using System.Net.Http.Headers;
+using System.Threading;
+using System.Threading.Tasks;
+using Jellyfin.Plugin.SRFPlay.Services.Interfaces;
+using Jellyfin.Plugin.SRFPlay.Utilities;
+using MediaBrowser.Common.Net;
+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 IStreamProxyService _proxyService;
+    private readonly IHttpClientFactory _httpClientFactory;
+
+    /// <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>
+    /// <param name="httpClientFactory">The HTTP client factory.</param>
+    public StreamProxyController(
+        ILogger<StreamProxyController> logger,
+        IStreamProxyService proxyService,
+        IHttpClientFactory httpClientFactory)
+    {
+        _logger = logger;
+        _proxyService = proxyService;
+        _httpClientFactory = httpClientFactory;
+    }
+
+    /// <summary>
+    /// Adds CORS headers to allow cross-origin requests from hls.js in browsers.
+    /// </summary>
+    private void AddCorsHeaders()
+    {
+        Response.Headers["Access-Control-Allow-Origin"] = "*";
+        Response.Headers["Access-Control-Allow-Methods"] = "GET, HEAD, OPTIONS";
+        Response.Headers["Access-Control-Allow-Headers"] = "Content-Type, Range, Accept, Origin";
+        Response.Headers["Access-Control-Expose-Headers"] = "Content-Length, Content-Range, Accept-Ranges";
+        Response.Headers["Access-Control-Max-Age"] = "86400"; // Cache preflight for 24 hours
+    }
+
+    /// <summary>
+    /// Adds Cache-Control headers appropriate for the stream type.
+    /// Livestreams need frequent manifest refresh, VOD can be cached longer.
+    /// </summary>
+    /// <param name="itemId">The item ID to check.</param>
+    private void AddManifestCacheHeaders(string itemId)
+    {
+        var metadata = _proxyService.GetStreamMetadata(itemId);
+        var isLiveStream = metadata?.IsLiveStream ?? false;
+
+        if (isLiveStream)
+        {
+            // Livestreams need frequent manifest refresh (segments rotate every ~6-10s)
+            Response.Headers["Cache-Control"] = "max-age=2, must-revalidate";
+            _logger.LogDebug("Setting livestream cache headers for {ItemId}", itemId);
+        }
+        else
+        {
+            // VOD manifests are static, can cache longer
+            Response.Headers["Cache-Control"] = "max-age=3600";
+        }
+    }
+
+    /// <summary>
+    /// Handles CORS preflight OPTIONS requests for all proxy endpoints.
+    /// </summary>
+    /// <returns>Empty response with CORS headers.</returns>
+    [HttpOptions("{itemId}/master.m3u8")]
+    [HttpOptions("{itemId}/{manifestPath}.m3u8")]
+    [HttpOptions("{itemId}/{*segmentPath}")]
+    [AllowAnonymous]
+    public IActionResult HandleOptions()
+    {
+        AddCorsHeaders();
+        return Ok();
+    }
+
+    /// <summary>
+    /// Proxies HLS master manifest requests.
+    /// </summary>
+    /// <param name="itemId">The item ID from URL path.</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)
+    {
+        AddCorsHeaders();
+        _logger.LogInformation("Proxy request for master manifest - Path ItemId: {PathItemId}, Query params: {QueryString}", itemId, Request.QueryString);
+
+        // Try to resolve the actual item ID (path ID might be a session ID during transcoding)
+        var actualItemId = ResolveItemId(itemId);
+
+        try
+        {
+            // Get the correct scheme (https if configured, otherwise use request scheme)
+            var scheme = GetProxyScheme();
+
+            // Build the base proxy URL for this item
+            // Preserve query parameters (token or itemId) from the original request
+            string baseProxyUrl;
+            if (Request.Query.TryGetValue("token", out var token) && !string.IsNullOrEmpty(token))
+            {
+                baseProxyUrl = $"{scheme}://{Request.Host}/Plugins/SRFPlay/Proxy/{itemId}?token={token}";
+                _logger.LogDebug("Using token-based proxy URL with token: {Token}", token.ToString());
+            }
+            else if (actualItemId != itemId)
+            {
+                // Legacy: If path ID differs from resolved ID, add itemId query parameter
+                baseProxyUrl = $"{scheme}://{Request.Host}/Plugins/SRFPlay/Proxy/{itemId}?itemId={actualItemId}";
+                _logger.LogInformation("Path itemId {PathId} differs from resolved itemId {ResolvedId}, adding query parameter", itemId, actualItemId);
+            }
+            else
+            {
+                // Simple case: no query parameters needed
+                baseProxyUrl = $"{scheme}://{Request.Host}/Plugins/SRFPlay/Proxy/{itemId}";
+                _logger.LogDebug("Path itemId matches resolved itemId: {ItemId}", itemId);
+            }
+
+            var manifestContent = await _proxyService.GetRewrittenManifestAsync(actualItemId, baseProxyUrl, cancellationToken).ConfigureAwait(false);
+
+            if (manifestContent == null)
+            {
+                _logger.LogWarning("Manifest not found for path itemId {PathItemId}, resolved itemId {ResolvedItemId} - stream may not be registered", itemId, actualItemId);
+                return NotFound();
+            }
+
+            // Set cache headers based on stream type (live vs VOD)
+            AddManifestCacheHeaders(actualItemId);
+
+            _logger.LogDebug("Returning master manifest for item {ItemId} ({Length} bytes)", itemId, manifestContent.Length);
+            return Content(manifestContent, "application/vnd.apple.mpegurl; charset=utf-8");
+        }
+        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)
+    {
+        AddCorsHeaders();
+        var fullPath = $"{manifestPath}.m3u8";
+        _logger.LogInformation("Proxy request for variant manifest - ItemId: {ItemId}, Path: {Path}", itemId, fullPath);
+
+        // Try to resolve the actual item ID
+        var actualItemId = ResolveItemId(itemId);
+
+        try
+        {
+            // Fetch the variant manifest as a segment
+            var manifestData = await _proxyService.GetSegmentAsync(actualItemId, 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 scheme = GetProxyScheme();
+            var baseProxyUrl = $"{scheme}://{Request.Host}/Plugins/SRFPlay/Proxy/{itemId}";
+            var rewrittenContent = RewriteSegmentUrls(manifestContent, baseProxyUrl);
+
+            // Set cache headers based on stream type (live vs VOD)
+            AddManifestCacheHeaders(actualItemId);
+
+            _logger.LogDebug("Returning variant manifest for item {ItemId} ({Length} bytes)", itemId, rewrittenContent.Length);
+            return Content(rewrittenContent, "application/vnd.apple.mpegurl; charset=utf-8");
+        }
+        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)
+    {
+        AddCorsHeaders();
+        _logger.LogDebug("Proxy request for segment - ItemId: {ItemId}, Path: {SegmentPath}", itemId, segmentPath);
+
+        // Try to resolve the actual item ID
+        var actualItemId = ResolveItemId(itemId);
+
+        try
+        {
+            var segmentData = await _proxyService.GetSegmentAsync(actualItemId, 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 = MimeTypeHelper.GetSegmentContentType(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>
+    /// Gets the correct scheme for proxy URLs (https if public URL is configured with https).
+    /// </summary>
+    /// <returns>The scheme to use (http or https).</returns>
+    private string GetProxyScheme()
+    {
+        // Check if PublicServerUrl is configured and uses HTTPS
+        var config = Plugin.Instance?.Configuration;
+        if (config != null && !string.IsNullOrWhiteSpace(config.PublicServerUrl))
+        {
+            if (config.PublicServerUrl.StartsWith("https://", StringComparison.OrdinalIgnoreCase))
+            {
+                return "https";
+            }
+        }
+
+        // Fall back to request scheme, but prefer https if forwarded headers indicate it
+        if (Request.Headers.TryGetValue("X-Forwarded-Proto", out var forwardedProto))
+        {
+            return forwardedProto.ToString().ToLowerInvariant();
+        }
+
+        return Request.Scheme;
+    }
+
+    /// <summary>
+    /// Resolves the actual item ID from the request.
+    /// </summary>
+    /// <param name="pathItemId">The item ID from the URL path.</param>
+    /// <returns>The resolved item ID.</returns>
+    private string ResolveItemId(string pathItemId)
+    {
+        // Check for token parameter first (preferred method)
+        if (Request.Query.TryGetValue("token", out var token) && !string.IsNullOrEmpty(token))
+        {
+            // Try to resolve the original item ID from the token via the proxy service
+            // We'll need to add a method to StreamProxyService to look up by token
+            _logger.LogInformation("Found token parameter: {Token}, will use path ID {PathItemId} for lookup", token.ToString(), pathItemId);
+            return pathItemId; // Use path ID for now; token prevents Jellyfin from rewriting the URL
+        }
+
+        // Check if there's an itemId query parameter (legacy fallback)
+        if (Request.Query.TryGetValue("itemId", out var queryItemId) && !string.IsNullOrEmpty(queryItemId))
+        {
+            _logger.LogInformation("Using itemId from query parameter: {QueryItemId} (path had: {PathItemId})", queryItemId.ToString(), pathItemId);
+            return queryItemId.ToString();
+        }
+
+        // No query parameters - use path ID as-is (normal case for segments and transcoding sessions)
+        _logger.LogDebug("No query parameters, using path ID as-is: {PathItemId}", pathItemId);
+        return pathItemId;
+    }
+
+    /// <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)
+    {
+        // Extract query parameters from the current request to propagate them
+        string queryParams;
+        if (Request.Query.TryGetValue("token", out var token) && !string.IsNullOrEmpty(token))
+        {
+            queryParams = $"?token={token}";
+        }
+        else if (Request.Query.TryGetValue("itemId", out var itemId) && !string.IsNullOrEmpty(itemId))
+        {
+            queryParams = $"?itemId={itemId}";
+        }
+        else
+        {
+            queryParams = string.Empty;
+        }
+
+        // Helper function to rewrite a single URL
+        string RewriteUrl(string url)
+        {
+            if (url.Contains("://", StringComparison.Ordinal))
+            {
+                // Absolute URL - extract filename and rewrite
+                var uri = new Uri(url.Trim());
+                var segments = uri.AbsolutePath.Split('/');
+                var fileName = segments[^1];
+                return $"{baseProxyUrl}/{fileName}{queryParams}";
+            }
+
+            // Relative URL - rewrite to proxy
+            return $"{baseProxyUrl}/{url.Trim()}{queryParams}";
+        }
+
+        var lines = manifestContent.Split('\n');
+        var result = new System.Text.StringBuilder();
+
+        foreach (var line in lines)
+        {
+            if (string.IsNullOrWhiteSpace(line))
+            {
+                result.AppendLine(line);
+            }
+            else if (line.StartsWith('#'))
+            {
+                // HLS tag line - check for URI="..." attributes (e.g., #EXT-X-MAP:URI="init.mp4")
+                if (line.Contains("URI=\"", StringComparison.Ordinal))
+                {
+                    var rewrittenLine = System.Text.RegularExpressions.Regex.Replace(
+                        line,
+                        @"URI=""([^""]+)""",
+                        match => $"URI=\"{RewriteUrl(match.Groups[1].Value)}\"");
+                    result.AppendLine(rewrittenLine);
+                }
+                else
+                {
+                    // Keep other metadata lines as-is
+                    result.AppendLine(line);
+                }
+            }
+            else
+            {
+                // Non-tag line with URL - rewrite it
+                result.AppendLine(RewriteUrl(line));
+            }
+        }
+
+        return result.ToString();
+    }
+
+    /// <summary>
+    /// Proxies image requests from SRF CDN, fixing Content-Type headers.
+    /// </summary>
+    /// <param name="url">The original image URL (base64 encoded).</param>
+    /// <param name="cancellationToken">Cancellation token.</param>
+    /// <returns>The image data with correct Content-Type.</returns>
+    [HttpGet("Image")]
+    [AllowAnonymous]
+    [ProducesResponseType(StatusCodes.Status200OK)]
+    [ProducesResponseType(StatusCodes.Status400BadRequest)]
+    [ProducesResponseType(StatusCodes.Status404NotFound)]
+    public async Task<IActionResult> GetImage(
+        [FromQuery] string url,
+        CancellationToken cancellationToken)
+    {
+        if (string.IsNullOrEmpty(url))
+        {
+            return BadRequest("URL parameter is required");
+        }
+
+        string decodedUrl;
+        try
+        {
+            // Decode base64 URL
+            var bytes = Convert.FromBase64String(url);
+            decodedUrl = System.Text.Encoding.UTF8.GetString(bytes);
+        }
+        catch (FormatException)
+        {
+            _logger.LogWarning("Invalid base64 URL parameter: {Url}", url);
+            return BadRequest("Invalid URL encoding");
+        }
+
+        _logger.LogDebug("Proxying image from: {Url}", decodedUrl);
+
+        try
+        {
+            var httpClient = _httpClientFactory.CreateClient(NamedClient.Default);
+
+            // Create request with proper headers
+            var request = new HttpRequestMessage(HttpMethod.Get, new Uri(decodedUrl));
+            request.Headers.UserAgent.ParseAdd(
+                "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36");
+            request.Headers.Accept.ParseAdd("image/jpeg, image/png, image/webp, image/*;q=0.8");
+
+            var response = await httpClient.SendAsync(
+                request,
+                HttpCompletionOption.ResponseHeadersRead,
+                cancellationToken).ConfigureAwait(false);
+
+            if (!response.IsSuccessStatusCode)
+            {
+                _logger.LogWarning(
+                    "Image fetch failed with status {StatusCode} for {Url}",
+                    response.StatusCode,
+                    decodedUrl);
+                return NotFound();
+            }
+
+            var imageData = await response.Content.ReadAsByteArrayAsync(cancellationToken)
+                .ConfigureAwait(false);
+
+            // Determine correct content type
+            var contentType = MimeTypeHelper.GetImageContentType(decodedUrl);
+
+            _logger.LogDebug(
+                "Returning proxied image ({Length} bytes, {ContentType})",
+                imageData.Length,
+                contentType);
+
+            return File(imageData, contentType);
+        }
+        catch (HttpRequestException ex)
+        {
+            _logger.LogError(ex, "Error fetching image from {Url}", decodedUrl);
+            return StatusCode(StatusCodes.Status502BadGateway);
+        }
+    }
+
+    /// <summary>
+    /// Generates a placeholder image with the given text centered.
+    /// </summary>
+    /// <param name="text">The text to display (base64 encoded).</param>
+    /// <returns>A PNG image with the text centered.</returns>
+    [HttpGet("Placeholder")]
+    [AllowAnonymous]
+    [ProducesResponseType(StatusCodes.Status200OK)]
+    [ProducesResponseType(StatusCodes.Status400BadRequest)]
+    public IActionResult GetPlaceholder([FromQuery] string text)
+    {
+        if (string.IsNullOrEmpty(text))
+        {
+            return BadRequest("Text parameter is required");
+        }
+
+        string decodedText;
+        try
+        {
+            var bytes = Convert.FromBase64String(text);
+            decodedText = System.Text.Encoding.UTF8.GetString(bytes);
+        }
+        catch (FormatException)
+        {
+            _logger.LogWarning("Invalid base64 text parameter: {Text}", text);
+            return BadRequest("Invalid text encoding");
+        }
+
+        _logger.LogDebug("Generating placeholder image for: {Text}", decodedText);
+
+        var imageStream = PlaceholderImageGenerator.GeneratePlaceholder(decodedText);
+        return File(imageStream, "image/png");
+    }
+}

Jellyfin.Plugin.SRFPlay/Jellyfin.Plugin.SRFPlay.csproj

@@ -14,6 +14,7 @@
     <PackageReference Include="Jellyfin.Controller" Version="10.9.11" />
     <PackageReference Include="Jellyfin.Model" Version="10.9.11" />
     <PackageReference Include="Socks5" Version="1.1.0" />
+    <PackageReference Include="SkiaSharp" Version="2.88.8" />
   </ItemGroup>
 
   <ItemGroup>
@@ -27,4 +28,9 @@
     <EmbeddedResource Include="Configuration\configPage.html" />
   </ItemGroup>
 
+  <ItemGroup>
+    <None Remove="..\assests\main logo.png" />
+    <EmbeddedResource Include="..\assests\main logo.png" LogicalName="Jellyfin.Plugin.SRFPlay.Images.logo.png" />
+  </ItemGroup>
+
 </Project>

Jellyfin.Plugin.SRFPlay/Providers/SRFEpisodeProvider.cs

@@ -1,11 +1,9 @@
 using System;
 using System.Collections.Generic;
-using System.Linq;
 using System.Net.Http;
 using System.Threading;
 using System.Threading.Tasks;
-using Jellyfin.Plugin.SRFPlay.Api;
-using Jellyfin.Plugin.SRFPlay.Services;
+using Jellyfin.Plugin.SRFPlay.Services.Interfaces;
 using MediaBrowser.Controller.Entities.TV;
 using MediaBrowser.Controller.Providers;
 using MediaBrowser.Model.Entities;
@@ -20,25 +18,19 @@ namespace Jellyfin.Plugin.SRFPlay.Providers;
 public class SRFEpisodeProvider : IRemoteMetadataProvider<Episode, EpisodeInfo>
 {
     private readonly ILogger<SRFEpisodeProvider> _logger;
-    private readonly ILoggerFactory _loggerFactory;
-    private readonly IHttpClientFactory _httpClientFactory;
-    private readonly MetadataCache _metadataCache;
+    private readonly IMediaCompositionFetcher _compositionFetcher;
 
     /// <summary>
     /// Initializes a new instance of the <see cref="SRFEpisodeProvider"/> class.
     /// </summary>
-    /// <param name="loggerFactory">The logger factory.</param>
-    /// <param name="httpClientFactory">The HTTP client factory.</param>
-    /// <param name="metadataCache">The metadata cache.</param>
+    /// <param name="logger">The logger.</param>
+    /// <param name="compositionFetcher">The media composition fetcher.</param>
     public SRFEpisodeProvider(
-        ILoggerFactory loggerFactory,
-        IHttpClientFactory httpClientFactory,
-        MetadataCache metadataCache)
+        ILogger<SRFEpisodeProvider> logger,
+        IMediaCompositionFetcher compositionFetcher)
     {
-        _loggerFactory = loggerFactory;
-        _logger = loggerFactory.CreateLogger<SRFEpisodeProvider>();
-        _httpClientFactory = httpClientFactory;
-        _metadataCache = metadataCache;
+        _logger = logger;
+        _compositionFetcher = compositionFetcher;
     }
 
     /// <inheritdoc />
@@ -56,26 +48,7 @@ public class SRFEpisodeProvider : IRemoteMetadataProvider<Episode, EpisodeInfo>
             {
                 _logger.LogDebug("Searching for episode with URN: {Urn}", urn);
 
-                var config = Plugin.Instance?.Configuration;
-                if (config == null)
-                {
-                    return results;
-                }
-
-                // Try cache first
-                var mediaComposition = _metadataCache.GetMediaComposition(urn, config.CacheDurationMinutes);
-
-                // If not in cache, fetch from API
-                if (mediaComposition == null)
-                {
-                    using var apiClient = new SRFApiClient(_loggerFactory);
-                    mediaComposition = await apiClient.GetMediaCompositionByUrnAsync(urn, cancellationToken).ConfigureAwait(false);
-
-                    if (mediaComposition != null)
-                    {
-                        _metadataCache.SetMediaComposition(urn, mediaComposition);
-                    }
-                }
+                var mediaComposition = await _compositionFetcher.GetMediaCompositionAsync(urn, cancellationToken).ConfigureAwait(false);
 
                 if (mediaComposition?.ChapterList != null && mediaComposition.ChapterList.Count > 0)
                 {
@@ -118,26 +91,7 @@ public class SRFEpisodeProvider : IRemoteMetadataProvider<Episode, EpisodeInfo>
 
             _logger.LogDebug("Fetching metadata for episode URN: {Urn}", urn);
 
-            var config = Plugin.Instance?.Configuration;
-            if (config == null)
-            {
-                return result;
-            }
-
-            // Try cache first
-            var mediaComposition = _metadataCache.GetMediaComposition(urn, config.CacheDurationMinutes);
-
-            // If not in cache, fetch from API
-            if (mediaComposition == null)
-            {
-                using var apiClient = new SRFApiClient(_loggerFactory);
-                mediaComposition = await apiClient.GetMediaCompositionByUrnAsync(urn, cancellationToken).ConfigureAwait(false);
-
-                if (mediaComposition != null)
-                {
-                    _metadataCache.SetMediaComposition(urn, mediaComposition);
-                }
-            }
+            var mediaComposition = await _compositionFetcher.GetMediaCompositionAsync(urn, cancellationToken).ConfigureAwait(false);
 
             if (mediaComposition?.ChapterList == null || mediaComposition.ChapterList.Count == 0)
             {

Jellyfin.Plugin.SRFPlay/Providers/SRFImageProvider.cs

@@ -1,10 +1,11 @@
 using System;
 using System.Collections.Generic;
-using System.Linq;
 using System.Net.Http;
+using System.Net.Http.Headers;
 using System.Threading;
 using System.Threading.Tasks;
-using Jellyfin.Plugin.SRFPlay.Api;
+using Jellyfin.Plugin.SRFPlay.Services.Interfaces;
+using Jellyfin.Plugin.SRFPlay.Utilities;
 using MediaBrowser.Common.Net;
 using MediaBrowser.Controller.Entities;
 using MediaBrowser.Controller.Providers;
@@ -21,18 +22,22 @@ public class SRFImageProvider : IRemoteImageProvider, IHasOrder
 {
     private readonly IHttpClientFactory _httpClientFactory;
     private readonly ILogger<SRFImageProvider> _logger;
-    private readonly ILoggerFactory _loggerFactory;
+    private readonly IMediaCompositionFetcher _compositionFetcher;
 
     /// <summary>
     /// Initializes a new instance of the <see cref="SRFImageProvider"/> class.
     /// </summary>
     /// <param name="httpClientFactory">The HTTP client factory.</param>
     /// <param name="loggerFactory">The logger factory.</param>
-    public SRFImageProvider(IHttpClientFactory httpClientFactory, ILoggerFactory loggerFactory)
+    /// <param name="compositionFetcher">The media composition fetcher.</param>
+    public SRFImageProvider(
+        IHttpClientFactory httpClientFactory,
+        ILoggerFactory loggerFactory,
+        IMediaCompositionFetcher compositionFetcher)
     {
         _httpClientFactory = httpClientFactory;
-        _loggerFactory = loggerFactory;
         _logger = loggerFactory.CreateLogger<SRFImageProvider>();
+        _compositionFetcher = compositionFetcher;
     }
 
     /// <inheritdoc />
@@ -78,8 +83,7 @@ public class SRFImageProvider : IRemoteImageProvider, IHasOrder
             _logger.LogDebug("Fetching images for SRF URN: {Urn}", urn);
 
             // Fetch media composition to get image URLs
-            using var apiClient = new SRFApiClient(_loggerFactory);
-            var mediaComposition = await apiClient.GetMediaCompositionByUrnAsync(urn, cancellationToken).ConfigureAwait(false);
+            var mediaComposition = await _compositionFetcher.GetMediaCompositionAsync(urn, cancellationToken).ConfigureAwait(false);
 
             if (mediaComposition == null)
             {
@@ -151,9 +155,51 @@ public class SRFImageProvider : IRemoteImageProvider, IHasOrder
     }
 
     /// <inheritdoc />
-    public Task<HttpResponseMessage> GetImageResponse(string url, CancellationToken cancellationToken)
+    public async Task<HttpResponseMessage> GetImageResponse(string url, CancellationToken cancellationToken)
     {
+        _logger.LogDebug("Fetching image from URL: {Url}", url);
+
         var httpClient = _httpClientFactory.CreateClient(NamedClient.Default);
-        return httpClient.GetAsync(new Uri(url), cancellationToken);
+
+        // Create request with proper headers - SRF CDN requires User-Agent
+        var request = new HttpRequestMessage(HttpMethod.Get, new Uri(url));
+        request.Headers.UserAgent.ParseAdd("Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36");
+        request.Headers.Accept.ParseAdd("image/jpeg, image/png, image/webp, image/*;q=0.8");
+
+        var response = await httpClient.SendAsync(request, cancellationToken).ConfigureAwait(false);
+
+        var originalContentType = response.Content.Headers.ContentType?.MediaType;
+        _logger.LogDebug(
+            "Image response status: {StatusCode}, Content-Type: {ContentType}, Content-Length: {Length}",
+            response.StatusCode,
+            originalContentType ?? "null",
+            response.Content.Headers.ContentLength);
+
+        // Fix Content-Type if it's not a proper image type - SRF CDN often returns wrong content type
+        // Jellyfin needs correct Content-Type to process images
+        if (response.IsSuccessStatusCode)
+        {
+            var needsContentTypeFix = string.IsNullOrEmpty(originalContentType) ||
+                                      originalContentType == "binary/octet-stream" ||
+                                      originalContentType == "application/octet-stream" ||
+                                      !originalContentType.StartsWith("image/", StringComparison.OrdinalIgnoreCase);
+
+            if (needsContentTypeFix)
+            {
+                // Determine correct content type from URL extension or default to JPEG
+                var contentType = MimeTypeHelper.GetImageContentType(url);
+                if (!string.IsNullOrEmpty(contentType))
+                {
+                    _logger.LogInformation(
+                        "Fixing Content-Type from '{OriginalType}' to '{NewType}' for {Url}",
+                        originalContentType ?? "null",
+                        contentType,
+                        url);
+                    response.Content.Headers.ContentType = new MediaTypeHeaderValue(contentType);
+                }
+            }
+        }
+
+        return response;
     }
 }

Jellyfin.Plugin.SRFPlay/Providers/SRFMediaProvider.cs

@@ -1,15 +1,12 @@
 using System;
 using System.Collections.Generic;
-using System.Linq;
 using System.Threading;
 using System.Threading.Tasks;
-using Jellyfin.Plugin.SRFPlay.Api;
-using Jellyfin.Plugin.SRFPlay.Services;
+using Jellyfin.Plugin.SRFPlay.Configuration;
+using Jellyfin.Plugin.SRFPlay.Services.Interfaces;
 using MediaBrowser.Controller.Entities;
 using MediaBrowser.Controller.Library;
 using MediaBrowser.Model.Dto;
-using MediaBrowser.Model.Entities;
-using MediaBrowser.Model.MediaInfo;
 using Microsoft.Extensions.Logging;
 
 namespace Jellyfin.Plugin.SRFPlay.Providers;
@@ -20,25 +17,27 @@ namespace Jellyfin.Plugin.SRFPlay.Providers;
 public class SRFMediaProvider : IMediaSourceProvider
 {
     private readonly ILogger<SRFMediaProvider> _logger;
-    private readonly ILoggerFactory _loggerFactory;
-    private readonly MetadataCache _metadataCache;
-    private readonly StreamUrlResolver _streamResolver;
+    private readonly IMediaCompositionFetcher _compositionFetcher;
+    private readonly IStreamUrlResolver _streamResolver;
+    private readonly IMediaSourceFactory _mediaSourceFactory;
 
     /// <summary>
     /// Initializes a new instance of the <see cref="SRFMediaProvider"/> class.
     /// </summary>
     /// <param name="loggerFactory">The logger factory.</param>
-    /// <param name="metadataCache">The metadata cache.</param>
+    /// <param name="compositionFetcher">The media composition fetcher.</param>
     /// <param name="streamResolver">The stream URL resolver.</param>
+    /// <param name="mediaSourceFactory">The media source factory.</param>
     public SRFMediaProvider(
         ILoggerFactory loggerFactory,
-        MetadataCache metadataCache,
-        StreamUrlResolver streamResolver)
+        IMediaCompositionFetcher compositionFetcher,
+        IStreamUrlResolver streamResolver,
+        IMediaSourceFactory mediaSourceFactory)
     {
-        _loggerFactory = loggerFactory;
         _logger = loggerFactory.CreateLogger<SRFMediaProvider>();
-        _metadataCache = metadataCache;
+        _compositionFetcher = compositionFetcher;
         _streamResolver = streamResolver;
+        _mediaSourceFactory = mediaSourceFactory;
     }
 
     /// <summary>
@@ -52,7 +51,7 @@ 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>();
 
@@ -61,42 +60,20 @@ public class SRFMediaProvider : IMediaSourceProvider
             // Check if this is an SRF item
             if (!item.ProviderIds.TryGetValue("SRF", out var urn) || string.IsNullOrEmpty(urn))
             {
-                return Task.FromResult<IEnumerable<MediaSourceInfo>>(sources);
+                return sources;
             }
 
-            _logger.LogDebug("Getting media sources for URN: {Urn}", urn);
-
-            var config = Plugin.Instance?.Configuration;
-            if (config == null)
-            {
-                return Task.FromResult<IEnumerable<MediaSourceInfo>>(sources);
-            }
+            _logger.LogDebug("GetMediaSources for URN: {Urn}, Item: {ItemName}", urn, item.Name);
 
             // For scheduled livestreams, use shorter cache TTL (5 minutes) so they refresh when they go live
-            // For regular content, use configured cache duration
-            var cacheDuration = urn.Contains("scheduled_livestream", StringComparison.OrdinalIgnoreCase)
-                ? 5
-                : config.CacheDurationMinutes;
+            var cacheDuration = urn.Contains("scheduled_livestream", StringComparison.OrdinalIgnoreCase) ? 5 : (int?)null;
 
-            // Try cache first
-            var mediaComposition = _metadataCache.GetMediaComposition(urn, cacheDuration);
-
-            // If not in cache, fetch from API
-            if (mediaComposition == null)
-            {
-                using var apiClient = new SRFApiClient(_loggerFactory);
-                mediaComposition = apiClient.GetMediaCompositionByUrnAsync(urn, cancellationToken).GetAwaiter().GetResult();
-
-                if (mediaComposition != null)
-                {
-                    _metadataCache.SetMediaComposition(urn, mediaComposition);
-                }
-            }
+            var mediaComposition = await _compositionFetcher.GetMediaCompositionAsync(urn, cancellationToken, cacheDuration).ConfigureAwait(false);
 
             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,127 +83,77 @@ 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);
+            // Get quality preference from config
+            var config = Plugin.Instance?.Configuration;
+            var qualityPref = config?.QualityPreference ?? QualityPreference.HD;
 
-            // Check if this is an upcoming livestream that hasn't started yet
-            var isUpcomingLivestream = chapter.Type == "SCHEDULED_LIVESTREAM" && string.IsNullOrEmpty(streamUrl);
+            // Use item ID in hex format without dashes
+            var itemIdStr = item.Id.ToString("N");
 
-            if (string.IsNullOrEmpty(streamUrl) && !isUpcomingLivestream)
+            // Use factory to create MediaSourceInfo
+            var mediaSource = await _mediaSourceFactory.CreateMediaSourceAsync(
+                chapter,
+                itemIdStr,
+                urn,
+                qualityPref,
+                cancellationToken).ConfigureAwait(false);
+
+            // For scheduled livestreams, retry with fresh data if no stream URL
+            if (mediaSource == null && chapter.Type == "SCHEDULED_LIVESTREAM")
             {
-                _logger.LogWarning("Could not resolve stream URL for URN: {Urn}", urn);
-                return Task.FromResult<IEnumerable<MediaSourceInfo>>(sources);
-            }
+                _logger.LogDebug("URN {Urn}: Scheduled livestream has no stream URL, fetching fresh data", urn);
 
-            // 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();
+                // Force fresh fetch with short cache duration
+                var freshMediaComposition = await _compositionFetcher.GetMediaCompositionAsync(urn, cancellationToken, 1).ConfigureAwait(false);
 
                 if (freshMediaComposition?.ChapterList != null && freshMediaComposition.ChapterList.Count > 0)
                 {
                     var freshChapter = freshMediaComposition.ChapterList[0];
-                    streamUrl = _streamResolver.GetStreamUrl(freshChapter, config.QualityPreference);
+                    mediaSource = await _mediaSourceFactory.CreateMediaSourceAsync(
+                        freshChapter,
+                        itemIdStr,
+                        urn,
+                        qualityPref,
+                        cancellationToken).ConfigureAwait(false);
 
-                    if (!string.IsNullOrEmpty(streamUrl))
+                    if (mediaSource != null)
                     {
-                        // 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
-                    {
-                        _logger.LogWarning("URN {Urn}: Livestream should be live but still no stream URL available", urn);
-                        return Task.FromResult<IEnumerable<MediaSourceInfo>>(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))
+            if (mediaSource == null)
             {
-                streamUrl = _streamResolver.GetAuthenticatedStreamUrlAsync(streamUrl, cancellationToken).GetAwaiter().GetResult();
-                _logger.LogDebug("Authenticated stream URL for URN: {Urn}", urn);
+                _logger.LogWarning("Could not resolve stream URL for URN: {Urn}", urn);
+                return sources;
             }
 
-            // Create media source
-            var mediaSource = new MediaSourceInfo
-            {
-                Id = urn,
-                Name = chapter.Title,
-                Path = streamUrl,
-                Protocol = MediaProtocol.Http,
-                Container = "m3u8",
-                SupportsDirectStream = true,
-                SupportsDirectPlay = true,
-                SupportsTranscoding = true,
-                IsRemote = true,
-                Type = MediaSourceType.Default,
-                RunTimeTicks = chapter.Duration > 0 ? TimeSpan.FromMilliseconds(chapter.Duration).Ticks : null,
-                VideoType = VideoType.VideoFile,
-                IsInfiniteStream = false,
-                RequiresOpening = false,
-                RequiresClosing = false,
-                SupportsProbing = true
-            };
-
-            // Add video stream info
-            mediaSource.MediaStreams = new List<MediaStream>
-            {
-                new MediaStream
-                {
-                    Type = MediaStreamType.Video,
-                    Codec = "h264",
-                    IsInterlaced = false,
-                    IsDefault = true
-                }
-            };
-
             sources.Add(mediaSource);
-            _logger.LogInformation("Resolved stream URL for {Title}: {Url}", chapter.Title, streamUrl);
+            _logger.LogDebug(
+                "MediaSource created for {Title} - Id={Id}, DirectPlay={DirectPlay}, Transcoding={Transcoding}",
+                chapter.Title,
+                mediaSource.Id,
+                mediaSource.SupportsDirectPlay,
+                mediaSource.SupportsTranscoding);
         }
         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 +164,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,7 +172,8 @@ public class SRFMediaProvider : IMediaSourceProvider
     /// <inheritdoc />
     public Task<ILiveStream> OpenMediaSource(string openToken, List<ILiveStream> currentLiveStreams, CancellationToken cancellationToken)
     {
-        // Not needed for static HTTP streams
-        throw new NotImplementedException();
+        // Not used - RequiresOpening is false, proxy handles authentication directly
+        _logger.LogWarning("OpenMediaSource unexpectedly called with openToken: {OpenToken}", openToken);
+        throw new NotSupportedException("OpenMediaSource not supported - streams use direct proxy access");
     }
 }

Jellyfin.Plugin.SRFPlay/Providers/SRFSeriesProvider.cs

@@ -1,14 +1,11 @@
 using System;
 using System.Collections.Generic;
-using System.Linq;
 using System.Net.Http;
 using System.Threading;
 using System.Threading.Tasks;
-using Jellyfin.Plugin.SRFPlay.Api;
-using Jellyfin.Plugin.SRFPlay.Services;
+using Jellyfin.Plugin.SRFPlay.Services.Interfaces;
 using MediaBrowser.Controller.Entities.TV;
 using MediaBrowser.Controller.Providers;
-using MediaBrowser.Model.Entities;
 using MediaBrowser.Model.Providers;
 using Microsoft.Extensions.Logging;
 
@@ -20,27 +17,19 @@ namespace Jellyfin.Plugin.SRFPlay.Providers;
 public class SRFSeriesProvider : IRemoteMetadataProvider<Series, SeriesInfo>
 {
     private readonly ILogger<SRFSeriesProvider> _logger;
-    private readonly ILoggerFactory _loggerFactory;
-    private readonly IHttpClientFactory _httpClientFactory;
-    private readonly MetadataCache _metadataCache;
+    private readonly IMediaCompositionFetcher _compositionFetcher;
 
     /// <summary>
     /// Initializes a new instance of the <see cref="SRFSeriesProvider"/> class.
     /// </summary>
-    /// <param name="logger">The logger instance.</param>
-    /// <param name="loggerFactory">The logger factory.</param>
-    /// <param name="httpClientFactory">The HTTP client factory.</param>
-    /// <param name="metadataCache">The metadata cache.</param>
+    /// <param name="logger">The logger.</param>
+    /// <param name="compositionFetcher">The media composition fetcher.</param>
     public SRFSeriesProvider(
         ILogger<SRFSeriesProvider> logger,
-        ILoggerFactory loggerFactory,
-        IHttpClientFactory httpClientFactory,
-        MetadataCache metadataCache)
+        IMediaCompositionFetcher compositionFetcher)
     {
         _logger = logger;
-        _loggerFactory = loggerFactory;
-        _httpClientFactory = httpClientFactory;
-        _metadataCache = metadataCache;
+        _compositionFetcher = compositionFetcher;
     }
 
     /// <inheritdoc />
@@ -58,26 +47,7 @@ public class SRFSeriesProvider : IRemoteMetadataProvider<Series, SeriesInfo>
             {
                 _logger.LogDebug("Searching for series with URN: {Urn}", urn);
 
-                var config = Plugin.Instance?.Configuration;
-                if (config == null)
-                {
-                    return results;
-                }
-
-                // Try cache first
-                var mediaComposition = _metadataCache.GetMediaComposition(urn, config.CacheDurationMinutes);
-
-                // If not in cache, fetch from API
-                if (mediaComposition == null)
-                {
-                    using var apiClient = new SRFApiClient(_loggerFactory);
-                    mediaComposition = await apiClient.GetMediaCompositionByUrnAsync(urn, cancellationToken).ConfigureAwait(false);
-
-                    if (mediaComposition != null)
-                    {
-                        _metadataCache.SetMediaComposition(urn, mediaComposition);
-                    }
-                }
+                var mediaComposition = await _compositionFetcher.GetMediaCompositionAsync(urn, cancellationToken).ConfigureAwait(false);
 
                 if (mediaComposition?.Show != null)
                 {
@@ -125,26 +95,7 @@ public class SRFSeriesProvider : IRemoteMetadataProvider<Series, SeriesInfo>
 
             _logger.LogDebug("Fetching metadata for series URN: {Urn}", urn);
 
-            var config = Plugin.Instance?.Configuration;
-            if (config == null)
-            {
-                return result;
-            }
-
-            // Try cache first
-            var mediaComposition = _metadataCache.GetMediaComposition(urn, config.CacheDurationMinutes);
-
-            // If not in cache, fetch from API
-            if (mediaComposition == null)
-            {
-                using var apiClient = new SRFApiClient(_loggerFactory);
-                mediaComposition = await apiClient.GetMediaCompositionByUrnAsync(urn, cancellationToken).ConfigureAwait(false);
-
-                if (mediaComposition != null)
-                {
-                    _metadataCache.SetMediaComposition(urn, mediaComposition);
-                }
-            }
+            var mediaComposition = await _compositionFetcher.GetMediaCompositionAsync(urn, cancellationToken).ConfigureAwait(false);
 
             if (mediaComposition?.Show == null)
             {

Jellyfin.Plugin.SRFPlay/ScheduledTasks/ContentRefreshTask.cs

@@ -2,7 +2,7 @@ using System;
 using System.Collections.Generic;
 using System.Threading;
 using System.Threading.Tasks;
-using Jellyfin.Plugin.SRFPlay.Services;
+using Jellyfin.Plugin.SRFPlay.Services.Interfaces;
 using MediaBrowser.Model.Tasks;
 using Microsoft.Extensions.Logging;
 
@@ -14,7 +14,7 @@ namespace Jellyfin.Plugin.SRFPlay.ScheduledTasks;
 public class ContentRefreshTask : IScheduledTask
 {
     private readonly ILogger<ContentRefreshTask> _logger;
-    private readonly ContentRefreshService _contentRefreshService;
+    private readonly IContentRefreshService _contentRefreshService;
 
     /// <summary>
     /// Initializes a new instance of the <see cref="ContentRefreshTask"/> class.
@@ -23,7 +23,7 @@ public class ContentRefreshTask : IScheduledTask
     /// <param name="contentRefreshService">The content refresh service.</param>
     public ContentRefreshTask(
         ILogger<ContentRefreshTask> logger,
-        ContentRefreshService contentRefreshService)
+        IContentRefreshService contentRefreshService)
     {
         _logger = logger;
         _contentRefreshService = contentRefreshService;

Jellyfin.Plugin.SRFPlay/ScheduledTasks/ExpirationCheckTask.cs

@@ -2,7 +2,7 @@ using System;
 using System.Collections.Generic;
 using System.Threading;
 using System.Threading.Tasks;
-using Jellyfin.Plugin.SRFPlay.Services;
+using Jellyfin.Plugin.SRFPlay.Services.Interfaces;
 using MediaBrowser.Model.Tasks;
 using Microsoft.Extensions.Logging;
 
@@ -14,19 +14,23 @@ namespace Jellyfin.Plugin.SRFPlay.ScheduledTasks;
 public class ExpirationCheckTask : IScheduledTask
 {
     private readonly ILogger<ExpirationCheckTask> _logger;
-    private readonly ContentExpirationService _expirationService;
+    private readonly IContentExpirationService _expirationService;
+    private readonly IStreamProxyService _streamProxyService;
 
     /// <summary>
     /// Initializes a new instance of the <see cref="ExpirationCheckTask"/> class.
     /// </summary>
     /// <param name="logger">The logger instance.</param>
     /// <param name="expirationService">The content expiration service.</param>
+    /// <param name="streamProxyService">The stream proxy service.</param>
     public ExpirationCheckTask(
         ILogger<ExpirationCheckTask> logger,
-        ContentExpirationService expirationService)
+        IContentExpirationService expirationService,
+        IStreamProxyService streamProxyService)
     {
         _logger = logger;
         _expirationService = expirationService;
+        _streamProxyService = streamProxyService;
     }
 
     /// <inheritdoc />
@@ -77,6 +81,10 @@ public class ExpirationCheckTask : IScheduledTask
             progress?.Report(50);
             var removedCount = await _expirationService.CheckAndRemoveExpiredContentAsync(cancellationToken).ConfigureAwait(false);
 
+            // Clean up old stream proxy mappings
+            progress?.Report(75);
+            _streamProxyService.CleanupOldMappings();
+
             progress?.Report(100);
             _logger.LogInformation("SRF Play expiration check task completed. Removed {Count} expired items", removedCount);
         }

Jellyfin.Plugin.SRFPlay/ServiceRegistrator.cs

@@ -1,13 +1,14 @@
+using Jellyfin.Plugin.SRFPlay.Api;
 using Jellyfin.Plugin.SRFPlay.Channels;
 using Jellyfin.Plugin.SRFPlay.Providers;
 using Jellyfin.Plugin.SRFPlay.ScheduledTasks;
 using Jellyfin.Plugin.SRFPlay.Services;
+using Jellyfin.Plugin.SRFPlay.Services.Interfaces;
 using MediaBrowser.Controller;
 using MediaBrowser.Controller.Channels;
 using MediaBrowser.Controller.Plugins;
 using MediaBrowser.Model.Tasks;
 using Microsoft.Extensions.DependencyInjection;
-using Microsoft.Extensions.Logging;
 
 namespace Jellyfin.Plugin.SRFPlay;
 
@@ -19,12 +20,18 @@ public class ServiceRegistrator : IPluginServiceRegistrator
     /// <inheritdoc />
     public void RegisterServices(IServiceCollection serviceCollection, IServerApplicationHost applicationHost)
     {
-        // Register services as singletons
-        serviceCollection.AddSingleton<MetadataCache>();
-        serviceCollection.AddSingleton<StreamUrlResolver>();
-        serviceCollection.AddSingleton<ContentExpirationService>();
-        serviceCollection.AddSingleton<ContentRefreshService>();
-        serviceCollection.AddSingleton<CategoryService>();
+        // Register API client factory
+        serviceCollection.AddSingleton<ISRFApiClientFactory, SRFApiClientFactory>();
+
+        // Register core services with interfaces
+        serviceCollection.AddSingleton<IMetadataCache, MetadataCache>();
+        serviceCollection.AddSingleton<IStreamUrlResolver, StreamUrlResolver>();
+        serviceCollection.AddSingleton<IMediaCompositionFetcher, MediaCompositionFetcher>();
+        serviceCollection.AddSingleton<IStreamProxyService, StreamProxyService>();
+        serviceCollection.AddSingleton<IMediaSourceFactory, MediaSourceFactory>();
+        serviceCollection.AddSingleton<IContentExpirationService, ContentExpirationService>();
+        serviceCollection.AddSingleton<IContentRefreshService, ContentRefreshService>();
+        serviceCollection.AddSingleton<ICategoryService, CategoryService>();
 
         // Register metadata providers
         serviceCollection.AddSingleton<SRFSeriesProvider>();

Jellyfin.Plugin.SRFPlay/Services/CategoryService.cs

@@ -1,11 +1,11 @@
 using System;
 using System.Collections.Generic;
-using System.Diagnostics.CodeAnalysis;
 using System.Linq;
 using System.Threading;
 using System.Threading.Tasks;
 using Jellyfin.Plugin.SRFPlay.Api;
 using Jellyfin.Plugin.SRFPlay.Api.Models;
+using Jellyfin.Plugin.SRFPlay.Services.Interfaces;
 using Microsoft.Extensions.Logging;
 
 namespace Jellyfin.Plugin.SRFPlay.Services;
@@ -13,10 +13,10 @@ namespace Jellyfin.Plugin.SRFPlay.Services;
 /// <summary>
 /// Service for managing topic/category data and filtering.
 /// </summary>
-public class CategoryService
+public class CategoryService : ICategoryService
 {
-    private readonly ILogger _logger;
-    private readonly ILoggerFactory _loggerFactory;
+    private readonly ILogger<CategoryService> _logger;
+    private readonly ISRFApiClientFactory _apiClientFactory;
     private readonly TimeSpan _topicsCacheDuration = TimeSpan.FromHours(24);
     private Dictionary<string, PlayV3Topic>? _topicsCache;
     private DateTime _topicsCacheExpiry = DateTime.MinValue;
@@ -24,19 +24,15 @@ public class CategoryService
     /// <summary>
     /// Initializes a new instance of the <see cref="CategoryService"/> class.
     /// </summary>
-    /// <param name="loggerFactory">The logger factory.</param>
-    public CategoryService(ILoggerFactory loggerFactory)
+    /// <param name="logger">The logger.</param>
+    /// <param name="apiClientFactory">The API client factory.</param>
+    public CategoryService(ILogger<CategoryService> logger, ISRFApiClientFactory apiClientFactory)
     {
-        _loggerFactory = loggerFactory;
-        _logger = loggerFactory.CreateLogger<CategoryService>();
+        _logger = logger;
+        _apiClientFactory = apiClientFactory;
     }
 
-    /// <summary>
-    /// Gets all topics for a business unit.
-    /// </summary>
-    /// <param name="businessUnit">The business unit.</param>
-    /// <param name="cancellationToken">The cancellation token.</param>
-    /// <returns>List of topics.</returns>
+    /// <inheritdoc />
     public async Task<List<PlayV3Topic>> GetTopicsAsync(string businessUnit, CancellationToken cancellationToken = default)
     {
         // Return cached topics if still valid
@@ -47,7 +43,7 @@ public class CategoryService
         }
 
         _logger.LogInformation("Fetching topics for business unit: {BusinessUnit}", businessUnit);
-        using var apiClient = new SRFApiClient(_loggerFactory);
+        using var apiClient = _apiClientFactory.CreateClient();
         var topics = await apiClient.GetAllTopicsAsync(businessUnit, cancellationToken).ConfigureAwait(false);
 
         if (topics != null && topics.Count > 0)
@@ -64,13 +60,7 @@ public class CategoryService
         return topics ?? new List<PlayV3Topic>();
     }
 
-    /// <summary>
-    /// Gets a topic by ID.
-    /// </summary>
-    /// <param name="topicId">The topic ID.</param>
-    /// <param name="businessUnit">The business unit.</param>
-    /// <param name="cancellationToken">The cancellation token.</param>
-    /// <returns>The topic, or null if not found.</returns>
+    /// <inheritdoc />
     public async Task<PlayV3Topic?> GetTopicByIdAsync(string topicId, string businessUnit, CancellationToken cancellationToken = default)
     {
         // Ensure topics are loaded
@@ -82,70 +72,14 @@ public class CategoryService
         return _topicsCache?.GetValueOrDefault(topicId);
     }
 
-    /// <summary>
-    /// Filters shows by topic ID.
-    /// </summary>
-    /// <param name="shows">The shows to filter.</param>
-    /// <param name="topicId">The topic ID to filter by.</param>
-    /// <returns>Filtered list of shows.</returns>
-    public IReadOnlyList<PlayV3Show> FilterShowsByTopic(IReadOnlyList<PlayV3Show> shows, string topicId)
-    {
-        if (string.IsNullOrEmpty(topicId))
-        {
-            return shows;
-        }
-
-        return shows
-            .Where(s => s.TopicList != null && s.TopicList.Contains(topicId))
-            .ToList();
-    }
-
-    /// <summary>
-    /// Groups shows by their topics.
-    /// </summary>
-    /// <param name="shows">The shows to group.</param>
-    /// <returns>Dictionary mapping topic IDs to shows.</returns>
-    public IReadOnlyDictionary<string, List<PlayV3Show>> GroupShowsByTopics(IReadOnlyList<PlayV3Show> shows)
-    {
-        var groupedShows = new Dictionary<string, List<PlayV3Show>>();
-
-        foreach (var show in shows)
-        {
-            if (show.TopicList == null || show.TopicList.Count == 0)
-            {
-                continue;
-            }
-
-            foreach (var topicId in show.TopicList)
-            {
-                if (!groupedShows.TryGetValue(topicId, out var showList))
-                {
-                    showList = new List<PlayV3Show>();
-                    groupedShows[topicId] = showList;
-                }
-
-                showList.Add(show);
-            }
-        }
-
-        return groupedShows;
-    }
-
-    /// <summary>
-    /// Gets shows for a specific topic, sorted by number of episodes.
-    /// </summary>
-    /// <param name="topicId">The topic ID.</param>
-    /// <param name="businessUnit">The business unit.</param>
-    /// <param name="maxResults">Maximum number of results to return.</param>
-    /// <param name="cancellationToken">The cancellation token.</param>
-    /// <returns>List of shows for the topic.</returns>
+    /// <inheritdoc />
     public async Task<List<PlayV3Show>> GetShowsByTopicAsync(
         string topicId,
         string businessUnit,
         int maxResults = 50,
         CancellationToken cancellationToken = default)
     {
-        using var apiClient = new SRFApiClient(_loggerFactory);
+        using var apiClient = _apiClientFactory.CreateClient();
         var allShows = await apiClient.GetAllShowsAsync(businessUnit, cancellationToken).ConfigureAwait(false);
 
         if (allShows == null || allShows.Count == 0)
@@ -164,43 +98,29 @@ public class CategoryService
         return filteredShows;
     }
 
-    /// <summary>
-    /// Gets video count for each topic.
-    /// </summary>
-    /// <param name="shows">The shows to analyze.</param>
-    /// <returns>Dictionary mapping topic IDs to video counts.</returns>
-    public IReadOnlyDictionary<string, int> GetVideoCountByTopic(IReadOnlyList<PlayV3Show> shows)
-    {
-        var topicCounts = new Dictionary<string, int>();
-
-        foreach (var show in shows)
-        {
-            if (show.TopicList == null || show.TopicList.Count == 0)
-            {
-                continue;
-            }
-
-            foreach (var topicId in show.TopicList)
-            {
-                if (!topicCounts.TryGetValue(topicId, out var count))
-                {
-                    count = 0;
-                }
-
-                topicCounts[topicId] = count + show.NumberOfEpisodes;
-            }
-        }
-
-        return topicCounts;
-    }
-
-    /// <summary>
-    /// Clears the topics cache.
-    /// </summary>
+    /// <inheritdoc />
     public void ClearCache()
     {
         _topicsCache = null;
         _topicsCacheExpiry = DateTime.MinValue;
         _logger.LogInformation("Topics cache cleared");
     }
+
+    /// <summary>
+    /// Filters shows by topic ID.
+    /// </summary>
+    /// <param name="shows">The shows to filter.</param>
+    /// <param name="topicId">The topic ID to filter by.</param>
+    /// <returns>Filtered list of shows.</returns>
+    private static IReadOnlyList<PlayV3Show> FilterShowsByTopic(IReadOnlyList<PlayV3Show> shows, string topicId)
+    {
+        if (string.IsNullOrEmpty(topicId))
+        {
+            return shows;
+        }
+
+        return shows
+            .Where(s => s.TopicList != null && s.TopicList.Contains(topicId))
+            .ToList();
+    }
 }

Jellyfin.Plugin.SRFPlay/Services/ContentExpirationService.cs

@@ -3,10 +3,9 @@ using System.Collections.Generic;
 using System.Linq;
 using System.Threading;
 using System.Threading.Tasks;
-using Jellyfin.Plugin.SRFPlay.Api;
+using Jellyfin.Plugin.SRFPlay.Services.Interfaces;
 using MediaBrowser.Controller.Entities;
 using MediaBrowser.Controller.Library;
-using MediaBrowser.Model.IO;
 using Microsoft.Extensions.Logging;
 
 namespace Jellyfin.Plugin.SRFPlay.Services;
@@ -14,13 +13,12 @@ namespace Jellyfin.Plugin.SRFPlay.Services;
 /// <summary>
 /// Service for managing content expiration.
 /// </summary>
-public class ContentExpirationService
+public class ContentExpirationService : IContentExpirationService
 {
     private readonly ILogger<ContentExpirationService> _logger;
-    private readonly ILoggerFactory _loggerFactory;
     private readonly ILibraryManager _libraryManager;
-    private readonly StreamUrlResolver _streamResolver;
-    private readonly MetadataCache _metadataCache;
+    private readonly IStreamUrlResolver _streamResolver;
+    private readonly IMediaCompositionFetcher _compositionFetcher;
 
     /// <summary>
     /// Initializes a new instance of the <see cref="ContentExpirationService"/> class.
@@ -28,18 +26,17 @@ public class ContentExpirationService
     /// <param name="loggerFactory">The logger factory.</param>
     /// <param name="libraryManager">The library manager.</param>
     /// <param name="streamResolver">The stream URL resolver.</param>
-    /// <param name="metadataCache">The metadata cache.</param>
+    /// <param name="compositionFetcher">The media composition fetcher.</param>
     public ContentExpirationService(
         ILoggerFactory loggerFactory,
         ILibraryManager libraryManager,
-        StreamUrlResolver streamResolver,
-        MetadataCache metadataCache)
+        IStreamUrlResolver streamResolver,
+        IMediaCompositionFetcher compositionFetcher)
     {
-        _loggerFactory = loggerFactory;
         _logger = loggerFactory.CreateLogger<ContentExpirationService>();
         _libraryManager = libraryManager;
         _streamResolver = streamResolver;
-        _metadataCache = metadataCache;
+        _compositionFetcher = compositionFetcher;
     }
 
     /// <summary>
@@ -119,26 +116,7 @@ public class ContentExpirationService
             return false;
         }
 
-        var config = Plugin.Instance?.Configuration;
-        if (config == null)
-        {
-            return false;
-        }
-
-        // Try cache first
-        var mediaComposition = _metadataCache.GetMediaComposition(urn, config.CacheDurationMinutes);
-
-        // If not in cache, fetch from API
-        if (mediaComposition == null)
-        {
-            using var apiClient = new SRFApiClient(_loggerFactory);
-            mediaComposition = await apiClient.GetMediaCompositionByUrnAsync(urn, cancellationToken).ConfigureAwait(false);
-
-            if (mediaComposition != null)
-            {
-                _metadataCache.SetMediaComposition(urn, mediaComposition);
-            }
-        }
+        var mediaComposition = await _compositionFetcher.GetMediaCompositionAsync(urn, cancellationToken).ConfigureAwait(false);
 
         if (mediaComposition?.ChapterList == null || mediaComposition.ChapterList.Count == 0)
         {
@@ -196,24 +174,7 @@ public class ContentExpirationService
                         continue;
                     }
 
-                    var config = Plugin.Instance?.Configuration;
-                    if (config == null)
-                    {
-                        continue;
-                    }
-
-                    var mediaComposition = _metadataCache.GetMediaComposition(urn, config.CacheDurationMinutes);
-
-                    if (mediaComposition == null)
-                    {
-                        using var apiClient = new SRFApiClient(_loggerFactory);
-                        mediaComposition = await apiClient.GetMediaCompositionByUrnAsync(urn, cancellationToken).ConfigureAwait(false);
-
-                        if (mediaComposition != null)
-                        {
-                            _metadataCache.SetMediaComposition(urn, mediaComposition);
-                        }
-                    }
+                    var mediaComposition = await _compositionFetcher.GetMediaCompositionAsync(urn, cancellationToken).ConfigureAwait(false);
 
                     if (mediaComposition?.ChapterList != null && mediaComposition.ChapterList.Count > 0)
                     {

Jellyfin.Plugin.SRFPlay/Services/ContentRefreshService.cs

@@ -4,7 +4,7 @@ using System.Linq;
 using System.Threading;
 using System.Threading.Tasks;
 using Jellyfin.Plugin.SRFPlay.Api;
-using Jellyfin.Plugin.SRFPlay.Api.Models;
+using Jellyfin.Plugin.SRFPlay.Services.Interfaces;
 using Microsoft.Extensions.Logging;
 
 namespace Jellyfin.Plugin.SRFPlay.Services;
@@ -12,24 +12,22 @@ namespace Jellyfin.Plugin.SRFPlay.Services;
 /// <summary>
 /// Service for refreshing content from SRF API.
 /// </summary>
-public class ContentRefreshService
+public class ContentRefreshService : IContentRefreshService
 {
     private readonly ILogger<ContentRefreshService> _logger;
-    private readonly ILoggerFactory _loggerFactory;
-    private readonly MetadataCache _metadataCache;
+    private readonly ISRFApiClientFactory _apiClientFactory;
 
     /// <summary>
     /// Initializes a new instance of the <see cref="ContentRefreshService"/> class.
     /// </summary>
     /// <param name="loggerFactory">The logger factory.</param>
-    /// <param name="metadataCache">The metadata cache.</param>
+    /// <param name="apiClientFactory">The API client factory.</param>
     public ContentRefreshService(
         ILoggerFactory loggerFactory,
-        MetadataCache metadataCache)
+        ISRFApiClientFactory apiClientFactory)
     {
-        _loggerFactory = loggerFactory;
         _logger = loggerFactory.CreateLogger<ContentRefreshService>();
-        _metadataCache = metadataCache;
+        _apiClientFactory = apiClientFactory;
     }
 
     /// <summary>
@@ -39,111 +37,20 @@ public class ContentRefreshService
     /// <returns>List of URNs for new content.</returns>
     public async Task<List<string>> RefreshLatestContentAsync(CancellationToken cancellationToken)
     {
-        var urns = new List<string>();
-
-        try
+        var config = Plugin.Instance?.Configuration;
+        if (config == null || !config.EnableLatestContent)
         {
-            var config = Plugin.Instance?.Configuration;
-            if (config == null || !config.EnableLatestContent)
-            {
-                _logger.LogDebug("Latest content refresh is disabled");
-                return urns;
-            }
-
-            _logger.LogInformation("Refreshing latest content for business unit: {BusinessUnit}", config.BusinessUnit);
-
-            using var apiClient = new SRFApiClient(_loggerFactory);
-            var businessUnit = config.BusinessUnit.ToString().ToLowerInvariant();
-
-            // Get all shows from Play v3 API
-            var shows = await apiClient.GetAllShowsAsync(businessUnit, cancellationToken).ConfigureAwait(false);
-
-            if (shows == null || shows.Count == 0)
-            {
-                _logger.LogWarning("No shows found for business unit: {BusinessUnit}", config.BusinessUnit);
-                return urns;
-            }
-
-            _logger.LogInformation("Found {Count} shows, fetching latest episodes from each", shows.Count);
-
-            // Get latest episodes from each show (limit to 20 shows to avoid overwhelming)
-            var showsToFetch = shows.Where(s => s.NumberOfEpisodes > 0)
-                .OrderByDescending(s => s.NumberOfEpisodes)
-                .Take(20)
-                .ToList();
-
-            foreach (var show in showsToFetch)
-            {
-                if (show.Id == null)
-                {
-                    continue;
-                }
-
-                try
-                {
-                    var videos = await apiClient.GetVideosForShowAsync(businessUnit, show.Id, cancellationToken).ConfigureAwait(false);
-                    if (videos != null && videos.Count > 0)
-                    {
-                        _logger.LogDebug("Show {Show} ({ShowId}): Found {Count} videos", show.Title, show.Id, videos.Count);
-
-                        // Filter to videos that are actually published (validFrom in the past)
-                        var now = DateTime.UtcNow;
-                        var publishedVideos = videos.Where(v =>
-                            v.ValidFrom == null || v.ValidFrom.Value.ToUniversalTime() <= now).ToList();
-
-                        _logger.LogDebug("Show {Show}: {PublishedCount} published out of {TotalCount} videos", show.Title, publishedVideos.Count, videos.Count);
-
-                        if (publishedVideos.Count > 0)
-                        {
-                            // Take only the most recent published video from each show
-                            var latestVideo = publishedVideos.OrderByDescending(v => v.Date).FirstOrDefault();
-                            if (latestVideo?.Urn != null)
-                            {
-                                urns.Add(latestVideo.Urn);
-                                _logger.LogInformation(
-                                    "Added latest video from show {Show}: {Title} (URN: {Urn}, Date: {Date}, ValidFrom: {ValidFrom}, ValidTo: {ValidTo})",
-                                    show.Title,
-                                    latestVideo.Title,
-                                    latestVideo.Urn,
-                                    latestVideo.Date,
-                                    latestVideo.ValidFrom,
-                                    latestVideo.ValidTo);
-                            }
-                            else
-                            {
-                                _logger.LogWarning("Show {Show}: Latest video has null URN", show.Title);
-                            }
-                        }
-                        else
-                        {
-                            _logger.LogDebug("Show {Show} has no published videos yet", show.Title);
-                        }
-                    }
-                    else
-                    {
-                        _logger.LogDebug("Show {Show} ({ShowId}): No videos returned from API", show.Title, show.Id);
-                    }
-                }
-                catch (Exception ex)
-                {
-                    _logger.LogWarning(ex, "Error fetching videos for show {ShowId}", show.Id);
-                }
-
-                // Respect cancellation
-                if (cancellationToken.IsCancellationRequested)
-                {
-                    break;
-                }
-            }
-
-            _logger.LogInformation("Refreshed {Count} latest content items from {ShowCount} shows", urns.Count, showsToFetch.Count);
-        }
-        catch (Exception ex)
-        {
-            _logger.LogError(ex, "Error refreshing latest content");
+            _logger.LogDebug("Latest content refresh is disabled");
+            return new List<string>();
         }
 
-        return urns;
+        return await FetchVideosFromShowsAsync(
+            config.BusinessUnit.ToString().ToLowerInvariant(),
+            minEpisodeCount: 0,
+            maxShows: 20,
+            videosPerShow: 1,
+            contentType: "latest",
+            cancellationToken).ConfigureAwait(false);
     }
 
     /// <summary>
@@ -153,43 +60,62 @@ public class ContentRefreshService
     /// <param name="cancellationToken">The cancellation token.</param>
     /// <returns>List of URNs for trending content.</returns>
     public async Task<List<string>> RefreshTrendingContentAsync(CancellationToken cancellationToken)
+    {
+        var config = Plugin.Instance?.Configuration;
+        if (config == null || !config.EnableTrendingContent)
+        {
+            _logger.LogDebug("Trending content refresh is disabled");
+            return new List<string>();
+        }
+
+        return await FetchVideosFromShowsAsync(
+            config.BusinessUnit.ToString().ToLowerInvariant(),
+            minEpisodeCount: 10,
+            maxShows: 15,
+            videosPerShow: 2,
+            contentType: "trending",
+            cancellationToken).ConfigureAwait(false);
+    }
+
+    /// <summary>
+    /// Fetches videos from shows based on filter criteria.
+    /// </summary>
+    private async Task<List<string>> FetchVideosFromShowsAsync(
+        string businessUnit,
+        int minEpisodeCount,
+        int maxShows,
+        int videosPerShow,
+        string contentType,
+        CancellationToken cancellationToken)
     {
         var urns = new List<string>();
 
         try
         {
-            var config = Plugin.Instance?.Configuration;
-            if (config == null || !config.EnableTrendingContent)
-            {
-                _logger.LogDebug("Trending content refresh is disabled");
-                return urns;
-            }
+            _logger.LogInformation("Refreshing {ContentType} content for business unit: {BusinessUnit}", contentType, businessUnit);
 
-            _logger.LogInformation("Refreshing trending content for business unit: {BusinessUnit}", config.BusinessUnit);
-
-            using var apiClient = new SRFApiClient(_loggerFactory);
-            var businessUnit = config.BusinessUnit.ToString().ToLowerInvariant();
-
-            // Get all shows from Play v3 API
+            using var apiClient = _apiClientFactory.CreateClient();
             var shows = await apiClient.GetAllShowsAsync(businessUnit, cancellationToken).ConfigureAwait(false);
 
             if (shows == null || shows.Count == 0)
             {
-                _logger.LogWarning("No shows found for business unit: {BusinessUnit}", config.BusinessUnit);
+                _logger.LogWarning("No shows found for business unit: {BusinessUnit}", businessUnit);
                 return urns;
             }
 
-            _logger.LogInformation("Found {Count} shows, fetching popular content", shows.Count);
+            _logger.LogInformation("Found {Count} shows, fetching {ContentType} content", shows.Count, contentType);
 
-            // Get videos from popular shows (those with many episodes)
-            var popularShows = shows.Where(s => s.NumberOfEpisodes > 10)
+            var filteredShows = shows
+                .Where(s => s.NumberOfEpisodes > minEpisodeCount)
                 .OrderByDescending(s => s.NumberOfEpisodes)
-                .Take(15)
+                .Take(maxShows)
                 .ToList();
 
-            foreach (var show in popularShows)
+            var now = DateTime.UtcNow;
+
+            foreach (var show in filteredShows)
             {
-                if (show.Id == null)
+                if (show.Id == null || cancellationToken.IsCancellationRequested)
                 {
                     continue;
                 }
@@ -197,64 +123,46 @@ public class ContentRefreshService
                 try
                 {
                     var videos = await apiClient.GetVideosForShowAsync(businessUnit, show.Id, cancellationToken).ConfigureAwait(false);
-                    if (videos != null && videos.Count > 0)
+                    if (videos == null || videos.Count == 0)
                     {
-                        _logger.LogDebug("Show {Show} ({ShowId}): Found {Count} videos for trending", show.Title, show.Id, videos.Count);
-
-                        // Filter to videos that are actually published (validFrom in the past)
-                        var now = DateTime.UtcNow;
-                        var publishedVideos = videos.Where(v =>
-                            v.ValidFrom == null || v.ValidFrom.Value.ToUniversalTime() <= now).ToList();
-
-                        _logger.LogDebug("Show {Show}: {PublishedCount} published out of {TotalCount} videos for trending", show.Title, publishedVideos.Count, videos.Count);
-
-                        if (publishedVideos.Count > 0)
-                        {
-                            // Take 2 recent published videos from each popular show
-                            var recentVideos = publishedVideos.OrderByDescending(v => v.Date).Take(2);
-                            foreach (var video in recentVideos)
-                            {
-                                if (video.Urn != null)
-                                {
-                                    urns.Add(video.Urn);
-                                    _logger.LogInformation(
-                                        "Added trending video from show {Show}: {Title} (URN: {Urn}, Date: {Date}, ValidFrom: {ValidFrom}, ValidTo: {ValidTo})",
-                                        show.Title,
-                                        video.Title,
-                                        video.Urn,
-                                        video.Date,
-                                        video.ValidFrom,
-                                        video.ValidTo);
-                                }
-                                else
-                                {
-                                    _logger.LogWarning("Show {Show}: Trending video has null URN - {Title}", show.Title, video.Title);
-                                }
-                            }
-                        }
+                        _logger.LogDebug("Show {Show} ({ShowId}): No videos returned from API", show.Title, show.Id);
+                        continue;
                     }
-                    else
+
+                    _logger.LogDebug("Show {Show} ({ShowId}): Found {Count} videos", show.Title, show.Id, videos.Count);
+
+                    // Filter to videos that are actually published (validFrom in the past)
+                    var publishedVideos = videos
+                        .Where(v => v.ValidFrom == null || v.ValidFrom.Value.ToUniversalTime() <= now)
+                        .OrderByDescending(v => v.Date)
+                        .Take(videosPerShow)
+                        .ToList();
+
+                    foreach (var video in publishedVideos)
                     {
-                        _logger.LogDebug("Show {Show} ({ShowId}): No videos returned from API for trending", show.Title, show.Id);
+                        if (video.Urn != null)
+                        {
+                            urns.Add(video.Urn);
+                            _logger.LogDebug(
+                                "Added {ContentType} video from show {Show}: {Title} (URN: {Urn})",
+                                contentType,
+                                show.Title,
+                                video.Title,
+                                video.Urn);
+                        }
                     }
                 }
                 catch (Exception ex)
                 {
                     _logger.LogWarning(ex, "Error fetching videos for show {ShowId}", show.Id);
                 }
-
-                // Respect cancellation
-                if (cancellationToken.IsCancellationRequested)
-                {
-                    break;
-                }
             }
 
-            _logger.LogInformation("Refreshed {Count} trending content items from {ShowCount} shows", urns.Count, popularShows.Count);
+            _logger.LogInformation("Refreshed {Count} {ContentType} content items from {ShowCount} shows", urns.Count, contentType, filteredShows.Count);
         }
         catch (Exception ex)
         {
-            _logger.LogError(ex, "Error refreshing trending content");
+            _logger.LogError(ex, "Error refreshing {ContentType} content", contentType);
         }
 
         return urns;

Jellyfin.Plugin.SRFPlay/Services/Interfaces/ICategoryService.cs

@@ -0,0 +1,48 @@
+using System.Collections.Generic;
+using System.Threading;
+using System.Threading.Tasks;
+using Jellyfin.Plugin.SRFPlay.Api.Models;
+
+namespace Jellyfin.Plugin.SRFPlay.Services.Interfaces;
+
+/// <summary>
+/// Interface for managing topic/category data and filtering.
+/// </summary>
+public interface ICategoryService
+{
+    /// <summary>
+    /// Gets all topics for a business unit.
+    /// </summary>
+    /// <param name="businessUnit">The business unit.</param>
+    /// <param name="cancellationToken">The cancellation token.</param>
+    /// <returns>List of topics.</returns>
+    Task<List<PlayV3Topic>> GetTopicsAsync(string businessUnit, CancellationToken cancellationToken = default);
+
+    /// <summary>
+    /// Gets a topic by ID.
+    /// </summary>
+    /// <param name="topicId">The topic ID.</param>
+    /// <param name="businessUnit">The business unit.</param>
+    /// <param name="cancellationToken">The cancellation token.</param>
+    /// <returns>The topic, or null if not found.</returns>
+    Task<PlayV3Topic?> GetTopicByIdAsync(string topicId, string businessUnit, CancellationToken cancellationToken = default);
+
+    /// <summary>
+    /// Gets shows for a specific topic, sorted by number of episodes.
+    /// </summary>
+    /// <param name="topicId">The topic ID.</param>
+    /// <param name="businessUnit">The business unit.</param>
+    /// <param name="maxResults">Maximum number of results to return.</param>
+    /// <param name="cancellationToken">The cancellation token.</param>
+    /// <returns>List of shows for the topic.</returns>
+    Task<List<PlayV3Show>> GetShowsByTopicAsync(
+        string topicId,
+        string businessUnit,
+        int maxResults = 50,
+        CancellationToken cancellationToken = default);
+
+    /// <summary>
+    /// Clears the topics cache.
+    /// </summary>
+    void ClearCache();
+}

Jellyfin.Plugin.SRFPlay/Services/Interfaces/IContentExpirationService.cs

@@ -0,0 +1,24 @@
+using System.Threading;
+using System.Threading.Tasks;
+
+namespace Jellyfin.Plugin.SRFPlay.Services.Interfaces;
+
+/// <summary>
+/// Interface for managing content expiration.
+/// </summary>
+public interface IContentExpirationService
+{
+    /// <summary>
+    /// Checks for expired content and removes it from the library.
+    /// </summary>
+    /// <param name="cancellationToken">The cancellation token.</param>
+    /// <returns>The number of items removed.</returns>
+    Task<int> CheckAndRemoveExpiredContentAsync(CancellationToken cancellationToken);
+
+    /// <summary>
+    /// Gets statistics about content expiration.
+    /// </summary>
+    /// <param name="cancellationToken">The cancellation token.</param>
+    /// <returns>Tuple with total count, expired count, and items expiring soon.</returns>
+    Task<(int Total, int Expired, int ExpiringSoon)> GetExpirationStatisticsAsync(CancellationToken cancellationToken);
+}

Jellyfin.Plugin.SRFPlay/Services/Interfaces/IContentRefreshService.cs

@@ -0,0 +1,39 @@
+using System.Collections.Generic;
+using System.Threading;
+using System.Threading.Tasks;
+
+namespace Jellyfin.Plugin.SRFPlay.Services.Interfaces;
+
+/// <summary>
+/// Interface for refreshing content from SRF API.
+/// </summary>
+public interface IContentRefreshService
+{
+    /// <summary>
+    /// Refreshes latest content from SRF API using Play v3.
+    /// </summary>
+    /// <param name="cancellationToken">The cancellation token.</param>
+    /// <returns>List of URNs for new content.</returns>
+    Task<List<string>> RefreshLatestContentAsync(CancellationToken cancellationToken);
+
+    /// <summary>
+    /// Refreshes trending content from SRF API using Play v3.
+    /// </summary>
+    /// <param name="cancellationToken">The cancellation token.</param>
+    /// <returns>List of URNs for trending content.</returns>
+    Task<List<string>> RefreshTrendingContentAsync(CancellationToken cancellationToken);
+
+    /// <summary>
+    /// Refreshes all content (latest and trending).
+    /// </summary>
+    /// <param name="cancellationToken">The cancellation token.</param>
+    /// <returns>Tuple with counts of latest and trending items.</returns>
+    Task<(int LatestCount, int TrendingCount)> RefreshAllContentAsync(CancellationToken cancellationToken);
+
+    /// <summary>
+    /// Gets content recommendations (combines latest and trending).
+    /// </summary>
+    /// <param name="cancellationToken">The cancellation token.</param>
+    /// <returns>List of recommended URNs.</returns>
+    Task<List<string>> GetRecommendedContentAsync(CancellationToken cancellationToken);
+}

Jellyfin.Plugin.SRFPlay/Services/Interfaces/IMediaCompositionFetcher.cs

@@ -0,0 +1,23 @@
+using System.Threading;
+using System.Threading.Tasks;
+using Jellyfin.Plugin.SRFPlay.Api.Models;
+
+namespace Jellyfin.Plugin.SRFPlay.Services.Interfaces;
+
+/// <summary>
+/// Interface for fetching media composition with caching support.
+/// </summary>
+public interface IMediaCompositionFetcher
+{
+    /// <summary>
+    /// Gets media composition by URN, using cache if available.
+    /// </summary>
+    /// <param name="urn">The URN to fetch.</param>
+    /// <param name="cancellationToken">Cancellation token.</param>
+    /// <param name="cacheDurationOverride">Optional override for cache duration (e.g., 5 min for livestreams).</param>
+    /// <returns>The media composition, or null if not found.</returns>
+    Task<MediaComposition?> GetMediaCompositionAsync(
+        string urn,
+        CancellationToken cancellationToken,
+        int? cacheDurationOverride = null);
+}

Jellyfin.Plugin.SRFPlay/Services/Interfaces/IMediaSourceFactory.cs

@@ -0,0 +1,51 @@
+using System.Collections.Generic;
+using System.Threading;
+using System.Threading.Tasks;
+using Jellyfin.Plugin.SRFPlay.Api.Models;
+using Jellyfin.Plugin.SRFPlay.Configuration;
+using MediaBrowser.Model.Dto;
+using MediaBrowser.Model.Entities;
+
+namespace Jellyfin.Plugin.SRFPlay.Services.Interfaces;
+
+/// <summary>
+/// Factory for creating MediaSourceInfo objects with consistent configuration.
+/// </summary>
+public interface IMediaSourceFactory
+{
+    /// <summary>
+    /// Creates a MediaSourceInfo for a chapter with proper stream authentication and proxy registration.
+    /// </summary>
+    /// <param name="chapter">The chapter containing stream resources.</param>
+    /// <param name="itemId">The unique item ID for proxy registration.</param>
+    /// <param name="urn">The URN of the content.</param>
+    /// <param name="qualityPreference">The preferred quality.</param>
+    /// <param name="cancellationToken">The cancellation token.</param>
+    /// <returns>A configured MediaSourceInfo, or null if stream URL cannot be resolved.</returns>
+    Task<MediaSourceInfo?> CreateMediaSourceAsync(
+        Chapter chapter,
+        string itemId,
+        string urn,
+        QualityPreference qualityPreference,
+        CancellationToken cancellationToken = default);
+
+    /// <summary>
+    /// Builds a proxy URL for an item.
+    /// </summary>
+    /// <param name="itemId">The item ID.</param>
+    /// <returns>The full proxy URL including server address.</returns>
+    string BuildProxyUrl(string itemId);
+
+    /// <summary>
+    /// Gets the server base URL (configured public URL or smart URL).
+    /// </summary>
+    /// <returns>The server base URL without trailing slash.</returns>
+    string GetServerBaseUrl();
+
+    /// <summary>
+    /// Creates MediaStream metadata based on quality preference.
+    /// </summary>
+    /// <param name="quality">The quality preference.</param>
+    /// <returns>List of MediaStream objects for video and audio.</returns>
+    IReadOnlyList<MediaStream> CreateMediaStreams(QualityPreference quality);
+}

Jellyfin.Plugin.SRFPlay/Services/Interfaces/IMetadataCache.cs

@@ -0,0 +1,41 @@
+using Jellyfin.Plugin.SRFPlay.Api.Models;
+
+namespace Jellyfin.Plugin.SRFPlay.Services.Interfaces;
+
+/// <summary>
+/// Interface for caching metadata from SRF API.
+/// </summary>
+public interface IMetadataCache
+{
+    /// <summary>
+    /// Gets cached media composition by URN.
+    /// </summary>
+    /// <param name="urn">The URN.</param>
+    /// <param name="cacheDurationMinutes">The cache duration in minutes.</param>
+    /// <returns>The cached media composition, or null if not found or expired.</returns>
+    MediaComposition? GetMediaComposition(string urn, int cacheDurationMinutes);
+
+    /// <summary>
+    /// Sets media composition in cache.
+    /// </summary>
+    /// <param name="urn">The URN.</param>
+    /// <param name="mediaComposition">The media composition to cache.</param>
+    void SetMediaComposition(string urn, MediaComposition mediaComposition);
+
+    /// <summary>
+    /// Removes media composition from cache.
+    /// </summary>
+    /// <param name="urn">The URN.</param>
+    void RemoveMediaComposition(string urn);
+
+    /// <summary>
+    /// Clears all cached data.
+    /// </summary>
+    void Clear();
+
+    /// <summary>
+    /// Gets the cache statistics.
+    /// </summary>
+    /// <returns>A tuple with cache count and size estimate.</returns>
+    (int Count, long SizeEstimate) GetStatistics();
+}

Jellyfin.Plugin.SRFPlay/Services/Interfaces/IStreamProxyService.cs

@@ -0,0 +1,67 @@
+using System.Threading;
+using System.Threading.Tasks;
+
+namespace Jellyfin.Plugin.SRFPlay.Services.Interfaces;
+
+/// <summary>
+/// Interface for proxying SRF Play streams and managing authentication.
+/// </summary>
+public interface IStreamProxyService
+{
+    /// <summary>
+    /// Registers a stream for proxying with an already-authenticated URL.
+    /// </summary>
+    /// <param name="itemId">The item ID.</param>
+    /// <param name="authenticatedUrl">The authenticated stream URL.</param>
+    /// <param name="urn">The SRF URN for this content (used for re-fetching fresh URLs).</param>
+    /// <param name="isLiveStream">Whether this is a livestream (livestreams always fetch fresh URLs).</param>
+    void RegisterStream(string itemId, string authenticatedUrl, string? urn = null, bool isLiveStream = false);
+
+    /// <summary>
+    /// Registers a stream for deferred authentication (authenticates on first playback request).
+    /// Use this when browsing to avoid wasting 30-second tokens before the user clicks play.
+    /// </summary>
+    /// <param name="itemId">The item ID.</param>
+    /// <param name="unauthenticatedUrl">The unauthenticated stream URL.</param>
+    /// <param name="urn">The SRF URN for this content.</param>
+    /// <param name="isLiveStream">Whether this is a livestream.</param>
+    void RegisterStreamDeferred(string itemId, string unauthenticatedUrl, string? urn = null, bool isLiveStream = false);
+
+    /// <summary>
+    /// Gets stream metadata for an item (URN and isLiveStream flag).
+    /// </summary>
+    /// <param name="itemId">The item ID.</param>
+    /// <returns>A tuple of (URN, IsLiveStream), or null if not found.</returns>
+    (string? Urn, bool IsLiveStream)? GetStreamMetadata(string itemId);
+
+    /// <summary>
+    /// Gets the authenticated URL for an item.
+    /// </summary>
+    /// <param name="itemId">The item ID.</param>
+    /// <param name="cancellationToken">Cancellation token.</param>
+    /// <returns>The authenticated URL, or null if not found or expired.</returns>
+    Task<string?> GetAuthenticatedUrlAsync(string itemId, CancellationToken cancellationToken = default);
+
+    /// <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.</param>
+    /// <param name="cancellationToken">Cancellation token.</param>
+    /// <returns>The rewritten manifest content.</returns>
+    Task<string?> GetRewrittenManifestAsync(string itemId, string baseProxyUrl, CancellationToken cancellationToken = default);
+
+    /// <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>
+    Task<byte[]?> GetSegmentAsync(string itemId, string segmentPath, CancellationToken cancellationToken = default);
+
+    /// <summary>
+    /// Cleans up old and expired stream mappings.
+    /// </summary>
+    void CleanupOldMappings();
+}

Jellyfin.Plugin.SRFPlay/Services/Interfaces/IStreamUrlResolver.cs

@@ -0,0 +1,42 @@
+using System.Threading;
+using System.Threading.Tasks;
+using Jellyfin.Plugin.SRFPlay.Api.Models;
+using Jellyfin.Plugin.SRFPlay.Configuration;
+
+namespace Jellyfin.Plugin.SRFPlay.Services.Interfaces;
+
+/// <summary>
+/// Interface for resolving stream URLs from media composition resources.
+/// </summary>
+public interface IStreamUrlResolver
+{
+    /// <summary>
+    /// Gets the best stream URL from a chapter based on quality preference.
+    /// </summary>
+    /// <param name="chapter">The chapter containing resources.</param>
+    /// <param name="qualityPreference">The quality preference.</param>
+    /// <returns>The stream URL, or null if no suitable stream found.</returns>
+    string? GetStreamUrl(Chapter chapter, QualityPreference qualityPreference);
+
+    /// <summary>
+    /// Checks if a chapter has non-DRM playable content.
+    /// </summary>
+    /// <param name="chapter">The chapter to check.</param>
+    /// <returns>True if playable content is available.</returns>
+    bool HasPlayableContent(Chapter chapter);
+
+    /// <summary>
+    /// Checks if content is expired based on ValidTo date.
+    /// </summary>
+    /// <param name="chapter">The chapter to check.</param>
+    /// <returns>True if the content is expired.</returns>
+    bool IsContentExpired(Chapter chapter);
+
+    /// <summary>
+    /// Authenticates a stream URL by fetching an Akamai token.
+    /// </summary>
+    /// <param name="streamUrl">The unauthenticated stream URL.</param>
+    /// <param name="cancellationToken">Cancellation token.</param>
+    /// <returns>The authenticated stream URL with token.</returns>
+    Task<string> GetAuthenticatedStreamUrlAsync(string streamUrl, CancellationToken cancellationToken = default);
+}

Jellyfin.Plugin.SRFPlay/Services/MediaCompositionFetcher.cs

@@ -0,0 +1,82 @@
+using System.Threading;
+using System.Threading.Tasks;
+using Jellyfin.Plugin.SRFPlay.Api;
+using Jellyfin.Plugin.SRFPlay.Api.Models;
+using Jellyfin.Plugin.SRFPlay.Services.Interfaces;
+using Microsoft.Extensions.Logging;
+
+namespace Jellyfin.Plugin.SRFPlay.Services;
+
+/// <summary>
+/// Service for fetching media composition with caching support.
+/// This consolidates the cache-check → API-fetch → cache-store pattern.
+/// </summary>
+public class MediaCompositionFetcher : IMediaCompositionFetcher
+{
+    private readonly ILogger<MediaCompositionFetcher> _logger;
+    private readonly IMetadataCache _metadataCache;
+    private readonly ISRFApiClientFactory _apiClientFactory;
+
+    /// <summary>
+    /// Initializes a new instance of the <see cref="MediaCompositionFetcher"/> class.
+    /// </summary>
+    /// <param name="logger">The logger.</param>
+    /// <param name="metadataCache">The metadata cache.</param>
+    /// <param name="apiClientFactory">The API client factory.</param>
+    public MediaCompositionFetcher(
+        ILogger<MediaCompositionFetcher> logger,
+        IMetadataCache metadataCache,
+        ISRFApiClientFactory apiClientFactory)
+    {
+        _logger = logger;
+        _metadataCache = metadataCache;
+        _apiClientFactory = apiClientFactory;
+    }
+
+    /// <inheritdoc />
+    public async Task<MediaComposition?> GetMediaCompositionAsync(
+        string urn,
+        CancellationToken cancellationToken,
+        int? cacheDurationOverride = null)
+    {
+        if (string.IsNullOrEmpty(urn))
+        {
+            _logger.LogDebug("GetMediaCompositionAsync called with null/empty URN");
+            return null;
+        }
+
+        var config = Plugin.Instance?.Configuration;
+        if (config == null)
+        {
+            _logger.LogWarning("Plugin configuration is null, cannot fetch media composition");
+            return null;
+        }
+
+        var cacheDuration = cacheDurationOverride ?? config.CacheDurationMinutes;
+
+        // Try cache first
+        var mediaComposition = _metadataCache.GetMediaComposition(urn, cacheDuration);
+        if (mediaComposition != null)
+        {
+            _logger.LogDebug("Cache hit for URN: {Urn}", urn);
+            return mediaComposition;
+        }
+
+        // Fetch from API
+        _logger.LogDebug("Cache miss for URN: {Urn}, fetching from API", urn);
+        using var apiClient = _apiClientFactory.CreateClient();
+        mediaComposition = await apiClient.GetMediaCompositionByUrnAsync(urn, cancellationToken).ConfigureAwait(false);
+
+        if (mediaComposition != null)
+        {
+            _metadataCache.SetMediaComposition(urn, mediaComposition);
+            _logger.LogDebug("Cached media composition for URN: {Urn}", urn);
+        }
+        else
+        {
+            _logger.LogWarning("Failed to fetch media composition for URN: {Urn}", urn);
+        }
+
+        return mediaComposition;
+    }
+}

Jellyfin.Plugin.SRFPlay/Services/MediaSourceFactory.cs

@@ -0,0 +1,175 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading;
+using System.Threading.Tasks;
+using Jellyfin.Plugin.SRFPlay.Api.Models;
+using Jellyfin.Plugin.SRFPlay.Configuration;
+using Jellyfin.Plugin.SRFPlay.Constants;
+using Jellyfin.Plugin.SRFPlay.Services.Interfaces;
+using MediaBrowser.Controller;
+using MediaBrowser.Model.Dto;
+using MediaBrowser.Model.Entities;
+using MediaBrowser.Model.MediaInfo;
+using Microsoft.Extensions.Logging;
+
+namespace Jellyfin.Plugin.SRFPlay.Services;
+
+/// <summary>
+/// Factory for creating MediaSourceInfo objects with consistent configuration.
+/// Consolidates duplicated logic from SRFMediaProvider and SRFPlayChannel.
+/// </summary>
+public class MediaSourceFactory : IMediaSourceFactory
+{
+    private readonly ILogger<MediaSourceFactory> _logger;
+    private readonly IStreamUrlResolver _streamResolver;
+    private readonly IStreamProxyService _proxyService;
+    private readonly IServerApplicationHost _appHost;
+
+    /// <summary>
+    /// Initializes a new instance of the <see cref="MediaSourceFactory"/> class.
+    /// </summary>
+    /// <param name="logger">The logger.</param>
+    /// <param name="streamResolver">The stream URL resolver.</param>
+    /// <param name="proxyService">The stream proxy service.</param>
+    /// <param name="appHost">The server application host.</param>
+    public MediaSourceFactory(
+        ILogger<MediaSourceFactory> logger,
+        IStreamUrlResolver streamResolver,
+        IStreamProxyService proxyService,
+        IServerApplicationHost appHost)
+    {
+        _logger = logger;
+        _streamResolver = streamResolver;
+        _proxyService = proxyService;
+        _appHost = appHost;
+    }
+
+    /// <inheritdoc />
+    public Task<MediaSourceInfo?> CreateMediaSourceAsync(
+        Chapter chapter,
+        string itemId,
+        string urn,
+        QualityPreference qualityPreference,
+        CancellationToken cancellationToken = default)
+    {
+        // Get stream URL based on quality preference (unauthenticated)
+        var streamUrl = _streamResolver.GetStreamUrl(chapter, qualityPreference);
+
+        if (string.IsNullOrEmpty(streamUrl))
+        {
+            _logger.LogWarning("Could not resolve stream URL for chapter: {ChapterId}", chapter.Id);
+            return Task.FromResult<MediaSourceInfo?>(null);
+        }
+
+        // Detect if this is a live stream
+        var isLiveStream = chapter.Type == "SCHEDULED_LIVESTREAM" ||
+                          urn.Contains("livestream", StringComparison.OrdinalIgnoreCase);
+
+        // Register stream with UNAUTHENTICATED URL - proxy will authenticate on-demand
+        // This avoids wasting 30-second tokens during category browsing
+        _proxyService.RegisterStreamDeferred(itemId, streamUrl, urn, isLiveStream);
+
+        // Build proxy URL
+        var proxyUrl = BuildProxyUrl(itemId);
+
+        _logger.LogDebug(
+            "Created media source for {Title} - ItemId: {ItemId}, IsLiveStream: {IsLiveStream}",
+            chapter.Title,
+            itemId,
+            isLiveStream);
+
+        // Create MediaSourceInfo with codec info so clients know they can direct play
+        // Provide MediaStreams with H.264+AAC so Android TV/ExoPlayer doesn't trigger transcoding
+        var mediaStreams = CreateMediaStreams(qualityPreference);
+
+        var mediaSource = new MediaSourceInfo
+        {
+            Id = itemId,
+            Name = chapter.Title,
+            Path = proxyUrl,
+            Protocol = MediaProtocol.Http,
+            // Use "hls" to trigger hls.js player in web client
+            Container = "hls",
+            SupportsDirectStream = true,
+            SupportsDirectPlay = true,
+            SupportsTranscoding = false,
+            IsRemote = true,
+            Type = MediaSourceType.Default,
+            RunTimeTicks = chapter.Duration > 0 ? TimeSpan.FromMilliseconds(chapter.Duration).Ticks : null,
+            VideoType = VideoType.VideoFile,
+            IsInfiniteStream = isLiveStream,
+            // Don't use RequiresOpening - it forces Jellyfin to transcode which breaks token auth
+            RequiresOpening = false,
+            RequiresClosing = false,
+            // Disable probing - we provide stream info directly
+            SupportsProbing = false,
+            ReadAtNativeFramerate = isLiveStream,
+            // Provide codec info so clients know they can direct play H.264+AAC
+            MediaStreams = mediaStreams.ToList(),
+            AnalyzeDurationMs = isLiveStream ? 1000 : 3000,
+            IgnoreDts = isLiveStream,
+            IgnoreIndex = isLiveStream,
+        };
+
+        return Task.FromResult<MediaSourceInfo?>(mediaSource);
+    }
+
+    /// <inheritdoc />
+    public string BuildProxyUrl(string itemId)
+    {
+        return $"{GetServerBaseUrl()}{ApiEndpoints.ProxyMasterManifestPath.Replace("{0}", itemId, StringComparison.Ordinal)}";
+    }
+
+    /// <inheritdoc />
+    public string GetServerBaseUrl()
+    {
+        var config = Plugin.Instance?.Configuration;
+        return config != null && !string.IsNullOrWhiteSpace(config.PublicServerUrl)
+            ? config.PublicServerUrl.TrimEnd('/')
+            : _appHost.GetSmartApiUrl(string.Empty);
+    }
+
+    /// <inheritdoc />
+    public IReadOnlyList<MediaStream> CreateMediaStreams(QualityPreference quality)
+    {
+        // Set resolution/bitrate based on quality preference
+        var (width, height, videoBitrate) = quality switch
+        {
+            QualityPreference.SD => (1280, 720, 2500000),
+            QualityPreference.HD => (1920, 1080, 5000000),
+            _ => (1280, 720, 3000000)
+        };
+
+        return new List<MediaStream>
+        {
+            new MediaStream
+            {
+                Type = MediaStreamType.Video,
+                Codec = "h264",
+                Profile = "high",
+                Level = 40,
+                Width = width,
+                Height = height,
+                BitRate = videoBitrate,
+                BitDepth = 8,
+                IsInterlaced = false,
+                IsDefault = true,
+                Index = 0,
+                IsAVC = true,
+                PixelFormat = "yuv420p"
+            },
+            new MediaStream
+            {
+                Type = MediaStreamType.Audio,
+                Codec = "aac",
+                Profile = "LC",
+                Channels = 2,
+                SampleRate = 48000,
+                BitRate = 128000,
+                IsDefault = true,
+                Index = 1
+            }
+        };
+    }
+}

Jellyfin.Plugin.SRFPlay/Services/MetadataCache.cs

@@ -2,6 +2,7 @@ using System;
 using System.Collections.Concurrent;
 using System.Threading;
 using Jellyfin.Plugin.SRFPlay.Api.Models;
+using Jellyfin.Plugin.SRFPlay.Services.Interfaces;
 using Microsoft.Extensions.Logging;
 
 namespace Jellyfin.Plugin.SRFPlay.Services;
@@ -9,7 +10,7 @@ namespace Jellyfin.Plugin.SRFPlay.Services;
 /// <summary>
 /// Service for caching metadata from SRF API.
 /// </summary>
-public sealed class MetadataCache : IDisposable
+public sealed class MetadataCache : IMetadataCache, IDisposable
 {
     private readonly ILogger<MetadataCache> _logger;
     private readonly ConcurrentDictionary<string, CacheEntry<MediaComposition>> _mediaCompositionCache;

Jellyfin.Plugin.SRFPlay/Services/StreamProxyService.cs

@@ -0,0 +1,962 @@
+using System;
+using System.Collections.Concurrent;
+using System.Collections.Generic;
+using System.Linq;
+using System.Net.Http;
+using System.Text.RegularExpressions;
+using System.Threading;
+using System.Threading.Tasks;
+using System.Web;
+using Jellyfin.Plugin.SRFPlay.Api;
+using Jellyfin.Plugin.SRFPlay.Configuration;
+using Jellyfin.Plugin.SRFPlay.Services.Interfaces;
+using MediaBrowser.Common.Net;
+using Microsoft.Extensions.Logging;
+
+namespace Jellyfin.Plugin.SRFPlay.Services;
+
+/// <summary>
+/// Service for proxying SRF Play streams and managing authentication.
+/// </summary>
+public class StreamProxyService : IStreamProxyService
+{
+    private readonly ILogger<StreamProxyService> _logger;
+    private readonly IStreamUrlResolver _streamResolver;
+    private readonly IMediaCompositionFetcher _compositionFetcher;
+    private readonly IHttpClientFactory _httpClientFactory;
+    private readonly ConcurrentDictionary<string, StreamInfo> _streamMappings;
+
+    /// <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>
+    /// <param name="compositionFetcher">The media composition fetcher.</param>
+    /// <param name="httpClientFactory">The HTTP client factory.</param>
+    public StreamProxyService(
+        ILogger<StreamProxyService> logger,
+        IStreamUrlResolver streamResolver,
+        IMediaCompositionFetcher compositionFetcher,
+        IHttpClientFactory httpClientFactory)
+    {
+        _logger = logger;
+        _streamResolver = streamResolver;
+        _compositionFetcher = compositionFetcher;
+        _httpClientFactory = httpClientFactory;
+        _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>
+    /// <param name="urn">The SRF URN for this content (used for re-fetching fresh URLs).</param>
+    /// <param name="isLiveStream">Whether this is a livestream (livestreams always fetch fresh URLs).</param>
+    public void RegisterStream(string itemId, string authenticatedUrl, string? urn = null, bool isLiveStream = false)
+    {
+        var tokenExpiry = ExtractTokenExpiry(authenticatedUrl);
+        var unauthenticatedUrl = StripAuthenticationFromUrl(authenticatedUrl);
+
+        var streamInfo = new StreamInfo
+        {
+            AuthenticatedUrl = authenticatedUrl,
+            UnauthenticatedUrl = unauthenticatedUrl,
+            RegisteredAt = DateTime.UtcNow,
+            TokenExpiresAt = tokenExpiry,
+            Urn = urn,
+            IsLiveStream = isLiveStream,
+            LastLivestreamFetchAt = isLiveStream ? DateTime.UtcNow : null
+        };
+
+        RegisterWithGuidFormats(itemId, streamInfo);
+
+        if (tokenExpiry.HasValue)
+        {
+            _logger.LogDebug(
+                "Registered stream for item {ItemId} (token expires at {ExpiresAt} UTC): {Url}",
+                itemId,
+                tokenExpiry.Value,
+                authenticatedUrl);
+        }
+        else
+        {
+            _logger.LogDebug("Registered stream for item {ItemId}: {Url}", itemId, authenticatedUrl);
+        }
+    }
+
+    /// <summary>
+    /// Registers a stream for deferred authentication (authenticates on first playback request).
+    /// </summary>
+    /// <param name="itemId">The item ID.</param>
+    /// <param name="unauthenticatedUrl">The unauthenticated stream URL.</param>
+    /// <param name="urn">The SRF URN for this content.</param>
+    /// <param name="isLiveStream">Whether this is a livestream.</param>
+    public void RegisterStreamDeferred(string itemId, string unauthenticatedUrl, string? urn = null, bool isLiveStream = false)
+    {
+        var streamInfo = new StreamInfo
+        {
+            AuthenticatedUrl = string.Empty, // Will be populated on first access
+            UnauthenticatedUrl = unauthenticatedUrl,
+            RegisteredAt = DateTime.UtcNow,
+            TokenExpiresAt = null,
+            Urn = urn,
+            IsLiveStream = isLiveStream,
+            LastLivestreamFetchAt = null,
+            NeedsAuthentication = true
+        };
+
+        RegisterWithGuidFormats(itemId, streamInfo);
+
+        _logger.LogDebug(
+            "Registered deferred stream for item {ItemId} (URN: {Urn}, will authenticate on first access)",
+            itemId,
+            urn ?? "null");
+    }
+
+    /// <summary>
+    /// Gets stream metadata for an item (URN and isLiveStream flag).
+    /// Used when propagating stream registration to transcoding sessions.
+    /// </summary>
+    /// <param name="itemId">The item ID.</param>
+    /// <returns>A tuple of (URN, IsLiveStream), or null if not found.</returns>
+    public (string? Urn, bool IsLiveStream)? GetStreamMetadata(string itemId)
+    {
+        if (_streamMappings.TryGetValue(itemId, out var streamInfo))
+        {
+            return (streamInfo.Urn, streamInfo.IsLiveStream);
+        }
+
+        // Try GUID normalization
+        var normalizedId = NormalizeGuid(itemId);
+        if (normalizedId != null)
+        {
+            foreach (var kvp in _streamMappings)
+            {
+                var normalizedKey = NormalizeGuid(kvp.Key);
+                if (normalizedKey != null && normalizedKey == normalizedId)
+                {
+                    return (kvp.Value.Urn, kvp.Value.IsLiveStream);
+                }
+            }
+        }
+
+        return null;
+    }
+
+    /// <summary>
+    /// Gets the authenticated URL for an item.
+    /// </summary>
+    /// <param name="itemId">The item ID.</param>
+    /// <param name="cancellationToken">Cancellation token.</param>
+    /// <returns>The authenticated URL, or null if not found or expired.</returns>
+    public async Task<string?> GetAuthenticatedUrlAsync(string itemId, CancellationToken cancellationToken = default)
+    {
+        _logger.LogInformation("GetAuthenticatedUrlAsync called for itemId: {ItemId}", itemId);
+
+        // Try direct lookup first
+        if (_streamMappings.TryGetValue(itemId, out var streamInfo))
+        {
+            // Log detailed StreamInfo state to diagnose stale alias issues
+            var tokenTimeLeft = streamInfo.TokenExpiresAt.HasValue
+                ? (streamInfo.TokenExpiresAt.Value - DateTime.UtcNow).TotalSeconds
+                : -1;
+            _logger.LogInformation(
+                "Found stream by direct lookup for itemId: {ItemId} - NeedsAuth={NeedsAuth}, IsLive={IsLive}, Urn={Urn}, TokenLeft={TokenLeft:F0}s, AuthUrl={HasAuth}",
+                itemId,
+                streamInfo.NeedsAuthentication,
+                streamInfo.IsLiveStream,
+                string.IsNullOrEmpty(streamInfo.Urn) ? "(empty)" : "set",
+                tokenTimeLeft,
+                !string.IsNullOrEmpty(streamInfo.AuthenticatedUrl));
+
+            // Check for stale alias: only look for fresher stream if current token is EXPIRED or EXPIRING SOON
+            // Don't replace a valid token (>5s left) with a new deferred registration
+            if (!streamInfo.NeedsAuthentication && tokenTimeLeft < 5)
+            {
+                var freshStream = FindFreshestStream();
+                if (freshStream != null && freshStream.Value.Value.NeedsAuthentication)
+                {
+                    _logger.LogWarning(
+                        "Token expiring soon ({TokenLeft:F0}s), switching to fresher deferred stream {ItemId} -> {FreshKey}",
+                        tokenTimeLeft,
+                        itemId,
+                        freshStream.Value.Key);
+                    _streamMappings.AddOrUpdate(itemId, freshStream.Value.Value, (key, old) => freshStream.Value.Value);
+                    return await ValidateAndReturnStreamAsync(itemId, freshStream.Value.Value, cancellationToken).ConfigureAwait(false);
+                }
+            }
+
+            return await ValidateAndReturnStreamAsync(itemId, streamInfo, cancellationToken).ConfigureAwait(false);
+        }
+
+        _logger.LogWarning("No direct match for itemId: {ItemId}, trying fallbacks... (Registered streams: {Count})", itemId, _streamMappings.Count);
+
+        // Fallback: Try to find by GUID variations (with/without dashes)
+        // This handles cases where Jellyfin uses different GUID formats
+        var normalizedId = NormalizeGuid(itemId);
+        if (normalizedId != null)
+        {
+            foreach (var kvp in _streamMappings)
+            {
+                var normalizedKey = NormalizeGuid(kvp.Key);
+                if (normalizedKey != null && normalizedKey == normalizedId)
+                {
+                    _logger.LogInformation(
+                        "Found stream by GUID normalization - Requested: {RequestedId}, Registered: {RegisteredId}",
+                        itemId,
+                        kvp.Key);
+                    var url = await ValidateAndReturnStreamAsync(kvp.Key, kvp.Value, cancellationToken).ConfigureAwait(false);
+                    if (url != null)
+                    {
+                        return url; // Found valid stream
+                    }
+
+                    // Stream found but expired, continue to next fallback
+                    _logger.LogDebug("GUID-normalized stream was expired, trying other fallbacks");
+                    break; // Exit foreach, continue to next fallback strategy
+                }
+            }
+        }
+
+        // Fallback: Live TV channelId_guid format lookup
+        // For Live TV streams, itemId format is "channelId_urnGuid"
+        // Try matching by suffix (urnGuid part) or prefix (channelId part)
+        if (itemId.Contains('_', StringComparison.Ordinal))
+        {
+            var parts = itemId.Split('_', 2);
+            var prefix = parts[0]; // channelId part
+            var suffix = parts.Length > 1 ? parts[1] : null; // urnGuid part
+
+            foreach (var kvp in _streamMappings)
+            {
+                // Check if registered key contains the same suffix (urnGuid)
+                if (suffix != null && kvp.Key.Contains(suffix, StringComparison.OrdinalIgnoreCase))
+                {
+                    _logger.LogInformation(
+                        "Found stream by Live TV suffix match - Requested: {RequestedId}, Registered: {RegisteredId}",
+                        itemId,
+                        kvp.Key);
+                    var url = await ValidateAndReturnStreamAsync(kvp.Key, kvp.Value, cancellationToken).ConfigureAwait(false);
+                    if (url != null)
+                    {
+                        // Also register with the requested itemId for future lookups
+                        _streamMappings.AddOrUpdate(itemId, kvp.Value, (key, old) => kvp.Value);
+                        return url;
+                    }
+                }
+
+                // Check if registered key starts with the same prefix (channelId)
+                if (kvp.Key.StartsWith(prefix + "_", StringComparison.OrdinalIgnoreCase))
+                {
+                    _logger.LogInformation(
+                        "Found stream by Live TV prefix match - Requested: {RequestedId}, Registered: {RegisteredId}",
+                        itemId,
+                        kvp.Key);
+                    var url = await ValidateAndReturnStreamAsync(kvp.Key, kvp.Value, cancellationToken).ConfigureAwait(false);
+                    if (url != null)
+                    {
+                        _streamMappings.AddOrUpdate(itemId, kvp.Value, (key, old) => kvp.Value);
+                        return url;
+                    }
+                }
+            }
+        }
+
+        // Last resort: Use active stream fallbacks (helps when Jellyfin creates random transcoding session IDs)
+        var activeStreams = _streamMappings.Where(kvp =>
+        {
+            if (!kvp.Value.TokenExpiresAt.HasValue)
+            {
+                return true; // No expiry
+            }
+
+            return DateTime.UtcNow < kvp.Value.TokenExpiresAt.Value;
+        }).ToList();
+
+        if (activeStreams.Count == 1)
+        {
+            _logger.LogInformation(
+                "Transcoding session detected: Aliasing {TranscodingId} -> {OriginalId} (single active stream)",
+                itemId,
+                activeStreams[0].Key);
+
+            // Register the transcoding session ID as an alias (update if stale alias exists)
+            _streamMappings.AddOrUpdate(itemId, activeStreams[0].Value, (key, old) => activeStreams[0].Value);
+
+            return await ValidateAndReturnStreamAsync(activeStreams[0].Key, activeStreams[0].Value, cancellationToken).ConfigureAwait(false);
+        }
+
+        // If multiple active streams, use the most recently registered one (likely the one being transcoded)
+        // This handles cases where Jellyfin creates a random transcoding session ID seconds after registration
+        if (activeStreams.Count > 1)
+        {
+            var mostRecent = activeStreams.OrderByDescending(kvp => kvp.Value.RegisteredAt).First();
+            var age = DateTime.UtcNow - mostRecent.Value.RegisteredAt;
+
+            // Only use this fallback if the stream was registered very recently (within 30 seconds)
+            // This indicates it's likely the stream currently being set up for transcoding
+            if (age.TotalSeconds < 30)
+            {
+                _logger.LogInformation(
+                    "Transcoding session detected: Aliasing {TranscodingId} -> {OriginalId} (registered {Seconds:F1}s ago)",
+                    itemId,
+                    mostRecent.Key,
+                    age.TotalSeconds);
+
+                // Register the transcoding session ID as an alias (update if stale alias exists)
+                _streamMappings.AddOrUpdate(itemId, mostRecent.Value, (key, old) => mostRecent.Value);
+
+                return await ValidateAndReturnStreamAsync(mostRecent.Key, mostRecent.Value, cancellationToken).ConfigureAwait(false);
+            }
+        }
+
+        _logger.LogWarning(
+            "No stream mapping found for item {ItemId}. Active streams: {Count}. Registered IDs: {RegisteredIds}",
+            itemId,
+            activeStreams.Count,
+            string.Join(", ", _streamMappings.Keys));
+        return null;
+    }
+
+    /// <summary>
+    /// Validates a stream and returns its URL if valid.
+    /// </summary>
+    private async Task<string?> ValidateAndReturnStreamAsync(string itemId, StreamInfo streamInfo, CancellationToken cancellationToken)
+    {
+        // Handle deferred authentication (first playback after browsing)
+        if (streamInfo.NeedsAuthentication)
+        {
+            _logger.LogInformation(
+                "First playback for item {ItemId} - authenticating stream on-demand",
+                itemId);
+
+            var authenticatedUrl = await AuthenticateOnDemandAsync(itemId, streamInfo, cancellationToken).ConfigureAwait(false);
+            if (authenticatedUrl != null)
+            {
+                return authenticatedUrl;
+            }
+
+            _logger.LogWarning("Failed to authenticate stream on-demand for item {ItemId}", itemId);
+            return null;
+        }
+
+        // For livestreams, use smart caching to avoid hammering the API
+        // Only fetch fresh if token is expiring soon or hasn't been fetched recently
+        if (streamInfo.IsLiveStream && !string.IsNullOrEmpty(streamInfo.Urn))
+        {
+            var now = DateTime.UtcNow;
+            var tokenTimeLeft = streamInfo.TokenExpiresAt.HasValue
+                ? (streamInfo.TokenExpiresAt.Value - now).TotalSeconds
+                : 30; // Assume 30s if no expiry
+
+            var timeSinceLastFetch = streamInfo.LastLivestreamFetchAt.HasValue
+                ? (now - streamInfo.LastLivestreamFetchAt.Value).TotalSeconds
+                : double.MaxValue;
+
+            // Use cached URL if: token has >10s left AND we fetched within last 15 seconds
+            if (tokenTimeLeft > 10 && timeSinceLastFetch < 15)
+            {
+                _logger.LogDebug(
+                    "Livestream {ItemId}: Using cached URL (token expires in {TokenTimeLeft:F0}s, last fetch {TimeSinceFetch:F0}s ago)",
+                    itemId,
+                    tokenTimeLeft,
+                    timeSinceLastFetch);
+                return streamInfo.AuthenticatedUrl;
+            }
+
+            _logger.LogInformation(
+                "Livestream {ItemId}: Fetching fresh URL (token expires in {TokenTimeLeft:F0}s, last fetch {TimeSinceFetch:F0}s ago)",
+                itemId,
+                tokenTimeLeft,
+                timeSinceLastFetch);
+
+            var freshUrl = await FetchFreshStreamUrlAsync(itemId, streamInfo, cancellationToken).ConfigureAwait(false);
+            if (freshUrl != null)
+            {
+                return freshUrl;
+            }
+
+            _logger.LogWarning("Failed to fetch fresh URL for livestream {ItemId}, falling back to cached URL", itemId);
+            // Fall through to use cached URL as fallback
+        }
+
+        // Check if token has expired or is about to expire
+        if (streamInfo.TokenExpiresAt.HasValue)
+        {
+            var now = DateTime.UtcNow;
+            var timeUntilExpiry = streamInfo.TokenExpiresAt.Value - now;
+
+            // Proactive refresh: refresh if token has expired OR will expire within 5 seconds
+            // This prevents race conditions during rapid segment fetching in transcoding
+            var shouldRefresh = now >= streamInfo.TokenExpiresAt.Value || timeUntilExpiry.TotalSeconds <= 5;
+
+            if (shouldRefresh)
+            {
+                var reason = now >= streamInfo.TokenExpiresAt.Value
+                    ? "expired"
+                    : $"expiring in {timeUntilExpiry.TotalSeconds:F1}s";
+
+                _logger.LogWarning(
+                    "Token {Reason} for item {ItemId} (expires at {ExpiresAt}, now is {Now}) - attempting to refresh",
+                    reason,
+                    itemId,
+                    streamInfo.TokenExpiresAt.Value,
+                    now);
+
+                // Try to refresh the token
+                var refreshedUrl = await RefreshTokenAsync(itemId, streamInfo, cancellationToken).ConfigureAwait(false);
+                if (refreshedUrl != null)
+                {
+                    _logger.LogInformation("Successfully refreshed token for item {ItemId}", itemId);
+                    return refreshedUrl;
+                }
+
+                _logger.LogWarning("Failed to refresh token for item {ItemId}, removing mapping", itemId);
+                _streamMappings.TryRemove(itemId, out _);
+                return null;
+            }
+
+            _logger.LogDebug(
+                "Token valid for item {ItemId} (expires at {ExpiresAt}, {TimeLeft:F1}s remaining)",
+                itemId,
+                streamInfo.TokenExpiresAt.Value,
+                timeUntilExpiry.TotalSeconds);
+        }
+
+        return streamInfo.AuthenticatedUrl;
+    }
+
+    /// <summary>
+    /// Fetches a fresh stream URL from the SRF API for livestreams.
+    /// </summary>
+    private async Task<string?> FetchFreshStreamUrlAsync(string itemId, StreamInfo streamInfo, CancellationToken cancellationToken)
+    {
+        if (string.IsNullOrEmpty(streamInfo.Urn))
+        {
+            return null;
+        }
+
+        try
+        {
+            // Use short cache duration (5 min) for livestreams
+            var mediaComposition = await _compositionFetcher.GetMediaCompositionAsync(streamInfo.Urn, cancellationToken, 5).ConfigureAwait(false);
+
+            if (mediaComposition?.ChapterList == null || mediaComposition.ChapterList.Count == 0)
+            {
+                _logger.LogWarning("No chapters found when refreshing livestream URL for URN: {Urn}", streamInfo.Urn);
+                return null;
+            }
+
+            var chapter = mediaComposition.ChapterList[0];
+            var config = Plugin.Instance?.Configuration ?? new PluginConfiguration();
+            var streamUrl = _streamResolver.GetStreamUrl(chapter, config.QualityPreference);
+
+            if (string.IsNullOrEmpty(streamUrl))
+            {
+                _logger.LogWarning("No stream URL found when refreshing livestream for URN: {Urn}", streamInfo.Urn);
+                return null;
+            }
+
+            // Authenticate the fresh URL
+            var authenticatedUrl = await _streamResolver.GetAuthenticatedStreamUrlAsync(streamUrl, cancellationToken).ConfigureAwait(false);
+
+            // Update the stored stream info with the fresh data
+            var newTokenExpiry = ExtractTokenExpiry(authenticatedUrl);
+            streamInfo.AuthenticatedUrl = authenticatedUrl;
+            streamInfo.UnauthenticatedUrl = StripAuthenticationFromUrl(authenticatedUrl);
+            streamInfo.TokenExpiresAt = newTokenExpiry;
+            streamInfo.LastLivestreamFetchAt = DateTime.UtcNow;
+
+            _logger.LogInformation(
+                "Fetched fresh livestream URL for item {ItemId} (URN: {Urn}, new expiry: {Expiry})",
+                itemId,
+                streamInfo.Urn,
+                newTokenExpiry);
+
+            return authenticatedUrl;
+        }
+        catch (Exception ex)
+        {
+            _logger.LogError(ex, "Error fetching fresh stream URL for livestream {ItemId} (URN: {Urn})", itemId, streamInfo.Urn);
+            return null;
+        }
+    }
+
+    /// <summary>
+    /// Attempts to refresh an expired token.
+    /// </summary>
+    private async Task<string?> RefreshTokenAsync(string itemId, StreamInfo streamInfo, CancellationToken cancellationToken)
+    {
+        if (string.IsNullOrEmpty(streamInfo.UnauthenticatedUrl))
+        {
+            _logger.LogWarning("Cannot refresh token for {ItemId} - no unauthenticated URL stored", itemId);
+            return null;
+        }
+
+        try
+        {
+            // Re-authenticate the stream URL
+            var newAuthenticatedUrl = await _streamResolver.GetAuthenticatedStreamUrlAsync(
+                streamInfo.UnauthenticatedUrl,
+                cancellationToken).ConfigureAwait(false);
+
+            if (string.IsNullOrEmpty(newAuthenticatedUrl))
+            {
+                return null;
+            }
+
+            // Update the stream info with the new token
+            var newTokenExpiry = ExtractTokenExpiry(newAuthenticatedUrl);
+            streamInfo.AuthenticatedUrl = newAuthenticatedUrl;
+            streamInfo.TokenExpiresAt = newTokenExpiry;
+
+            _logger.LogInformation(
+                "Refreshed token for item {ItemId} (new expiry: {ExpiresAt} UTC)",
+                itemId,
+                newTokenExpiry);
+
+            return newAuthenticatedUrl;
+        }
+        catch (Exception ex)
+        {
+            _logger.LogError(ex, "Error refreshing token for item {ItemId}", itemId);
+            return null;
+        }
+    }
+
+    /// <summary>
+    /// Authenticates a stream on-demand (first playback after browsing).
+    /// </summary>
+    private async Task<string?> AuthenticateOnDemandAsync(string itemId, StreamInfo streamInfo, CancellationToken cancellationToken)
+    {
+        if (string.IsNullOrEmpty(streamInfo.UnauthenticatedUrl))
+        {
+            _logger.LogWarning("Cannot authenticate on-demand for {ItemId} - no unauthenticated URL stored", itemId);
+            return null;
+        }
+
+        try
+        {
+            // Authenticate the stream URL
+            var authenticatedUrl = await _streamResolver.GetAuthenticatedStreamUrlAsync(
+                streamInfo.UnauthenticatedUrl,
+                cancellationToken).ConfigureAwait(false);
+
+            if (string.IsNullOrEmpty(authenticatedUrl))
+            {
+                return null;
+            }
+
+            // Update the stream info - no longer needs authentication
+            var tokenExpiry = ExtractTokenExpiry(authenticatedUrl);
+            streamInfo.AuthenticatedUrl = authenticatedUrl;
+            streamInfo.TokenExpiresAt = tokenExpiry;
+            streamInfo.NeedsAuthentication = false;
+
+            if (streamInfo.IsLiveStream)
+            {
+                streamInfo.LastLivestreamFetchAt = DateTime.UtcNow;
+            }
+
+            _logger.LogInformation(
+                "Authenticated stream on-demand for item {ItemId} (expires at {ExpiresAt} UTC)",
+                itemId,
+                tokenExpiry);
+
+            return authenticatedUrl;
+        }
+        catch (Exception ex)
+        {
+            _logger.LogError(ex, "Error authenticating stream on-demand for item {ItemId}", itemId);
+            return null;
+        }
+    }
+
+    /// <summary>
+    /// Strips authentication parameters from a URL to get the base unauthenticated URL.
+    /// </summary>
+    private string StripAuthenticationFromUrl(string url)
+    {
+        try
+        {
+            var uri = new Uri(url);
+            var query = uri.Query;
+
+            // Remove hdnts authentication parameter (Akamai token authentication)
+            if (query.Contains("hdnts=", StringComparison.OrdinalIgnoreCase))
+            {
+                // Keep other parameters like caption, webvttbaseurl
+                var queryParams = System.Web.HttpUtility.ParseQueryString(query);
+                queryParams.Remove("hdnts");
+
+                var newQuery = queryParams.Count > 0 ? "?" + queryParams.ToString() : string.Empty;
+                return $"{uri.Scheme}://{uri.Host}{uri.AbsolutePath}{newQuery}";
+            }
+
+            return url;
+        }
+        catch (Exception ex)
+        {
+            _logger.LogWarning(ex, "Failed to strip authentication from URL, using as-is");
+            return url;
+        }
+    }
+
+    /// <summary>
+    /// Normalizes a GUID string to a consistent format for comparison.
+    /// </summary>
+    private string? NormalizeGuid(string input)
+    {
+        if (string.IsNullOrEmpty(input))
+        {
+            return null;
+        }
+
+        // Try to parse as GUID (handles both with and without dashes)
+        if (Guid.TryParse(input, out var guid))
+        {
+            return guid.ToString("N"); // Always return format without dashes
+        }
+
+        return null;
+    }
+
+    /// <summary>
+    /// Finds the freshest (most recently registered) stream that needs authentication or has a valid token.
+    /// </summary>
+    /// <returns>The freshest stream entry, or null if none found.</returns>
+    private KeyValuePair<string, StreamInfo>? FindFreshestStream()
+    {
+        var now = DateTime.UtcNow;
+
+        // Find streams that either need authentication (fresh deferred registration)
+        // or have tokens that aren't expired yet
+        var candidates = _streamMappings.Where(kvp =>
+        {
+            if (kvp.Value.NeedsAuthentication)
+            {
+                return true; // Fresh deferred registration
+            }
+
+            if (!kvp.Value.TokenExpiresAt.HasValue)
+            {
+                return true; // No expiry
+            }
+
+            // Token not expired yet
+            return now < kvp.Value.TokenExpiresAt.Value;
+        }).ToList();
+
+        if (candidates.Count == 0)
+        {
+            return null;
+        }
+
+        // Prefer the most recently registered stream
+        return candidates.OrderByDescending(kvp => kvp.Value.RegisteredAt).First();
+    }
+
+    /// <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 = await GetAuthenticatedUrlAsync(itemId, cancellationToken).ConfigureAwait(false);
+        if (authenticatedUrl == null)
+        {
+            return null;
+        }
+
+        try
+        {
+            _logger.LogInformation("Fetching manifest from: {Url}", authenticatedUrl);
+            using var httpClient = _httpClientFactory.CreateClient(NamedClient.Default);
+            var manifestContent = await httpClient.GetStringAsync(authenticatedUrl, cancellationToken).ConfigureAwait(false);
+
+            _logger.LogDebug("Original manifest ({Length} bytes):\n{Content}", manifestContent.Length, manifestContent);
+
+            // Rewrite the manifest to replace Akamai URLs with proxy URLs
+            var rewrittenContent = RewriteManifestUrls(manifestContent, authenticatedUrl, baseProxyUrl);
+
+            _logger.LogDebug("Rewritten manifest for item {ItemId} ({Length} bytes):\n{Content}", itemId, rewrittenContent.Length, rewrittenContent);
+            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 = await GetAuthenticatedUrlAsync(itemId, cancellationToken).ConfigureAwait(false);
+        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 - BaseUri: {BaseUri}, BaseUrl: {BaseUrl}, SegmentPath: {SegmentPath}, FullUrl: {FullUrl}",
+                authenticatedUrl,
+                baseUrl,
+                segmentPath,
+                segmentUrl);
+            using var httpClient = _httpClientFactory.CreateClient(NamedClient.Default);
+            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])}";
+
+        // Extract query parameters from proxyBaseUrl to propagate them
+        var queryParams = string.Empty;
+        var queryStart = proxyBaseUrl.IndexOf('?', StringComparison.Ordinal);
+        if (queryStart >= 0)
+        {
+            queryParams = proxyBaseUrl[queryStart..];
+            proxyBaseUrl = proxyBaseUrl[..queryStart]; // Remove query from base URL
+            _logger.LogDebug("Extracted query parameters from proxy URL: {QueryParams}", queryParams);
+        }
+
+        // Helper function to rewrite a URL to proxy
+        string RewriteUrl(string url)
+        {
+            // Try to parse as absolute URL
+            if (Uri.TryCreate(url, UriKind.Absolute, out var absoluteUri))
+            {
+                // Check if it's from the same CDN host
+                if (!absoluteUri.Host.Equals(baseUri.Host, StringComparison.OrdinalIgnoreCase))
+                {
+                    // External URL (e.g., subtitles from different domain) - leave as-is
+                    _logger.LogDebug("Leaving external URL unchanged: {Url}", url);
+                    return url;
+                }
+
+                // Same host - extract just the filename (last path segment)
+                var segments = absoluteUri.AbsolutePath.Split('/');
+                var filename = segments[^1];
+                return $"{proxyBaseUrl}/{filename}{queryParams}";
+            }
+
+            // Relative URL - extract just the path without query params
+            var path = url;
+            var queryIndex = path.IndexOf('?', StringComparison.Ordinal);
+            if (queryIndex >= 0)
+            {
+                path = path[..queryIndex];
+            }
+
+            return $"{proxyBaseUrl}/{path}{queryParams}";
+        }
+
+        // Pattern 1: Standalone URL lines (non-# lines ending with media extensions)
+        var pattern1 = @"(?:^|\n)([^#\n][^\n]*\.(?:m3u8|ts|mp4|m4s|aac)[^\n]*)";
+        var rewritten = Regex.Replace(manifestContent, pattern1, match =>
+        {
+            var url = match.Groups[1].Value.Trim();
+            return $"\n{RewriteUrl(url)}";
+        });
+
+        // Pattern 2: URI="..." attributes in HLS tags (e.g., #EXT-X-MEDIA, #EXT-X-I-FRAME-STREAM-INF)
+        var pattern2 = @"URI=""([^""]+)""";
+        rewritten = Regex.Replace(rewritten, pattern2, match =>
+        {
+            var url = match.Groups[1].Value;
+            return $"URI=\"{RewriteUrl(url)}\"";
+        });
+
+        return rewritten;
+    }
+
+    /// <summary>
+    /// Extracts the token expiry time from a stream URL with hdnts parameter.
+    /// </summary>
+    /// <param name="url">The authenticated stream URL.</param>
+    /// <returns>The expiry time, or null if not found.</returns>
+    private DateTime? ExtractTokenExpiry(string url)
+    {
+        try
+        {
+            var uri = new Uri(url);
+            var query = uri.Query;
+
+            // Parse the hdnts parameter (e.g., "exp=1763282021")
+            var match = Regex.Match(query, @"exp=(\d+)");
+            if (match.Success && long.TryParse(match.Groups[1].Value, out var unixTimestamp))
+            {
+                // Convert Unix timestamp to DateTime
+                var expiry = DateTimeOffset.FromUnixTimeSeconds(unixTimestamp).UtcDateTime;
+                _logger.LogDebug("Extracted token expiry from URL: {Expiry} UTC (unix: {Unix})", expiry, unixTimestamp);
+                return expiry;
+            }
+
+            _logger.LogDebug("No token expiry found in URL: {Url}", url);
+            return null;
+        }
+        catch (Exception ex)
+        {
+            _logger.LogWarning(ex, "Failed to extract token expiry from URL: {Url}", url);
+            return null;
+        }
+    }
+
+    /// <summary>
+    /// Cleans up old and expired stream mappings.
+    /// </summary>
+    public void CleanupOldMappings()
+    {
+        var cutoff = DateTime.UtcNow.AddHours(-24);
+        var now = DateTime.UtcNow;
+        var keysToRemove = new System.Collections.Generic.List<string>();
+
+        foreach (var kvp in _streamMappings)
+        {
+            var shouldRemove = false;
+
+            // Remove if registered more than 24 hours ago
+            if (kvp.Value.RegisteredAt < cutoff)
+            {
+                shouldRemove = true;
+                _logger.LogDebug("Marking item {ItemId} for cleanup (old registration)", kvp.Key);
+            }
+
+            // Remove if token has expired
+            if (kvp.Value.TokenExpiresAt.HasValue && kvp.Value.TokenExpiresAt.Value <= now)
+            {
+                shouldRemove = true;
+                _logger.LogDebug("Marking item {ItemId} for cleanup (expired token)", kvp.Key);
+            }
+
+            if (shouldRemove)
+            {
+                keysToRemove.Add(kvp.Key);
+            }
+        }
+
+        foreach (var key in keysToRemove)
+        {
+            _streamMappings.TryRemove(key, out _);
+        }
+
+        if (keysToRemove.Count > 0)
+        {
+            _logger.LogInformation("Cleaned up {Count} old/expired stream mappings", keysToRemove.Count);
+        }
+    }
+
+    /// <summary>
+    /// Registers a stream with multiple GUID format variations to handle Jellyfin's ID transformations.
+    /// </summary>
+    /// <param name="itemId">The item ID.</param>
+    /// <param name="streamInfo">The stream information to register.</param>
+    private void RegisterWithGuidFormats(string itemId, StreamInfo streamInfo)
+    {
+        _streamMappings.AddOrUpdate(itemId, streamInfo, (key, old) => streamInfo);
+
+        if (Guid.TryParse(itemId, out var guid))
+        {
+            var formats = new[]
+            {
+                guid.ToString("N"), // Without dashes: 00000000000000000000000000000000
+                guid.ToString("D"), // With dashes: 00000000-0000-0000-0000-000000000000
+                guid.ToString("B"), // With braces: {00000000-0000-0000-0000-000000000000}
+            };
+
+            foreach (var format in formats)
+            {
+                if (format != itemId) // Don't duplicate the original
+                {
+                    _streamMappings.AddOrUpdate(format, streamInfo, (key, old) => streamInfo);
+                }
+            }
+
+            _logger.LogDebug("Registered stream with {Count} GUID format variations", formats.Length);
+        }
+    }
+
+    /// <summary>
+    /// Stream information.
+    /// </summary>
+    private sealed class StreamInfo
+    {
+        public string AuthenticatedUrl { get; set; } = string.Empty;
+
+        public string UnauthenticatedUrl { get; set; } = string.Empty;
+
+        public DateTime RegisteredAt { get; set; }
+
+        public DateTime? TokenExpiresAt { get; set; }
+
+        /// <summary>
+        /// Gets or sets the SRF URN for this stream (used for re-fetching fresh URLs).
+        /// </summary>
+        public string? Urn { get; set; }
+
+        /// <summary>
+        /// Gets or sets a value indicating whether this is a livestream.
+        /// Livestreams always fetch fresh URLs from the API to avoid stale CDN paths.
+        /// </summary>
+        public bool IsLiveStream { get; set; }
+
+        /// <summary>
+        /// Gets or sets when this livestream URL was last fetched from the API.
+        /// Used to prevent rapid-fire API calls from clients like Android TV.
+        /// </summary>
+        public DateTime? LastLivestreamFetchAt { get; set; }
+
+        /// <summary>
+        /// Gets or sets a value indicating whether this stream needs authentication on first access.
+        /// True when registered via RegisterStreamDeferred (authentication deferred until playback).
+        /// </summary>
+        public bool NeedsAuthentication { get; set; }
+    }
+}

Jellyfin.Plugin.SRFPlay/Services/StreamUrlResolver.cs

@@ -6,6 +6,9 @@ using System.Threading;
 using System.Threading.Tasks;
 using Jellyfin.Plugin.SRFPlay.Api.Models;
 using Jellyfin.Plugin.SRFPlay.Configuration;
+using Jellyfin.Plugin.SRFPlay.Constants;
+using Jellyfin.Plugin.SRFPlay.Services.Interfaces;
+using MediaBrowser.Common.Net;
 using Microsoft.Extensions.Logging;
 
 namespace Jellyfin.Plugin.SRFPlay.Services;
@@ -13,20 +16,20 @@ namespace Jellyfin.Plugin.SRFPlay.Services;
 /// <summary>
 /// Service for resolving stream URLs from media composition resources.
 /// </summary>
-public class StreamUrlResolver : IDisposable
+public class StreamUrlResolver : IStreamUrlResolver
 {
     private readonly ILogger<StreamUrlResolver> _logger;
-    private readonly HttpClient _httpClient;
-    private bool _disposed;
+    private readonly IHttpClientFactory _httpClientFactory;
 
     /// <summary>
     /// Initializes a new instance of the <see cref="StreamUrlResolver"/> class.
     /// </summary>
     /// <param name="logger">The logger instance.</param>
-    public StreamUrlResolver(ILogger<StreamUrlResolver> logger)
+    /// <param name="httpClientFactory">The HTTP client factory.</param>
+    public StreamUrlResolver(ILogger<StreamUrlResolver> logger, IHttpClientFactory httpClientFactory)
     {
         _logger = logger;
-        _httpClient = new HttpClient();
+        _httpClientFactory = httpClientFactory;
     }
 
     /// <summary>
@@ -87,6 +90,17 @@ public class StreamUrlResolver : IDisposable
             chapter.Id,
             hlsResources.Count);
 
+        // Log all HLS resources with their quality info to help debug quality selection
+        foreach (var resource in hlsResources)
+        {
+            _logger.LogInformation(
+                "Available HLS resource - Quality={Quality}, Protocol={Protocol}, Streaming={Streaming}, URL={Url}",
+                resource.Quality ?? "NULL",
+                resource.Protocol ?? "NULL",
+                resource.Streaming ?? "NULL",
+                resource.Url);
+        }
+
         if (hlsResources.Count == 0)
         {
             _logger.LogWarning("No HLS resources found for chapter: {ChapterId}", chapter.Id);
@@ -114,6 +128,10 @@ public class StreamUrlResolver : IDisposable
         }
 
         // Select based on quality preference
+        _logger.LogInformation(
+            "Selecting stream with quality preference: {QualityPreference}",
+            qualityPreference);
+
         Resource? selectedResource = qualityPreference switch
         {
             QualityPreference.HD => SelectHDResource(hlsResources) ?? SelectBestAvailableResource(hlsResources),
@@ -127,7 +145,7 @@ public class StreamUrlResolver : IDisposable
             _logger.LogDebug(
                 "Selected stream for chapter {ChapterId}: Quality={Quality}, Protocol={Protocol}, URL={Url}",
                 chapter.Id,
-                selectedResource.Quality,
+                selectedResource.Quality ?? "NULL",
                 selectedResource.Protocol,
                 selectedResource.Url);
             return selectedResource.Url;
@@ -144,23 +162,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;
@@ -243,11 +244,12 @@ public class StreamUrlResolver : IDisposable
 
             // Build ACL path: /{segment1}/{segment2}/*
             var aclPath = $"/{pathSegments[0]}/{pathSegments[1]}/*";
-            var tokenUrl = $"https://tp.srgssr.ch/akahd/token?acl={Uri.EscapeDataString(aclPath)}";
+            var tokenUrl = $"{ApiEndpoints.AkamaiTokenEndpoint}?acl={Uri.EscapeDataString(aclPath)}";
 
             _logger.LogDebug("Fetching auth token from: {TokenUrl}", tokenUrl);
 
-            var response = await _httpClient.GetAsync(tokenUrl, cancellationToken).ConfigureAwait(false);
+            using var httpClient = _httpClientFactory.CreateClient(NamedClient.Default);
+            var response = await httpClient.GetAsync(tokenUrl, cancellationToken).ConfigureAwait(false);
             response.EnsureSuccessStatusCode();
 
             var jsonContent = await response.Content.ReadAsStringAsync(cancellationToken).ConfigureAwait(false);
@@ -278,28 +280,4 @@ public class StreamUrlResolver : IDisposable
             return streamUrl; // Return original URL as fallback
         }
     }
-
-    /// <inheritdoc/>
-    public void Dispose()
-    {
-        Dispose(true);
-        GC.SuppressFinalize(this);
-    }
-
-    /// <summary>
-    /// Releases the unmanaged resources and optionally releases the managed resources.
-    /// </summary>
-    /// <param name="disposing">True to release both managed and unmanaged resources; false to release only unmanaged resources.</param>
-    protected virtual void Dispose(bool disposing)
-    {
-        if (!_disposed)
-        {
-            if (disposing)
-            {
-                _httpClient?.Dispose();
-            }
-
-            _disposed = true;
-        }
-    }
 }

Jellyfin.Plugin.SRFPlay/Utilities/Extensions.cs

@@ -0,0 +1,41 @@
+using Jellyfin.Plugin.SRFPlay.Configuration;
+using MediaBrowser.Controller.Entities;
+
+namespace Jellyfin.Plugin.SRFPlay.Utilities;
+
+/// <summary>
+/// Extension methods for common plugin operations.
+/// </summary>
+public static class Extensions
+{
+    /// <summary>
+    /// Gets the SRF URN from the item's provider IDs.
+    /// </summary>
+    /// <param name="item">The base item.</param>
+    /// <returns>The SRF URN, or null if not found or empty.</returns>
+    public static string? GetSrfUrn(this BaseItem item)
+    {
+        return item.ProviderIds.TryGetValue("SRF", out var urn) && !string.IsNullOrEmpty(urn)
+            ? urn
+            : null;
+    }
+
+    /// <summary>
+    /// Converts the BusinessUnit enum to its lowercase string representation.
+    /// </summary>
+    /// <param name="businessUnit">The business unit.</param>
+    /// <returns>The lowercase string representation.</returns>
+    public static string ToLowerString(this BusinessUnit businessUnit)
+    {
+        return businessUnit.ToString().ToLowerInvariant();
+    }
+
+    /// <summary>
+    /// Gets the plugin configuration safely, returning null if not available.
+    /// </summary>
+    /// <returns>The plugin configuration, or null if not available.</returns>
+    public static PluginConfiguration? GetPluginConfig()
+    {
+        return Plugin.Instance?.Configuration;
+    }
+}

Jellyfin.Plugin.SRFPlay/Utilities/MimeTypeHelper.cs

@@ -0,0 +1,74 @@
+using System;
+
+namespace Jellyfin.Plugin.SRFPlay.Utilities;
+
+/// <summary>
+/// Helper class for determining MIME content types.
+/// </summary>
+public static class MimeTypeHelper
+{
+    /// <summary>
+    /// Gets the MIME content type for an image based on URL or file extension.
+    /// </summary>
+    /// <param name="url">The image URL.</param>
+    /// <returns>The MIME content type, defaulting to "image/jpeg" for SRF images.</returns>
+    public static string GetImageContentType(string? url)
+    {
+        if (string.IsNullOrEmpty(url))
+        {
+            return "image/jpeg";
+        }
+
+        var uri = new Uri(url);
+        var path = uri.AbsolutePath.ToLowerInvariant();
+
+        if (path.EndsWith(".png", StringComparison.Ordinal))
+        {
+            return "image/png";
+        }
+
+        if (path.EndsWith(".gif", StringComparison.Ordinal))
+        {
+            return "image/gif";
+        }
+
+        if (path.EndsWith(".webp", StringComparison.Ordinal))
+        {
+            return "image/webp";
+        }
+
+        if (path.EndsWith(".jpg", StringComparison.Ordinal) || path.EndsWith(".jpeg", StringComparison.Ordinal))
+        {
+            return "image/jpeg";
+        }
+
+        // Default to JPEG for SRF images (most common)
+        return "image/jpeg";
+    }
+
+    /// <summary>
+    /// Gets the MIME content type for a media segment based on file extension.
+    /// </summary>
+    /// <param name="path">The segment path or filename.</param>
+    /// <returns>The MIME content type.</returns>
+    public static string GetSegmentContentType(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/Utilities/PlaceholderImageGenerator.cs

@@ -0,0 +1,141 @@
+using System.IO;
+using SkiaSharp;
+
+namespace Jellyfin.Plugin.SRFPlay.Utilities;
+
+/// <summary>
+/// Generates placeholder images for content without thumbnails.
+/// </summary>
+public static class PlaceholderImageGenerator
+{
+    private const int Width = 640;
+    private const int Height = 360; // 16:9 aspect ratio
+
+    /// <summary>
+    /// Generates a placeholder image with the given text centered.
+    /// </summary>
+    /// <param name="text">The text to display (typically channel/show name).</param>
+    /// <returns>A memory stream containing the PNG image.</returns>
+    public static MemoryStream GeneratePlaceholder(string text)
+    {
+        using var surface = SKSurface.Create(new SKImageInfo(Width, Height));
+        var canvas = surface.Canvas;
+
+        // Dark gradient background
+        using var backgroundPaint = new SKPaint();
+        using var shader = SKShader.CreateLinearGradient(
+            new SKPoint(0, 0),
+            new SKPoint(Width, Height),
+            new[] { new SKColor(45, 45, 48), new SKColor(28, 28, 30) },
+            null,
+            SKShaderTileMode.Clamp);
+        backgroundPaint.Shader = shader;
+        canvas.DrawRect(0, 0, Width, Height, backgroundPaint);
+
+        // Text
+        using var textPaint = new SKPaint
+        {
+            Color = SKColors.White,
+            IsAntialias = true,
+            TextAlign = SKTextAlign.Center,
+            Typeface = SKTypeface.FromFamilyName("Arial", SKFontStyle.Bold)
+        };
+
+        // Calculate font size and wrap text if needed
+        float fontSize = 48;
+        textPaint.TextSize = fontSize;
+        var maxWidth = Width * 0.85f;
+        var maxHeight = Height * 0.8f;
+
+        var lines = WrapText(text, textPaint, maxWidth, maxHeight, ref fontSize);
+
+        // Draw each line centered
+        var lineHeight = fontSize * 1.2f;
+        var totalHeight = lines.Count * lineHeight;
+        var startY = ((Height - totalHeight) / 2) + fontSize;
+
+        foreach (var line in lines)
+        {
+            canvas.DrawText(line, Width / 2, startY, textPaint);
+            startY += lineHeight;
+        }
+
+        // Encode to PNG
+        using var image = surface.Snapshot();
+        using var data = image.Encode(SKEncodedImageFormat.Png, 100);
+
+        var stream = new MemoryStream();
+        data.SaveTo(stream);
+        stream.Position = 0;
+        return stream;
+    }
+
+    /// <summary>
+    /// Wraps text to fit within the specified width and height constraints.
+    /// </summary>
+    /// <param name="text">The text to wrap.</param>
+    /// <param name="paint">The paint to use for measuring.</param>
+    /// <param name="maxWidth">Maximum width for each line.</param>
+    /// <param name="maxHeight">Maximum total height.</param>
+    /// <param name="fontSize">Font size (will be adjusted if needed).</param>
+    /// <returns>List of text lines.</returns>
+    private static System.Collections.Generic.List<string> WrapText(
+        string text,
+        SKPaint paint,
+        float maxWidth,
+        float maxHeight,
+        ref float fontSize)
+    {
+        const float minFontSize = 20;
+        var words = text.Split(' ');
+        var lines = new System.Collections.Generic.List<string>();
+
+        while (fontSize >= minFontSize)
+        {
+            paint.TextSize = fontSize;
+            lines.Clear();
+
+            var currentLine = string.Empty;
+            foreach (var word in words)
+            {
+                var testLine = string.IsNullOrEmpty(currentLine) ? word : $"{currentLine} {word}";
+                var testWidth = paint.MeasureText(testLine);
+
+                if (testWidth > maxWidth && !string.IsNullOrEmpty(currentLine))
+                {
+                    lines.Add(currentLine);
+                    currentLine = word;
+                }
+                else
+                {
+                    currentLine = testLine;
+                }
+            }
+
+            if (!string.IsNullOrEmpty(currentLine))
+            {
+                lines.Add(currentLine);
+            }
+
+            // Check if total height fits
+            var lineHeight = fontSize * 1.2f;
+            var totalHeight = lines.Count * lineHeight;
+
+            if (totalHeight <= maxHeight)
+            {
+                break;
+            }
+
+            // Reduce font size and try again
+            fontSize -= 2;
+        }
+
+        // If still doesn't fit, just return what we have
+        if (lines.Count == 0)
+        {
+            lines.Add(text);
+        }
+
+        return lines;
+    }
+}

Jellyfin.Plugin.SRFPlay/Utilities/UrnHelper.cs

@@ -0,0 +1,27 @@
+using System;
+using System.Security.Cryptography;
+using System.Text;
+
+namespace Jellyfin.Plugin.SRFPlay.Utilities;
+
+/// <summary>
+/// Helper class for URN-related operations.
+/// </summary>
+public static class UrnHelper
+{
+    /// <summary>
+    /// Generates a deterministic GUID from a URN.
+    /// This ensures the same URN always produces the same GUID.
+    /// MD5 is used for non-cryptographic purposes only (generating stable IDs).
+    /// </summary>
+    /// <param name="urn">The URN to convert.</param>
+    /// <returns>A deterministic GUID string.</returns>
+#pragma warning disable CA5351 // MD5 is used for non-cryptographic purposes (ID generation)
+    public static string ToGuid(string urn)
+    {
+        var hash = MD5.HashData(Encoding.UTF8.GetBytes(urn));
+        var guid = new Guid(hash);
+        return guid.ToString();
+    }
+#pragma warning restore CA5351
+}

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

@@ -1,6 +1,20 @@
 # Jellyfin SRF Play Plugin
 
-A Jellyfin plugin for accessing SRF Play (Swiss Radio and Television) video-on-demand content.
+A Jellyfin plugin for accessing SRF Play (Swiss Radio and Television) video-on-demand content and live sports streaming.
+
+## Status
+
+**Beta/Alpha** - This plugin has been tested on two Jellyfin instances and is working. Some clients may experience issues with hardware decoding, which appears to be client-specific behavior.
+
+## Quick Install
+
+Add this repository URL in Jellyfin (Dashboard → Plugins → Repositories):
+
+```
+https://gitea.tourolle.paris/dtourolle/jellyfin-srfPlay/raw/branch/master/manifest.json
+```
+
+Then install "SRF Play" from the plugin catalog.
 
 ## Features
 
@@ -14,95 +28,41 @@ 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
 
-## Project Status
+## Screenshots
 
-### ✅ Completed Components
+### Channel Menu
+![SRF Play Menu](res/menu.png)
 
-#### Phase 1: Project Setup
-- ✅ Renamed from Template to SRFPlay
-- ✅ Updated all namespaces and identifiers
-- ✅ Configured plugin metadata (ID, name)
+The main channel interface showing the content folders.
+### Playback
+![SRF Play Playback](res/playback.png)
 
-#### Phase 2: Core API Infrastructure
-- ✅ API Models (MediaComposition, Chapter, Resource, Show, Episode)
-- ✅ SRF API Client with HTTP client wrapper
-- ✅ JSON deserialization support
-- ✅ Error handling and logging
+Video playback with HLS streaming support and quality selection.
 
-#### Phase 3: Configuration
-- ✅ Business unit selection (SRF/RTS/RSI/RTR/SWI)
-- ✅ Quality preferences (Auto/SD/HD)
-- ✅ Content refresh intervals
-- ✅ Expiration check settings
-- ✅ Cache duration configuration
-- ✅ HTML configuration page
+## Testing
 
-#### Phase 4: Services
-- ✅ Stream URL Resolver
-  - HLS stream selection
-  - Quality-based filtering
-  - DRM content filtering
-  - Content expiration checking
-  - Akamai token authentication
-  - Upcoming livestream detection
-- ✅ Metadata Cache Service
-  - Efficient caching with configurable duration
-  - Thread-safe with ReaderWriterLockSlim
-  - IDisposable implementation
-  - Dynamic TTL for scheduled livestreams
-- ✅ Content Expiration Service
-  - Automatic expiration checking
-  - Library cleanup of expired content
-  - Statistics and monitoring
-- ✅ Content Refresh Service
-  - Latest and trending content discovery
-  - Scheduled sports livestreams
-  - Automatic cache population
-  - Recommendations system
+The plugin includes comprehensive testing:
 
-#### Phase 5: Content Providers
-- ✅ Series Provider (for show metadata)
-- ✅ Episode Provider (for episode metadata)
-- ✅ Image Provider (for thumbnails and artwork)
-- ✅ Media Provider (for playback URLs and HLS streams)
+- **Unit tests** (xUnit framework) for core services
+- **API spec validation tests** for all business units (SRF, RTS, RSI, RTR, SWI)
+- **Integration testing** - Tested on multiple Jellyfin instances with VOD and live sports streaming
 
-#### Phase 6: Scheduled Tasks
-- ✅ Content Refresh Task
-  - Periodic discovery of new content
-  - Configurable refresh intervals
-- ✅ Expiration Check Task
-  - Automatic cleanup of expired content
-  - Configurable check intervals
+**Run tests:**
+```bash
+# All tests
+dotnet test
 
-#### Phase 7: Dependency Injection & Integration
-- ✅ Service registration (ServiceRegistrator)
-- ✅ Jellyfin provider interfaces implementation
-- ✅ Plugin initialization and configuration
+# Unit tests only
+dotnet test --filter "Category!=Integration&Category!=APISpec"
 
-#### Phase 8: Live Sports Streaming
-- ✅ Play v3 API integration for scheduled livestreams
-- ✅ Sports events folder in channel
-- ✅ Upcoming event detection and display
-- ✅ Akamai token authentication for streams
-- ✅ Dynamic cache refresh for live events
-- ✅ Event scheduling with ValidFrom/ValidTo handling
-- ✅ Automatic stream URL resolution when events go live
+# API spec tests only
+dotnet test --filter "Category=APISpec"
 
-### ✅ Build Status
-**Successfully compiling!** All code analysis warnings resolved.
+# With coverage
+dotnet test --collect:"XPlat Code Coverage"
+```
 
-### 🧪 Testing Status
-- [ ] Unit tests
-- [ ] Integration testing with Jellyfin instance
-- [ ] End-to-end playback testing for VOD content
-- [ ] Live sports streaming validation
-
-### 📝 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
-5. Performance optimization if needed
+See [Test Documentation](Jellyfin.Plugin.SRFPlay.Tests/README.md) for more details.
 
 ## API Information
 
@@ -152,7 +112,7 @@ dotnet build
 
 The compiled plugin will be in `bin/Debug/net8.0/`
 
-## Installation
+## Manual Installation
 
 1. Build the plugin (see above)
 2. Copy the compiled DLL to your Jellyfin plugins directory
@@ -262,9 +222,7 @@ Currently focused on SRF but easily extensible.
 
 ## Development
 
-### Current Status
-
-All core functionality is implemented and compiling successfully! The plugin includes:
+The plugin includes:
 - Complete API integration with SRF Play (Integration Layer v2.0 and Play v3)
 - **Live sports streaming** with scheduled event detection
 - Channel with Latest, Trending, and Live Sports folders
@@ -275,25 +233,15 @@ All core functionality is implemented and compiling successfully! The plugin inc
 - Scheduled tasks for content refresh
 - Smart caching with dynamic TTL for upcoming livestreams
 
-### Testing
+### Known Issues
 
-To test the plugin:
-
-1. Build the plugin: `dotnet build`
-2. Copy `bin/Debug/net8.0/Jellyfin.Plugin.SRFPlay.dll` to your Jellyfin plugins directory
-3. Restart Jellyfin
-4. Configure the plugin in Dashboard → Plugins → SRF Play
-5. Add a library with the SRF Play content provider
-
-### Known Limitations
-
-- This is a first version that has not been tested with a live Jellyfin instance yet
-- Some edge cases may need handling
-- Performance optimization may be needed for large content catalogs
+- Some clients may experience issues with hardware decoding (appears to be client-specific)
+- Some edge cases may need additional handling
+- Performance optimization may be needed for very large content catalogs
 
 ### Contributing
 
-This plugin is in active development. Contributions welcome!
+Contributions welcome!
 
 ## License
 

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"

manifest.json

@@ -0,0 +1,37 @@
+[
+  {
+    "guid": "a4b12f86-8c3d-4e9a-b7f2-1d5e6c8a9b4f",
+    "name": "SRF Play",
+    "description": "SRF Play plugin for Jellyfin enables streaming of content from SRF (Swiss Radio and Television). Access live TV channels and on-demand content from Switzerland's German-language public broadcaster directly within Jellyfin.",
+    "overview": "Stream SRF content in Jellyfin",
+    "owner": "dtourolle",
+    "category": "Live TV",
+    "imageUrl": "https://gitea.tourolle.paris/dtourolle/jellyfin-srfPlay/raw/branch/master/assests/main%20logo.png",
+    "versions": [
+      {
+        "version": "1.0.14",
+        "changelog": "Release 1.0.14",
+        "targetAbi": "10.9.0.0",
+        "sourceUrl": "https://gitea.tourolle.paris/dtourolle/jellyfin-srfPlay/releases/download/v1.0.14/srfplay_1.0.14.0.zip",
+        "checksum": "49e6afe16f7abf95c099ecc1d016e725",
+        "timestamp": "2025-12-30T12:38:41Z"
+      },
+      {
+        "version": "1.0.13",
+        "changelog": "Release 1.0.13",
+        "targetAbi": "10.9.0.0",
+        "sourceUrl": "https://gitea.tourolle.paris/dtourolle/jellyfin-srfPlay/releases/download/v1.0.13/srfplay_1.0.13.0.zip",
+        "checksum": "ac7c1e33c926c21f8e4319da91ef079c",
+        "timestamp": "2025-12-21T13:02:37Z"
+      },
+      {
+        "version": "1.0.12",
+        "changelog": "Release 1.0.12",
+        "targetAbi": "10.9.0.0",
+        "sourceUrl": "https://gitea.tourolle.paris/dtourolle/jellyfin-srfPlay/releases/download/v1.0.12/srfplay_1.0.12.0.zip",
+        "checksum": "47baa02ade413253db94fe3ba0763f69",
+        "timestamp": "2025-12-20T13:35:38Z"
+      }
+    ]
+  }
+]