Fix issue with Jellyfin using local IP adress not server public URL, now pulic URL is set in plugin.

Jellyfin.Plugin.SRFPlay/Channels/SRFPlayChannel.cs

@@ -7,6 +7,7 @@ using System.Text;
 using System.Threading;
 using System.Threading.Tasks;
 using Jellyfin.Plugin.SRFPlay.Services;
+using MediaBrowser.Controller;
 using MediaBrowser.Controller.Channels;
 using MediaBrowser.Controller.Providers;
 using MediaBrowser.Model.Channels;
@@ -27,6 +28,7 @@ public class SRFPlayChannel : IChannel, IHasCacheKey
     private readonly StreamUrlResolver _streamResolver;
     private readonly StreamProxyService _proxyService;
     private readonly CategoryService? _categoryService;
+    private readonly IServerApplicationHost _appHost;
 
     /// <summary>
     /// Initializes a new instance of the <see cref="SRFPlayChannel"/> class.
@@ -35,12 +37,14 @@ public class SRFPlayChannel : IChannel, IHasCacheKey
     /// <param name="contentRefreshService">The content refresh service.</param>
     /// <param name="streamResolver">The stream resolver.</param>
     /// <param name="proxyService">The stream proxy service.</param>
+    /// <param name="appHost">The server application host.</param>
     /// <param name="categoryService">The category service (optional).</param>
     public SRFPlayChannel(
         ILoggerFactory loggerFactory,
         ContentRefreshService contentRefreshService,
         StreamUrlResolver streamResolver,
         StreamProxyService proxyService,
+        IServerApplicationHost appHost,
         CategoryService? categoryService = null)
     {
         _loggerFactory = loggerFactory;
@@ -48,6 +52,7 @@ public class SRFPlayChannel : IChannel, IHasCacheKey
         _contentRefreshService = contentRefreshService;
         _streamResolver = streamResolver;
         _proxyService = proxyService;
+        _appHost = appHost;
         _categoryService = categoryService;
 
         if (_categoryService == null)
@@ -471,9 +476,14 @@ public class SRFPlayChannel : IChannel, IHasCacheKey
                 // Register stream with proxy service
                 _proxyService.RegisterStream(itemId, streamUrl);
 
+                // Get the server URL for proxy - prefer configured public URL for remote clients
+                var serverUrl = !string.IsNullOrWhiteSpace(config.PublicServerUrl)
+                    ? config.PublicServerUrl.TrimEnd('/') // Use configured public URL (important for Android/remote clients)
+                    : _appHost.GetSmartApiUrl(string.Empty); // Fall back to Jellyfin's smart URL resolution
+
                 // Create proxy URL as absolute HTTP URL (required for ffmpeg)
-                // Use localhost as Jellyfin should be able to access its own endpoints
+                // Use the actual server URL so remote clients can access it
-                var proxyUrl = $"http://localhost:8096/Plugins/SRFPlay/Proxy/{itemId}/master.m3u8";
+                var proxyUrl = $"{serverUrl}/Plugins/SRFPlay/Proxy/{itemId}/master.m3u8";
 
                 // Build overview
                 var overview = chapter.Description ?? chapter.Lead;

Jellyfin.Plugin.SRFPlay/Configuration/PluginConfiguration.cs

@@ -142,4 +142,11 @@ 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;
 }

Jellyfin.Plugin.SRFPlay/Configuration/configPage.html

@@ -82,6 +82,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>
@@ -110,6 +121,7 @@
                         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();
                     });
                 });
@@ -129,6 +141,7 @@
                     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/Controllers/StreamProxyController.cs

@@ -34,7 +34,7 @@ public class StreamProxyController : ControllerBase
     /// <summary>
     /// Proxies HLS master manifest requests.
     /// </summary>
