@pictor-sdk/video-android 0.1.3 → 0.1.5

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pictor-sdk/video-android",
-  "version": "0.1.3",
+  "version": "0.1.5",
   "description": "Optional Android video playback and export adapter for Pictor. Requires Android API 29+.",
   "license": "MIT",
   "main": "./dist/index.js",

package/src/compositionSpike.ts

@@ -34,6 +34,10 @@ export interface CompositionSpikeItem {
   /** Clipping bounds in **source** time, which is where speed is applied. */
   startUs: number
   endUs: number
+  /** Full source duration, before trimming or speed. Omit only for legacy callers. */
+  sourceDurationUs?: number
+  /** Exclusive project-time end from the playlist compiler, after trim and speed. */
+  timelineEndUs?: number
   speed: number
 }
 
@@ -122,6 +126,8 @@ export interface CompositionSpikeState {
   playbackState?: number
   durationUs?: number
   presentedUs?: number | null
+  /** Playlist window belonging to the latched frame, not the current playhead. */
+  presentedWindowIndex?: number
   /** How old the presented frame was when it was read, so a stalled sample can be excluded. */
   presentedAgeNs?: number
   /** How long the paired read itself took. Bounds the pairing error. */
@@ -148,6 +154,7 @@ export function compositionSpikeSpec(
   const playlist = playlistOf(project)
   const items: CompositionSpikeItem[] = []
   const unsupported = playlist.unsupported.map((u) => `${u.clipId}: ${u.reason}`)
+  const clips = new Map(project.clips.map((clip) => [clip.id, clip]))
   for (const item of playlist.items) {
     const uri = resolve(item.source as unknown as { kind: string; uri?: string })
     if (uri === null) {
@@ -158,6 +165,8 @@ export function compositionSpikeSpec(
       uri,
       startUs: Number(item.startUs),
       endUs: Number(item.endUs),
+      sourceDurationUs: clips.get(item.clipId)?.metadata.duration,
+      timelineEndUs: Number(item.timelineEndUs),
       speed: item.speed,
     })
   }

package/src/useCompositionPlayback.ts

@@ -1,4 +1,5 @@
 import { useCallback, useEffect, useMemo, useRef, useState } from 'react'
+import { AppState } from 'react-native'
 import {
   playIntent,
   playlistOf,
@@ -213,13 +214,66 @@ export function useCompositionPlayback(
     setUnsupported(
       refused.map((reason) => ({ clipId: reason.split(':')[0] ?? '', reason }) as UnsupportedSource),
     )
-    if (spec.items.length === 0) return
+    /*
+      A project with nothing in it is a reconciliation too.
+
+      This used to return here, and returning is not nothing: the player is a
+      process-wide singleton that goes on playing whatever it last loaded. So
+      removing the only clip *while it was playing* left the removed clip
+      audible until it reached its own end — measured on a Pixel 7 as roughly
+      four more seconds of a six-second clip, three times out of three — with
+      the picture already cleared and the clock already reading 0:00.000,
+      because those follow the document and only the player does not.
+
+      Pausing is the whole fix. The composition is deliberately **not**
+      released: emptying a timeline is usually a step on the way to putting
+      something else in it, and `loaded.current` is left alone so that undoing
+      the removal reuses the composition already loaded instead of rebuilding
+      one that has not changed. Releasing is what `PlaybackLifecycle` does when
+      the *screen* goes, which is a different question from what the document
+      currently holds.
+
+      Nothing here touches the document. Playback stopping says nothing about
+      where the playhead should be.
+    */
+    if (spec.items.length === 0) {
+      spikePause()
+      return
+    }
     const started = spikeStart(spec) as { ok?: boolean }
     // A refusal is not a load. Recording it as one is what left an editor
     // waiting for an edit the person had already made.
     if (started.ok === true) loaded.current = signature
   }, [enabled, signature, surfaceGeneration, project, mix])
 
+  /*
+    Backgrounding pauses; returning re-arms.
+
+    The same wiring `useMedia3Playback` has, and its absence here was the same
+    bug `PlaybackLifecycle` was written to fix, reintroduced by a newer playback
+    path that never got it. `useVideoSurface` already retires the presentation
+    surface when the app leaves, so the picture stopped and the sound carried
+    on — measured on a Pixel 7 as a composition still reporting `playing` with
+    its position advancing from 1.3 s to 4.4 s across a press of Home.
+
+    Suspend rather than teardown: the picker comes up over the editor as a
+    background transition, and rebuilding a player the screen never lost would
+    be a stall nobody asked for. The document is not touched either way.
+  */
+  useEffect(() => {
+    const subscription = AppState.addEventListener('change', (next) => {
+      if (next === 'active') {
+        lifecycle.resume()
+        setLifecycleEpoch(lifecycle.epoch)
+        return
+      }
+      lifecycle.suspend('background')
+      setLifecycleEpoch(lifecycle.epoch)
+      setPlaying(false)
+    })
+    return () => subscription.remove()
+  }, [lifecycle])
+
   useEffect(() => {
     return () => {
       lifecycle.teardown('unmount')