@poolse/react-native-calls 0.1.3 → 0.3.0

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

@@ -1,20 +1,38 @@
 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
 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
 
 /**
  * The shipped [MediaPort], over LiveKit's native Android SDK. Wire it
@@ -24,84 +42,368 @@ import kotlinx.coroutines.launch
  * lives in its own source set (`src/main/livekit`) kept off the core
  * library's classpath. Lifecycle and signaling are not its concern — it
  * joins a room with the server-minted token, publishes the mic (and
- * camera for video), and reports room transitions back through
- * [MediaEvents]. The runtime decides everything else.
+ * camera for video), routes audio, and reports room transitions back
+ * through [MediaEvents]. The runtime decides everything else.
+ *
+ * Threading: every method is called on the main thread (the runtime's
+ * thread) and every coroutine runs on Main.immediate, so [room] is only
+ * ever touched on main. Coroutines still re-check that the room they
+ * captured is the current one — a join/leave may have replaced it
+ * while they were suspended.
  */
 class LiveKitMediaPort(
   private val context: Context,
   private val events: MediaEvents,
-) : MediaPort {
+) : MediaPort, CallVideoSource {
 
   private val scope = CoroutineScope(SupervisorJob() + Dispatchers.Main.immediate)
-  private var room: Room? = null
+  @Volatile private var room: Room? = null
   private var eventJob: Job? = null
+  private var media: String = "audio"
+
+  /** Speaker forced by the user; null = the media-type default. */
+  private var speakerWanted: Boolean? = null
+
+  /**
+   * The user's mute / camera choices for the CURRENT call. They survive
+   * a rejoin: /reconnect rebuilds the room, and blindly re-enabling the
+   * mic there went live while the UI still showed "muted". Reset only
+   * when the call ends ([leave]) or a different call joins.
+   */
+  private var mutedWanted = false
+  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) {
-    leave()
+    // Rejoin of the same call keeps the user's choices; so do choices
+    // made while this call was still connecting (joinedCallId null). A
+    // different call joining without a leave starts clean.
+    if (joinedCallId != null && bundle.callId != joinedCallId) resetWanted()
+    joinedCallId = bundle.callId
+    detach()
+    media = bundle.media
     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)
