mixed refactor

Jellyfin.Plugin.SRFPlay/Providers/SRFLiveStream.cs

@@ -1,139 +0,0 @@
-using System;
-using System.IO;
-using System.Threading;
-using System.Threading.Tasks;
-using Jellyfin.Plugin.SRFPlay.Services.Interfaces;
-using MediaBrowser.Controller.Library;
-using MediaBrowser.Model.Dto;
-using Microsoft.Extensions.Logging;
-
-namespace Jellyfin.Plugin.SRFPlay.Providers;
-
-/// <summary>
-/// Live stream wrapper for SRF Play streams to handle transcoding sessions.
-/// </summary>
-internal sealed class SRFLiveStream : ILiveStream
-{
-    private readonly ILogger _logger;
-    private readonly IStreamProxyService _proxyService;
-    private readonly string _originalItemId;
-    private MediaSourceInfo? _mediaSource;
-
-    /// <summary>
-    /// Initializes a new instance of the <see cref="SRFLiveStream"/> class.
-    /// </summary>
-    /// <param name="logger">The logger.</param>
-    /// <param name="proxyService">The stream proxy service.</param>
-    /// <param name="originalItemId">The original item ID.</param>
-    /// <param name="openToken">The open token.</param>
-    public SRFLiveStream(
-        ILogger logger,
-        IStreamProxyService proxyService,
-        string originalItemId,
-        string openToken)
-    {
-        _logger = logger;
-        _proxyService = proxyService;
-        _originalItemId = originalItemId;
-        OriginalStreamId = openToken;
-        UniqueId = openToken;
-    }
-
-    /// <inheritdoc />
-    public int ConsumerCount { get; set; }
-
-    /// <inheritdoc />
-    public string OriginalStreamId { get; set; }
-
-    /// <inheritdoc />
-    public string UniqueId { get; }
-
-    /// <inheritdoc />
-    public string TunerHostId => string.Empty;
-
-    /// <inheritdoc />
-    public bool EnableStreamSharing => false;
-
-    /// <inheritdoc />
-    public MediaSourceInfo MediaSource
-    {
-        get => _mediaSource ?? throw new InvalidOperationException("MediaSource not set");
-        set
-        {
-            _mediaSource = value;
-            _logger.LogInformation(
-                "SRFLiveStream MediaSource set - Id: {MediaSourceId}, Path: {Path}, OriginalItemId: {OriginalItemId}",
-                value.Id,
-                value.Path,
-                _originalItemId);
-
-            // When Jellyfin assigns a live stream ID (for transcoding), register the stream with that ID too
-            if (value.Id != _originalItemId)
-            {
-                _logger.LogInformation(
-                    "Transcoding session detected - LiveStream ID {LiveStreamId} differs from original item ID {OriginalItemId}. Registering stream with both IDs.",
-                    value.Id,
-                    _originalItemId);
-
-                // Get the authenticated URL and metadata from the original registration
-                var authenticatedUrl = _proxyService.GetAuthenticatedUrl(_originalItemId);
-                var metadata = _proxyService.GetStreamMetadata(_originalItemId);
-                if (authenticatedUrl != null)
-                {
-                    // Register the same stream URL with the transcoding session ID, preserving metadata
-                    var urn = metadata?.Urn;
-                    var isLiveStream = metadata?.IsLiveStream ?? false;
-                    _proxyService.RegisterStream(value.Id, authenticatedUrl, urn, isLiveStream);
-                    _logger.LogInformation(
-                        "Registered stream for transcoding session ID: {LiveStreamId} (URN: {Urn}, IsLiveStream: {IsLiveStream})",
-                        value.Id,
-                        urn ?? "null",
-                        isLiveStream);
-                }
-                else
-                {
-                    _logger.LogWarning("Could not find authenticated URL for original item {OriginalItemId}", _originalItemId);
-                }
-            }
-        }
-    }
-
-    /// <inheritdoc />
-    public Task Close()
-    {
-        _logger.LogInformation("Closing SRF live stream for item {OriginalItemId}", _originalItemId);
-        return Task.CompletedTask;
-    }
-
-    /// <inheritdoc />
-    public Task Open(CancellationToken cancellationToken)
-    {
-        _logger.LogInformation("Opening SRF live stream for item {OriginalItemId}", _originalItemId);
-        return Task.CompletedTask;
-    }
-
-    /// <inheritdoc />
-    public Stream GetStream()
-    {
-        throw new NotSupportedException("Direct stream access not supported for SRF streams");
-    }
-
-    /// <inheritdoc />
-    public void Dispose()
-    {
-        Dispose(true);
-        GC.SuppressFinalize(this);
-    }
-
-    /// <summary>
-    /// Releases the unmanaged resources used by the SRFLiveStream 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>
-    private void Dispose(bool disposing)
-    {
-        if (disposing)
-        {
-            _logger.LogDebug("Disposing SRF live stream for item {OriginalItemId}", _originalItemId);
-        }
-    }
-}

