myetv-player 1.1.0 → 1.1.1

package/README.md

@@ -119,6 +119,7 @@ const player = new MYETVvideoplayer('my-video', {
 | `brandLogoEnabled` | boolean | `false` | Show/hide the brand logo in the controlbar |
 | `brandLogoUrl` | string | `''` | Brand logo url in the controlbar (png, jpg, gif) - image height 44px - image width 120px |
 | `brandLogoLinkUrl` | string | `''` | Optional URL to open in a new page when clicking the brand logo in the controlbar
+| `brandLogoTooltipText` | string | `''` | Optional Custom tooltip of the brand logo (the default is the url of the brand logo, if present)
 | `watermarkUrl` | string | `''` | Optional URL of the image watermark over the video, reccomended dimension: width: 180px, height: 100px
 | `watermarkLink` | string | `''` | Optional URL to open in a new page when clicking the watermark logo in the video
 | `watermarkPosition` | string | `''` | Optional where to show the watermark logo in the video (values are: top-left, top-right, bottom-left, bottom-right)
@@ -283,8 +284,21 @@ console.log(player.getCurrentResolution()); // Get current resolution
 ```
 ## API Events
 The MYETV Video Player includes a comprehensive custom event system that allows you to monitor all player state changes in real-time.
+### on player ready
+Description: Triggered when the video player is ready
+
+When: Player is ready to receive other events
+```
+player.addEventListener('playerready', (event) => {
+    console.log('Player is ready!', event);
+//now it's secure to call other apis method
+        player.setVolume(0.8);
+        player.play();
+});
+```
 ### on played
 Description: Triggered when the video starts playing
+
 When: User presses play or video starts automatically
 ```
 player.addEventListener('played', (event) => {
@@ -294,24 +308,72 @@ player.addEventListener('played', (event) => {
     });
 });
 ```
+### on playing
+Description: Triggered when the video is playing
+
+When: Video is effectively playing
+```
+player.addEventListener('playing', (event) => {
+    console.log('Video is playing at', event.currentTime);
+});
+```
 ### on paused
 Description: Triggered when the video is pause
+
 When: User presses pause or video stops
 ```
 player.addEventListener('paused', (event) => {
     console.log('Video paused at:', event.currentTime + 's');
 });
 ```
+### on waiting
+Description: Triggered when the video is buffering
+
+When: Video is buffering and is waiting
+```
+player.addEventListener('waiting', (event) => {
+    console.log('Video is buffering...');
+});
+```
+### on seeking
+Description: Triggered when the video is being seeking
+
+When: The user is seeking over the video
+```
+player.addEventListener('seeking', (event) => {
+    console.log('User is seeking to', event.targetTime);
+});
+```
+### on seeked
+Description: Triggered when the video is finished seeked
+
+When: The user have finished seeking and seeked the video
+```
+player.addEventListener('seeked', (event) => {
+    console.log('Seek completed at', event.currentTime);
+});
+```
 ### on ended
 Description: Triggered when the video is ended
+
 When: Video is ended
 ```
 player.addEventListener('ended', (e) => {
     console.log('Video terminato!', e.currentTime, e.duration, e.playlistInfo);
 });
 ```
+### on error
+Description: Triggered when the video have some error
+
+When: Video have some error on load
+```
+player.addEventListener('error', (event) => {
+    console.error('Playback error:', event.message);
+});
+```
 ### on subtitle change
 Description: Triggered when subtitles are enabled/disabled or track changes
+
 When: User toggles subtitles or switches subtitle tracks
 ```
 player.addEventListener('subtitlechange', (event) => {
@@ -324,6 +386,7 @@ player.addEventListener('subtitlechange', (event) => {
 ```
 ### on chapters change
 Description: Triggered when chapters are changes
+
 When: User switches chapters tracks
 ```
 player.on('chapterchange', (data) => {
@@ -332,6 +395,7 @@ player.on('chapterchange', (data) => {
 ```
 ### on pip change
 Description: Triggered when Picture-in-Picture mode changes
+
 When: Video enters or exits PiP mode
 ```
 player.addEventListener('pipchange', (event) => {
@@ -340,6 +404,7 @@ player.addEventListener('pipchange', (event) => {
 ```
 ### on fullscreen change
 Description: Triggered when fullscreen mode changes
+
 When: Player enters or exits fullscreen mode
 ```
 player.addEventListener('fullscreenchange', (event) => {
@@ -348,6 +413,7 @@ player.addEventListener('fullscreenchange', (event) => {
 ```
 ### on speed change
 Description: Triggered when playback speed changes
+
 When: User modifies playback speed (0.5x, 1x, 1.5x, 2x, etc.)
 ```
 player.addEventListener('speedchange', (event) => {
@@ -356,6 +422,7 @@ player.addEventListener('speedchange', (event) => {
 ```
 ### on time update
 Description: Triggered during playback to update progress
+
 When: Every 250ms during playback (throttled for performance)
 ```
 player.addEventListener('timeupdate', (event) => {
@@ -366,6 +433,7 @@ player.addEventListener('timeupdate', (event) => {
 ```
 ### on volumechange
 Description: Triggered when volume or mute state changes
+
 When: User modifies volume or toggles mute
 ```
 player.addEventListener('volumechange', (event) => {
@@ -384,6 +452,7 @@ player.addEventListener('playlistchange', (e) => {
 ```
 ### Main APIs
 getEventData()
+
 Returns all requested state data in a single object:
 ```
 const state = player.getEventData();

package/dist/myetv-player.js

@@ -433,6 +433,7 @@ constructor(videoElement, options = {}) {
         brandLogoEnabled: false,  // Enable/disable brand logo
         brandLogoUrl: '',         // URL for brand logo image
         brandLogoLinkUrl: '',     // Optional URL to open when clicking the logo
+        brandLogoTooltipText: '', // Tooltip text for brand logo
         playlistEnabled: true,    // Enable/disable playlist detection
         playlistAutoPlay: true,   // Auto-play next video when current ends
         playlistLoop: false,      // Loop playlist when reaching the end
@@ -508,18 +509,42 @@ constructor(videoElement, options = {}) {
 
     // Custom event system
     this.eventCallbacks = {
-        'played': [],
-        'paused': [],
-        'subtitlechange': [],
-        'chapterchange': [],
-        'pipchange': [],
-        'fullscreenchange': [],
-        'speedchange': [],
-        'timeupdate': [],
-        'volumechange': [],
-        'qualitychange': [],
-        'playlistchange': [],
-        'ended': []
+        // Core lifecycle events
+        'playerready': [],     // Fired when player is fully initialized and ready
+        'played': [],          // Fired when video starts playing
+        'paused': [],          // Fired when video is paused
+        'ended': [],           // Fired when video playback ends
+
+        // Playback state events
+        'playing': [],         // Fired when video is actually playing (after buffering)
+        'waiting': [],         // Fired when video is waiting for data (buffering)
+        'seeking': [],         // Fired when seek operation starts
+        'seeked': [],          // Fired when seek operation completes
+
+        // Loading events
+        'loadstart': [],       // Fired when browser starts looking for media
+        'loadedmetadata': [],  // Fired when metadata (duration, dimensions) is loaded
+        'loadeddata': [],      // Fired when data for current frame is loaded
+        'canplay': [],         // Fired when browser can start playing video
+        'progress': [],        // Fired periodically while downloading media
+        'durationchange': [],  // Fired when duration attribute changes
+
+        // Error events
+        'error': [],           // Fired when media loading or playback error occurs
+        'stalled': [],         // Fired when browser is trying to get data but it's not available
+
+        // Control events
+        'timeupdate': [],      // Fired when current playback position changes
+        'volumechange': [],    // Fired when volume or muted state changes
+        'speedchange': [],     // Fired when playback speed changes
+        'qualitychange': [],   // Fired when video quality changes
+
+        // Feature events
+        'subtitlechange': [],  // Fired when subtitle track changes
+        'chapterchange': [],   // Fired when video chapter changes
+        'pipchange': [],       // Fired when picture-in-picture mode changes
+        'fullscreenchange': [], // Fired when fullscreen mode changes
+        'playlistchange': []   // Fired when playlist item changes
     };
 
     // Playlist management
@@ -881,6 +906,14 @@ markPlayerReady() {
             this.container.classList.add('player-initialized');
         }
 
+        this.triggerEvent('playerready', {
+            playerState: this.getPlayerState(),
+            qualities: this.qualities,
+            subtitles: this.textTracks,
+            chapters: this.chapters,
+            playlist: this.getPlaylistInfo()
+        });
+
         if (this.video) {
             this.video.style.visibility = '';
             this.video.style.opacity = '';
@@ -1742,7 +1775,14 @@ createBrandLogo() {
     const logo = document.createElement('img');
     logo.className = 'brand-logo';
     logo.src = this.options.brandLogoUrl;
-    logo.alt = this.t('brand_logo');
+    logo.alt = 'Brand logo';
+
+    // Add tooltip ONLY if link URL is present
+    if (this.options.brandLogoLinkUrl) {
+        // Use custom tooltip text if provided, otherwise fallback to URL
+        logo.title = this.options.brandLogoTooltipText || this.options.brandLogoLinkUrl;
+        // NON usare data-tooltip per evitare che venga sovrascritto da updateTooltips()
+    }
 
     // Handle loading error
     logo.onerror = () => {
@@ -1758,7 +1798,7 @@ createBrandLogo() {
     if (this.options.brandLogoLinkUrl) {
         logo.style.cursor = 'pointer';
         logo.addEventListener('click', (e) => {
-            e.stopPropagation(); // Prevent video controls interference
+            e.stopPropagation();
             window.open(this.options.brandLogoLinkUrl, '_blank', 'noopener,noreferrer');
             if (this.options.debug) console.log('Brand logo clicked, opening:', this.options.brandLogoLinkUrl);
         });
@@ -1766,15 +1806,10 @@ createBrandLogo() {
         logo.style.cursor = 'default';
     }
 
-    // Position the brand logo at the right of the controlbar (at the left of the buttons)
     controlsRight.insertBefore(logo, controlsRight.firstChild);
 
     if (this.options.debug) {
-        if (this.options.brandLogoLinkUrl) {
-            console.log('Brand logo with click handler created for:', this.options.brandLogoLinkUrl);
-        } else {
-            console.log('Brand logo created (no link)');
-        }
+        console.log('Brand logo created with tooltip:', logo.title || 'no tooltip');
     }
 }
 
@@ -2420,36 +2455,129 @@ addEventListener(eventType, callback) {
     }
 
     bindEvents() {
-        if (this.video) {
-            this.video.addEventListener('loadedmetadata', () => {
-                this.updateDuration();
-                setTimeout(() => {
-                    this.initializeSubtitles();
-                }, 100);
+    if (this.video) {
+
+        // Playback events
+        this.video.addEventListener('playing', () => {
+            this.hideLoading();
+            // Trigger playing event - video is now actually playing
+            this.triggerEvent('playing', {
+                currentTime: this.getCurrentTime(),
+                duration: this.getDuration()
             });
-            this.video.addEventListener('timeupdate', () => this.updateProgress());
-            this.video.addEventListener('progress', () => this.updateBuffer());
-            this.video.addEventListener('waiting', () => {
-                if (!this.isChangingQuality) {
-                    this.showLoading();
-                }
+        });
+
+        this.video.addEventListener('waiting', () => {
+            if (!this.isChangingQuality) {
+                this.showLoading();
+                // Trigger waiting event - video is buffering
+                this.triggerEvent('waiting', {
+                    currentTime: this.getCurrentTime()
+                });
+            }
+        });
+
+        this.video.addEventListener('seeking', () => {
+            // Trigger seeking event - seek operation started
+            this.triggerEvent('seeking', {
+                currentTime: this.getCurrentTime(),
+                targetTime: this.video.currentTime
             });
-            this.video.addEventListener('canplay', () => {
-                if (!this.isChangingQuality) {
-                    this.hideLoading();
-                }
+        });
+
+        this.video.addEventListener('seeked', () => {
+            // Trigger seeked event - seek operation completed
+            this.triggerEvent('seeked', {
+                currentTime: this.getCurrentTime()
             });
-            this.video.addEventListener('ended', () => this.onVideoEnded());
-            this.video.addEventListener('loadstart', () => {
-                if (!this.isChangingQuality) {
-                    this.showLoading();
-                }
+        });
+
+        // Loading events
+        this.video.addEventListener('loadstart', () => {
+            if (!this.isChangingQuality) {
+                this.showLoading();
+            }
+            // Trigger loadstart event - browser started loading media
+            this.triggerEvent('loadstart');
+        });
+
+        this.video.addEventListener('loadedmetadata', () => {
+            this.updateDuration();
+
+            // Trigger loadedmetadata event - video metadata loaded
+            this.triggerEvent('loadedmetadata', {
+                duration: this.getDuration(),
+                videoWidth: this.video.videoWidth,
+                videoHeight: this.video.videoHeight
             });
-            this.video.addEventListener('loadeddata', () => {
-                if (!this.isChangingQuality) {
-                    this.hideLoading();
-                }
+
+            // Initialize subtitles after metadata is loaded
+            setTimeout(() => {
+                this.initializeSubtitles();
+            }, 100);
+        });
+
+        this.video.addEventListener('loadeddata', () => {
+            if (!this.isChangingQuality) {
+                this.hideLoading();
+            }
+            // Trigger loadeddata event - current frame data loaded
+            this.triggerEvent('loadeddata', {
+                currentTime: this.getCurrentTime()
+            });
+        });
+
+        this.video.addEventListener('canplay', () => {
+            if (!this.isChangingQuality) {
+                this.hideLoading();
+            }
+            // Trigger canplay event - video can start playing
+            this.triggerEvent('canplay', {
+                currentTime: this.getCurrentTime(),
+                duration: this.getDuration()
             });
+        });
+
+        this.video.addEventListener('progress', () => {
+            this.updateBuffer();
+            // Trigger progress event - browser is downloading media
+            this.triggerEvent('progress', {
+                buffered: this.getBufferedTime(),
+                duration: this.getDuration()
+            });
+        });
+
+        this.video.addEventListener('durationchange', () => {
+            this.updateDuration();
+            // Trigger durationchange event - video duration changed
+            this.triggerEvent('durationchange', {
+                duration: this.getDuration()
+            });
+        });
+
+        // Error events
+        this.video.addEventListener('error', (e) => {
+            this.onVideoError(e);
+            // Trigger error event - media loading/playback error occurred
+            this.triggerEvent('error', {
+                code: this.video.error?.code,
+                message: this.video.error?.message,
+                src: this.video.currentSrc || this.video.src
+            });
+        });
+
+        this.video.addEventListener('stalled', () => {
+            // Trigger stalled event - browser is trying to fetch data but it's not available
+            this.triggerEvent('stalled', {
+                currentTime: this.getCurrentTime()
+            });
+        });
+
+
+            this.video.addEventListener('timeupdate', () => this.updateProgress());
+
+            this.video.addEventListener('ended', () => this.onVideoEnded());
+
             // Complete video click logic with doubleTapPause support (DESKTOP)
             this.video.addEventListener('click', () => {
                 if (!this.options.pauseClick) return;

package/dist/myetv-player.min.js

@@ -419,6 +419,7 @@ constructor(videoElement, options = {}) {
         brandLogoEnabled: false, 
         brandLogoUrl: '',        
         brandLogoLinkUrl: '',    
+        brandLogoTooltipText: '',
         playlistEnabled: true,   
         playlistAutoPlay: true,  
         playlistLoop: false,     
@@ -494,18 +495,42 @@ constructor(videoElement, options = {}) {
 
    
     this.eventCallbacks = {
-        'played': [],
-        'paused': [],
-        'subtitlechange': [],
-        'chapterchange': [],
-        'pipchange': [],
+       
+        'playerready': [],    
+        'played': [],         
+        'paused': [],         
+        'ended': [],          
+
+       
+        'playing': [],        
+        'waiting': [],        
+        'seeking': [],        
+        'seeked': [],         
+
+       
+        'loadstart': [],      
+        'loadedmetadata': [], 
+        'loadeddata': [],     
+        'canplay': [],        
+        'progress': [],       
+        'durationchange': [], 
+
+       
+        'error': [],          
+        'stalled': [],        
+
+       
+        'timeupdate': [],     
+        'volumechange': [],   
+        'speedchange': [],    
+        'qualitychange': [],  
+
+       
+        'subtitlechange': [], 
+        'chapterchange': [],  
+        'pipchange': [],      
         'fullscreenchange': [],
-        'speedchange': [],
-        'timeupdate': [],
-        'volumechange': [],
-        'qualitychange': [],
-        'playlistchange': [],
-        'ended': []
+        'playlistchange': []  
     };
 
    
@@ -867,6 +892,14 @@ markPlayerReady() {
             this.container.classList.add('player-initialized');
         }
 
+        this.triggerEvent('playerready', {
+            playerState: this.getPlayerState(),
+            qualities: this.qualities,
+            subtitles: this.textTracks,
+            chapters: this.chapters,
+            playlist: this.getPlaylistInfo()
+        });
+
         if (this.video) {
             this.video.style.visibility = '';
             this.video.style.opacity = '';
@@ -1716,7 +1749,14 @@ createBrandLogo() {
     const logo = document.createElement('img');
     logo.className = 'brand-logo';
     logo.src = this.options.brandLogoUrl;
-    logo.alt = this.t('brand_logo');
+    logo.alt = 'Brand logo';
+
+   
+    if (this.options.brandLogoLinkUrl) {
+       
+        logo.title = this.options.brandLogoTooltipText || this.options.brandLogoLinkUrl;
+       
+    }
 
    
     logo.onerror = () => {
@@ -1740,15 +1780,10 @@ createBrandLogo() {
         logo.style.cursor = 'default';
     }
 
-   
     controlsRight.insertBefore(logo, controlsRight.firstChild);
 
     if (this.options.debug) {
-        if (this.options.brandLogoLinkUrl) {
-            console.log('Brand logo with click handler created for:', this.options.brandLogoLinkUrl);
-        } else {
-            console.log('Brand logo created (no link)');
-        }
+        console.log('Brand logo created with tooltip:', logo.title || 'no tooltip');
     }
 }
 
@@ -2335,36 +2370,129 @@ addEventListener(eventType, callback) {
     }
 
     bindEvents() {
-        if (this.video) {
-            this.video.addEventListener('loadedmetadata', () => {
-                this.updateDuration();
-                setTimeout(() => {
-                    this.initializeSubtitles();
-                }, 100);
+    if (this.video) {
+
+       
+        this.video.addEventListener('playing', () => {
+            this.hideLoading();
+           
+            this.triggerEvent('playing', {
+                currentTime: this.getCurrentTime(),
+                duration: this.getDuration()
             });
-            this.video.addEventListener('timeupdate', () => this.updateProgress());
-            this.video.addEventListener('progress', () => this.updateBuffer());
-            this.video.addEventListener('waiting', () => {
-                if (!this.isChangingQuality) {
-                    this.showLoading();
-                }
+        });
+
+        this.video.addEventListener('waiting', () => {
+            if (!this.isChangingQuality) {
+                this.showLoading();
+               
+                this.triggerEvent('waiting', {
+                    currentTime: this.getCurrentTime()
+                });
+            }
+        });
+
+        this.video.addEventListener('seeking', () => {
+           
+            this.triggerEvent('seeking', {
+                currentTime: this.getCurrentTime(),
+                targetTime: this.video.currentTime
             });
-            this.video.addEventListener('canplay', () => {
-                if (!this.isChangingQuality) {
-                    this.hideLoading();
-                }
+        });
+
+        this.video.addEventListener('seeked', () => {
+           
+            this.triggerEvent('seeked', {
+                currentTime: this.getCurrentTime()
             });
-            this.video.addEventListener('ended', () => this.onVideoEnded());
-            this.video.addEventListener('loadstart', () => {
-                if (!this.isChangingQuality) {
-                    this.showLoading();
-                }
+        });
+
+       
+        this.video.addEventListener('loadstart', () => {
+            if (!this.isChangingQuality) {
+                this.showLoading();
+            }
+           
+            this.triggerEvent('loadstart');
+        });
+
+        this.video.addEventListener('loadedmetadata', () => {
+            this.updateDuration();
+
+           
+            this.triggerEvent('loadedmetadata', {
+                duration: this.getDuration(),
+                videoWidth: this.video.videoWidth,
+                videoHeight: this.video.videoHeight
             });
-            this.video.addEventListener('loadeddata', () => {
-                if (!this.isChangingQuality) {
-                    this.hideLoading();
-                }
+
+           
+            setTimeout(() => {
+                this.initializeSubtitles();
+            }, 100);
+        });
+
+        this.video.addEventListener('loadeddata', () => {
+            if (!this.isChangingQuality) {
+                this.hideLoading();
+            }
+           
+            this.triggerEvent('loadeddata', {
+                currentTime: this.getCurrentTime()
             });
+        });
+
+        this.video.addEventListener('canplay', () => {
+            if (!this.isChangingQuality) {
+                this.hideLoading();
+            }
+           
+            this.triggerEvent('canplay', {
+                currentTime: this.getCurrentTime(),
+                duration: this.getDuration()
+            });
+        });
+
+        this.video.addEventListener('progress', () => {
+            this.updateBuffer();
+           
+            this.triggerEvent('progress', {
+                buffered: this.getBufferedTime(),
+                duration: this.getDuration()
+            });
+        });
+
+        this.video.addEventListener('durationchange', () => {
+            this.updateDuration();
+           
+            this.triggerEvent('durationchange', {
+                duration: this.getDuration()
+            });
+        });
+
+       
+        this.video.addEventListener('error', (e) => {
+            this.onVideoError(e);
+           
+            this.triggerEvent('error', {
+                code: this.video.error?.code,
+                message: this.video.error?.message,
+                src: this.video.currentSrc || this.video.src
+            });
+        });
+
+        this.video.addEventListener('stalled', () => {
+           
+            this.triggerEvent('stalled', {
+                currentTime: this.getCurrentTime()
+            });
+        });
+
+
+            this.video.addEventListener('timeupdate', () => this.updateProgress());
+
+            this.video.addEventListener('ended', () => this.onVideoEnded());
+
            
             this.video.addEventListener('click', () => {
                 if (!this.options.pauseClick) return;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "myetv-player",
-  "version": "1.1.0",
+  "version": "1.1.1",
   "description": "MYETV Video Player - Modular JavaScript and SCSS Build System",
   "main": "dist/myetv-player.js",
   "scripts": {
@@ -33,3 +33,4 @@
 
 
 
+

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;
@@ -716,6 +724,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 +1143,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) {
@@ -1051,6 +1186,8 @@ width: fit-content;
             // 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
@@ -1700,7 +1837,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 +2017,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());
@@ -2651,18 +2790,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
             });
         }
 
@@ -3151,6 +3311,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');

package/src/core.js

@@ -37,6 +37,7 @@ constructor(videoElement, options = {}) {
         brandLogoEnabled: false,  // Enable/disable brand logo
         brandLogoUrl: '',         // URL for brand logo image
         brandLogoLinkUrl: '',     // Optional URL to open when clicking the logo
+        brandLogoTooltipText: '', // Tooltip text for brand logo
         playlistEnabled: true,    // Enable/disable playlist detection
         playlistAutoPlay: true,   // Auto-play next video when current ends
         playlistLoop: false,      // Loop playlist when reaching the end
@@ -112,18 +113,42 @@ constructor(videoElement, options = {}) {
 
     // Custom event system
     this.eventCallbacks = {
-        'played': [],
-        'paused': [],
-        'subtitlechange': [],
-        'chapterchange': [],
-        'pipchange': [],
-        'fullscreenchange': [],
-        'speedchange': [],
-        'timeupdate': [],
-        'volumechange': [],
-        'qualitychange': [],
-        'playlistchange': [],
-        'ended': []
+        // Core lifecycle events
+        'playerready': [],     // Fired when player is fully initialized and ready
+        'played': [],          // Fired when video starts playing
+        'paused': [],          // Fired when video is paused
+        'ended': [],           // Fired when video playback ends
+
+        // Playback state events
+        'playing': [],         // Fired when video is actually playing (after buffering)
+        'waiting': [],         // Fired when video is waiting for data (buffering)
+        'seeking': [],         // Fired when seek operation starts
+        'seeked': [],          // Fired when seek operation completes
+
+        // Loading events
+        'loadstart': [],       // Fired when browser starts looking for media
+        'loadedmetadata': [],  // Fired when metadata (duration, dimensions) is loaded
+        'loadeddata': [],      // Fired when data for current frame is loaded
+        'canplay': [],         // Fired when browser can start playing video
+        'progress': [],        // Fired periodically while downloading media
+        'durationchange': [],  // Fired when duration attribute changes
+
+        // Error events
+        'error': [],           // Fired when media loading or playback error occurs
+        'stalled': [],         // Fired when browser is trying to get data but it's not available
+
+        // Control events
+        'timeupdate': [],      // Fired when current playback position changes
+        'volumechange': [],    // Fired when volume or muted state changes
+        'speedchange': [],     // Fired when playback speed changes
+        'qualitychange': [],   // Fired when video quality changes
+
+        // Feature events
+        'subtitlechange': [],  // Fired when subtitle track changes
+        'chapterchange': [],   // Fired when video chapter changes
+        'pipchange': [],       // Fired when picture-in-picture mode changes
+        'fullscreenchange': [], // Fired when fullscreen mode changes
+        'playlistchange': []   // Fired when playlist item changes
     };
 
     // Playlist management
@@ -485,6 +510,14 @@ markPlayerReady() {
             this.container.classList.add('player-initialized');
         }
 
+        this.triggerEvent('playerready', {
+            playerState: this.getPlayerState(),
+            qualities: this.qualities,
+            subtitles: this.textTracks,
+            chapters: this.chapters,
+            playlist: this.getPlaylistInfo()
+        });
+
         if (this.video) {
             this.video.style.visibility = '';
             this.video.style.opacity = '';
@@ -1346,7 +1379,14 @@ createBrandLogo() {
     const logo = document.createElement('img');
     logo.className = 'brand-logo';
     logo.src = this.options.brandLogoUrl;
-    logo.alt = this.t('brand_logo');
+    logo.alt = 'Brand logo';
+
+    // Add tooltip ONLY if link URL is present
+    if (this.options.brandLogoLinkUrl) {
+        // Use custom tooltip text if provided, otherwise fallback to URL
+        logo.title = this.options.brandLogoTooltipText || this.options.brandLogoLinkUrl;
+        // NON usare data-tooltip per evitare che venga sovrascritto da updateTooltips()
+    }
 
     // Handle loading error
     logo.onerror = () => {
@@ -1362,7 +1402,7 @@ createBrandLogo() {
     if (this.options.brandLogoLinkUrl) {
         logo.style.cursor = 'pointer';
         logo.addEventListener('click', (e) => {
-            e.stopPropagation(); // Prevent video controls interference
+            e.stopPropagation();
             window.open(this.options.brandLogoLinkUrl, '_blank', 'noopener,noreferrer');
             if (this.options.debug) console.log('Brand logo clicked, opening:', this.options.brandLogoLinkUrl);
         });
@@ -1370,15 +1410,10 @@ createBrandLogo() {
         logo.style.cursor = 'default';
     }
 
-    // Position the brand logo at the right of the controlbar (at the left of the buttons)
     controlsRight.insertBefore(logo, controlsRight.firstChild);
 
     if (this.options.debug) {
-        if (this.options.brandLogoLinkUrl) {
-            console.log('Brand logo with click handler created for:', this.options.brandLogoLinkUrl);
-        } else {
-            console.log('Brand logo created (no link)');
-        }
+        console.log('Brand logo created with tooltip:', logo.title || 'no tooltip');
     }
 }
 

package/src/events.js

@@ -165,36 +165,129 @@
     }
 
     bindEvents() {
-        if (this.video) {
-            this.video.addEventListener('loadedmetadata', () => {
-                this.updateDuration();
-                setTimeout(() => {
-                    this.initializeSubtitles();
-                }, 100);
+    if (this.video) {
+
+        // Playback events
+        this.video.addEventListener('playing', () => {
+            this.hideLoading();
+            // Trigger playing event - video is now actually playing
+            this.triggerEvent('playing', {
+                currentTime: this.getCurrentTime(),
+                duration: this.getDuration()
             });
-            this.video.addEventListener('timeupdate', () => this.updateProgress());
-            this.video.addEventListener('progress', () => this.updateBuffer());
-            this.video.addEventListener('waiting', () => {
-                if (!this.isChangingQuality) {
-                    this.showLoading();
-                }
+        });
+
+        this.video.addEventListener('waiting', () => {
+            if (!this.isChangingQuality) {
+                this.showLoading();
+                // Trigger waiting event - video is buffering
+                this.triggerEvent('waiting', {
+                    currentTime: this.getCurrentTime()
+                });
+            }
+        });
+
+        this.video.addEventListener('seeking', () => {
+            // Trigger seeking event - seek operation started
+            this.triggerEvent('seeking', {
+                currentTime: this.getCurrentTime(),
+                targetTime: this.video.currentTime
             });
-            this.video.addEventListener('canplay', () => {
-                if (!this.isChangingQuality) {
-                    this.hideLoading();
-                }
+        });
+
+        this.video.addEventListener('seeked', () => {
+            // Trigger seeked event - seek operation completed
+            this.triggerEvent('seeked', {
+                currentTime: this.getCurrentTime()
             });
-            this.video.addEventListener('ended', () => this.onVideoEnded());
-            this.video.addEventListener('loadstart', () => {
-                if (!this.isChangingQuality) {
-                    this.showLoading();
-                }
+        });
+
+        // Loading events
+        this.video.addEventListener('loadstart', () => {
+            if (!this.isChangingQuality) {
+                this.showLoading();
+            }
+            // Trigger loadstart event - browser started loading media
+            this.triggerEvent('loadstart');
+        });
+
+        this.video.addEventListener('loadedmetadata', () => {
+            this.updateDuration();
+
+            // Trigger loadedmetadata event - video metadata loaded
+            this.triggerEvent('loadedmetadata', {
+                duration: this.getDuration(),
+                videoWidth: this.video.videoWidth,
+                videoHeight: this.video.videoHeight
             });
-            this.video.addEventListener('loadeddata', () => {
-                if (!this.isChangingQuality) {
-                    this.hideLoading();
-                }
+
+            // Initialize subtitles after metadata is loaded
+            setTimeout(() => {
+                this.initializeSubtitles();
+            }, 100);
+        });
+
+        this.video.addEventListener('loadeddata', () => {
+            if (!this.isChangingQuality) {
+                this.hideLoading();
+            }
+            // Trigger loadeddata event - current frame data loaded
+            this.triggerEvent('loadeddata', {
+                currentTime: this.getCurrentTime()
             });
+        });
+
+        this.video.addEventListener('canplay', () => {
+            if (!this.isChangingQuality) {
+                this.hideLoading();
+            }
+            // Trigger canplay event - video can start playing
+            this.triggerEvent('canplay', {
+                currentTime: this.getCurrentTime(),
+                duration: this.getDuration()
+            });
+        });
+
+        this.video.addEventListener('progress', () => {
+            this.updateBuffer();
+            // Trigger progress event - browser is downloading media
+            this.triggerEvent('progress', {
+                buffered: this.getBufferedTime(),
+                duration: this.getDuration()
+            });
+        });
+
+        this.video.addEventListener('durationchange', () => {
+            this.updateDuration();
+            // Trigger durationchange event - video duration changed
+            this.triggerEvent('durationchange', {
+                duration: this.getDuration()
+            });
+        });
+
+        // Error events
+        this.video.addEventListener('error', (e) => {
+            this.onVideoError(e);
+            // Trigger error event - media loading/playback error occurred
+            this.triggerEvent('error', {
+                code: this.video.error?.code,
+                message: this.video.error?.message,
+                src: this.video.currentSrc || this.video.src
+            });
+        });
+
+        this.video.addEventListener('stalled', () => {
+            // Trigger stalled event - browser is trying to fetch data but it's not available
+            this.triggerEvent('stalled', {
+                currentTime: this.getCurrentTime()
+            });
+        });
+
+
+            this.video.addEventListener('timeupdate', () => this.updateProgress());
+
+            this.video.addEventListener('ended', () => this.onVideoEnded());
+
             // Complete video click logic with doubleTapPause support (DESKTOP)
             this.video.addEventListener('click', () => {
                 if (!this.options.pauseClick) return;