-    /// <param name="itemId">The item ID.</param>
+    /// <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")]
@@ -47,12 +47,21 @@ public class StreamProxyController : ControllerBase
     {
         _logger.LogInformation("Proxy request for master manifest - ItemId: {ItemId}", itemId);
 
+        // Try to resolve the actual item ID (path ID might be a session ID during transcoding)
+        var actualItemId = ResolveItemId(itemId);
+
         try
         {
-            // Build the base proxy URL for this item
+            // Build the base proxy URL for this item (use original itemId from path to maintain URL structure)
-            var baseProxyUrl = $"{Request.Scheme}://{Request.Host}/Plugins/SRFPlay/Proxy/{itemId}";
+            // Always include the actualItemId as a query parameter to ensure proper resolution during transcoding
+            var baseProxyUrl = $"{Request.Scheme}://{Request.Host}/Plugins/SRFPlay/Proxy/{itemId}?itemId={actualItemId}";
 
-            var manifestContent = await _proxyService.GetRewrittenManifestAsync(itemId, baseProxyUrl, cancellationToken).ConfigureAwait(false);
+            if (actualItemId != itemId)
+            {
+                _logger.LogDebug("Path itemId {PathId} differs from resolved itemId {ResolvedId}, adding query parameter", itemId, actualItemId);
+            }
+
+            var manifestContent = await _proxyService.GetRewrittenManifestAsync(actualItemId, baseProxyUrl, cancellationToken).ConfigureAwait(false);
 
             if (manifestContent == null)
             {
@@ -89,10 +98,13 @@ public class StreamProxyController : ControllerBase
         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(itemId, fullPath, cancellationToken).ConfigureAwait(false);
+            var manifestData = await _proxyService.GetSegmentAsync(actualItemId, fullPath, cancellationToken).ConfigureAwait(false);
 
             if (manifestData == null)
             {
@@ -133,9 +145,12 @@ public class StreamProxyController : ControllerBase
     {
         _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(itemId, segmentPath, cancellationToken).ConfigureAwait(false);
+            var segmentData = await _proxyService.GetSegmentAsync(actualItemId, segmentPath, cancellationToken).ConfigureAwait(false);
 
             if (segmentData == null)
             {
@@ -156,6 +171,26 @@ public class StreamProxyController : ControllerBase
         }
     }
 
+    /// <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 if there's an itemId query parameter (fallback for transcoding sessions)
+        if (Request.Query.TryGetValue("itemId", out var queryItemId) && !string.IsNullOrEmpty(queryItemId))
+        {
+            _logger.LogDebug("Using itemId from query parameter: {QueryItemId} (path had: {PathItemId})", queryItemId.ToString(), pathItemId);
+            return queryItemId.ToString();
+        }
+
+        // If path ID and query ID don't match, it's likely a transcoding session
+        // Try to use the proxy service fallback to find the correct stream
+        _logger.LogDebug("No itemId query parameter found, using path ID as-is: {PathItemId}", pathItemId);
+        return pathItemId;
+    }
+
     /// <summary>
     /// Rewrites segment URLs in a manifest to point to proxy.
     /// </summary>
@@ -164,6 +199,11 @@ public class StreamProxyController : ControllerBase
     /// <returns>The rewritten manifest.</returns>
     private string RewriteSegmentUrls(string manifestContent, string baseProxyUrl)
     {
+        // Extract the itemId query parameter from the current request to propagate it
+        var itemIdParam = Request.Query.TryGetValue("itemId", out var itemId) && !string.IsNullOrEmpty(itemId)
+            ? $"?itemId={itemId}"
+            : string.Empty;
+
         var lines = manifestContent.Split('\n');
         var result = new System.Text.StringBuilder();
 
@@ -180,12 +220,12 @@ public class StreamProxyController : ControllerBase
                 var uri = new Uri(line.Trim());
                 var segments = uri.AbsolutePath.Split('/');
                 var fileName = segments[^1];
-                result.AppendLine(CultureInfo.InvariantCulture, $"{baseProxyUrl}/{fileName}");
+                result.AppendLine(CultureInfo.InvariantCulture, $"{baseProxyUrl}/{fileName}{itemIdParam}");
             }
             else
             {
                 // Relative URL - rewrite to proxy
-                result.AppendLine(CultureInfo.InvariantCulture, $"{baseProxyUrl}/{line.Trim()}");
+                result.AppendLine(CultureInfo.InvariantCulture, $"{baseProxyUrl}/{line.Trim()}{itemIdParam}");
             }
         }
 

Jellyfin.Plugin.SRFPlay/Providers/SRFMediaProvider.cs

@@ -5,6 +5,7 @@ using System.Threading;
 using System.Threading.Tasks;
 using Jellyfin.Plugin.SRFPlay.Api;
 using Jellyfin.Plugin.SRFPlay.Services;
+using MediaBrowser.Controller;
 using MediaBrowser.Controller.Entities;
 using MediaBrowser.Controller.Library;
 using MediaBrowser.Model.Dto;
@@ -24,6 +25,7 @@ public class SRFMediaProvider : IMediaSourceProvider
     private readonly MetadataCache _metadataCache;
     private readonly StreamUrlResolver _streamResolver;
     private readonly StreamProxyService _proxyService;
+    private readonly IServerApplicationHost _appHost;
 
     /// <summary>
     /// Initializes a new instance of the <see cref="SRFMediaProvider"/> class.
@@ -32,17 +34,20 @@ public class SRFMediaProvider : IMediaSourceProvider
     /// <param name="metadataCache">The metadata cache.</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 SRFMediaProvider(
         ILoggerFactory loggerFactory,
         MetadataCache metadataCache,
         StreamUrlResolver streamResolver,
-        StreamProxyService proxyService)
+        StreamProxyService proxyService,
+        IServerApplicationHost appHost)
     {
         _loggerFactory = loggerFactory;
         _logger = loggerFactory.CreateLogger<SRFMediaProvider>();
         _metadataCache = metadataCache;
         _streamResolver = streamResolver;
         _proxyService = proxyService;
+        _appHost = appHost;
     }
 
     /// <summary>
