@poolse/react-native-calls 0.2.0 → 0.4.0

package/ios/Platform/VoipPush.swift

@@ -0,0 +1,172 @@
+import CallKit
+import Foundation
+import PushKit
+
+/// Native PushKit intake — the iOS twin of CallMessagingService. The
+/// registry is created at launch (PoolseCallsAppDelegateSubscriber →
+/// `PoolseCallsSetup.registerVoipEarly()`), long before JS, so a VoIP push that
+/// wakes a killed app is reported to CallKit natively within PushKit's
+/// budget.
+///
+/// Contract with iOS: EVERY VoIP push reports a call to CallKit
+/// synchronously, before `completion()` — stale, duplicate, control or
+/// unparseable ones included (reported, then ended `.failed`). Breaking
+/// it gets the app killed and, repeated, VoIP delivery revoked.
+final class VoipPush: NSObject, PKPushRegistryDelegate {
+  static let shared = VoipPush()
+
+  private var registry: PKPushRegistry?
+  private let lock = NSLock()
+  private var _token: String?
+
+  /// The current VoIP token (hex), readable from any thread.
+  var token: String? {
+    lock.lock(); defer { lock.unlock() }
+    return _token
+  }
+
+  /// The bridge's token subscriber (process-level, like CallCore.listener).
+  static var tokenListener: ((String) -> Void)?
+
+  /// Idempotent. Main thread.
+  func register() {
+    guard registry == nil else { return }
+    _ = CallKitController.shared // the provider must exist before any push
+    let r = PKPushRegistry(queue: .main)
+    r.delegate = self
+    r.desiredPushTypes = [.voIP]
+    registry = r
+    if let data = r.pushToken(for: .voIP) { setToken(data) }
+  }
+
+  private func setToken(_ data: Data) {
+    let hex = data.map { String(format: "%02x", $0) }.joined()
+    lock.lock(); _token = hex; lock.unlock()
+    VoipPush.tokenListener?(hex)
+  }
+
+  // MARK: - PKPushRegistryDelegate
+
+  func pushRegistry(_ registry: PKPushRegistry, didUpdate pushCredentials: PKPushCredentials, for type: PKPushType) {
+    guard type == .voIP else { return }
+    setToken(pushCredentials.token)
+  }
+
+  func pushRegistry(_ registry: PKPushRegistry, didInvalidatePushTokenFor type: PKPushType) {
+    guard type == .voIP else { return }
+    lock.lock(); _token = nil; lock.unlock()
+  }
+
+  func pushRegistry(_ registry: PKPushRegistry, didReceiveIncomingPushWith payload: PKPushPayload,
+                    for type: PKPushType, completion: @escaping () -> Void) {
+    if type == .voIP { handle(payload.dictionaryPayload) }
+    completion()
+  }
+
+  // MARK: - handling
+
+  private func handle(_ raw: [AnyHashable: Any]) {
+    let ck = CallKitController.shared
+    let p = VoipPayload(raw)
+    let core = CallCore.getOrNull()
+
+    switch p.event {
+    case "ring_ended", "finished":
+      // A control push on the VoIP channel still has to report a call.
+      ck.reportAndFail(callId: p.callId, title: p.title)
+      guard let core = core, let callId = p.callId else { return }
+      if p.event == "ring_ended" { core.onRingEnded(callId: callId, reason: p.reason ?? "finished") }
+      else { core.onCallFinished(callId: callId, reason: p.reason) }
+    default:
+      guard let ring = p.ringContext() else {
+        ck.reportAndFail(callId: p.callId, title: p.title)
+        return
+      }
+      guard let core = core, core.isRingLive(ring) else {
+        ck.reportAndFail(callId: ring.callId, title: p.title)
+        return
+      }
+      ck.reportIncoming(ring: ring)
+      core.onRing(ring)
+      // A ring the machine did not take (busy, superseded) must not stay
+      // on the CallKit screen: reconcile once the ring is processed.
+      core.reconcileCallKitSoon()
+    }
+  }
+}
+
+/// Lenient VoIP payload reader: top-level keys, or nested under `data` /
+/// `payload` / `call`; strings, numbers or bools for any field.
+struct VoipPayload {
+  private let fields: [String: Any]
+
+  init(_ raw: [AnyHashable: Any]) {
+    var out: [String: Any] = [:]
+    for nest in ["data", "payload", "call"] {
+      if let inner = raw[nest] as? [AnyHashable: Any] {
+        for (k, v) in inner { if let k = k as? String { out[k] = v } }
+      } else if let s = raw[nest] as? String, let d = s.data(using: .utf8),
+                let inner = (try? JSONSerialization.jsonObject(with: d)) as? [String: Any] {
+        for (k, v) in inner { out[k] = v }
+      }
+    }
+    for (k, v) in raw { if let k = k as? String, !(v is [AnyHashable: Any]) { out[k] = v } }
+    fields = out
+  }
+
+  func string(_ key: String) -> String? {
+    switch fields[key] {
+    case let s as String: return s.isEmpty ? nil : s
+    case let n as NSNumber: return n.stringValue
+    default: return nil
+    }
+  }
+
+  func int64(_ key: String) -> Int64? {
+    switch fields[key] {
+    case let n as NSNumber: return n.int64Value
+    case let s as String: return Int64(s) ?? Double(s).map { Int64($0) }
+    default: return nil
+    }
+  }
+
+  func bool(_ key: String) -> Bool? {
+    switch fields[key] {
+    case let n as NSNumber: return n.boolValue
+    case let s as String: return ["1", "true", "yes"].contains(s.lowercased())
+    default: return nil
+    }
+  }
+
+  var callId: String? { string("call_id") }
+  var event: String? { string("event") }
+  var reason: String? { string("reason") }
+  var title: String? { string("conversation_name") ?? string("caller_name") }
+
+  var media: String {
+    if let m = string("media")?.lowercased(), m == "video" || m == "audio" { return m }
+    return bool("has_video") == true ? "video" : "audio"
+  }
+
+  /// Epoch ms; a seconds value (< 1e12) is scaled. Missing: sent_at (or
+  /// now) + 60 s — the server's ring_ended(timeout) is the real cut-off.
+  private var deadlineMs: Int64 {
+    func ms(_ v: Int64) -> Int64 { v < 1_000_000_000_000 ? v * 1000 : v }
+    if let d = int64("ring_deadline"), d > 0 { return ms(d) }
+    let base = int64("sent_at").map(ms) ?? Int64(Date().timeIntervalSince1970 * 1000)
+    return base + 60_000
+  }
+
+  func ringContext() -> RingContext? {
+    guard let callId = callId, let conversationId = string("conversation_id"), let grant = string("grant") else { return nil }
+    return RingContext(
+      callId: callId,
+      conversationId: conversationId,
+      conversationName: string("conversation_name"),
+      callerName: string("caller_name"),
+      media: media,
+      grant: grant,
+      ringDeadlineEpochMs: deadlineMs
+    )
+  }
+}

