wip: add vui timing injection, receive the requested fps from camera in rn layer, normalize timestamp

Implements HLS-compatible fragmented MP4 recording on Android using
AndroidX Media3 FragmentedMp4Muxer, matching the iOS implementation.

Changes:
- Add FragmentedRecordingManager for fMP4 segment output
- Add ChunkedRecorderInterface to abstract recorder implementations
- Add onInitSegmentReady callback for init segment (init.mp4)
- Update onVideoChunkReady to include segment duration
- RecordingSession now uses FragmentedRecordingManager by default

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>

package/android/src/main/java/com/mrousavy/camera/CameraView+Events.kt

@@ -40,15 +40,26 @@ fun CameraView.invokeOnStopped() {
   this.sendEvent(event)
 }
 
-fun CameraView.invokeOnChunkReady(filepath: File, index: Int) {
-  Log.e(CameraView.TAG, "invokeOnError(...):")
+fun CameraView.invokeOnChunkReady(filepath: File, index: Int, durationUs: Long?) {
+  Log.i(CameraView.TAG, "invokeOnChunkReady(...): index=$index, filepath=$filepath, durationUs=$durationUs")
   val event = Arguments.createMap()
   event.putInt("index", index)
   event.putString("filepath", filepath.toString())
+  if (durationUs != null) {
+    event.putDouble("duration", durationUs / 1_000_000.0) // Convert microseconds to seconds
+  }
   val reactContext = context as ReactContext
   reactContext.getJSModule(RCTEventEmitter::class.java).receiveEvent(id, "onVideoChunkReady", event)
 }
 
+fun CameraView.invokeOnInitReady(filepath: File) {
+  Log.i(CameraView.TAG, "invokeOnInitReady(...): filepath=$filepath")
+  val event = Arguments.createMap()
+  event.putString("filepath", filepath.toString())
+  val reactContext = context as ReactContext
+  reactContext.getJSModule(RCTEventEmitter::class.java).receiveEvent(id, "onInitReady", event)
+}
+
 fun CameraView.invokeOnError(error: Throwable) {
   Log.e(CameraView.TAG, "invokeOnError(...):")
   error.printStackTrace()

package/android/src/main/java/com/mrousavy/camera/CameraView.kt

@@ -271,8 +271,12 @@ class CameraView(context: Context) :
     invokeOnStopped()
   }
 
-  override fun onVideoChunkReady(filepath: File, index: Int) {
-    invokeOnChunkReady(filepath, index)
+  override fun onVideoChunkReady(filepath: File, index: Int, durationUs: Long?) {
+    invokeOnChunkReady(filepath, index, durationUs)
+  }
+
+  override fun onInitSegmentReady(filepath: File) {
+    invokeOnInitReady(filepath)
   }
 
   override fun onCodeScanned(codes: List<Barcode>, scannerFrame: CodeScannerFrame) {

package/android/src/main/java/com/mrousavy/camera/CameraViewManager.kt

@@ -32,6 +32,7 @@ class CameraViewManager : ViewGroupManager<CameraView>() {
       .put("cameraError", MapBuilder.of("registrationName", "onError"))
       .put("cameraCodeScanned", MapBuilder.of("registrationName", "onCodeScanned"))
       .put("onVideoChunkReady", MapBuilder.of("registrationName", "onVideoChunkReady"))
+      .put("onInitReady", MapBuilder.of("registrationName", "onInitReady"))
       .build()?.toMutableMap()
 
   override fun getName(): String = TAG

package/android/src/main/java/com/mrousavy/camera/core/CameraSession.kt

@@ -426,12 +426,14 @@ class CameraSession(private val context: Context, private val cameraManager: Cam
 
       val fps = configuration?.fps ?: 30
 
-      // Get actual device rotation from WindowManager instead of relying on
-      // the orientation prop from React, which may not update on Android when
-      // rotating between landscape-left and landscape-right.
+      // Get actual device rotation from WindowManager since the React Native orientation hook
+      // doesn't update when rotating between landscape-left and landscape-right on Android.
+      // Map device rotation to the correct orientationHint for video recording:
+      // - Counter-clockwise (ROTATION_90) → 90° hint
+      // - Clockwise (ROTATION_270) → 270° hint
       val windowManager = context.getSystemService(Context.WINDOW_SERVICE) as WindowManager
       val deviceRotation = windowManager.defaultDisplay.rotation
-      val actualOrientation = when (deviceRotation) {
+      val recordingOrientation = when (deviceRotation) {
         Surface.ROTATION_0 -> Orientation.PORTRAIT
         Surface.ROTATION_90 -> Orientation.LANDSCAPE_LEFT
         Surface.ROTATION_180 -> Orientation.PORTRAIT_UPSIDE_DOWN
@@ -446,7 +448,7 @@ class CameraSession(private val context: Context, private val cameraManager: Cam
         enableAudio,
         fps,
         videoOutput.enableHdr,
-        orientation,
+        recordingOrientation,
         options,
         filePath,
         callback,
@@ -511,7 +513,8 @@ class CameraSession(private val context: Context, private val cameraManager: Cam
     fun onInitialized()
     fun onStarted()
     fun onStopped()
-    fun onVideoChunkReady(filepath: File, index: Int)
+    fun onVideoChunkReady(filepath: File, index: Int, durationUs: Long?)
+    fun onInitSegmentReady(filepath: File)
     fun onCodeScanned(codes: List<Barcode>, scannerFrame: CodeScannerFrame)
   }
 }

package/android/src/main/java/com/mrousavy/camera/core/ChunkedRecorder.kt

@@ -14,7 +14,7 @@ import java.io.File
 import java.nio.ByteBuffer
 
 class ChunkedRecordingManager(private val encoder: MediaCodec, private val outputDirectory: File, private val orientationHint: Int, private val iFrameInterval: Int, private val callbacks: CameraSession.Callback) :
-  MediaCodec.Callback() {
+  MediaCodec.Callback(), ChunkedRecorderInterface {
   companion object {
     private const val TAG = "ChunkedRecorder"
 
@@ -73,7 +73,7 @@ class ChunkedRecordingManager(private val encoder: MediaCodec, private val outpu
 
   private val targetDurationUs = iFrameInterval * 1000000
 
-  val surface: Surface = encoder.createInputSurface()
+  override val surface: Surface = encoder.createInputSurface()
 
   init {
     if (!this.outputDirectory.exists()) {
@@ -95,7 +95,9 @@ class ChunkedRecordingManager(private val encoder: MediaCodec, private val outpu
     fun finish() {
       muxer.stop()
       muxer.release()
-      callbacks.onVideoChunkReady(filepath, chunkIndex)
+      // Calculate duration from start time - this is approximate
+      // The new FragmentedRecordingManager provides accurate duration
+      callbacks.onVideoChunkReady(filepath, chunkIndex, null)
     }
   }
 
@@ -105,6 +107,12 @@ class ChunkedRecordingManager(private val encoder: MediaCodec, private val outpu
     muxerContext?.finish()
     chunkIndex++
 
+    val format = this.encodedFormat
+    if (format == null) {
+      Log.e(TAG, "Cannot create muxer: encodedFormat is null (onOutputFormatChanged not called yet)")
+      return
+    }
+
     val newFileName = "$chunkIndex.mp4"
     val newOutputFile = File(this.outputDirectory, newFileName)
     Log.i(TAG, "Creating new muxer for file: $newFileName")
@@ -114,7 +122,7 @@ class ChunkedRecordingManager(private val encoder: MediaCodec, private val outpu
     )
     muxer.setOrientationHint(orientationHint)
     muxerContext = MuxerContext(
-        muxer, newOutputFile, chunkIndex, bufferInfo.presentationTimeUs, this.encodedFormat!!, this.callbacks
+        muxer, newOutputFile, chunkIndex, bufferInfo.presentationTimeUs, format, this.callbacks
     )
   }
 
@@ -123,15 +131,16 @@ class ChunkedRecordingManager(private val encoder: MediaCodec, private val outpu
   }
 
   private fun chunkLengthUs(bufferInfo: BufferInfo): Long {
-    return bufferInfo.presentationTimeUs - muxerContext!!.startTimeUs
+    val context = muxerContext ?: return 0L
+    return bufferInfo.presentationTimeUs - context.startTimeUs
   }
 
-  fun start() {
+  override fun start() {
     encoder.start()
     recording = true
   }
 
-  fun finish() {
+  override fun finish() {
     synchronized(this) {
       muxerContext?.finish()
       recording = false
@@ -155,7 +164,13 @@ class ChunkedRecordingManager(private val encoder: MediaCodec, private val outpu
       if (muxerContext == null || (atKeyframe(bufferInfo) && chunkLengthUs(bufferInfo) >= targetDurationUs)) {
         this.createNextMuxer(bufferInfo)
       }
-      muxerContext!!.muxer.writeSampleData(muxerContext!!.videoTrack, encodedData, bufferInfo)
+      val context = muxerContext
+      if (context == null) {
+        Log.e(TAG, "Cannot write sample data: muxerContext is null")
+        encoder.releaseOutputBuffer(index, false)
+        return
+      }
+      context.muxer.writeSampleData(context.videoTrack, encodedData, bufferInfo)
       encoder.releaseOutputBuffer(index, false)
     }
   }

package/android/src/main/java/com/mrousavy/camera/core/ChunkedRecorderInterface.kt

@@ -0,0 +1,15 @@
+package com.mrousavy.camera.core
+
+import android.view.Surface
+
+/**
+ * Common interface for chunked video recorders.
+ * Implemented by both ChunkedRecordingManager (regular MP4) and
+ * FragmentedRecordingManager (HLS-compatible fMP4).
+ */
+interface ChunkedRecorderInterface {
+    val surface: Surface
+
+    fun start()
+    fun finish()
+}

package/android/src/main/java/com/mrousavy/camera/core/FragmentedRecordingManager.kt

@@ -0,0 +1,180 @@
+package com.mrousavy.camera.core
+
+import android.media.MediaCodec
+import android.media.MediaCodec.BufferInfo
+import android.media.MediaCodecInfo
+import android.media.MediaFormat
+import android.util.Log
+import android.util.Size
+import android.view.Surface
+import com.mrousavy.camera.types.Orientation
+import com.mrousavy.camera.types.RecordVideoOptions
+import java.io.File
+
+/**
+ * A recording manager that produces HLS-compatible fragmented MP4 segments.
+ *
+ * Uses HlsMuxer (following Android's MediaMuxer pattern) to produce:
+ * - init.mp4: Initialization segment (ftyp + moov with mvex)
+ * - 0.mp4, 1.mp4, ...: Media segments (moof + mdat)
+ */
+class FragmentedRecordingManager(
+    private val encoder: MediaCodec,
+    private val muxer: HlsMuxer,
+    private val configuredFps: Int
+) : MediaCodec.Callback(), ChunkedRecorderInterface {
+
+    companion object {
+        private const val TAG = "FragmentedRecorder"
+        private const val DEFAULT_SEGMENT_DURATION_SECONDS = 6
+
+        fun fromParams(
+            callbacks: CameraSession.Callback,
+            size: Size,
+            enableAudio: Boolean,
+            fps: Int? = null,
+            cameraOrientation: Orientation,
+            bitRate: Int,
+            options: RecordVideoOptions,
+            outputDirectory: File,
+            segmentDurationSeconds: Int = DEFAULT_SEGMENT_DURATION_SECONDS
+        ): FragmentedRecordingManager {
+            val mimeType = options.videoCodec.toMimeType()
+            // Use cameraOrientation from Android (computed from device rotation)
+            // instead of options.orientation from JS which may be stale
+            val recordingOrientationDegrees = cameraOrientation.toDegrees()
+
+            // Swap dimensions based on orientation - same logic as ChunkedRecordingManager
+            // When camera is in landscape orientation, we need to swap width/height for the encoder
+            val (width, height) = if (cameraOrientation.isLandscape()) {
+                size.height to size.width
+            } else {
+                size.width to size.height
+            }
+
+            Log.d(TAG, "Input size: ${size.width}x${size.height}, " +
+                    "encoder size: ${width}x${height}, " +
+                    "orientation: $cameraOrientation ($recordingOrientationDegrees°)")
+
+            val format = MediaFormat.createVideoFormat(mimeType, width, height)
+            val codec = MediaCodec.createEncoderByType(mimeType)
+
+            format.setInteger(
+                MediaFormat.KEY_COLOR_FORMAT,
+                MediaCodecInfo.CodecCapabilities.COLOR_FormatSurface
+            )
+
+            val effectiveFps = fps ?: 30
+            format.setInteger(MediaFormat.KEY_FRAME_RATE, effectiveFps)
+            format.setInteger(MediaFormat.KEY_I_FRAME_INTERVAL, segmentDurationSeconds)
+            format.setInteger(MediaFormat.KEY_BIT_RATE, bitRate)
+
+            Log.d(TAG, "Video Format: $format, orientation: $recordingOrientationDegrees")
+
+            codec.configure(format, null, null, MediaCodec.CONFIGURE_FLAG_ENCODE)
+
+            // Create muxer with callbacks and orientation
+            val muxer = HlsMuxer(
+                outputDirectory = outputDirectory,
+                callback = object : HlsMuxer.Callback {
+                    override fun onInitSegmentReady(file: File) {
+                        callbacks.onInitSegmentReady(file)
+                    }
+
+                    override fun onMediaSegmentReady(file: File, index: Int, durationUs: Long) {
+                        callbacks.onVideoChunkReady(file, index, durationUs)
+                    }
+                },
+                orientationDegrees = recordingOrientationDegrees
+            )
+            muxer.setSegmentDuration(segmentDurationSeconds * 1_000_000L)
+
+            Log.d(TAG, "Created HlsMuxer with orientation: $recordingOrientationDegrees degrees, fps: $effectiveFps")
+
+            return FragmentedRecordingManager(codec, muxer, effectiveFps)
+        }
+    }
+
+    private var recording = false
+    private var muxerStarted = false
+    private var trackIndex = -1
+
+    override val surface: Surface = encoder.createInputSurface()
+
+    init {
+        encoder.setCallback(this)
+    }
+
+    override fun start() {
+        encoder.start()
+        recording = true
+    }
+
+    override fun finish() {
+        synchronized(this) {
+            recording = false
+
+            if (muxerStarted) {
+                muxer.stop()
+                muxer.release()
+            }
+
+            try {
+                encoder.stop()
+                encoder.release()
+            } catch (e: Exception) {
+                Log.e(TAG, "Error stopping encoder", e)
+            }
+        }
+    }
+
+    // MediaCodec.Callback methods
+
+    override fun onInputBufferAvailable(codec: MediaCodec, index: Int) {
+        // Not used for Surface input
+    }
+
+    override fun onOutputBufferAvailable(codec: MediaCodec, index: Int, bufferInfo: BufferInfo) {
+        synchronized(this) {
+            if (!recording) {
+                encoder.releaseOutputBuffer(index, false)
+                return
+            }
+
+            if (!muxerStarted) {
+                encoder.releaseOutputBuffer(index, false)
+                return
+            }
+
+            val buffer = encoder.getOutputBuffer(index)
+            if (buffer == null) {
+                Log.e(TAG, "getOutputBuffer returned null")
+                encoder.releaseOutputBuffer(index, false)
+                return
+            }
+
+            try {
+                muxer.writeSampleData(trackIndex, buffer, bufferInfo)
+            } catch (e: Exception) {
+                Log.e(TAG, "Error writing sample", e)
+            }
+
+            encoder.releaseOutputBuffer(index, false)
+        }
+    }
+
+    override fun onError(codec: MediaCodec, e: MediaCodec.CodecException) {
+        Log.e(TAG, "Codec error: ${e.message}")
+    }
+
+    override fun onOutputFormatChanged(codec: MediaCodec, format: MediaFormat) {
+        synchronized(this) {
+            Log.i(TAG, "Output format changed: $format")
+
+            // Pass configured fps to muxer (not the encoder's output format fps which may differ)
+            trackIndex = muxer.addTrack(format, configuredFps)
+            muxer.start()
+            muxerStarted = true
+        }
+    }
+}

package/android/src/main/java/com/mrousavy/camera/core/RecordingSession.kt

@@ -14,6 +14,7 @@ import android.os.Environment
 import java.text.SimpleDateFormat
 import java.util.Locale
 import java.util.Date
+
 class RecordingSession(
   context: Context,
   val cameraId: String,
@@ -27,6 +28,8 @@ class RecordingSession(
   private val callback: (video: Video) -> Unit,
   private val onError: (error: CameraError) -> Unit,
   private val allCallbacks: CameraSession.Callback,
+  // Use FragmentedRecordingManager for HLS-compatible fMP4 output
+  private val useFragmentedMp4: Boolean = true
 ) {
   companion object {
     private const val TAG = "RecordingSession"
@@ -34,6 +37,9 @@ class RecordingSession(
     private const val AUDIO_SAMPLING_RATE = 44_100
     private const val AUDIO_BIT_RATE = 16 * AUDIO_SAMPLING_RATE
     private const val AUDIO_CHANNELS = 1
+
+    // Segment duration in seconds (matching iOS default of 6 seconds)
+    private const val SEGMENT_DURATION_SECONDS = 6
   }
 
   data class Video(val path: String, val durationMs: Long, val size: Size)
@@ -41,16 +47,33 @@ class RecordingSession(
   private val outputPath: File = File(filePath)
 
   private val bitRate = getBitRate()
-  private val recorder = ChunkedRecordingManager.fromParams(
-    allCallbacks,
-    size,
-    enableAudio,
-    fps,
-    cameraOrientation,
-    bitRate,
-    options,
-    outputPath
-  )
+
+  // Use FragmentedRecordingManager for HLS-compatible fMP4 output,
+  // or fall back to ChunkedRecordingManager for regular MP4 chunks
+  private val recorder: ChunkedRecorderInterface = if (useFragmentedMp4) {
+    FragmentedRecordingManager.fromParams(
+      allCallbacks,
+      size,
+      enableAudio,
+      fps,
+      cameraOrientation,
+      bitRate,
+      options,
+      outputPath,
+      SEGMENT_DURATION_SECONDS
+    )
+  } else {
+    ChunkedRecordingManager.fromParams(
+      allCallbacks,
+      size,
+      enableAudio,
+      fps,
+      cameraOrientation,
+      bitRate,
+      options,
+      outputPath
+    )
+  }
   private var startTime: Long? = null
   val surface: Surface
     get() {

package/android/src/main/java/com/mrousavy/camera/utils/withPromise.kt

@@ -11,6 +11,6 @@ inline fun withPromise(promise: Promise, closure: () -> Any?) {
   } catch (e: Throwable) {
     e.printStackTrace()
     val error = if (e is CameraError) e else UnknownCameraError(e)
-    promise.reject("${error.domain}/${error.id}", error.message, error.cause)
+    promise.reject("${error.domain}/${error.id}", error.message ?: "Unknown error", error.cause)
   }
 }