@@ -174,16 +179,29 @@ public class SRFMediaProvider : IMediaSourceProvider
             var itemIdStr = item.Id.ToString("N"); // Use hex format without dashes
             _proxyService.RegisterStream(itemIdStr, streamUrl);
 
-            // Create proxy URL as absolute HTTP URL (required for ffmpeg)
+            // Get the server URL for proxy - prefer configured public URL for remote clients
-            // Use localhost as Jellyfin should be able to access its own endpoints
+            var serverUrl = !string.IsNullOrWhiteSpace(config.PublicServerUrl)
-            var proxyUrl = $"http://localhost:8096/Plugins/SRFPlay/Proxy/{itemIdStr}/master.m3u8";
+                ? config.PublicServerUrl.TrimEnd('/') // Use configured public URL (important for Android/remote clients)
+                : _appHost.GetSmartApiUrl(string.Empty); // Fall back to Jellyfin's smart URL resolution
 
-            _logger.LogInformation("Using proxy URL for item {ItemId}: {ProxyUrl}", itemIdStr, proxyUrl);
+            // Create proxy URL as absolute HTTP URL (required for ffmpeg)
+            // Use the actual server URL so remote clients can access it
+            // Include item ID as query parameter to preserve it during transcoding
+            var proxyUrl = $"{serverUrl}/Plugins/SRFPlay/Proxy/{itemIdStr}/master.m3u8?itemId={itemIdStr}";
+
+            _logger.LogInformation(
+                "Using proxy URL for item {ItemId}: {ProxyUrl} (PublicServerUrl configured: {IsPublicConfigured})",
+                itemIdStr,
+                proxyUrl,
+                !string.IsNullOrWhiteSpace(config.PublicServerUrl));
+
+            // Detect if this is a live stream
+            var isLiveStream = chapter.Type == "SCHEDULED_LIVESTREAM" || urn.Contains("livestream", StringComparison.OrdinalIgnoreCase);
 
             // Create media source using proxy URL - enables DirectPlay!
             var mediaSource = new MediaSourceInfo
             {
-                Id = item.Id.ToString(), // Use item GUID, not URN string (required for transcoding)
+                Id = itemIdStr, // Must match the ID used in proxy URL registration
                 Name = chapter.Title,
                 Path = proxyUrl, // Proxy URL instead of direct Akamai URL
                 Protocol = MediaProtocol.Http,
@@ -195,11 +213,11 @@ public class SRFMediaProvider : IMediaSourceProvider
                 Type = MediaSourceType.Default,
                 RunTimeTicks = chapter.Duration > 0 ? TimeSpan.FromMilliseconds(chapter.Duration).Ticks : null,
                 VideoType = VideoType.VideoFile,
-                IsInfiniteStream = false,
+                IsInfiniteStream = isLiveStream, // True for live streams!
                 RequiresOpening = false,
                 RequiresClosing = false,
                 SupportsProbing = false, // Disable probing for proxy URLs
-                ReadAtNativeFramerate = false,
+                ReadAtNativeFramerate = isLiveStream, // Read at native framerate for live streams
                 MediaStreams = new List<MediaBrowser.Model.Entities.MediaStream>
                 {
                     new MediaBrowser.Model.Entities.MediaStream
@@ -224,20 +242,22 @@ public class SRFMediaProvider : IMediaSourceProvider
             sources.Add(mediaSource);
             _logger.LogInformation("Resolved stream URL for {Title}: {Url}", chapter.Title, streamUrl);
             _logger.LogInformation(
-                "MediaSource created - Id={Id}, DirectStream={DirectStream}, DirectPlay={DirectPlay}, Probing={Probing}, Container={Container}, Protocol={Protocol}, IsRemote={IsRemote}",
+                "MediaSource created - Id={Id}, DirectStream={DirectStream}, DirectPlay={DirectPlay}, Probing={Probing}, Container={Container}, Protocol={Protocol}, IsRemote={IsRemote}, IsLiveStream={IsLiveStream}",
                 mediaSource.Id,
                 mediaSource.SupportsDirectStream,
                 mediaSource.SupportsDirectPlay,
                 mediaSource.SupportsProbing,
                 mediaSource.Container,
                 mediaSource.Protocol,
-                mediaSource.IsRemote);
+                mediaSource.IsRemote,
+                isLiveStream);
             _logger.LogInformation(
-                "MediaSource capabilities - SupportsTranscoding={Transcoding}, RequiresOpening={RequiresOpening}, RequiresClosing={RequiresClosing}, Type={Type}",
+                "MediaSource capabilities - SupportsTranscoding={Transcoding}, RequiresOpening={RequiresOpening}, RequiresClosing={RequiresClosing}, Type={Type}, IsInfiniteStream={IsInfiniteStream}",
                 mediaSource.SupportsTranscoding,
                 mediaSource.RequiresOpening,
                 mediaSource.RequiresClosing,
-                mediaSource.Type);
+                mediaSource.Type,
+                mediaSource.IsInfiniteStream);
         }
         catch (Exception ex)
         {

Jellyfin.Plugin.SRFPlay/Services/StreamProxyService.cs

@@ -1,9 +1,11 @@
 using System;
 using System.Collections.Concurrent;
+using System.Linq;
 using System.Net.Http;
 using System.Text.RegularExpressions;
 using System.Threading;
 using System.Threading.Tasks;
+using System.Web;
 using Microsoft.Extensions.Logging;
 
 namespace Jellyfin.Plugin.SRFPlay.Services;
@@ -42,29 +44,271 @@ public class StreamProxyService : IDisposable
     /// <param name="authenticatedUrl">The authenticated stream URL.</param>
     public void RegisterStream(string itemId, string authenticatedUrl)
     {
+        var tokenExpiry = ExtractTokenExpiry(authenticatedUrl);
+        var unauthenticatedUrl = StripAuthenticationFromUrl(authenticatedUrl);
+
         var streamInfo = new StreamInfo
         {
             AuthenticatedUrl = authenticatedUrl,
-            RegisteredAt = DateTime.UtcNow
+            UnauthenticatedUrl = unauthenticatedUrl,
+            RegisteredAt = DateTime.UtcNow,
+            TokenExpiresAt = tokenExpiry
         };
 
+        // Register with the provided item ID
         _streamMappings.AddOrUpdate(itemId, streamInfo, (key, old) => streamInfo);
+
+        // Also register with alternative GUID formats to handle Jellyfin's ID transformations
+        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);
+        }
+
+        if (tokenExpiry.HasValue)
+        {
+            _logger.LogInformation(
+                "Registered stream for item {ItemId} (token expires at {ExpiresAt} UTC): {Url}",
+                itemId,
+                tokenExpiry.Value,
+                authenticatedUrl);
+        }
+        else
+        {
             _logger.LogInformation("Registered stream for item {ItemId}: {Url}", itemId, authenticatedUrl);
         }