package/ios/PoolseCalls.podspec

@@ -0,0 +1,64 @@
+require 'json'
+
+package = JSON.parse(File.read(File.join(__dir__, '..', 'package.json')))
+
+# LiveKit's Swift SDK (and its LiveKitUniFFI / collections dependencies)
+# is no longer published to CocoaPods trunk: it lives in LiveKit's own
+# spec repo. A podspec cannot declare a source, and the host's Podfile is
+# generated by `expo prebuild`, so instead of asking every host to add
+#
+#     source 'https://cdn.cocoapods.org/'
+#     source 'https://github.com/livekit/podspecs.git'
+#
+# we append LiveKit's spec repo to the resolver's sources while this
+# podspec is loaded (autolinking evaluates it inside `pod install`).
+# Trunk stays first, so every other pod resolves exactly as before.
+# Opt out with POOLSE_CALLS_NO_LIVEKIT_SOURCE=1 (then add the lines above).
+LIVEKIT_SPECS_SOURCE = 'https://github.com/livekit/podspecs.git'
+if ENV['POOLSE_CALLS_NO_LIVEKIT_SOURCE'] != '1' &&
+   defined?(Pod::Installer::Analyzer) &&
+   !Pod::Installer::Analyzer.method_defined?(:poolse_calls_original_sources)
+  Pod::Installer::Analyzer.class_eval do
+    alias_method :poolse_calls_original_sources, :sources
+    def sources
+      @poolse_calls_sources ||= begin
+        list = poolse_calls_original_sources
+        if list.any? { |s| s.respond_to?(:url) && s.url.to_s.sub(/\.git\z/, '') == LIVEKIT_SPECS_SOURCE.sub(/\.git\z/, '') }
+          list
+        else
+          list + [Pod::Config.instance.sources_manager.find_or_create_source_with_url(LIVEKIT_SPECS_SOURCE)]
+        end
+      end
+    end
+  end
+end
+
+Pod::Spec.new do |s|
+  s.name           = 'PoolseCalls'
+  s.version        = package['version']
+  s.summary        = package['description']
+  s.description    = package['description']
+  s.license        = package['license']
+  s.author         = 'Torsten Labs DOO'
+  s.homepage       = 'https://poolse.dev'
+  s.platforms      = { :ios => '15.1' }
+  s.swift_version  = '5.9'
+  s.source         = { :git => 'https://github.com/poolse/poolse-js-sdk.git' }
+  s.static_framework = true
+
+  s.dependency 'ExpoModulesCore'
+  # 2.15.1: LiveKitWebRTC 144.7559.10 (LKRTC-prefixed symbols in its own
+  # LiveKitWebRTC.framework) — links beside react-native-webrtc's
+  # WebRTC.framework without duplicate symbols. Not 2.16+: their vendored
+  # nanopb headers use <pb.h> angled includes that do not resolve when
+  # CocoaPods builds the pod as a static library (Expo's default).
+  s.dependency 'LiveKitClient', '= 2.15.1'
+
+  s.pod_target_xcconfig = {
+    'DEFINES_MODULE' => 'YES',
+    'SWIFT_COMPILATION_MODE' => 'wholemodule',
+  }
+
+  s.frameworks = 'CallKit', 'PushKit', 'AVFoundation', 'UIKit'
+  s.source_files = 'Core/**/*.swift', 'Platform/**/*.swift', 'Module/**/*.swift'
+end

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@poolse/react-native-calls",
-  "version": "0.2.0",
+  "version": "0.4.0",
   "description": "Native call core for poolse — Kotlin/Swift calling engine with a thin React Native bridge. Ring, answer and carry audio with the app killed and the phone locked.",
   "license": "MIT",
   "type": "module",
