@pictor-sdk/video-android 0.1.4 → 0.1.5

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pictor-sdk/video-android",
-  "version": "0.1.4",
+  "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/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')