@poolse/react-native-calls 0.2.0 → 0.4.0

package/android/src/main/java/dev/poolse/callcore/android/CallCore.kt

@@ -67,6 +67,7 @@ class CallCore private constructor(context: Context) {
   private var conversationName: String? = null
   private var mutedSelf = false
   private var cameraOn = false
+  private var cameraFacing: String? = null
   private var audioRoute: String? = null
 
   /** Last snapshot emitted; read by the bridge's getCallState from any thread. */
@@ -146,14 +147,22 @@ class CallCore private constructor(context: Context) {
     runtime.reemit()
   }
 
-  fun setCamera(on: Boolean) {
-    runtime.post { cameraOn = on }
-    runtime.setCamera(on)
-    runtime.reemit()
-  }
+  /**
+   * Not optimistic: `cameraOn` in the snapshot flips only when the
+   * media adapter reports the local camera track actually published
+   * (it may be refused — e.g. no CAMERA permission).
+   */
+  fun setCamera(on: Boolean) = runtime.setCamera(on)
 
   fun switchCamera() = runtime.switchCamera()
 
+  /**
+   * A video slot for `<CallVideoView>`, or null when the media engine
+   * renders no video (signalling-only build). Main thread.
+   */
+  fun createVideoSurface(context: Context): CallVideoSurface? =
+    (media as? CallVideoSource)?.createVideoSurface(context)
+
   fun setSpeaker(on: Boolean) {
     // Optimistic; the media adapter reports the route it actually got.
     runtime.post { audioRoute = if (on) "speaker" else "earpiece" }
@@ -188,7 +197,6 @@ class CallCore private constructor(context: Context) {
       // The server corrected the media (a join defaults to audio until
       // its bundle says otherwise): re-derive what depends on it.
       if (extrasMedia != null) {
-        cameraOn = state.media == "video"
         audioRoute = null
         CallForegroundService.updateCall(state.callId ?: "", state.media)
       }
@@ -210,6 +218,7 @@ class CallCore private constructor(context: Context) {
       audioRoute = audioRoute ?: if (state.media == "video") "speaker" else "earpiece",
       mutedSelf = mutedSelf,
       cameraOn = cameraOn,
+      cameraFacing = cameraFacing,
     )
     lastSnapshot = snap
     reconcileAndroid(state)
@@ -222,8 +231,9 @@ class CallCore private constructor(context: Context) {
     roster = emptyList()
     conversationName = null
     mutedSelf = false
-    // Video calls publish the camera on join (LiveKitMediaPort).
-    cameraOn = media == "video"
+    // Reported by the media adapter once the camera is really published.
+    cameraOn = false
+    cameraFacing = null
     audioRoute = null
   }
 
@@ -286,6 +296,10 @@ class CallCore private constructor(context: Context) {
       runtime.post { audioRoute = route }
       runtime.reemit()
     }
+    override fun onLocalCamera(on: Boolean, facing: String?) {
+      runtime.post { cameraOn = on; cameraFacing = facing }
+      runtime.reemit()
+    }
   }
 
   private fun bringAppToFront(callId: String, from: Context?): Boolean {
@@ -450,6 +464,8 @@ interface MediaEvents {
   fun onParticipants(participants: List<MediaParticipant>)
   /** `earpiece` | `speaker` | `bluetooth` | `headset`. */
   fun onAudioRoute(route: String)
+  /** The local camera track is (not) published + enabled; [facing] `front` | `back`. */
+  fun onLocalCamera(on: Boolean, facing: String?) {}
 }
 
 data class MediaParticipant(
@@ -457,6 +473,7 @@ data class MediaParticipant(
   val identity: String,
   val speaking: Boolean,
   val muted: Boolean,
+  /** True only with a published, subscribed, unmuted camera track — a frame to draw. */
   val cameraOn: Boolean = false,
   /** The host app's own id for the user, when the SFU carries it; else the identity. */
   val externalId: String = identity,

package/android/src/main/java/dev/poolse/callcore/android/CallVideo.kt

@@ -0,0 +1,36 @@
+package dev.poolse.callcore.android
+
+import android.content.Context
+import android.view.View
+
+/**
+ * Video rendering, kept SFU-agnostic: a [dev.poolse.callcore.MediaPort]
+ * that can render video ALSO implements this; the bridge's view asks
+ * [CallCore.createVideoSurface] and never sees the SFU's types. A port
+ * without video (the signalling-only fallback) simply doesn't implement
+ * it, and the view stays empty.
+ *
+ * Main thread only — surfaces live in the view hierarchy, and the media
+ * adapter keeps its room on main.
+ */
+interface CallVideoSource {
+  fun createVideoSurface(context: Context): CallVideoSurface
+}
+
+/** One on-screen video slot, bound to a participant's camera. */
+interface CallVideoSurface {
+  /** The Android view to host; it fills its parent. */
+  val view: View
+
+  /**
+   * What to show. [participantId] is the remote's userId (SFU
+   * identity); [local] shows the self view instead. [mirror] null =
+   * the default (mirrored for the local front camera only). [fit] is
+   * `cover` or `contain`. Rebinds immediately and again whenever the
+   * underlying track appears, disappears, mutes or the room is replaced.
+   */
+  fun configure(participantId: String?, local: Boolean, mirror: Boolean?, fit: String)
+
+  /** Detach from any track and free the renderer. Idempotent. */
+  fun release()
+}

package/android/src/main/java/dev/poolse/callcore/android/SnapshotJson.kt

@@ -20,8 +20,23 @@ internal fun MachineState.toSnapshot(
   audioRoute: String = "earpiece",
   mutedSelf: Boolean = false,
   cameraOn: Boolean = false,
+  cameraFacing: String? = null,
 ): Map<String, Any?>? {
   if (phase == Phase.IDLE) return null
+  return buildMap {
+    putAll(snapshotCore(conversationName, participants, audioRoute, mutedSelf, cameraOn))
+    // Optional in the contract: present only while a camera is published.
+    if (cameraFacing != null) put("cameraFacing", cameraFacing)
+  }
+}
+
+private fun MachineState.snapshotCore(
+  conversationName: String?,
+  participants: List<Map<String, Any>>,
+  audioRoute: String,
+  mutedSelf: Boolean,
+  cameraOn: Boolean,
+): Map<String, Any?> {
   return mapOf(
     "cv" to 1,
     "callId" to callId,

package/android/src/main/java/expo/modules/poolsecalls/PoolseCallVideoView.kt

@@ -0,0 +1,64 @@
+package expo.modules.poolsecalls
+
+import android.content.Context
+import android.view.ViewGroup
+import dev.poolse.callcore.android.CallCore
+import dev.poolse.callcore.android.CallVideoSurface
+import expo.modules.kotlin.AppContext
+import expo.modules.kotlin.views.ExpoView
+
+/**
+ * `<CallVideoView>` on Android: a thin host for the core's
+ * [CallVideoSurface]. All binding logic (which track, rebinds on
+ * subscribe/mute/rejoin) lives in the media adapter; this view only
+ * forwards props and ties the surface's lifetime to the window.
+ */
+class PoolseCallVideoView(context: Context, appContext: AppContext) : ExpoView(context, appContext) {
+
+  // The renderer is a native child React does not lay out: let Android
+  // measure it (and re-measure when the video's size changes).
+  override val shouldUseAndroidLayout = true
+
+  private var surface: CallVideoSurface? = null
+
+  var participantId: String? = null
+    set(v) { field = v; apply() }
+  var local: Boolean = false
+    set(v) { field = v; apply() }
+  var mirror: Boolean? = null
+    set(v) { field = v; apply() }
+  var fit: String = "cover"
+    set(v) { field = v; apply() }
+
+  override fun onAttachedToWindow() {
+    super.onAttachedToWindow()
+    attachSurface()
+  }
+
+  override fun onDetachedFromWindow() {
+    detachSurface()
+    super.onDetachedFromWindow()
+  }
+
+  private fun attachSurface() {
+    if (surface != null) return
+    // No core yet (never configured) or no video-capable SFU: stay empty.
+    val s = CallCore.peek()?.createVideoSurface(context) ?: return
+    surface = s
+    addView(s.view, LayoutParams(ViewGroup.LayoutParams.MATCH_PARENT, ViewGroup.LayoutParams.MATCH_PARENT))
+    apply()
+  }
+
+  internal fun detachSurface() {
+    val s = surface ?: return
+    surface = null
+    s.release()
+    removeView(s.view)
+  }
+
+  private fun apply() {
+    // Mounted before the core existed (configure still pending): try again.
+    val s = surface ?: run { if (isAttachedToWindow) attachSurface(); return }
+    s.configure(participantId, local, mirror, if (fit == "contain") "contain" else "cover")
+  }
+}

package/android/src/main/java/expo/modules/poolsecalls/PoolseCallsModule.kt

@@ -32,6 +32,16 @@ class PoolseCallsModule : Module() {
 
     Events("onCallState")
 
+    // <CallVideoView>: renders a participant's (or our own) camera.
+    View(PoolseCallVideoView::class) {
+      Name("PoolseCallVideo")
+      Prop("participantId") { view: PoolseCallVideoView, id: String? -> view.participantId = id }
+      Prop("local") { view: PoolseCallVideoView, local: Boolean? -> view.local = local ?: false }
+      Prop("mirror") { view: PoolseCallVideoView, mirror: Boolean? -> view.mirror = mirror }
+      Prop("fit") { view: PoolseCallVideoView, fit: String? -> view.fit = fit ?: "cover" }
+      OnViewDestroys { view: PoolseCallVideoView -> view.detachSurface() }
+    }
+
     // Snapshots → the single JS event. Null (idle) becomes an explicit
     // cleared payload so the JS side always has a definite state. The
     // listener is process-level, so subscribing before configure works.

package/android/src/main/livekit/java/dev/poolse/callcore/livekit/LiveKitMediaPort.kt

@@ -1,12 +1,18 @@
 package dev.poolse.callcore.livekit
 
+import android.Manifest
 import android.content.Context
+import android.content.pm.PackageManager
 import android.util.Log
+import androidx.core.content.ContextCompat
 import com.twilio.audioswitch.AudioDevice
 import dev.poolse.callcore.CallSessionBundle
 import dev.poolse.callcore.MediaPort
+import dev.poolse.callcore.android.CallVideoSource
+import dev.poolse.callcore.android.CallVideoSurface
 import dev.poolse.callcore.android.MediaEvents
 import dev.poolse.callcore.android.MediaParticipant
+import io.livekit.android.ConnectOptions
 import io.livekit.android.LiveKit
 import io.livekit.android.audio.AudioSwitchHandler
 import io.livekit.android.events.DisconnectReason
@@ -14,11 +20,17 @@ import io.livekit.android.events.RoomEvent
 import io.livekit.android.events.collect
 import io.livekit.android.room.Room
 import io.livekit.android.room.participant.Participant
+import io.livekit.android.room.track.CameraPosition
+import io.livekit.android.room.track.LocalVideoTrack
+import io.livekit.android.room.track.RemoteTrackPublication
+import io.livekit.android.room.track.Track
+import io.livekit.android.room.track.VideoTrack
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.Job
 import kotlinx.coroutines.SupervisorJob
 import kotlinx.coroutines.cancel
+import kotlinx.coroutines.delay
 import kotlinx.coroutines.launch
 import org.json.JSONObject
 
@@ -42,7 +54,7 @@ import org.json.JSONObject
 class LiveKitMediaPort(
   private val context: Context,
   private val events: MediaEvents,
-) : MediaPort {
+) : MediaPort, CallVideoSource {
 
   private val scope = CoroutineScope(SupervisorJob() + Dispatchers.Main.immediate)
   @Volatile private var room: Room? = null
@@ -62,6 +74,9 @@ class LiveKitMediaPort(
   private var cameraWanted: Boolean? = null
   private var joinedCallId: String? = null
 
+  /** Live `<CallVideoView>` slots; rebound whenever what they show may have changed. */
+  private val surfaces = linkedSetOf<LiveKitVideoSurface>()
+
   override fun join(bundle: CallSessionBundle) {
     // Rejoin of the same call keeps the user's choices; so do choices
     // made while this call was still connecting (joinedCallId null). A
@@ -73,26 +88,55 @@ class LiveKitMediaPort(
     val wantsVideo = bundle.media == "video"
     val newRoom = LiveKit.create(appContext = context.applicationContext)
     configureAudio(newRoom, wantsVideo)
+    // A 1:1/small call: never let the SFU pause a subscribed camera for
+    // "not visible" — a track whose view mounts late would stay black.
+    // (Renderers are still registered with visibility via addRenderer.)
+    newRoom.adaptiveStream = false
+    newRoom.dynacast = false
     room = newRoom
+    refreshVideo() // surfaces re-initialise against the new room's EGL
     eventJob = scope.launch { observe(newRoom) }
     scope.launch {
-      runCatching {
-        newRoom.connect(bundle.livekitUrl, bundle.livekitToken)
-        if (room !== newRoom) return@runCatching
-        newRoom.localParticipant.setMicrophoneEnabled(!mutedWanted)
-        if (cameraWanted ?: wantsVideo) newRoom.localParticipant.setCameraEnabled(true)
+      val connected = runCatching {
+        newRoom.connect(bundle.livekitUrl, bundle.livekitToken, ConnectOptions(autoSubscribe = true))
       }.onFailure {
         Log.w(TAG, "connect failed", it)
         if (room === newRoom) {
           // Don't leave a half-open room (and its audio mode) behind.
           eventJob?.cancel()
           eventJob = null
-          teardown(newRoom)
           room = null
+          refreshVideo()
+          teardown(newRoom)
           events.onFailed()
         }
-      }
+      }.isSuccess
+      if (!connected || room !== newRoom) return@launch
+      // Publishing failures must not fail the call: audio-only is a call.
+      runCatching { newRoom.localParticipant.setMicrophoneEnabled(!mutedWanted) }
+        .onFailure { Log.w(TAG, "microphone publish failed", it) }
+      if (cameraWanted ?: wantsVideo) enableCamera(newRoom, true)
+      reportLocalCamera(newRoom)
+      refreshVideo()
+    }
+  }
+
+  private fun cameraGranted() =
+    ContextCompat.checkSelfPermission(context, Manifest.permission.CAMERA) ==
+      PackageManager.PERMISSION_GRANTED
+
+  /**
+   * Publish / unpublish the camera. Without the CAMERA grant a video
+   * call joins audio-only instead of failing; a later setCamera(true)
+   * after the user grants it publishes then.
+   */
+  private suspend fun enableCamera(r: Room, on: Boolean) {
+    if (on && !cameraGranted()) {
+      Log.i(TAG, "CAMERA not granted: staying audio-only")
+      return
     }
+    runCatching { r.localParticipant.setCameraEnabled(on) }
+      .onFailure { Log.w(TAG, "camera ${if (on) "publish" else "unpublish"} failed", it) }
   }
 
   /** The call is over for this device: drop the room AND the call's choices. */
@@ -114,7 +158,10 @@ class LiveKitMediaPort(
     eventJob = null
     val r = room ?: return
     room = null
+    // Unbind every view from this room's tracks BEFORE its EGL is released.
+    refreshVideo()
     teardown(r)
+    events.onLocalCamera(false, null)
   }
 
   private fun teardown(r: Room) {
@@ -134,12 +181,78 @@ class LiveKitMediaPort(
   override fun setCamera(on: Boolean) {
     cameraWanted = on
     val r = room ?: return
-    scope.launch { runCatching { r.localParticipant.setCameraEnabled(on) } }
+    scope.launch {
+      enableCamera(r, on)
+      if (room !== r) return@launch
+      reportLocalCamera(r)
+      refreshVideo()
+    }
   }
 
+  /** Front ↔ back on the published camera track. */
   override fun switchCamera() {
-    // The host's VideoTrackView performs the actual flip; exposing the
-    // control here keeps the port surface complete.
+    val r = room ?: return
+    val track = localCameraTrack(r) ?: return
+    val next = if (track.options.position == CameraPosition.BACK) CameraPosition.FRONT else CameraPosition.BACK
+    runCatching { track.switchCamera(null, next) }.onFailure { Log.w(TAG, "switchCamera failed", it) }
+    // The capturer switches asynchronously and updates the options when
+    // done: report (and re-mirror the self view) once it has.
+    scope.launch {
+      delay(SWITCH_SETTLE_MS)
+      if (room !== r) return@launch
+      reportLocalCamera(r)
+      refreshVideo()
+    }
+  }
+
+  // ── video ───────────────────────────────────────────────────────────
+
+  override fun createVideoSurface(context: Context): CallVideoSurface =
+    LiveKitVideoSurface(context, this).also { surfaces += it }
+
+  internal fun unregister(surface: LiveKitVideoSurface) { surfaces -= surface }
+
+  internal fun currentRoom(): Room? = room
+
+  private fun refreshVideo() {
+    for (s in surfaces.toList()) s.rebind()
+  }
+
+  private fun localCameraTrack(r: Room): LocalVideoTrack? =
+    r.localParticipant.getTrackPublication(Track.Source.CAMERA)
+      ?.takeIf { !it.muted }?.track as? LocalVideoTrack
+
+  /**
+   * The camera track a view should show: the local one, or the remote
+   * participant's — only once it is published, SUBSCRIBED and unmuted.
+   */
+  internal fun cameraTrack(participantId: String?, local: Boolean): VideoTrack? {
+    val r = room ?: return null
+    if (local) return localCameraTrack(r)
+    val p = r.remoteParticipants.values.firstOrNull { it.identity?.value == participantId } ?: return null
+    return remoteCamera(p)
+  }
+
+  private fun remoteCamera(p: Participant): VideoTrack? {
+    val pub = p.getTrackPublication(Track.Source.CAMERA) as? RemoteTrackPublication ?: return null
+    if (!pub.subscribed || pub.muted) return null
+    return pub.track as? VideoTrack
+  }
+
+  /** `front` | `back` of the published local camera, or null when none. */
+  internal fun cameraFacing(): String? {
+    val r = room ?: return null
+    return when (localCameraTrack(r)?.options?.position) {
+      CameraPosition.FRONT -> "front"
+      CameraPosition.BACK -> "back"
+      null -> null
+    }
+  }
+
+  private fun reportLocalCamera(r: Room) {
+    if (room !== r) return
+    val on = localCameraTrack(r) != null
+    events.onLocalCamera(on, if (on) cameraFacing() else null)
   }
 
   override fun setSpeaker(on: Boolean) {
@@ -219,6 +332,7 @@ class LiveKitMediaPort(
           // answered before our media came up): they will not "connect".
           if (room.remoteParticipants.isNotEmpty()) events.onRemoteJoined()
           emit(room)
+          refreshVideo()
         }
         // LiveKit is resuming the SAME session (ICE restart / signal
         // resume). Only reflect it: tearing the room down here fought
@@ -230,13 +344,23 @@ class LiveKitMediaPort(
         is RoomEvent.Disconnected -> {
           if (event.reason != DisconnectReason.CLIENT_INITIATED) events.onLost()
         }
-        is RoomEvent.ParticipantConnected -> { events.onRemoteJoined(); emit(room) }
+        is RoomEvent.ParticipantConnected -> { events.onRemoteJoined(); emit(room); refreshVideo() }
+        // Anything that can make a camera appear, vanish or freeze:
+        // update the roster's cameraOn, the local camera state, and
+        // rebind every video view.
         is RoomEvent.ParticipantDisconnected,
-        is RoomEvent.ActiveSpeakersChanged,
+        is RoomEvent.TrackSubscribed,
+        is RoomEvent.TrackUnsubscribed,
         is RoomEvent.TrackMuted,
         is RoomEvent.TrackUnmuted,
         is RoomEvent.TrackPublished,
         is RoomEvent.TrackUnpublished,
+        is RoomEvent.LocalTrackSubscribed -> {
+          emit(room)
+          reportLocalCamera(room)
+          refreshVideo()
+        }
+        is RoomEvent.ActiveSpeakersChanged,
         is RoomEvent.ParticipantMetadataChanged,
         is RoomEvent.ParticipantAttributesChanged -> emit(room)
         else -> Unit
@@ -254,7 +378,9 @@ class LiveKitMediaPort(
           identity = identity,
           speaking = it.isSpeaking,
           muted = !it.isMicrophoneEnabled(),
-          cameraOn = it.isCameraEnabled(),
+          // Video, not avatar, only when there is a frame to draw:
+          // published, subscribed and unmuted.
+          cameraOn = remoteCamera(it) != null,
           externalId = externalIdOf(it) ?: identity,
         )
       },
@@ -270,11 +396,13 @@ class LiveKitMediaPort(
 
   fun dispose() {
     leave()
+    for (s in surfaces.toList()) s.release()
     scope.cancel()
   }
 
   companion object {
     private const val TAG = "PoolseLiveKit"
+    private const val SWITCH_SETTLE_MS = 600L
 
     /** Pass as `mediaFactory` in CallCoreConfig. */
     val factory: (Context, MediaEvents) -> MediaPort = { ctx, ev -> LiveKitMediaPort(ctx, ev) }

package/android/src/main/livekit/java/dev/poolse/callcore/livekit/LiveKitVideoSurface.kt

@@ -0,0 +1,107 @@
+package dev.poolse.callcore.livekit
+
+import android.content.Context
+import android.util.Log
+import android.view.View
+import dev.poolse.callcore.android.CallVideoSurface
+import io.livekit.android.renderer.TextureViewRenderer
+import io.livekit.android.room.Room
+import io.livekit.android.room.track.VideoTrack
+import livekit.org.webrtc.RendererCommon
+
+/**
+ * A [CallVideoSurface] over LiveKit's [TextureViewRenderer]. TextureView,
+ * not SurfaceView: a local picture-in-picture overlapping a full-screen
+ * remote composes like any view, with no SurfaceView z-order fights.
+ *
+ * The renderer is initialised against the CURRENT room's EGL context
+ * ([Room.initVideoRenderer]); a rejoin builds a new room, so [rebind]
+ * re-initialises it. Tracks are attached with [VideoTrack.addRenderer]
+ * — for a remote track that registers the view's visibility with the
+ * SDK, so adaptive stream (if ever enabled) resumes the track as soon as
+ * the view is on screen instead of keeping it paused.
+ *
+ * Main thread only, like the port that owns it.
+ */
+internal class LiveKitVideoSurface(
+  context: Context,
+  private val port: LiveKitMediaPort,
+) : CallVideoSurface {
+
+  private val renderer = TextureViewRenderer(context)
+  override val view: View get() = renderer
+
+  private var initRoom: Room? = null
+  private var track: VideoTrack? = null
+  private var released = false
+
+  private var participantId: String? = null
+  private var local = false
+  private var mirror: Boolean? = null
+  private var fit = "cover"
+
+  override fun configure(participantId: String?, local: Boolean, mirror: Boolean?, fit: String) {
+    this.participantId = participantId
+    this.local = local
+    this.mirror = mirror
+    this.fit = fit
+    rebind()
+  }
+
+  /** Re-resolve the track (and the room) this slot should show. */
+  fun rebind() {
+    if (released) return
+    val room = port.currentRoom()
+    if (room !== initRoom) {
+      // Detach from the old room's track BEFORE its EGL goes away.
+      detachTrack()
+      if (initRoom != null) runCatching { renderer.release() }
+      initRoom = null
+      if (room != null) {
+        runCatching { room.initVideoRenderer(renderer); initRoom = room }
+          .onFailure { Log.w(TAG, "initVideoRenderer failed", it) }
+      }
+    }
+
+    val next = if (initRoom != null) port.cameraTrack(participantId, local) else null
+    if (next !== track) {
+      detachTrack()
+      if (next != null) {
+        runCatching { next.addRenderer(renderer); track = next }
+          .onFailure { Log.w(TAG, "addRenderer failed", it) }
+      }
+    }
+    // No camera: hide the renderer so its last frozen frame never shows;
+    // the UI draws the avatar from the snapshot's cameraOn.
+    renderer.visibility = if (track != null) View.VISIBLE else View.INVISIBLE
+    if (initRoom != null) {
+      runCatching {
+        renderer.setMirror(mirror ?: (local && port.cameraFacing() != "back"))
+        renderer.setScalingType(
+          if (fit == "contain") RendererCommon.ScalingType.SCALE_ASPECT_FIT
+          else RendererCommon.ScalingType.SCALE_ASPECT_FILL,
+        )
+      }
+    }
+  }
+
+  private fun detachTrack() {
+    val t = track ?: return
+    track = null
+    runCatching { t.removeRenderer(renderer) }
+    runCatching { renderer.clearImage() }
+  }
+
+  override fun release() {
+    if (released) return
+    released = true
+    detachTrack()
+    if (initRoom != null) runCatching { renderer.release() }
+    initRoom = null
+    port.unregister(this)
+  }
+
+  private companion object {
+    const val TAG = "PoolseCallVideo"
+  }
+}

package/dist/index.cjs

@@ -1,5 +1,7 @@
 'use strict';
 
+var react = require('react');
+var reactNative = require('react-native');
 var expoModulesCore = require('expo-modules-core');
 
 // src/index.ts
@@ -33,18 +35,50 @@ var onRingEnded = (callId, reason) => native?.onRingEnded(callId, reason);
 var onCallFinished = (callId, reason) => native?.onCallFinished(callId, reason ?? null);
 var canUseFullScreenIntent = () => native?.canUseFullScreenIntent() ?? true;
 var openFullScreenIntentSettings = () => native?.openFullScreenIntentSettings();
+function getVoipToken() {
+  return native?.getVoipToken?.() ?? null;
+}
+function onVoipToken(cb) {
+  if (!native || !native.getVoipToken) return () => void 0;
+  const sub = native.addListener("onVoipToken", cb);
+  return () => sub.remove();
+}
+var nativeVideo;
+function nativeVideoView() {
+  if (nativeVideo !== void 0) return nativeVideo;
+  nativeVideo = null;
+  if (native) {
+    try {
+      nativeVideo = expoModulesCore.requireNativeViewManager("PoolseCalls", "PoolseCallVideo");
+    } catch {
+      nativeVideo = null;
+    }
+  }
+  return nativeVideo;
+}
+function CallVideoView(props) {
+  const Native = nativeVideoView();
+  if (!Native) {
+    const { participantId: _p, local: _l, mirror: _m, fit: _f, ...rest } = props;
+    return react.createElement(reactNative.View, rest);
+  }
+  return react.createElement(Native, props);
+}
 
+exports.CallVideoView = CallVideoView;
 exports.answer = answer;
 exports.canUseFullScreenIntent = canUseFullScreenIntent;
 exports.configure = configure;
 exports.decline = decline;
 exports.getCallState = getCallState;
+exports.getVoipToken = getVoipToken;
 exports.hangUp = hangUp;
 exports.join = join;
 exports.nativeCallsAvailable = nativeCallsAvailable;
 exports.onCallFinished = onCallFinished;
 exports.onCallState = onCallState;
 exports.onRingEnded = onRingEnded;
+exports.onVoipToken = onVoipToken;
 exports.openFullScreenIntentSettings = openFullScreenIntentSettings;
 exports.place = place;
 exports.setCamera = setCamera;