myetv-player 1.1.0 → 1.1.2

package/plugins/youtube/myetv-player-youtube-plugin.js

@@ -14,7 +14,8 @@
                 autoplay: options.autoplay !== undefined ? options.autoplay : false,
                 showYouTubeUI: options.showYouTubeUI !== undefined ? options.showYouTubeUI : false,
                 autoLoadFromData: options.autoLoadFromData !== undefined ? options.autoLoadFromData : true,
-                quality: options.quality || 'auto',
+                quality: options.quality || 'default',
+                
                 enableQualityControl: options.enableQualityControl !== undefined ? options.enableQualityControl : true,
                 enableCaptions: options.enableCaptions !== undefined ? options.enableCaptions : true,
 
@@ -31,6 +32,13 @@
                 ...options
             };
 
+            // Normalize 'auto' to 'default' for YouTube API compatibility
+            if (this.options.quality === 'auto') {
+                this.options.quality = 'default';
+            }
+            // Track original user choice for UI display
+            this.userQualityChoice = options.quality || 'default';
+
             this.ytPlayer = null;
             this.isYouTubeReady = false;
             this.videoId = this.options.videoId;
@@ -46,6 +54,7 @@
             this.mouseMoveOverlay = null;
             this.qualityCheckAttempts = 0;
             this.captionCheckAttempts = 0;
+            this.liveStreamChecked = false;
             this.captionStateCheckInterval = null;
             this.qualityMonitorInterval = null;
             this.resizeListenerAdded = false;
@@ -69,6 +78,7 @@
                 { code: 'ar', name: 'Arabic' },
                 { code: 'pt', name: 'Portuguese' },
                 { code: 'ru', name: 'Russian' },
+                { code: 'zh', name: 'Chinese' },
                 { code: 'ja', name: 'Japanese' },
                 { code: 'de', name: 'German' },
                 { code: 'fr', name: 'French' },
@@ -716,6 +726,131 @@ width: fit-content;
             this.api.triggerEvent('youtubeplugin:videoloaded', { videoId });
         }
 