Jellyfin.Plugin.SRFPlay/Providers/SRFMediaProvider.cs

@@ -4,12 +4,9 @@ using System.Threading;
 using System.Threading.Tasks;
 using Jellyfin.Plugin.SRFPlay.Configuration;
 using Jellyfin.Plugin.SRFPlay.Services.Interfaces;
-using MediaBrowser.Controller;
 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;
@@ -22,8 +19,7 @@ public class SRFMediaProvider : IMediaSourceProvider
     private readonly ILogger<SRFMediaProvider> _logger;
     private readonly IMediaCompositionFetcher _compositionFetcher;
     private readonly IStreamUrlResolver _streamResolver;
-    private readonly IStreamProxyService _proxyService;
-    private readonly IServerApplicationHost _appHost;
+    private readonly IMediaSourceFactory _mediaSourceFactory;
 
     /// <summary>
     /// Initializes a new instance of the <see cref="SRFMediaProvider"/> class.
@@ -31,20 +27,17 @@ public class SRFMediaProvider : IMediaSourceProvider
     /// <param name="loggerFactory">The logger factory.</param>
     /// <param name="compositionFetcher">The media composition fetcher.</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>
+    /// <param name="mediaSourceFactory">The media source factory.</param>
     public SRFMediaProvider(
         ILoggerFactory loggerFactory,
         IMediaCompositionFetcher compositionFetcher,
         IStreamUrlResolver streamResolver,
-        IStreamProxyService proxyService,
-        IServerApplicationHost appHost)
+        IMediaSourceFactory mediaSourceFactory)
     {
         _logger = loggerFactory.CreateLogger<SRFMediaProvider>();
         _compositionFetcher = compositionFetcher;
         _streamResolver = streamResolver;
-        _proxyService = proxyService;
-        _appHost = appHost;
+        _mediaSourceFactory = mediaSourceFactory;
     }
 
     /// <summary>
@@ -64,24 +57,13 @@ public class SRFMediaProvider : IMediaSourceProvider
 
         try
         {
-            // Log detailed information about the request
-            var stackTrace = new System.Diagnostics.StackTrace(true);
-            var callingMethod = stackTrace.GetFrame(1)?.GetMethod();
-            _logger.LogInformation(
-                "GetMediaSources called - Item: {ItemName}, Type: {ItemType}, Id: {ItemId}, CalledBy: {CallingMethod}",
-                item.Name,
-                item.GetType().Name,
-                item.Id,
-                callingMethod?.DeclaringType?.Name + "." + callingMethod?.Name);
-
             // Check if this is an SRF item
             if (!item.ProviderIds.TryGetValue("SRF", out var urn) || string.IsNullOrEmpty(urn))
             {
-                _logger.LogDebug("Item {ItemName} is not an SRF item, returning empty sources", item.Name);
                 return sources;
             }
 
-            _logger.LogInformation("Getting media sources for URN: {Urn}, Item: {ItemName}", urn, item.Name);
+            _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
             var cacheDuration = urn.Contains("scheduled_livestream", StringComparison.OrdinalIgnoreCase) ? 5 : (int?)null;
@@ -111,13 +93,23 @@ public class SRFMediaProvider : IMediaSourceProvider
                 return sources;
             }
 