-        newRoom.localParticipant.setMicrophoneEnabled(true)
-        if (wantsVideo) newRoom.localParticipant.setCameraEnabled(true)
-      }.onFailure { events.onFailed() }
+      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
+          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. */
   override fun leave() {
+    detach()
+    resetWanted()
+    joinedCallId = null
+  }
+
+  private fun resetWanted() {
+    mutedWanted = false
+    cameraWanted = null
+    speakerWanted = null
+  }
+
+  /** Drop the current room only (a rejoin replaces it). */
+  private fun detach() {
     eventJob?.cancel()
     eventJob = null
-    room?.disconnect()
+    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) {
+    runCatching { r.disconnect() }
+    // disconnect() keeps the room's engine, capturer and audio handler
+    // alive for a later reconnect; this port never reuses a room, so
+    // release it or every call leaks a PeerConnectionFactory.
+    runCatching { r.release() }
   }
 
   override fun setMuted(muted: Boolean) {
-    scope.launch { room?.localParticipant?.setMicrophoneEnabled(!muted) }
+    mutedWanted = muted
+    val r = room ?: return
+    scope.launch { runCatching { r.localParticipant.setMicrophoneEnabled(!muted) } }
   }
 
   override fun setCamera(on: Boolean) {
-    scope.launch { room?.localParticipant?.setCameraEnabled(on) }
+    cameraWanted = on
+    val r = room ?: return
+    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) {
+    speakerWanted = on
+    val handler = room?.audioHandler as? AudioSwitchHandler ?: return
+    applyRoute(handler)
+  }
+
+  // ── audio routing ───────────────────────────────────────────────────
+
+  /**
+   * A voice call is held to the ear: earpiece by default (a connected
+   * headset or Bluetooth device first); video defaults to the speaker.
+   * Set before connect — the handler starts during connect.
+   */
+  private fun configureAudio(r: Room, video: Boolean) {
+    val handler = r.audioHandler as? AudioSwitchHandler ?: return
+    handler.preferredDeviceList = if (video) {
+      listOf(
+        AudioDevice.BluetoothHeadset::class.java,
+        AudioDevice.WiredHeadset::class.java,
+        AudioDevice.Speakerphone::class.java,
+        AudioDevice.Earpiece::class.java,
+      )
+    } else {
+      listOf(
+        AudioDevice.BluetoothHeadset::class.java,
+        AudioDevice.WiredHeadset::class.java,
+        AudioDevice.Earpiece::class.java,
+        AudioDevice.Speakerphone::class.java,
+      )
+    }
+    handler.audioDeviceChangeListener = { devices, selected ->
+      // A user's speaker choice survives device-list changes, except
+      // that plugging in a headset always wins (as the dialer does).
+      val wanted = speakerWanted
+      if (wanted != null && selected != null && room?.audioHandler === handler) {
+        val external = selected is AudioDevice.BluetoothHeadset || selected is AudioDevice.WiredHeadset
+        val isSpeaker = selected is AudioDevice.Speakerphone
+        if (!external && isSpeaker != wanted) devices.pick(wanted)?.let(handler::selectDevice)
+      }
+      events.onAudioRoute(routeOf(handler.selectedAudioDevice ?: selected))
+    }
+  }
+
+  private fun applyRoute(handler: AudioSwitchHandler) {
+    val want = speakerWanted ?: (media == "video")
+    handler.availableAudioDevices.pick(want)?.let(handler::selectDevice)
+    events.onAudioRoute(routeOf(handler.selectedAudioDevice))
+  }
+
+  /** Speaker, or the best private route: Bluetooth → wired → earpiece. */
+  private fun List<AudioDevice>.pick(speaker: Boolean): AudioDevice? =
+    if (speaker) firstOrNull { it is AudioDevice.Speakerphone }
+    else firstOrNull { it is AudioDevice.BluetoothHeadset }
+      ?: firstOrNull { it is AudioDevice.WiredHeadset }
+      ?: firstOrNull { it is AudioDevice.Earpiece }
+
+  private fun routeOf(d: AudioDevice?): String = when (d) {
+    is AudioDevice.Speakerphone -> "speaker"
+    is AudioDevice.BluetoothHeadset -> "bluetooth"
+    is AudioDevice.WiredHeadset -> "headset"
+    is AudioDevice.Earpiece -> "earpiece"
+    null -> if (media == "video") "speaker" else "earpiece"
+  }
+
+  // ── room events ─────────────────────────────────────────────────────
+
   private suspend fun observe(room: Room) {
     room.events.collect { event ->
+      if (this.room !== room) return@collect
       when (event) {
-        is RoomEvent.Connected -> events.onConnected()
-        is RoomEvent.Reconnecting, is RoomEvent.Disconnected -> events.onLost()
+        is RoomEvent.Connected -> {
+          (room.audioHandler as? AudioSwitchHandler)?.let { if (speakerWanted != null) applyRoute(it) }
+          events.onConnected()
+          // Somebody may already be in (a late join, or a callee who
+          // 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
+        // its own recovery and turned every network blip into a rejoin.
+        is RoomEvent.Reconnecting -> events.onReconnecting()
         is RoomEvent.Reconnected -> events.onRecovered()
-        is RoomEvent.ParticipantConnected -> { events.onRemoteJoined(); emit(room) }
+        // LiveKit gave up (or the server removed us). Our own leave()
+        // never gets here — the collector is cancelled first.
+        is RoomEvent.Disconnected -> {
+          if (event.reason != DisconnectReason.CLIENT_INITIATED) events.onLost()
+        }
+        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 -> emit(room)
+        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
       }
+      Unit
     }
   }
 
+  /** The REMOTE roster — the local participant is never included. */
   private fun emit(room: Room) {
     events.onParticipants(
       room.remoteParticipants.values.map {
+        val identity = it.identity?.value ?: ""
         MediaParticipant(
-          identity = it.identity?.value ?: "",
+          identity = identity,
           speaking = it.isSpeaking,
-          muted = it.audioTrackPublications.firstOrNull()?.first?.muted ?: true,
+          muted = !it.isMicrophoneEnabled(),
+          // Video, not avatar, only when there is a frame to draw:
+          // published, subscribed and unmuted.
+          cameraOn = remoteCamera(it) != null,
+          externalId = externalIdOf(it) ?: identity,
         )
       },
     )
   }
 
-  fun dispose() = scope.cancel()
+  /** The host's own user id, if the server put it in attributes/metadata. */
+  private fun externalIdOf(p: Participant): String? =
+    runCatching { p.attributes["external_id"] }.getOrNull()?.ifEmpty { null }
+      ?: p.metadata?.let { m ->
+        runCatching { JSONObject(m).optString("external_id", "") }.getOrNull()?.ifEmpty { null }
+      }
+
+  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/android/src/test/java/dev/poolse/callcore/android/CallHttpClientTest.kt

@@ -0,0 +1,61 @@
+package dev.poolse.callcore.android
+
+import dev.poolse.callcore.CallSessionBundle
+import dev.poolse.callcore.HttpResult
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertTrue
+import org.junit.Test
+
+/**
+ * The HTTP classifier/parser, without a network: status + body →
+ * HttpResult exactly as CONTRACT.md §4 maps them.
+ */
+class CallHttpClientTest {
+
+  private val full = """
+    {"cv":1,"created":false,
+     "call":{"id":"c1","conversation_id":"v1","conversation_name":"Boiler","media":"video"},
+     "livekit":{"url":"wss://sfu","token":"lk-new"},
+     "control_token":"ctl-new"}
+  """.trimIndent()
+
+  private val current = CallSessionBundle(
+    callId = "c1", conversationId = "v1", conversationName = "Boiler", media = "audio",
+    created = true, livekitUrl = "wss://old", livekitToken = "lk-old", controlToken = "ctl-old",
+  )
+
+  @Test fun `full bundle parses (answer, join, place and now reconnect)`() {
+    val r = CallHttpClient.classify(200, full, current) as HttpResult.Ok
+    assertEquals("c1", r.bundle.callId)
+    assertEquals("lk-new", r.bundle.livekitToken)
+    assertEquals("ctl-new", r.bundle.controlToken)
+    assertEquals("video", r.bundle.media)
+    assertEquals(false, r.bundle.created)
+  }
+
+  @Test fun `old reconnect shape is applied onto the current bundle`() {
+    val r = CallHttpClient.classify(200, """{"cv":1,"livekit":{"url":"wss://sfu2","token":"lk-2"}}""", current)
+      as HttpResult.Ok
+    assertEquals(current.copy(livekitUrl = "wss://sfu2", livekitToken = "lk-2"), r.bundle)
+  }
+
+  @Test fun `unparseable 2xx is a failure, not a retry`() {
+    assertTrue(CallHttpClient.classify(200, "<html>", null) is HttpResult.Failed)
+    assertTrue(CallHttpClient.classify(200, """{"livekit":{"token":"x"}}""", null) is HttpResult.Failed)
+  }
+
+  @Test fun `error envelope code is read`() {
+    val r = CallHttpClient.classify(401, """{"error":{"code":"grant_spent","message":"…"}}""")
+    assertEquals(HttpResult.AuthFailed("grant_spent"), r)
+    assertEquals(HttpResult.AuthFailed("http_403"), CallHttpClient.classify(403, null))
+  }
+
+  @Test fun `status mapping`() {
+    assertEquals(HttpResult.Gone, CallHttpClient.classify(410, null))
+    assertEquals(HttpResult.Gone, CallHttpClient.classify(404, """{"error":{"code":"no_call"}}"""))
+    assertEquals(HttpResult.Failed("http_503"), CallHttpClient.classify(503, null))
+    assertEquals(HttpResult.Timeout, CallHttpClient.classify(502, null))
+    assertEquals(HttpResult.Timeout, CallHttpClient.classify(429, null))
+    assertEquals(HttpResult.Failed("bad"), CallHttpClient.classify(422, """{"error":{"code":"bad"}}"""))
+  }
+}

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
@@ -28,18 +30,50 @@ var hangUp = () => native?.hangUp();
 var setMuted = (muted) => native?.setMuted(muted);
 var setCamera = (on) => native?.setCamera(on);
 var switchCamera = () => native?.switchCamera();
+var setSpeaker = (on) => native?.setSpeaker(on);
+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();
+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.hangUp = hangUp;
 exports.join = join;
 exports.nativeCallsAvailable = nativeCallsAvailable;
+exports.onCallFinished = onCallFinished;
 exports.onCallState = onCallState;
+exports.onRingEnded = onRingEnded;
+exports.openFullScreenIntentSettings = openFullScreenIntentSettings;
 exports.place = place;
 exports.setCamera = setCamera;
 exports.setMuted = setMuted;
+exports.setSpeaker = setSpeaker;
 exports.switchCamera = switchCamera;
 //# sourceMappingURL=index.cjs.map
 //# sourceMappingURL=index.cjs.map