+setAdaptiveQuality() {
+    if (!this.ytPlayer) return;
+
+    try {
+        // Check network connection speed if available
+        const connection = navigator.connection || navigator.mozConnection || navigator.webkitConnection;
+        let suggestedQuality = 'default';
+
+        if (connection) {
+            const effectiveType = connection.effectiveType; // '4g', '3g', '2g', 'slow-2g'
+            const downlink = connection.downlink; // Mbps
+
+            if (this.api.player.options.debug) {
+                console.log('[YT Plugin] Connection:', effectiveType, 'Downlink:', downlink, 'Mbps');
+            }
+
+            // Set quality based on connection speed
+            if (effectiveType === 'slow-2g' || downlink < 0.5) {
+                suggestedQuality = 'small'; // 240p
+            } else if (effectiveType === '2g' || downlink < 1) {
+                suggestedQuality = 'medium'; // 360p
+            } else if (effectiveType === '3g' || downlink < 2.5) {
+                suggestedQuality = 'large'; // 480p
+            } else if (downlink < 5) {
+                suggestedQuality = 'hd720'; // 720p
+            } else if (downlink < 10) {
+                suggestedQuality = 'hd1080'; // 1080p
+            } else if (downlink < 20) {
+                suggestedQuality = 'hd1440'; // 1440p (2K)
+            } else if (downlink < 35) {
+                suggestedQuality = 'hd2160'; // 2160p (4K)
+            } else {
+                suggestedQuality = 'highres'; // 8K o migliore disponibile
+            }
+
+            if (this.api.player.options.debug) {
+                console.log('[YT Plugin] Setting suggested quality:', suggestedQuality);
+            }
+
+            this.ytPlayer.setPlaybackQuality(suggestedQuality);
+        } else {
+            // Fallback: start with medium quality on unknown devices
+            if (this.api.player.options.debug) {
+                console.log('[YT Plugin] Connection API not available, using large (480p) as safe default');
+            }
+            this.ytPlayer.setPlaybackQuality('large'); // 480p come default sicuro
+        }
+    } catch (error) {
+        if (this.api.player.options.debug) {
+            console.error('[YT Plugin] Error setting adaptive quality:', error);
+        }
+    }
+}
+
+startBufferMonitoring() {
+    if (this.bufferMonitorInterval) {
+        clearInterval(this.bufferMonitorInterval);
+    }
+
+    let bufferingCount = 0;
+    let lastState = null;
+
+    this.bufferMonitorInterval = setInterval(() => {
+        if (!this.ytPlayer) return;
+
+        try {
+            const state = this.ytPlayer.getPlayerState();
+
+            // Detect buffering (state 3)
+            if (state === YT.PlayerState.BUFFERING) {
+                bufferingCount++;
+
+                if (this.api.player.options.debug) {
+                    console.log('[YT Plugin] Buffering detected, count:', bufferingCount);
+                }
+
+                // If buffering happens too often, reduce quality
+                if (bufferingCount >= 3) {
+                    const currentQuality = this.ytPlayer.getPlaybackQuality();
+                    const availableQualities = this.ytPlayer.getAvailableQualityLevels();
+
+                    if (this.api.player.options.debug) {
+                        console.log('[YT Plugin] Too much buffering, current quality:', currentQuality);
+                        console.log('[YT Plugin] Available qualities:', availableQualities);
+                    }
+
+                    // Quality hierarchy (highest to lowest)
+                    const qualityLevels = ['highres', 'hd1080', 'hd720', 'large', 'medium', 'small', 'tiny'];
+                    const currentIndex = qualityLevels.indexOf(currentQuality);
+
+                    // Try to go to next lower quality
+                    if (currentIndex < qualityLevels.length - 1) {
+                        const lowerQuality = qualityLevels[currentIndex + 1];
+
+                        // Check if lower quality is available
+                        if (availableQualities.includes(lowerQuality)) {
+                            if (this.api.player.options.debug) {
+                                console.log('[YT Plugin] Reducing quality to:', lowerQuality);
+                            }
+
+                            this.ytPlayer.setPlaybackQuality(lowerQuality);
+                            bufferingCount = 0; // Reset counter
+                        }
+                    }
+                }
+            } else if (state === YT.PlayerState.PLAYING) {
+                // Reset buffering count when playing smoothly
+                if (lastState === YT.PlayerState.BUFFERING) {
+                    setTimeout(() => {
+                        if (this.ytPlayer.getPlayerState() === YT.PlayerState.PLAYING) {
+                            bufferingCount = Math.max(0, bufferingCount - 1);
+                        }
+                    }, 5000); // Wait 5 seconds of smooth playback
+                }
+            }
+
+            lastState = state;
+        } catch (error) {
+            if (this.api.player.options.debug) {
+                console.error('[YT Plugin] Error in buffer monitoring:', error);
+            }
+        }
+    }, 1000); // Check every second
+}
+
         createMouseMoveOverlay() {
             if (this.mouseMoveOverlay) return;
 
@@ -1010,6 +1145,8 @@ width: fit-content;
             this.injectYouTubeCSSOverride();
 
             this.syncControls();
+            // Start buffer monitoring for auto quality adjustment
+            this.startBufferMonitoring();
 
             // Hide custom controls when YouTube native UI is enabled
             if (this.options.showYouTubeUI) {
@@ -1044,13 +1181,16 @@ width: fit-content;
             // Handle responsive layout for PiP and subtitles buttons
             this.handleResponsiveLayout();
 
+            this.playAttemptTimeout = null;
+
             // Hide PiP from settings menu (separate function, called after responsive layout)
             setTimeout(() => this.hidePipFromSettingsMenuOnly(), 500);
-            setTimeout(() => this.hidePipFromSettingsMenuOnly(), 1500);
-            setTimeout(() => this.hidePipFromSettingsMenuOnly(), 3000);
+
             // Check if this is a live stream
             setTimeout(() => this.checkIfLiveStream(), 2000);
             setTimeout(() => this.checkIfLiveStream(), 5000);
+            // Set adaptive quality based on connection
+            setTimeout(() => this.setAdaptiveQuality(), 1000);
 
 
             // Listen for window resize
@@ -1062,13 +1202,9 @@ width: fit-content;
 
             // Load qualities with multiple attempts
             setTimeout(() => this.loadAvailableQualities(), 500);
-            setTimeout(() => this.loadAvailableQualities(), 1000);
-            setTimeout(() => this.loadAvailableQualities(), 2000);
 
             // Load captions with multiple attempts
             setTimeout(() => this.loadAvailableCaptions(), 500);
-            setTimeout(() => this.loadAvailableCaptions(), 1000);
-            setTimeout(() => this.loadAvailableCaptions(), 2000);
 
             if (this.options.quality && this.options.quality !== 'default') {
                 setTimeout(() => this.setQuality(this.options.quality), 1000);
@@ -1700,7 +1836,7 @@ width: fit-content;
                 const actualQuality = this.ytPlayer.getPlaybackQuality();
 
                 // Only update UI if in AUTO mode, otherwise respect manual selection
-                if (this.currentQuality === 'default' || this.currentQuality === 'auto') {
+                if (this.userQualityChoice === 'default' || this.userQualityChoice === 'auto') {
                     if (actualQuality !== this.currentPlayingQuality) {
                         this.currentPlayingQuality = actualQuality;
                         if (this.api.player.options.debug) {
@@ -1880,6 +2016,8 @@ width: fit-content;
             if (!this.ytPlayer || !this.ytPlayer.setPlaybackQuality) return false;
 
             try {
+                // Track user's quality choice for display
+                this.userQualityChoice = quality;
                 if (this.api.player.options.debug) {
                     console.log('[YT Plugin] Setting quality to:', quality);
                     console.log('[YT Plugin] Current quality:', this.ytPlayer.getPlaybackQuality());
@@ -2562,6 +2700,49 @@ width: fit-content;
             };
             if (this.api.player.options.debug) console.log('[YT Plugin] State:', states[event.data], event.data);
 
+            // Know if video have some problems to start
+            if (event.data === YT.PlayerState.UNSTARTED || event.data === -1) {
+                // start timeout when video is unstarted
+                if (this.playAttemptTimeout) {
+                    clearTimeout(this.playAttemptTimeout);
+                }
+
+                this.playAttemptTimeout = setTimeout(() => {
+                    if (!this.ytPlayer) return;
+
+                    const currentState = this.ytPlayer.getPlayerState();
+
+                    // If video is unstrated after timeout, consider it restricted
+                    if (currentState === YT.PlayerState.UNSTARTED || currentState === -1) {
+                        if (this.api.player.options.debug) {
+                            console.log('YT Plugin: Video stuck in UNSTARTED - possibly members-only or restricted');
+                        }
+
+                        // Trigger ended event
+                        this.api.triggerEvent('ended', {
+                            reason: 'video_restricted_or_membership',
+                            state: currentState
+                        });
+
+                        // Show poster overlay if present
+                        this.showPosterOverlay();
+
+                        // Trigger custom event
+                        this.api.triggerEvent('youtubeplugin:membershiprestricted', {
+                            videoId: this.videoId
+                        });
+                    }
+                }, 15000); // 15 seconds of timeout
+
+            } else if (event.data === YT.PlayerState.PLAYING ||
+                event.data === YT.PlayerState.BUFFERING) {
+                // Clear the timeout if video starts correctly
+                if (this.playAttemptTimeout) {
+                    clearTimeout(this.playAttemptTimeout);
+                    this.playAttemptTimeout = null;
+                }
+            }
+
             // Get play/pause icons
             const playIcon = this.api.container.querySelector('.play-icon');
             const pauseIcon = this.api.container.querySelector('.pause-icon');
@@ -2651,18 +2832,39 @@ width: fit-content;
         }
 
         onPlayerError(event) {
-            const errorMessages = {
-                2: 'Invalid video ID',
-                5: 'HTML5 player error',
-                100: 'Video not found or private',
-                101: 'Video not allowed in embedded players',
-                150: 'Video not allowed in embedded players'
-            };
-            const errorMsg = errorMessages[event.data] || 'Unknown error';
-            if (this.api.player.options.debug) console.error('[YT Plugin] Error:', errorMsg);
+            const errorCode = event.data;
+
+            if (this.api.player.options.debug) {
+                console.error('[YT Plugin] Player error:', errorCode);
+            }
+
+            // Error codes che indicano video non disponibile
+            const unavailableErrors = [
+                2,   // Invalid video ID
+                5,   // HTML5 player error
+                100, // Video not found / removed
+                101, // Video not allowed to be played in embedded players (private/restricted)
+                150  // Same as 101
+            ];
+
+            if (unavailableErrors.includes(errorCode)) {
+                if (this.api.player.options.debug) {
+                    console.log('[YT Plugin] Video unavailable, triggering ended event');
+                }
+
+                // Trigger the ended event from your player API
+                this.api.triggerEvent('ended', {
+                    reason: 'video_unavailable',
+                    errorCode: errorCode
+                });
+
+                // Optional: show poster overlay again
+                this.showPosterOverlay();
+            }
+
             this.api.triggerEvent('youtubeplugin:error', {
-                errorCode: event.data,
-                errorMessage: errorMsg
+                errorCode: errorCode,
+                videoId: this.videoId
             });
         }
 
@@ -3126,6 +3328,12 @@ width: fit-content;
         dispose() {
             if (this.api.player.options.debug) console.log('[YT Plugin] Disposing');
 
+            // Cleanup timeout
+            if (this.playAttemptTimeout) {
+                clearTimeout(this.playAttemptTimeout);
+                this.playAttemptTimeout = null;
+            }
+
             if (this.timeUpdateInterval) {
                 clearInterval(this.timeUpdateInterval);
                 this.timeUpdateInterval = null;
@@ -3151,6 +3359,16 @@ width: fit-content;
                 this.ytPlayerContainer = null;
             }
 
+            if (this.bufferMonitorInterval) {
+                clearInterval(this.bufferMonitorInterval);
+                this.bufferMonitorInterval = null;
+            }
+
+            if (this.qualityMonitorInterval) {
+                clearInterval(this.qualityMonitorInterval);
+                this.qualityMonitorInterval = null;
+            }
+
             this.removeMouseMoveOverlay();
 
             this.api.container.classList.remove('youtube-active');