@@ -22,6 +22,12 @@
     "android/build.gradle",
     "android/consumer-rules.pro",
     "android/src",
+    "ios/Core",
+    "ios/Platform",
+    "ios/Module",
+    "ios/PoolseCalls.podspec",
+    "!ios/CoreTests",
+    "!**/.build",
     "expo-module.config.json",
     "README.md"
   ],

package/src/expo-modules-core.d.ts

@@ -8,4 +8,9 @@
 // cannot collide with the app's own copy of the types.
 declare module 'expo-modules-core' {
   export function requireOptionalNativeModule<T>(name: string): T | null;
+  /** A native view registered by an Expo module (`View(...)` + `Name(...)`). */
+  export function requireNativeViewManager<P>(
+    moduleName: string,
+    viewName?: string,
+  ): import('react').ComponentType<P>;
 }

package/src/index.ts

@@ -6,7 +6,9 @@
 // On a platform or build without the native module (Expo Go, web,
 // unlinked), every command is a safe no-op and the state stays idle —
 // so a host can render against this unconditionally.
-import { requireOptionalNativeModule } from 'expo-modules-core';
+import { createElement, type ComponentType, type ReactElement } from 'react';
+import { View, type ViewProps } from 'react-native';
+import { requireNativeViewManager, requireOptionalNativeModule } from 'expo-modules-core';
 
 /**
  * A call's complete state. `null` means idle — no call. After a call
@@ -36,18 +38,35 @@ export interface Snapshot {
     externalId: string;
     speaking: boolean;
     muted: boolean;
+    /** True only with a published, subscribed, unmuted camera track (show video, not avatar). */
     cameraOn: boolean;
   }>;
   audioRoute: 'earpiece' | 'speaker' | 'bluetooth' | 'headset';
   mutedSelf: boolean;
+  /** True only while the local camera track is actually published and enabled. */
   cameraOn: boolean;