-            // Get stream URL based on quality preference
+            // Get quality preference from config
             var config = Plugin.Instance?.Configuration;
             var qualityPref = config?.QualityPreference ?? QualityPreference.HD;
-            var streamUrl = _streamResolver.GetStreamUrl(chapter, qualityPref);
 
-            // For scheduled livestreams, always fetch fresh data to ensure stream URL is current
-            if (chapter.Type == "SCHEDULED_LIVESTREAM" && string.IsNullOrEmpty(streamUrl))
+            // Use item ID in hex format without dashes
+            var itemIdStr = item.Id.ToString("N");
+
+            // 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.LogDebug("URN {Urn}: Scheduled livestream has no stream URL, fetching fresh data", urn);
 
@@ -127,9 +119,14 @@ public class SRFMediaProvider : IMediaSourceProvider
                 if (freshMediaComposition?.ChapterList != null && freshMediaComposition.ChapterList.Count > 0)
                 {
                     var freshChapter = freshMediaComposition.ChapterList[0];
-                    streamUrl = _streamResolver.GetStreamUrl(freshChapter, qualityPref);
+                    mediaSource = await _mediaSourceFactory.CreateMediaSourceAsync(
+                        freshChapter,
+                        itemIdStr,
+                        urn,
+                        qualityPref,
+                        cancellationToken).ConfigureAwait(false);
 
-                    if (!string.IsNullOrEmpty(streamUrl))
+                    if (mediaSource != null)
                     {
                         chapter = freshChapter;
                         _logger.LogInformation("URN {Urn}: Got fresh stream URL for scheduled livestream", urn);
@@ -137,87 +134,19 @@ public class SRFMediaProvider : IMediaSourceProvider
                 }
             }
 
-            if (string.IsNullOrEmpty(streamUrl))
+            if (mediaSource == null)
             {
                 _logger.LogWarning("Could not resolve stream URL for URN: {Urn}", urn);
                 return sources;
             }
 
-            // Authenticate the stream URL (required for all SRF streams, especially livestreams)
-            if (!string.IsNullOrEmpty(streamUrl))
-            {
-                streamUrl = await _streamResolver.GetAuthenticatedStreamUrlAsync(streamUrl, cancellationToken).ConfigureAwait(false);
-                _logger.LogDebug("Authenticated stream URL for URN: {Urn}", urn);
-            }
-
-            // Detect if this is a live stream
-            var isLiveStream = chapter.Type == "SCHEDULED_LIVESTREAM" || urn.Contains("livestream", StringComparison.OrdinalIgnoreCase);
-            _logger.LogInformation(
-                "Livestream detection - ChapterType: {ChapterType}, URN: {Urn}, IsLiveStream: {IsLiveStream}",
-                chapter.Type,
-                urn,
-                isLiveStream);
-
-            // Register stream with proxy service
-            var itemIdStr = item.Id.ToString("N"); // Use hex format without dashes
-            _proxyService.RegisterStream(itemIdStr, streamUrl, urn, isLiveStream);
-
-            // Get the server URL for proxy - prefer configured public URL for remote clients
-            var serverUrl = config != null && !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 - item ID is all we need since proxy handles auth
-            var proxyUrl = $"{serverUrl}/Plugins/SRFPlay/Proxy/{itemIdStr}/master.m3u8";
-
-            _logger.LogInformation(
-                "Using proxy URL for item {ItemId}: {ProxyUrl} (PublicServerUrl configured: {IsPublicConfigured})",
-                itemIdStr,
-                proxyUrl,
-                config != null && !string.IsNullOrWhiteSpace(config.PublicServerUrl));
-
-            // Create media source using proxy URL - enables DirectPlay!
-            var mediaSource = new MediaSourceInfo
-            {
-                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,
-                Container = "hls",
-                SupportsDirectStream = true,
-                SupportsDirectPlay = true, // ✅ Enabled! Proxy handles auth
-                SupportsTranscoding = false, // Prefer DirectPlay - no transcoding needed for HLS
-                IsRemote = false, // False because it's a local proxy endpoint
-                Type = MediaSourceType.Default,
-                RunTimeTicks = chapter.Duration > 0 ? TimeSpan.FromMilliseconds(chapter.Duration).Ticks : null,
-                VideoType = VideoType.VideoFile,
-                IsInfiniteStream = isLiveStream, // True for live streams!
-                RequiresOpening = false, // Proxy handles auth - no need for OpenMediaSource
-                RequiresClosing = false,
-                SupportsProbing = true, // Enable probing so Jellyfin can verify stream compatibility
-                ReadAtNativeFramerate = isLiveStream, // Read at native framerate for live streams
-                MediaStreams = CreateMediaStreams(qualityPref)
-            };
-
             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}, IsLiveStream={IsLiveStream}",
