Update manifest.json for release v1.6.1.24 [skip ci]

Jellyfin.Plugin.MediaBarEnhanced/Configuration/configPage.html

@@ -115,14 +115,10 @@
                         </div>
                         <div id="customMediaIdsContainer">
                             <div class="inputContainer">
-                                <label class="inputLabel inputLabelUnfocused" for="CustomMediaIds">Default Media/Collection/Playlist
-                                    IDs
-                                    (Newline or Comma separated)</label>
+                                <label class="inputLabel inputLabelUnfocused" for="CustomMediaIds">Default Media/Collection/Playlist IDs (Newline or Comma-separated)</label>
                                 <textarea class="emby-textarea" is="emby-textarea" id="CustomMediaIds" name="CustomMediaIds"
                                     style="width: 100%; height: 150px; font-family: monospace;"></textarea>
-                                <div class="fieldDescription">Enter the IDs of the items you want to show in the slideshow as
-                                    your default content.
-                                    You can separate them by new line or comma.
+                                <div class="fieldDescription">Enter the IDs of the items you want to show in the slideshow as your default content. You can separate them by new line or comma.
                                     <br><br>
                                     <b>Manual Trailer/Video Override:</b> You can specify a YouTube URL <b>OR</b> a Jellyfin Item ID (e.g. for a Theme Video) for an item by adding it in
                                     brackets: <br> <code>e.g. ID DESCRIPTION [https://youtu.be/...]</code> or <code>ID [JellyfinItemId] DESCRIPTION</code>.
@@ -132,11 +128,9 @@
                                         <li><b>YouTube URL:</b> Play a remote trailer from YouTube.</li>
                                         <li><b>Jellyfin Item ID (GUID):</b> Play the video of another library item (e.g. a Theme Video or Backdrop Video) using the native player.</li>
                                     </ul>
-                                    You can also add a description after the ID using any separator like space, pipe
-                                    (|) or dash (-): <br>e.g. <code>ID DESCRIPTION</code> or <code>ID | DESCRIPTION</code>
+                                    You can also add a description after the ID using any separator like space, pipe (|) or dash (-): <br>e.g. <code>ID DESCRIPTION</code> or <code>ID | DESCRIPTION</code>
                                     <br><br>
-                                    <b>Note:</b> If using a <b>Collection Name</b> (instead of an ID) combined with a description, you <b>MUST</b> use 
-                                    the pipe (|) separator.
+                                    <b>Note:</b> If using a <b>Collection Name</b> (instead of an ID) combined with a description, you <b>MUST</b> use the pipe (|) separator.
                                     <br>
                                     <b>Note:</b> The separator <b>MUST NOT</b> be a hex character (0-9, a-f).
                                 </div>
@@ -198,7 +192,7 @@
                                 <input is="emby-checkbox" type="checkbox" id="UseSponsorBlock" name="UseSponsorBlock" />
                                 <span>Use SponsorBlock</span>
                             </label>
-                            <div class="fieldDescription">Skip intro/outro segments in YouTube trailers.</div>
+                            <div class="fieldDescription">Skip intro/outro segments in YouTube trailers (if data is available).</div>
                         </div>
                         <div class="selectContainer">
                             <label class="selectLabel" for="PreferredVideoQuality">Preferred YouTube Quality</label>
@@ -603,7 +597,7 @@
                         '<div class="inputContainer">' +
                         '    <label class="inputLabel" style="margin-bottom:0.5em; display:block;">Media IDs</label>' +
                         '    <textarea is="emby-textarea" class="emby-textarea section-ids" style="width: 100%; height: 80px; font-family: monospace;">' + (data.MediaIds || '') + '</textarea>' +
-                        '    <div class="fieldDescription">Comma-separated list of Movie/Series/Collection IDs to show during this season.</div>' +
+                        '    <div class="fieldDescription">Comma-separated or Newline separated list of Movie/Series/Collection IDs to show during this season.<br>Same options available as for the default media IDs.</div>' +
                         '</div>';
 
                     div.querySelector('.remove-section').addEventListener('click', function() {

Jellyfin.Plugin.MediaBarEnhanced/Jellyfin.Plugin.MediaBarEnhanced.csproj

@@ -12,7 +12,7 @@
     <!-- <TreatWarningsAsErrors>false</TreatWarningsAsErrors> -->
     <Title>Jellyfin Media Bar Enhanced Plugin</Title>
     <Authors>CodeDevMLH</Authors>
-    <Version>1.6.1.14</Version>
+    <Version>1.6.1.24</Version>
     <RepositoryUrl>https://github.com/CodeDevMLH/jellyfin-plugin-media-bar-enhanced</RepositoryUrl>
   </PropertyGroup>
 

Jellyfin.Plugin.MediaBarEnhanced/Web/mediaBarEnhanced.js

@@ -1490,7 +1490,6 @@ const VisibilityObserver = {
    * Initializes visibility observer
    */
   init() {
-    // MARK: Mark
     const observer = new MutationObserver(() => this.updateVisibility());
     // let debounceTimer = null;
     // const observer = new MutationObserver(() => {
@@ -1720,6 +1719,13 @@ const SlideCreator = {
                   if (iframe) {
                     iframe.setAttribute('tabindex', '-1');
                     iframe.setAttribute('inert', '');
+                    // Preserve video-backdrop class on the iframe (YT API replaces the original div)
+                    iframe.classList.add('backdrop', 'video-backdrop');
+                    if (CONFIG.fullWidthVideo) {
+                      iframe.classList.add('video-backdrop-full');
+                    } else {
+                      iframe.classList.add('video-backdrop-default');
+                    }
                   }
 
                   // Store start/end time and videoId for later use
@@ -1738,18 +1744,18 @@ const SlideCreator = {
                     event.target.setPlaybackQuality(quality);
                   }
 
-                  // Only play if this is the active slide AND the slideshow is visible
+                  // Only play if this is the active slide and not paused
                   const slide = document.querySelector(`.slide[data-item-id="${itemId}"]`);
                   const isVideoPlayerOpen = document.querySelector('.videoPlayerContainer') || document.querySelector('.youtubePlayerContainer');
 
-                  if (slide && slide.classList.contains('active') && !document.hidden && (!isVideoPlayerOpen || isVideoPlayerOpen.classList.contains('hide'))) {
-                      const currentIndex = STATE.slideshow.currentSlideIndex;
-                      const currentItemId = STATE.slideshow.itemIds[currentIndex];
-                      if (currentItemId !== itemId) {
-                          console.log(`Slide ${itemId} is no longer active (current: ${currentItemId}), aborting playback.`);
-                          event.target.mute(); // Mute just in case
-                          return;
-                      }
+                  const isActive = slide && slide.classList.contains('active');
+                  const isHidden = document.hidden;
+                  const isPaused = STATE.slideshow.isPaused;
+                  const isPlayerOpen = isVideoPlayerOpen && !isVideoPlayerOpen.classList.contains('hide');
+                  console.log(`[MBE-READY] onReady for ${itemId}: active=${isActive}, hidden=${isHidden}, paused=${isPaused}, playerOpen=${!!isPlayerOpen}`);
+
+                  if (isActive && !isHidden && !isPaused && !isPlayerOpen) {
+                    console.log(`[MBE-READY] → Playing video for ${itemId}`);
                     event.target.playVideo();
                     
                     // Check if it actually started playing after a short delay (handling autoplay blocks)
@@ -1782,6 +1788,8 @@ const SlideCreator = {
                   }
                 },
                 'onStateChange': (event) => {
+                  const stateNames = {[-1]: 'UNSTARTED', 0: 'ENDED', 1: 'PLAYING', 2: 'PAUSED', 3: 'BUFFERING', 5: 'CUED'};
+                  console.log(`[MBE-STATE] ${itemId}: ${stateNames[event.data] || event.data}`);
                   if (event.data === YT.PlayerState.ENDED) {
                     SlideshowManager.nextSlide();
                   }
@@ -1826,10 +1834,8 @@ const SlideCreator = {
 
         backdrop.addEventListener('play', (event) => {
           const slide = document.querySelector(`.slide[data-item-id="${itemId}"]`);
-          const currentIndex = STATE.slideshow.currentSlideIndex;
-          const currentItemId = STATE.slideshow.itemIds[currentIndex];
-          
-          if (!slide || !slide.classList.contains('active') || currentItemId !== itemId) {
+
+          if (!slide || !slide.classList.contains('active')) {
               console.log(`Local video ${itemId} started playing but is not active, pausing.`);
               event.target.pause();
               event.target.currentTime = 0;
@@ -2314,8 +2320,6 @@ const SlideshowManager = {
       }
 
       currentSlide.classList.add("active");
-      
-      STATE.slideshow.currentSlideIndex = index;
 
       // Restore focus for TV mode navigation continuity
       requestAnimationFrame(() => {
@@ -2337,7 +2341,29 @@ const SlideshowManager = {
 
       // Manage Video Playback: Stop others, Play current
       this.pauseOtherVideos(currentItemId);
-      this.playCurrentVideo(currentSlide, currentItemId);
+
+      if (!STATE.slideshow.isPaused) {
+        this.playCurrentVideo(currentSlide, currentItemId);
+      } else {
+        // Check if new slide has video — Option B: un-pause for video slides
+        const videoBackdrop = currentSlide.querySelector('.video-backdrop');
+        if (videoBackdrop) {
+          STATE.slideshow.isPaused = false;
+          const pauseButton = document.querySelector('.pause-button');
+          if (pauseButton) {
+            pauseButton.innerHTML = '<i class="material-icons">pause</i>';
+            const pauseLabel = LocalizationUtils.getLocalizedString('ButtonPause', 'Pause');
+            pauseButton.setAttribute('aria-label', pauseLabel);
+            pauseButton.setAttribute('title', pauseLabel);
+          }
+          this.playCurrentVideo(currentSlide, currentItemId);
+        }
+        // Update mute button visibility
+        const muteButton = document.querySelector('.mute-button');
+        if (muteButton) {
+          muteButton.style.display = videoBackdrop ? 'block' : 'none';
+        }
+      }
 
       const enableAnimations = MediaBarEnhancedSettingsManager.getSetting('slideAnimations', CONFIG.slideAnimationEnabled);
 
@@ -2350,6 +2376,8 @@ const SlideshowManager = {
         if (logo) logo.classList.add("animate");
       }
 
+      STATE.slideshow.currentSlideIndex = index;
+
       if (index === 0 || !previousVisibleSlide) {
         const dotsContainer = container.querySelector(".dots-container");
         if (dotsContainer) {
@@ -2370,7 +2398,8 @@ const SlideshowManager = {
       this.updateDots();
 
       // Only restart interval if we are NOT waiting for a video to end
-      const hasVideo = currentSlide.querySelector('.video-backdrop');
+      const hasVideo = currentSlide.querySelector('.video-backdrop') || 
+        (STATE.slideshow.videoPlayers && STATE.slideshow.videoPlayers[currentItemId]);
       if (STATE.slideshow.slideInterval && !STATE.slideshow.isPaused) {
         if (CONFIG.waitForTrailerToEnd && hasVideo) {
           STATE.slideshow.slideInterval.stop();
@@ -2433,6 +2462,8 @@ const SlideshowManager = {
     // Preload next slides
     for (let i = 1; i <= preloadCount; i++) {
         const nextIndex = (currentIndex + i) % totalItems;
+        if (nextIndex === currentIndex) break;
+        
         const itemId = STATE.slideshow.itemIds[nextIndex];
         SlideCreator.createSlideForItemId(itemId);
     }
@@ -2440,6 +2471,8 @@ const SlideshowManager = {
     // Preload previous slides
     for (let i = 1; i <= preloadCount; i++) {
         const prevIndex = (currentIndex - i + totalItems) % totalItems;
+        if (prevIndex === currentIndex) break;
+
         const prevItemId = STATE.slideshow.itemIds[prevIndex];
         SlideCreator.createSlideForItemId(prevItemId);
     }
@@ -2681,23 +2714,33 @@ const SlideshowManager = {
   },
 
   /**
-   * Plays the video backdrop on the given slide and updates mute button visibility
+   * Plays the video backdrop on the given slide and updates mute button visibility.
+   * Includes a retry mechanism for YouTube players that aren't ready yet.
    * @param {Element} slide - The slide DOM element
    * @param {string} itemId - The item ID of the slide
-   * @returns {boolean} Whether a video was found and playback attempted
    */
   playCurrentVideo(slide, itemId) {
+    // Find video element — check class (covers both original div and iframe with class restored by onReady)
     const videoBackdrop = slide.querySelector('.video-backdrop');
+    const ytPlayer = STATE.slideshow.videoPlayers && STATE.slideshow.videoPlayers[itemId];
+    const hasAnyVideo = !!(videoBackdrop || ytPlayer);
+
+    console.log(`[MBE-PLAY] playCurrentVideo for ${itemId}: videoBackdrop=${videoBackdrop?.tagName || 'null'}, ytPlayer=${!!ytPlayer}, ytReady=${ytPlayer && typeof ytPlayer.loadVideoById === 'function'}`);
 
     // Update mute button visibility
     const muteButton = document.querySelector('.mute-button');
     if (muteButton) {
-      muteButton.style.display = videoBackdrop ? 'block' : 'none';
+      muteButton.style.display = hasAnyVideo ? 'block' : 'none';
     }
 
-    if (!videoBackdrop) return false;
+    if (!hasAnyVideo) {
+      console.log(`[MBE-PLAY] No video found for ${itemId}, skipping`);
+      return;
+    }
 
-    if (videoBackdrop.tagName === 'VIDEO') {
+    // HTML5 <video> element
+    if (videoBackdrop && videoBackdrop.tagName === 'VIDEO') {
+      console.log(`[MBE-PLAY] Playing HTML5 video for ${itemId}`);
       videoBackdrop.currentTime = 0;
       videoBackdrop.muted = STATE.slideshow.isMuted;
       if (!STATE.slideshow.isMuted) videoBackdrop.volume = 0.4;
@@ -2705,54 +2748,113 @@ const SlideshowManager = {
       videoBackdrop.play().catch(() => {
         setTimeout(() => {
           if (videoBackdrop.paused && slide.classList.contains('active')) {
-            console.warn(`Autoplay blocked for ${itemId}, attempting muted fallback`);
+            console.warn(`[MBE-PLAY] Autoplay blocked for ${itemId}, muted fallback`);
             videoBackdrop.muted = true;
-            videoBackdrop.play().catch(err => console.error("Muted fallback failed", err));
+            videoBackdrop.play().catch(err => console.error('[MBE-PLAY] Muted fallback failed', err));
           }
         }, 1000);
       });
-      return true;
+      return;
     }
 
-    // YouTube player
-    const player = STATE.slideshow.videoPlayers?.[itemId];
-    if (player && typeof player.loadVideoById === 'function' && player._videoId) {
-      player.loadVideoById({
-        videoId: player._videoId,
-        startSeconds: player._startTime || 0,
-        endSeconds: player._endTime
+    // YouTube player — try to play now if ready
+    if (ytPlayer && typeof ytPlayer.loadVideoById === 'function' && ytPlayer._videoId) {
+      console.log(`[MBE-PLAY] YouTube player READY for ${itemId}, calling loadVideoById`);
+      ytPlayer.loadVideoById({
+        videoId: ytPlayer._videoId,
+        startSeconds: ytPlayer._startTime || 0,
+        endSeconds: ytPlayer._endTime
       });
-      
+
       if (STATE.slideshow.isMuted) {
-        player.mute();
+        ytPlayer.mute();
       } else {
-        player.unMute();
-        player.setVolume(40);
+        ytPlayer.unMute();
+        ytPlayer.setVolume(40);
       }
 
+      // Pause slideshow timer for video if configured
+      if (CONFIG.waitForTrailerToEnd && STATE.slideshow.slideInterval) {
+        STATE.slideshow.slideInterval.stop();
+      }
+
+      // 1s check: if still not playing, force muted retry
       setTimeout(() => {
         if (!slide.classList.contains('active')) return;
-
-        if (player.getPlayerState &&
-          player.getPlayerState() !== YT.PlayerState.PLAYING &&
-          player.getPlayerState() !== YT.PlayerState.BUFFERING) {
-          console.log("YouTube loadVideoById didn't start playback, retrying muted...");
-          player.mute();
-          player.playVideo();
-        }
-      }, 1000);
-      return true;
-    } else if (player && typeof player.seekTo === 'function') {
-      // Fallback if loadVideoById is not available or videoId missing but player object exists
-      const startTime = player._startTime || 0;
-      player.seekTo(startTime);
-      player.playVideo();
-      return true;
+        try {
+          const state = ytPlayer.getPlayerState();
+          if (state !== YT.PlayerState.PLAYING && state !== YT.PlayerState.BUFFERING) {
+            console.warn(`[MBE-PLAY] loadVideoById didn't start for ${itemId} (state=${state}), muted retry`);
+            ytPlayer.mute();
+            ytPlayer.playVideo();
+          }
+        } catch (e) { console.warn('[MBE-PLAY] Error checking player state:', e); }
+      }, 1500);
+      return;
     }
 
-    return false;
+    // YouTube player NOT ready yet (onReady hasn't fired). 
+    // onReady will handle it IF the slide is still active when it fires.
+    // But as safety net: retry every 500ms for up to 6 seconds.
+    console.log(`[MBE-PLAY] YouTube player NOT READY for ${itemId}, starting retry loop (onReady will also attempt)`);
+    let retryCount = 0;
+    const maxRetries = 12; // 12 × 500ms = 6 seconds
+    const retryTimer = setInterval(() => {
+      retryCount++;
+
+      // Abort if slide changed or paused
+      if (!slide.classList.contains('active') || STATE.slideshow.isPaused) {
+        console.log(`[MBE-PLAY] Retry aborted for ${itemId} (slide inactive or paused)`);
+        clearInterval(retryTimer);
+        return;
+      }
+
+      const p = STATE.slideshow.videoPlayers && STATE.slideshow.videoPlayers[itemId];
+
+      // Check if player is now playing (onReady may have started it)
+      if (p && typeof p.getPlayerState === 'function') {
+        try {
+          const state = p.getPlayerState();
+          if (state === YT.PlayerState.PLAYING || state === YT.PlayerState.BUFFERING) {
+            console.log(`[MBE-PLAY] Player for ${itemId} is already playing (started by onReady), stopping retry`);
+            clearInterval(retryTimer);
+            return;
+          }
+        } catch (e) { /* player not fully ready yet */ }
+      }
+
+      // Check if player is now ready
+      if (p && typeof p.loadVideoById === 'function' && p._videoId) {
+        console.log(`[MBE-PLAY] Retry #${retryCount}: Player for ${itemId} now READY, calling loadVideoById`);
+        clearInterval(retryTimer);
+
+        p.loadVideoById({
+          videoId: p._videoId,
+          startSeconds: p._startTime || 0,
+          endSeconds: p._endTime
+        });
+
+        if (STATE.slideshow.isMuted) {
+          p.mute();
+        } else {
+          p.unMute();
+          p.setVolume(40);
+        }
+
+        if (CONFIG.waitForTrailerToEnd && STATE.slideshow.slideInterval) {
+          STATE.slideshow.slideInterval.stop();
+        }
+        return;
+      }
+
+      if (retryCount >= maxRetries) {
+        console.warn(`[MBE-PLAY] Gave up retrying for ${itemId} after ${maxRetries * 500}ms`);
+        clearInterval(retryTimer);
+      }
+    }, 500);
   },
 
+
   /**
    * Stops all video playback (YouTube and HTML5)
    * Used when navigating away from the home screen

README.md

@@ -155,21 +155,48 @@ Configure the plugin via **Dashboard** > **Plugins** > **Media Bar Enhanced**.
 Define exactly what shows up in your bar.
 
 *   **Enable Custom Media IDs**: Restrict the slideshow to a specific list of IDs.
-    *   **Manual Trailer Override**: Add `[YouTube_URL]` after an ID to force a specific trailer.
+    *   **Manual Trailer Override**: Add `[YouTube_URL]` or `[Jellyfin_ID]` after an ID to force a specific trailer/video.
     *   Example ID: `a1b2c3d4e5... [https://www.youtube.com/watch?v=VIDEO_ID]`
+    *   Example ID: `z1b2c3d4e5... [Jellyfin_ID]`
+    *   **Example Mixed List**:
+        ```
+        a1b2c3d4e5f6...                         <-- Plays local item video
+        6bdu812812hd... [https://youtu.be/...]  <-- Item metadata + Custom YouTube Trailer
+        12h44h124sf7... [hdc78127z4ff...]       <-- Item metadata + Custom Jellyfin Trailer/Video etc.
+        ```
     *   Example Collection Name: `Halloween Collection [https://...] | My Description` (Note: Use `|` to separate description from name if using a name instead of an ID)
+*   **Apply Limits to Custom IDs**: If enabled, the "Content Limits" (see below) will also apply to your Custom Media IDs list. By default, custom lists show all listed items regardless of limits.
 *   **Enable Seasonal Content Mode**: Advanced date-based scheduling.
-    *   Format: `DD.MM-DD.MM | Name | ID1, ID2, ID3`
-    *   Example: `20.10-31.10 | Halloween | <ID_OF_HALLOWEEN_COLLECTION>`
-    *   If the current date matches a range, those IDs are used. Otherwise, it defaults to standard behavior or the Custom Media IDs list.
+    *   **GUI Configuration**: You can easily add "Seasons" via the **Add Season** button.
+    *   **Active Period**: Select the Start and End Day/Month for each season.
+    *   **Media IDs**: Enter the Comma-separated list of IDs (Movies, Series, Collections) for that season.
+    *   **Priority**: If the current date matches a defined season, those IDs are used. If multiple seasons overlap, the first matching one is used. If no season matches, it falls back to the Default Custom Media IDs.
 
 **How to get IDs:**
 Check the URL of an item in the web interface:
 `.../web/#/details?id=YOUR_ITEM_ID_HERE&...`
 
+### Content Sorting
+Customize the order of slides in the Media Bar.
+
+*   **Sort By**: Choose criteria like *Random*, *Premiere Date*, *Production Year*, *Critic Rating*, *Community Rating*, *Name*, or *Runtime*.
+*   **Sort Order**: Ascending or Descending.
+*   **Note**: Sorting applies to both server-fetched content AND Custom Media IDs. Select **Original** to preserve the exact order of your Custom Media IDs list.
+
+### Content Limits
+Fine-tune performance by limiting the number of items fetched from the server.
+
+*   **Total Max Items**: Maximum total items to fetch (combined).
+*   **Max Movies**: Maximum movies to include (for random selection).
+*   **Max Tv Shows**: Maximum TV shows to include (for random selection).
+*   **Preload Count**: Number of slides to preload for smooth transitions.
+    *   *Intelligent Preloading*: The plugin uses a safe preloading strategy that respects this count but handles small lists gracefully to avoid playback issues.
+*   **Max Pagination Dots**: Maximum number of dots to show. If exceeded, it switches to a counter (e.g., 1/20).
+
 ### Advanced Settings
 *   **Slide Animations**: Enable/disable the "Zoom In" effect.
 *   **Use SponsorBlock**: Skips non-content segments in YouTube trailers (if the data exists).
+*   **Preferred YouTube Quality**: Select your preferred resolution (*Auto*, *Maximum*, *1080p*, *720p*).
 *   **Start Muted**: Videos start without sound (user can unmute).
 *   **Full Width Video**: Stretches video to cover the entire width (good for desktop, crop on mobile).
 *   **Enable Loading Screen**: Enable/disable the loading indicator while the bar initializes.

manifest.json

@@ -9,12 +9,12 @@
     "imageUrl": "https://git.mahom03-spacecloud.de/CodeDevMLH/jellyfin-plugin-media-bar-enhanced/raw/branch/main/logo.png",
     "versions": [
       {
-        "version": "1.6.1.14",
+        "version": "1.6.1.24",
         "changelog": "- fix tv mode issue\n- refactor video playback management",
         "targetAbi": "10.11.0.0",
-        "sourceUrl": "https://git.mahom03-spacecloud.de/CodeDevMLH/jellyfin-plugin-media-bar-enhanced/releases/download/v1.6.1.14/Jellyfin.Plugin.MediaBarEnhanced.zip",
-        "checksum": "6af6dd96995a90bf91d811467c88da04",
-        "timestamp": "2026-02-13T02:23:28Z"
+        "sourceUrl": "https://git.mahom03-spacecloud.de/CodeDevMLH/jellyfin-plugin-media-bar-enhanced/releases/download/v1.6.1.24/Jellyfin.Plugin.MediaBarEnhanced.zip",
+        "checksum": "466a2504753288ac48d3a9fd6b697f27",
+        "timestamp": "2026-02-14T01:12:44Z"
       },
       {
         "version": "1.6.0.2",