unified-video-framework 1.4.238 → 1.4.240

package/packages/web/src/WebPlayer.ts

@@ -149,6 +149,7 @@ export class WebPlayer extends BasePlayer {
   private fallbackErrors: Array<{ url: string; error: any }> = [];
   private isLoadingFallback: boolean = false;
   private currentRetryAttempt: number = 0;
+  private lastFailedUrl: string = ''; // Track last failed URL to avoid duplicate error handling
 
   // Debug logging helper
   private debugLog(message: string, ...args: any[]): void {
@@ -458,9 +459,17 @@ export class WebPlayer extends BasePlayer {
 
     this.video.addEventListener('canplay', () => {
       this.debugLog('📡 canplay event fired');
+
+      // Reset fallback tracking on successful load
+      if (this.isLoadingFallback) {
+        this.debugLog('✅ Fallback source loaded successfully!');
+        this.isLoadingFallback = false;
+        this.lastFailedUrl = '';
+      }
+
       this.setBuffering(false);
       this.emit('onReady');
-      
+
       // Update time display when video is ready to play
       this.updateTimeDisplay();
       
@@ -514,28 +523,51 @@ export class WebPlayer extends BasePlayer {
     });
 
     this.video.addEventListener('error', async (e) => {
-      if (!this.video) return;
+      if (!this.video || !this.video.src) return;
+
       const error = this.video.error;
       if (error) {
+        const currentSrc = this.video.src || this.video.currentSrc || '';
+
+        // Avoid processing the same error multiple times
+        if (this.lastFailedUrl === currentSrc && this.isLoadingFallback) {
+          this.debugLog(`⚠️ Duplicate error for same URL while loading fallback, ignoring: ${currentSrc}`);
+          return;
+        }
+
+        this.lastFailedUrl = currentSrc;
         this.debugLog(`Video error detected (code: ${error.code}):`, error.message);
+        this.debugLog(`Failed source: ${currentSrc}`);
+        this.debugLog(`Fallback check - isLoadingFallback: ${this.isLoadingFallback}`);
+        this.debugLog(`Fallback check - fallbackSources:`, this.source?.fallbackSources);
+        this.debugLog(`Fallback check - fallbackPoster:`, this.source?.fallbackPoster);
+        this.debugLog(`Fallback check - has fallbackSources: ${!!this.source?.fallbackSources?.length}`);
+        this.debugLog(`Fallback check - has fallbackPoster: ${!!this.source?.fallbackPoster}`);
 
         // Try fallback sources if available and not already loading one
         if (!this.isLoadingFallback && (this.source?.fallbackSources?.length || this.source?.fallbackPoster)) {
+          this.debugLog('✅ Attempting to load fallback sources...');
           const fallbackLoaded = await this.tryFallbackSource(error);
           if (fallbackLoaded) {
+            this.debugLog('✅ Fallback loaded successfully!');
             // Successfully loaded fallback, don't call handleError
             return;
           }
+          this.debugLog('❌ All fallbacks failed');
+        } else {
+          this.debugLog('❌ No fallback sources available or already loading');
         }
 
         // No fallback available or all fallbacks failed - handle error normally
-        this.handleError({
-          code: `MEDIA_ERR_${error.code}`,
-          message: error.message || this.getMediaErrorMessage(error.code),
-          type: 'media',
-          fatal: true,
-          details: error
-        });
+        if (!this.isLoadingFallback) {
+          this.handleError({
+            code: `MEDIA_ERR_${error.code}`,
+            message: error.message || this.getMediaErrorMessage(error.code),
+            type: 'media',
+            fatal: true,
+            details: error
+          });
+        }
       }
     });
 
@@ -578,6 +610,10 @@ export class WebPlayer extends BasePlayer {
     this.source = source as any;
     this.subtitles = (source.subtitles || []) as any;
 
+    this.debugLog('Loading video source:', source.url);
+    this.debugLog('Fallback sources provided:', source.fallbackSources);
+    this.debugLog('Fallback poster provided:', source.fallbackPoster);
+
     // Reset autoplay flag for new source
     this.autoplayAttempted = false;
 
@@ -586,6 +622,7 @@ export class WebPlayer extends BasePlayer {
     this.fallbackErrors = [];
     this.isLoadingFallback = false;
     this.currentRetryAttempt = 0;
+    this.lastFailedUrl = '';
 
     // Clean up previous instances
     await this.cleanup();
@@ -652,11 +689,24 @@ export class WebPlayer extends BasePlayer {
    * Try loading the next fallback source
    */
   private async tryFallbackSource(error: any): Promise<boolean> {
-    if (this.isLoadingFallback) return false;
+    this.debugLog('🔄 tryFallbackSource called');
+    this.debugLog('🔄 isLoadingFallback:', this.isLoadingFallback);
+    this.debugLog('🔄 fallbackSources:', this.source?.fallbackSources);
+    this.debugLog('🔄 fallbackSources length:', this.source?.fallbackSources?.length);
+    this.debugLog('🔄 Current fallbackSourceIndex:', this.fallbackSourceIndex);
+    this.debugLog('🔄 Current retry attempt:', this.currentRetryAttempt);
+
+    if (this.isLoadingFallback) {
+      this.debugLog('⚠️ Already loading a fallback, skipping');
+      return false;
+    }
+
     if (!this.source?.fallbackSources || this.source.fallbackSources.length === 0) {
+      this.debugLog('⚠️ No fallback sources available, trying fallback poster');
       return this.showFallbackPoster();
     }
 
+    this.debugLog('✅ Starting fallback loading process');
     this.isLoadingFallback = true;
 
     // Record current error
@@ -667,11 +717,15 @@ export class WebPlayer extends BasePlayer {
     this.fallbackErrors.push({ url: currentUrl, error });
     this.debugLog(`Source failed: ${currentUrl}`, error);
 
-    // Check retry attempts for current source
+    // Don't retry the main URL - go straight to first fallback
+    // Only retry actual fallback sources
+    const isMainUrl = this.fallbackSourceIndex === -1;
     const maxRetries = this.source.fallbackRetryAttempts || 1;
-    if (this.currentRetryAttempt < maxRetries) {
+
+    if (!isMainUrl && this.currentRetryAttempt < maxRetries) {
+      // Only retry if this is a fallback source (not the main URL)
       this.currentRetryAttempt++;
-      this.debugLog(`Retrying source (attempt ${this.currentRetryAttempt}/${maxRetries}): ${currentUrl}`);
+      this.debugLog(`Retrying fallback source (attempt ${this.currentRetryAttempt}/${maxRetries}): ${currentUrl}`);
 
       const retryDelay = this.source.fallbackRetryDelay || 1000;
       await new Promise(resolve => setTimeout(resolve, retryDelay));
@@ -679,14 +733,20 @@ export class WebPlayer extends BasePlayer {
       try {
         const sourceType = this.detectSourceType({ url: currentUrl, type: this.source.type });
         await this.loadVideoSource(currentUrl, sourceType, this.source);
-        this.isLoadingFallback = false;
-        this.currentRetryAttempt = 0;
-        this.debugLog(`Retry successful for: ${currentUrl}`);
-        return true;
+        // Don't mark as successful immediately - let it load and see if error happens
+        // Just continue and see what happens
+        this.debugLog(`Retry initiated for: ${currentUrl} - waiting for load confirmation...`);
+        // Return false to continue the fallback chain if this fails again
       } catch (retryError) {
         this.debugLog(`Retry failed for: ${currentUrl}`, retryError);
         // Continue to next fallback
       }
+    } else {
+      if (isMainUrl) {
+        this.debugLog(`⏭️ Skipping retry of main URL, moving to first fallback source`);
+      } else {
+        this.debugLog(`⏭️ Max retries (${maxRetries}) reached for ${currentUrl}, moving to next fallback`);
+      }
     }
 
     // Move to next fallback source