Handle seek completion

src/Video.web.tsx

@@ -11,6 +11,41 @@ import React, {
 import shaka from 'shaka-player';
 import type {VideoRef, ReactVideoProps, VideoMetadata} from './types';
 
+// Action Queue Class
+class ActionQueue {
+  private queue: { action: () => Promise<void>; name: string }[] = [];
+  private isRunning = false;
+
+  enqueue(action: () => Promise<void>, name: string) {
+    this.queue.push({ action, name });
+    this.runNext();
+  }
+
+  private async runNext() {
+    if (this.isRunning || this.queue.length === 0) {
+      console.log("Refusing to run in runNext", this.queue.length, this.isRunning);
+      return;
+    }
+    this.isRunning = true;
+    const { action, name } = this.queue.shift()!;
+    console.log(`Running action: ${name}`);
+
+    const actionPromise = action();
+    const timeoutPromise = new Promise<void>((_, reject) =>
+      setTimeout(() => reject(new Error(`Action ${name} timed out`)), 2000)
+    );
+
+    try {
+      await Promise.race([actionPromise, timeoutPromise]);
+    } catch (e) {
+      console.error('Error in queued action:', e);
+    } finally {
+      this.isRunning = false;
+      this.runNext();
+    }
+  }
+}
+
 function shallowEqual(obj1: any, obj2: any) {
   // If both are strictly equal (covers primitive types and identical object references)
   if (obj1 === obj2) return true;
@@ -56,6 +91,7 @@ const Video = forwardRef<VideoRef, ReactVideoProps>(
       onError,
       onReadyForDisplay,
       onSeek,
+      onSeekComplete,
       onVolumeChange,
       onEnd,
       onPlaybackStateChanged,
@@ -64,44 +100,61 @@ const Video = forwardRef<VideoRef, ReactVideoProps>(
   ) => {
     const nativeRef = useRef<HTMLVideoElement>(null);
     const shakaPlayerRef = useRef<shaka.Player | null>(null);
-    const [ currentSource, setCurrentSource ] = useState<object | null>(null);
+    const [currentSource, setCurrentSource] = useState<object | null>(null);
+    const actionQueue = useRef(new ActionQueue());
 
     const isSeeking = useRef(false);
+
     const seek = useCallback(
-      async (time: number, _tolerance?: number) => {
+      (time: number, _tolerance?: number) => {
-        if (isNaN(time)) {
+        actionQueue.current.enqueue(async () => {
-          throw new Error('Specified time is not a number');
+          if (isNaN(time)) {
-        }
+            throw new Error('Specified time is not a number');
-        if (!nativeRef.current) {
+          }
-          console.warn('Video Component is not mounted');
+          if (!nativeRef.current) {
-          return;
+            console.warn('Video Component is not mounted');
-        }
+            return;
-        time = Math.max(0, Math.min(time, nativeRef.current.duration));
+          }
-        nativeRef.current.currentTime = time;
+          time = Math.max(0, Math.min(time, nativeRef.current.duration));
-        onSeek?.({seekTime: time, currentTime: nativeRef.current.currentTime});
+          nativeRef.current.currentTime = time;
+          onSeek?.({
+            seekTime: time,
+            currentTime: nativeRef.current.currentTime,
+          });
+        }, 'seek');
       },
       [onSeek],
     );
 
     const pause = useCallback(() => {
-      if (!nativeRef.current) {
+      actionQueue.current.enqueue(async () => {
-        return;
+        if (!nativeRef.current) {
-      }
+          return;
-      nativeRef.current.pause();
+        }
+        await nativeRef.current.pause();
+      }, 'pause');
     }, []);
 
     const resume = useCallback(() => {
-      if (!nativeRef.current) {
+      actionQueue.current.enqueue(async () => {
-        return;
+        if (!nativeRef.current) {
-      }
+          return;
-      nativeRef.current.play();
+        }
+        try {
+          await nativeRef.current.play();
+        } catch (e) {
+          console.error('Error playing video:', e);
+        }
+      }, 'resume');
     }, []);
 
     const setVolume = useCallback((vol: number) => {
-      if (!nativeRef.current) {
+      actionQueue.current.enqueue(async () => {
-        return;
+        if (!nativeRef.current) {
-      }
+          return;
-      nativeRef.current.volume = Math.max(0, Math.min(vol, 100)) / 100;
+        }
+        nativeRef.current.volume = Math.max(0, Math.min(vol, 100)) / 100;
+      }, 'setVolume');
     }, []);
 
     const getCurrentPosition = useCallback(async () => {
@@ -156,7 +209,7 @@ const Video = forwardRef<VideoRef, ReactVideoProps>(
             console.error('Could not toggle fullscreen/screen lock status', e);
           }
         };
-        run();
+        actionQueue.current.enqueue(run, 'setFullScreen');
       },
       [],
     );
@@ -219,6 +272,7 @@ const Video = forwardRef<VideoRef, ReactVideoProps>(
         resume();
       }
     }, [paused, pause, resume]);
+
     useEffect(() => {
       if (volume === undefined) {
         return;
@@ -253,62 +307,107 @@ const Video = forwardRef<VideoRef, ReactVideoProps>(
       nativeRef.current.playbackRate = rate;
     }, [rate]);
 
-
     const makeNewShaka = useCallback(() => {
-      if (shakaPlayerRef.current) {
+      console.log("makeNewShaka");
-        shakaPlayerRef.current.unload()
+      actionQueue.current.enqueue(async () => {
-      }
+        console.log("makeNewShaka actionQueue");
-      shakaPlayerRef.current = new shaka.Player();
+        if (!nativeRef.current) {
+          console.warn('No video element to attach Shaka Player');
+          return;
+        }
 
+        // Pause the video before changing the source
+        nativeRef.current.pause();
 
-      if (source?.cropStart) {
+        // Unload the previous Shaka player if it exists
-        shakaPlayerRef.current.configure({playRangeStart: source?.cropStart / 1000})
+        if (shakaPlayerRef.current) {
-      }
+          await shakaPlayerRef.current.unload();
-      if (source?.cropEnd) {
+          shakaPlayerRef.current = null;
-        shakaPlayerRef.current.configure({playRangeEnd: source?.cropEnd / 1000})
+        }
-      }
+
+        // Create a new Shaka player and attach it to the video element
+        shakaPlayerRef.current = new shaka.Player();
+
+        shakaPlayerRef.current.attach(nativeRef.current);
+
+        if (source?.cropStart) {
+          shakaPlayerRef.current.configure({
+            playRangeStart: source?.cropStart / 1000,
+          });
+        }
+        if (source?.cropEnd) {
+          shakaPlayerRef.current.configure({
+            playRangeEnd: source?.cropEnd / 1000,
+          });
+        }
 
-      //@ts-ignore
-      shakaPlayerRef.current.addEventListener("error", (event) => {
         //@ts-ignore
-        const shakaError = event.detail;
+        shakaPlayerRef.current.addEventListener('error', event => {
-        console.error('Shaka Player Error', shakaError);
+          //@ts-ignore
-        onError?.({
+          const shakaError = event.detail;
-          error: {
+          console.error('Shaka Player Error', shakaError);
-            errorString: shakaError.message,
+          onError?.({
-            code: shakaError.code,
+            error: {
-          },
+              errorString: shakaError.message,
+              code: shakaError.code,
+            },
+          });
         });
-      });
 
-      console.log("Initializing and attaching shaka")
+        console.log('Initializing and attaching shaka');
-      //@ts-ignore
-      shakaPlayerRef.current.attach(nativeRef.current);
 
-      //@ts-ignore
+        // Load the new source
-      shakaPlayerRef.current.load(source?.uri).then(
+        try {
-        () => console.log(`${source?.uri} finished loading`)
+          //@ts-ignore
-      );
+          await shakaPlayerRef.current.load(source?.uri);
-      console.log("Started shaka loading");
+          console.log(`${source?.uri} finished loading`);
-    }, [source, setCurrentSource]);
 
-    const nativeRefDefined = nativeRef.current ? true : false;
+          // Optionally resume playback if not paused
+          if (!paused) {
+            try {
+              await nativeRef.current.play();
+            } catch (e) {
+              console.error('Error playing video:', e);
+            }
+          }
+        } catch (e) {
+          console.error('Error loading video with Shaka Player', e);
+          onError?.({
+            error: {
+              //@ts-ignore
+              errorString: e.message,
+              //@ts-ignore
+              code: e.code,
+            },
+          });
+        }
+      }, 'makeNewShaka');
+    }, [source, paused, onError]);
+
+    const nativeRefDefined = !!nativeRef.current;
 
     useEffect(() => {
       if (!nativeRef.current) {
-        console.log("Not starting shaka yet bc undefined")
+        console.log('Not starting shaka yet because video element is undefined');
         return;
       }
       if (!shallowEqual(source, currentSource)) {
-        console.log("Making new shaka, Old source: ", currentSource, "New source", source);
+        console.log(
+          'Making new shaka, Old source: ',
+          currentSource,
+          'New source',
+          source,
+        );
         //@ts-ignore
         setCurrentSource(source);
-        makeNewShaka()
+        makeNewShaka();
       }
-    }, [source, nativeRefDefined, currentSource])
+    }, [source, nativeRefDefined, currentSource, makeNewShaka]);
 
     useMediaSession(source?.metadata, nativeRef, showNotificationControls);
 
+    const cropStartSeconds = (source?.cropStart || 0) / 1000;
+
     return (
       <video
         ref={nativeRef}
@@ -351,7 +450,7 @@ const Video = forwardRef<VideoRef, ReactVideoProps>(
             return;
           }
           onProgress?.({
-            currentTime: nativeRef.current.currentTime,
+            currentTime: nativeRef.current.currentTime - cropStartSeconds,
             playableDuration: nativeRef.current.buffered.length
               ? nativeRef.current.buffered.end(
                   nativeRef.current.buffered.length - 1,
@@ -390,7 +489,16 @@ const Video = forwardRef<VideoRef, ReactVideoProps>(
           })
         }
         onSeeking={() => (isSeeking.current = true)}
-        onSeeked={() => (isSeeking.current = false)}
+        onSeeked={() => {
+                (isSeeking.current = false)
+
+                onSeekComplete?.({
+                    currentTime: (nativeRef.current?.currentTime || 0.0) - cropStartSeconds,
+                    seekTime: 0.0,
+                    target: 0.0,
+
+                })
+            }}
         onVolumeChange={() => {
           if (!nativeRef.current) {
             return;