+    }
 
     /// <summary>
     /// Gets the authenticated URL for an item.
     /// </summary>
     /// <param name="itemId">The item ID.</param>
-    /// <returns>The authenticated URL, or null if not found.</returns>
+    /// <returns>The authenticated URL, or null if not found or expired.</returns>
     public string? GetAuthenticatedUrl(string itemId)
     {
+        // Try direct lookup first
         if (_streamMappings.TryGetValue(itemId, out var streamInfo))
         {
+            return ValidateAndReturnStream(itemId, streamInfo);
+        }
+
+        // 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 = ValidateAndReturnStream(kvp.Key, kvp.Value);
+                    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
+                }
+            }
+        }
+
+        // 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.LogWarning(
+                "No exact match for {RequestedId}, but found single active stream {RegisteredId} - using as fallback",
+                itemId,
+                activeStreams[0].Key);
+            return ValidateAndReturnStream(activeStreams[0].Key, activeStreams[0].Value);
+        }
+
+        // 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.LogWarning(
+                    "No exact match for {RequestedId}, but using most recently registered stream {RegisteredId} (registered {Seconds}s ago) as fallback",
+                    itemId,
+                    mostRecent.Key,
+                    age.TotalSeconds);
+                return ValidateAndReturnStream(mostRecent.Key, mostRecent.Value);
+            }
+        }
+
+        _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 string? ValidateAndReturnStream(string itemId, StreamInfo streamInfo)
+    {
+        // Check if token has expired
+        if (streamInfo.TokenExpiresAt.HasValue)
+        {
+            var now = DateTime.UtcNow;
+            if (now >= streamInfo.TokenExpiresAt.Value)
+            {
+                _logger.LogWarning(
+                    "Token expired for item {ItemId} (expired at {ExpiresAt}, now is {Now}) - attempting to refresh",
+                    itemId,
+                    streamInfo.TokenExpiresAt.Value,
+                    now);
+
+                // Try to refresh the token
+                var refreshedUrl = RefreshToken(itemId, streamInfo);
+                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} remaining)",
+                itemId,
+                streamInfo.TokenExpiresAt.Value,
+                streamInfo.TokenExpiresAt.Value - now);
+        }
+
         return streamInfo.AuthenticatedUrl;
     }
 