+  /** Facing of the published local camera; absent when the camera is off. */
+  cameraFacing?: 'front' | 'back';
 }
 
 export interface ConfigureOptions {
   /** Drawable resource NAME for the call notification's small icon. */
   smallIcon?: string;
-  /** Raw resource NAME of the ringback tone (Android). */
+  /** Ringback tone: raw resource NAME (Android); main-bundle sound name, mp3/caf/wav (iOS). */
   ringback?: string;
+  /**
+   * iOS: the APNs environment of this build's `aps-environment`
+   * entitlement. Echoed back with the VoIP token so the server pushes to
+   * the right gateway. Ignored on Android.
+   */
+  apnsEnvironment?: 'production' | 'sandbox';
+}
+
+/** The iOS PushKit (VoIP) token and the APNs environment it belongs to. */
+export interface VoipToken {
+  /** Hex-encoded PushKit token. */
+  token: string;
+  environment: 'production' | 'sandbox' | string;
 }
 
 export interface PlaceOptions {
@@ -74,7 +93,9 @@ interface PoolseCallsNative {
   onCallFinished(callId: string, reason: string | null): void;
   canUseFullScreenIntent(): boolean;
   openFullScreenIntentSettings(): void;
+  getVoipToken?(): VoipToken | null;
   addListener(event: 'onCallState', cb: (payload: NativeSnapshot) => void): { remove(): void };
+  addListener(event: 'onVoipToken', cb: (payload: VoipToken) => void): { remove(): void };
 }
 
 const native = requireOptionalNativeModule<PoolseCallsNative>('PoolseCalls');
@@ -146,3 +167,65 @@ export const canUseFullScreenIntent = (): boolean => native?.canUseFullScreenInt
 
 /** Open the system screen where the user grants full-screen intents (falls back to notification settings). */
 export const openFullScreenIntentSettings = (): void => native?.openFullScreenIntentSettings();
+
+// ── VoIP push (iOS) ───────────────────────────────────────────────────
+
+/**
+ * iOS: the current PushKit VoIP token, registered natively at launch.
+ * `null` until iOS issues one, and always on Android (FCM carries rings).
+ */
+export function getVoipToken(): VoipToken | null {
+  return native?.getVoipToken?.() ?? null;
+}
+
+/** iOS: fires whenever PushKit issues (or rotates) the VoIP token. No-op on Android. */
+export function onVoipToken(cb: (token: VoipToken) => void): Unsubscribe {
+  if (!native || !native.getVoipToken) return () => undefined;
+  const sub = native.addListener('onVoipToken', cb);
+  return () => sub.remove();
+}
+
+// ── video ─────────────────────────────────────────────────────────────
+
+export interface CallVideoViewProps extends ViewProps {
+  /** Remote participant's userId (LiveKit identity). Omit with local=true for self view. */
+  participantId?: string;
+  local?: boolean;
+  /** default: true for local front camera, false otherwise */
+  mirror?: boolean;
+  /** default 'cover' */
+  fit?: 'cover' | 'contain';
+}
+
+type NativeVideoProps = CallVideoViewProps;
+
+let nativeVideo: ComponentType<NativeVideoProps> | null | undefined;
+
+/** Resolved lazily (first render) and only when the native module exists. */
+function nativeVideoView(): ComponentType<NativeVideoProps> | null {
+  if (nativeVideo !== undefined) return nativeVideo;
+  nativeVideo = null;
+  if (native) {
+    try {
+      nativeVideo = requireNativeViewManager<NativeVideoProps>('PoolseCalls', 'PoolseCallVideo');
+    } catch {
+      nativeVideo = null; // an older native build without the view
+    }
+  }
+  return nativeVideo;
+}
+
+/**
+ * A participant's camera (or, with `local`, your own), rendered natively
+ * by the call core. Shows nothing (stays transparent) while that camera
+ * is off — draw the avatar from the snapshot's `cameraOn` underneath.
+ * Without the native module it renders an empty View.
+ */
+export function CallVideoView(props: CallVideoViewProps): ReactElement | null {
+  const Native = nativeVideoView();
+  if (!Native) {
+    const { participantId: _p, local: _l, mirror: _m, fit: _f, ...rest } = props;
+    return createElement(View, rest);
+  }
+  return createElement(Native, props);
+}

package/src/react-shims.d.ts

@@ -0,0 +1,22 @@
+// Minimal ambient declarations for the React / React Native surface this
+// package touches, so it type-checks without either installed in the
+// monorepo (the host app always supplies both). The emitted
+// `dist/index.d.ts` imports the REAL types by module name, so consumers
+// type-check against their own React Native — these shims never ship.
+declare module 'react' {
+  export interface ReactElement {
+    type: unknown;
+    props: unknown;
+    key: string | null;
+  }
+  export type ComponentType<P = object> = (props: P) => ReactElement | null;
+  export function createElement(type: unknown, props?: unknown, ...children: unknown[]): ReactElement;
+}
+
+declare module 'react-native' {
+  export interface ViewProps {
+    style?: unknown;
+    testID?: string;
+  }
+  export const View: unknown;
+}