+            _logger.LogDebug(
+                "MediaSource created for {Title} - Id={Id}, DirectPlay={DirectPlay}, Transcoding={Transcoding}",
+                chapter.Title,
                 mediaSource.Id,
-                mediaSource.SupportsDirectStream,
                 mediaSource.SupportsDirectPlay,
-                mediaSource.SupportsProbing,
-                mediaSource.Container,
-                mediaSource.Protocol,
-                mediaSource.IsRemote,
-                isLiveStream);
-            _logger.LogInformation(
-                "MediaSource capabilities - SupportsTranscoding={Transcoding}, RequiresOpening={RequiresOpening}, RequiresClosing={RequiresClosing}, Type={Type}, IsInfiniteStream={IsInfiniteStream}",
-                mediaSource.SupportsTranscoding,
-                mediaSource.RequiresOpening,
-                mediaSource.RequiresClosing,
-                mediaSource.Type,
-                mediaSource.IsInfiniteStream);
+                mediaSource.SupportsTranscoding);
         }
         catch (Exception ex)
         {
@@ -247,51 +176,4 @@ public class SRFMediaProvider : IMediaSourceProvider
         _logger.LogWarning("OpenMediaSource unexpectedly called with openToken: {OpenToken}", openToken);
         throw new NotSupportedException("OpenMediaSource not supported - streams use direct proxy access");
     }
-
-    /// <summary>
-    /// Creates MediaStream metadata based on quality preference.
-    /// These are approximate values - HLS adaptive streaming will use actual stream qualities.
-    /// </summary>
-    private static List<MediaBrowser.Model.Entities.MediaStream> CreateMediaStreams(QualityPreference quality)
-    {
-        // Set resolution/bitrate based on quality preference
-        // These are typical values for SRF streams - actual HLS will adapt
-        var (width, height, videoBitrate) = quality switch
-        {
-            QualityPreference.SD => (1280, 720, 2500000),
-            QualityPreference.HD => (1920, 1080, 5000000),
-            _ => (1280, 720, 3000000)
-        };
-
-        return new List<MediaBrowser.Model.Entities.MediaStream>
-        {
-            new MediaBrowser.Model.Entities.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 MediaBrowser.Model.Entities.MediaStream
-            {
-                Type = MediaStreamType.Audio,
-                Codec = "aac",
-                Profile = "LC",
-                Channels = 2,
-                SampleRate = 48000,
-                BitRate = 128000,
-                IsDefault = true,
-                Index = 1
-            }
-        };
-    }
 }