-        _logger.LogWarning("No stream mapping found for item {ItemId}", itemId);
+    /// <summary>
+    /// Attempts to refresh an expired token.
+    /// </summary>
+    private string? RefreshToken(string itemId, StreamInfo streamInfo)
+    {
+        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 synchronously (blocking call)
+            var newAuthenticatedUrl = _streamResolver.GetAuthenticatedStreamUrlAsync(
+                streamInfo.UnauthenticatedUrl,
+                CancellationToken.None).GetAwaiter().GetResult();
+
+            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>
+    /// 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;
     }
 
@@ -159,6 +403,19 @@ public class StreamProxyService : IDisposable
         var baseUri = new Uri(originalBaseUrl);
         var baseUrl = $"{baseUri.Scheme}://{baseUri.Host}{string.Join('/', baseUri.AbsolutePath.Split('/')[..^1])}";
 
+        // Extract itemId query parameter from proxyBaseUrl to propagate it
+        var itemIdParam = string.Empty;
+        var queryMarker = "?itemId=";
+        if (proxyBaseUrl.Contains(queryMarker, StringComparison.Ordinal))
+        {
+            var queryStart = proxyBaseUrl.IndexOf(queryMarker, StringComparison.Ordinal);
+            if (queryStart >= 0)
+            {
+                itemIdParam = proxyBaseUrl[queryStart..];
+                proxyBaseUrl = proxyBaseUrl[..queryStart]; // Remove query from base URL
+            }
+        }
+
         // Pattern to match .m3u8 and .ts/.mp4 segment references
         var pattern = @"(?:^|\n)([^#\n][^\n]*\.(?:m3u8|ts|mp4|m4s|aac)[^\n]*)";
 
@@ -172,27 +429,76 @@ public class StreamProxyService : IDisposable
             {
                 // Rewrite absolute URLs to proxy
                 var relativePath = url.Replace(baseUrl + "/", string.Empty, StringComparison.Ordinal);
-                return $"\n{proxyBaseUrl}/{relativePath}";
+                return $"\n{proxyBaseUrl}/{relativePath}{itemIdParam}";
             }
 
             // Relative URL - rewrite to proxy
-            return $"\n{proxyBaseUrl}/{url}";
+            return $"\n{proxyBaseUrl}/{url}{itemIdParam}";
         });
 
         return rewritten;
     }
 
     /// <summary>
-    /// Cleans up old stream mappings.
+    /// 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);
             }
@@ -201,12 +507,11 @@ public class StreamProxyService : IDisposable
         foreach (var key in keysToRemove)
         {
             _streamMappings.TryRemove(key, out _);
-            _logger.LogDebug("Removed old stream mapping for item {ItemId}", key);
         }
 
         if (keysToRemove.Count > 0)
         {
-            _logger.LogInformation("Cleaned up {Count} old stream mappings", keysToRemove.Count);
+            _logger.LogInformation("Cleaned up {Count} old/expired stream mappings", keysToRemove.Count);
         }
     }
 
@@ -245,6 +550,10 @@ public class StreamProxyService : IDisposable
     {
         public string AuthenticatedUrl { get; set; } = string.Empty;
 
+        public string UnauthenticatedUrl { get; set; } = string.Empty;
+
         public DateTime RegisteredAt { get; set; }
+
+        public DateTime? TokenExpiresAt { get; set; }
     }
 }

Jellyfin.Plugin.SRFPlay/Services/StreamUrlResolver.cs

@@ -87,6 +87,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 +125,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),
@@ -124,10 +139,10 @@ public class StreamUrlResolver : IDisposable
 
         if (selectedResource != null)
         {
-            _logger.LogDebug(
+            _logger.LogInformation(
-                "Selected stream for chapter {ChapterId}: Quality={Quality}, Protocol={Protocol}, URL={Url}",
+                "✅ 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;