unified-video-framework 1.4.437 → 1.4.438

package/packages/web/src/WebPlayer.ts

@@ -172,6 +172,8 @@ export class WebPlayer extends BasePlayer {
   private currentRetryAttempt: number = 0;
   private lastFailedUrl: string = ''; // Track last failed URL to avoid duplicate error handling
   private isFallbackPosterMode: boolean = false; // True when showing fallback poster (no playable sources)
+  private hlsErrorRetryCount: number = 0; // Track HLS error recovery attempts
+  private readonly MAX_HLS_ERROR_RETRIES: number = 3; // Max HLS recovery attempts before fallback
 
   // Live stream detection
   private lastDuration: number = 0; // Track duration changes to detect live streams
@@ -727,6 +729,7 @@ export class WebPlayer extends BasePlayer {
     this.currentRetryAttempt = 0;
     this.lastFailedUrl = '';
     this.isFallbackPosterMode = false; // Reset fallback poster mode
+    this.hlsErrorRetryCount = 0; // Reset HLS error retry count
 
     // Clean up previous instances
     await this.cleanup();
@@ -1122,6 +1125,9 @@ export class WebPlayer extends BasePlayer {
       this.hls.attachMedia(this.video);
 
       this.hls.on(window.Hls.Events.MANIFEST_PARSED, (event: any, data: any) => {
+        // Reset HLS error retry count on successful manifest load
+        this.hlsErrorRetryCount = 0;
+
         // Extract quality levels
         this.qualities = data.levels.map((level: any, index: number) => ({
           height: level.height,
@@ -1164,27 +1170,101 @@ export class WebPlayer extends BasePlayer {
     }
   }
 
-  private handleHLSError(data: any): void {
+  private async handleHLSError(data: any): Promise<void> {
     const Hls = window.Hls;
+
+    this.debugLog(`🔴 HLS Error: type=${data.type}, details=${data.details}, fatal=${data.fatal}`);
+
+    // Check if we've exceeded max retry attempts
+    if (this.hlsErrorRetryCount >= this.MAX_HLS_ERROR_RETRIES) {
+      this.debugLog(`🔴 HLS max retries (${this.MAX_HLS_ERROR_RETRIES}) exceeded, triggering fallback`);
+      this.hls?.destroy();
+      this.hls = null;
+
+      // Try fallback sources
+      const fallbackLoaded = await this.tryFallbackSource({
+        code: 'HLS_ERROR',
+        message: data.details,
+        type: data.type,
+        fatal: true,
+        details: data
+      });
+
+      if (!fallbackLoaded) {
+        this.handleError({
+          code: 'HLS_ERROR',
+          message: `HLS stream failed after ${this.MAX_HLS_ERROR_RETRIES} retries: ${data.details}`,
+          type: 'media',
+          fatal: true,
+          details: data
+        });
+      }
+      return;
+    }
+
     switch (data.type) {
       case Hls.ErrorTypes.NETWORK_ERROR:
-        console.error('Fatal network error, trying to recover');
-        this.hls.startLoad();
+        this.hlsErrorRetryCount++;
+        this.debugLog(`🔴 Fatal network error (attempt ${this.hlsErrorRetryCount}/${this.MAX_HLS_ERROR_RETRIES}), trying to recover`);
+
+        // For manifest errors (like 404), recovery won't help - go straight to fallback
+        if (data.details === 'manifestLoadError' || data.details === 'manifestParsingError') {
+          this.debugLog(`🔴 Manifest error detected (${data.details}), skipping recovery - triggering fallback`);
+          this.hls?.destroy();
+          this.hls = null;
+
+          const fallbackLoaded = await this.tryFallbackSource({
+            code: 'HLS_MANIFEST_ERROR',
+            message: data.details,
+            type: 'network',
+            fatal: true,
+            details: data
+          });
+
+          if (!fallbackLoaded) {
+            this.handleError({
+              code: 'HLS_MANIFEST_ERROR',
+              message: `Failed to load HLS manifest: ${data.details}`,
+              type: 'media',
+              fatal: true,
+              details: data
+            });
+          }
+        } else {
+          // For other network errors, try recovery
+          this.hls?.startLoad();
+        }
         break;
+
       case Hls.ErrorTypes.MEDIA_ERROR:
-        console.error('Fatal media error, trying to recover');
-        this.hls.recoverMediaError();
+        this.hlsErrorRetryCount++;
+        this.debugLog(`🔴 Fatal media error (attempt ${this.hlsErrorRetryCount}/${this.MAX_HLS_ERROR_RETRIES}), trying to recover`);
+        this.hls?.recoverMediaError();
         break;
+
       default:
-        console.error('Fatal error, cannot recover');
-        this.handleError({
+        this.debugLog(`🔴 Fatal unrecoverable HLS error: ${data.details}`);
+        this.hls?.destroy();
+        this.hls = null;
+
+        // Try fallback sources for unrecoverable errors
+        const fallbackLoaded = await this.tryFallbackSource({
           code: 'HLS_ERROR',
           message: data.details,
           type: 'media',
           fatal: true,
           details: data
         });
-        this.hls.destroy();
+
+        if (!fallbackLoaded) {
+          this.handleError({
+            code: 'HLS_ERROR',
+            message: data.details,
+            type: 'media',
+            fatal: true,
+            details: data
+          });
+        }
         break;
     }
   }