@voltkit-rtc/react-native 0.1.0 → 0.1.2

package/src/local-media.ts

@@ -307,13 +307,28 @@ async function publishDevices(client: StreamClient, options: LocalPublishOptions
   if (publishing.has(client) || localStream(client)?.getTracks().some((track) => track.readyState === 'live')) {
     throw new RpcError('source-already-published', 'already publishing: unpublish() first');
   }
-  const permissions = client.mediaPermissions;
-  if (audio !== false && !permissions.audio) throw new RpcError('media-disabled', 'audio is switched off for this project');
-  if (video !== false && !permissions.video) throw new RpcError('media-disabled', 'video is switched off for this project');
-  if (!registerVoltkitGlobals()) throw webrtcMissing();
-
   publishing.add(client);
+  // Stop wins over a start still under way (0.1.2): unpublish() -- the user's Stop -- while the permission dialog is up
+  // or the camera is opening says so with localStreamChanged(null). No device opens after it, what opened is released,
+  // nothing is published, and this start rejects with `unpublished`.
+  let stopped = false;
+  const unwatch = client.on('localStreamChanged', (local) => {
+    if (local === null) stopped = true;
+  });
+  const stoppedError = () => new RpcError('unpublished', 'unpublish() ran while the camera and microphone were opening');
   try {
+    let permissions = client.mediaPermissions;
+    if ((audio !== false && !permissions.audio) || (video !== false && !permissions.video)) {
+      // A hint from the join (client 0.9.14): the controller is asked before refusing. Null: it cannot say, and the
+      // client's publish lets it decide.
+      const fresh = await refreshPermissions(client, permissions);
+      permissions = fresh ?? { ...permissions, audio: true, video: true };
+      if (stopped) throw stoppedError();
+    }
+    if (audio !== false && !permissions.audio) throw new RpcError('media-disabled', 'audio is switched off for this project');
+    if (video !== false && !permissions.video) throw new RpcError('media-disabled', 'video is switched off for this project');
+    if (!registerVoltkitGlobals()) throw webrtcMissing();
+
     const kinds: MediaPermissionKind[] = [];
     if (video !== false) kinds.push('camera');
     if (audio !== false) kinds.push('microphone');
@@ -323,27 +338,50 @@ async function publishDevices(client: StreamClient, options: LocalPublishOptions
       if (status !== 'granted') throw permissionRefused(kind, status);
     }
     // The dialog stays up as long as the user thinks: the call may be over by now (the screen unmounted, a kick, the
-    // room closed). Nothing opens a device for a session that is gone.
+    // room closed), or the user tapped Stop. Nothing opens a device then.
+    if (stopped) throw stoppedError();
     if (client.connectionState !== 'connected') throw new RpcError('not-connected', 'the session ended while the permissions were being asked for');
     const constraints = captureConstraints(options, permissions);
     const platform = reactNativePlatform();
     const stream = (await platform.getUserMedia!(constraints)) as unknown as ClientStream;
-    try {
-      // With the constraints, a reconnect that finds the devices gone opens them again.
-      await client.publish(stream, constraints, publishOptions);
-    } catch (error) {
-      // Released here, the stream before its tracks (platform/streams.ts): the client kept none of it.
+    // Released here, the stream before its tracks (platform/streams.ts): the client kept none of it.
+    const release = () => {
       const book = streamBook();
       const tracks = (stream as unknown as StreamLike).getTracks();
       book.release(stream as unknown as StreamLike);
       for (const track of tracks) book.stop(track as TrackLike);
+    };
+    if (stopped) {
+      release();
+      throw stoppedError();
+    }
+    try {
+      // With the constraints, a reconnect that finds the devices gone opens them again.
+      await client.publish(stream, constraints, publishOptions);
+    } catch (error) {
+      release();
       throw error;
     }
   } finally {
+    if (typeof unwatch === 'function') unwatch();
     publishing.delete(client);
   }
 }
 
+/**
+ * The project's permissions as the controller says now (client 0.9.14), or null when it cannot say. A client older
+ * than 0.9.14 cannot ask: its hint stands. A failed question leaves the hint standing too.
+ */
+async function refreshPermissions(client: StreamClient, hint: MediaPermissions): Promise<MediaPermissions | null> {
+  const refresh = (client as { refreshMediaPermissions?: () => Promise<MediaPermissions | null> }).refreshMediaPermissions;
+  if (typeof refresh !== 'function') return hint;
+  try {
+    return await refresh.call(client);
+  } catch {
+    return hint;
+  }
+}
+
 /** Each quality's 16:9 frame, as the SDK sends it. */
 const FRAMES: Record<VideoQuality, { width: number; height: number }> = {
   '1080p': { width: 1920, height: 1080 },

package/src/native-session.tsx

@@ -13,7 +13,7 @@
  *   Failures reach the provider's onError as `media-unavailable` with `{ feature: 'callService' }`.
  */
 import { useEffect, useMemo, useRef, useSyncExternalStore } from 'react';
-import type { StreamClient } from '@voltkit-rtc/client';
+import type { ClientOptions, StreamClient } from '@voltkit-rtc/client';
 import { useVoltkitClient } from '@voltkit-rtc/react';
 import type { CallServiceOptions as NativeCallServiceOptions, CallServiceStatus, Spec } from './specs/NativeVoltkitRtc';
 import { listen, nativeConstants, nativeModule } from './native';
@@ -48,6 +48,7 @@ interface Want {
   micPublished: boolean;
   cameraPublished: boolean;
   sharing: boolean;
+  /** The client switches its camera off in the background, so the service needs no camera type. */
   pauseCamera: boolean;
   text: CallServiceText;
   leave(): void;
@@ -66,10 +67,14 @@ export interface CallServiceState {
 const NOT_DECLARED: CallServiceState = Object.freeze({ declared: false, running: false, types: Object.freeze([]) as unknown as string[] });
 
 class CallServices {
-  /** What each call wants, read afresh at every decision: a call's state is its client's, which emits no event for some changes. */
-  private readonly wants = new Map<object, () => Want>();
+  /**
+   * What each call wants, read afresh at every decision: a call's state is its client's, which emits no event for some
+   * changes. With how to tell the call when its state cannot be read at all.
+   */
+  private readonly wants = new Map<object, { want: () => Want; report: (error: Error) => void }>();
   private running = false;
-  private busy = false;
+  /** The call to the native module under way: a `failed` event during a start or update is its rejection's twin. */
+  private inFlight: 'start' | 'update' | 'stop' | null = null;
   private again = false;
   /** The options the service runs with, as sent. */
   private applied: string | null = null;
@@ -79,8 +84,8 @@ class CallServices {
   private state: CallServiceState | null = null;
   private readonly listeners = new Set<() => void>();
 
-  set(key: object, want: (() => Want) | null): void {
-    if (want) this.wants.set(key, want);
+  set(key: object, want: (() => Want) | null, report: (error: Error) => void = () => undefined): void {
+    if (want) this.wants.set(key, { want, report });
     else this.wants.delete(key);
     this.reconcile();
   }
@@ -120,7 +125,26 @@ class CallServices {
   }
 
   private live(): Want[] {
-    return [...this.wants.values()].map((want) => want()).filter((w) => w.live);
+    const live: Want[] = [];
+    for (const [key, { want, report }] of [...this.wants]) {
+      let w: Want;
+      try {
+        w = want();
+      } catch (err) {
+        // A client whose state cannot be read (a wrapper that throws on a read): this call is left out of the service
+        // for good, said once, and never keeps the other calls from theirs (the verifier's F3 on 0.1.1).
+        this.wants.delete(key);
+        logError('a call is left out of the call service: its client\'s state could not be read', err);
+        try {
+          report(callServiceFailed(`this call is left out, its client's state could not be read: ${describeError(err)}`));
+        } catch (reportErr) {
+          logError('onError threw', reportErr);
+        }
+        continue;
+      }
+      if (w.live) live.push(w);
+    }
+    return live;
   }
 
   private reconcile(): void {
@@ -128,7 +152,7 @@ class CallServices {
     if (!module || !nativeConstants()?.callServiceDeclared) return;
     const live = this.live();
     this.watch(module, live.length > 0 || this.running);
-    if (this.busy) {
+    if (this.inFlight) {
       this.again = true;
       return;
     }
@@ -146,7 +170,7 @@ class CallServices {
   }
 
   private run(module: Spec, what: 'start' | 'update' | 'stop', options: NativeCallServiceOptions | null): void {
-    this.busy = true;
+    this.inFlight = what;
     const key = options ? JSON.stringify(options) : null;
     const call = what === 'stop' ? module.stopCallService() : what === 'start' ? module.startCallService(options!) : module.updateCallService(options!);
     call.then(
@@ -166,7 +190,7 @@ class CallServices {
         for (const want of this.live()) want.report(error);
       },
     ).finally(() => {
-      this.busy = false;
+      this.inFlight = null;
       if (this.again) {
         this.again = false;
         this.reconcile();
@@ -220,6 +244,8 @@ class CallServices {
         for (const want of this.live()) want.leave();
         return;
       case 'failed': {
+        // VoltkitCallService.runWith tells `failed` and then rejects the start or update: the rejection reports it (RN010-2).
+        if (this.inFlight === 'start' || this.inFlight === 'update') return;
         const error = callServiceFailed(message || 'Android refused it');
         for (const want of this.live()) want.report(error);
         return;
@@ -265,7 +291,7 @@ export function useCallService(): CallServiceState {
 export interface NativeSessionProps {
   audio: AudioSessionOptions | false | undefined;
   callService: boolean | CallServiceText | undefined;
-  /** The client's pauseCameraInBackground, as it was made. */
+  /** The provider's background.pauseCamera: for a client whose own options cannot be read (see pausesCameraInBackground). */
   pauseCamera: boolean;
   onError: { readonly current: ((error: Error) => void) | undefined };
 }
@@ -305,7 +331,8 @@ export function NativeSession({ audio, callService, pauseCamera, onError }: Nati
   useEffect(() => {
     if (!client || !wantsService || !nativeModule()) return;
     const key = {};
-    callServices.set(key, () => wantOf(client, latest.current, (error) => onError.current?.(error)));
+    const report = (error: Error) => onError.current?.(error);
+    callServices.set(key, () => wantOf(client, latest.current, report), report);
     const update = () => callServices.changed();
     // publish() and a camera switch emit no event of their own: useLocalMedia's calls say so through the local session.
     const offs = [
@@ -330,9 +357,28 @@ function wantOf(client: StreamClient, latest: { text: CallServiceText; pauseCame
     micPublished: (local?.getAudioTracks().length ?? 0) > 0,
     cameraPublished: (local?.getVideoTracks().length ?? 0) > 0,
     sharing: localSessionOf(client).screen !== null,
-    pauseCamera: latest.pauseCamera,
+    pauseCamera: pausesCameraInBackground(client) ?? latest.pauseCamera,
     text: latest.text,
     leave: () => client.close(),
     report,
   };
 }
+
+/**
+ * Whether the client switches its camera off in the background, from its own options: the provider's `background` only
+ * describes a client the provider made, and an app-made one (`createClient`, the `client` prop) keeps its camera on with
+ * `pauseCamera: false` while the service was asked for no camera type, so Android cut the camera (RN010-1). The client
+ * pauses only with `pauseCameraInBackground === true` (left out, the camera runs on). Null when the options cannot be
+ * read (missing, not an object, or a read that throws: a wrapped or stubbed client): the provider's setting stands in.
+ */
+function pausesCameraInBackground(client: StreamClient): boolean | null {
+  let options: unknown;
+  try {
+    options = (client as unknown as { options?: unknown }).options;
+  } catch {
+    // A wrapper that forbids the read (a logging or sealing Proxy): not an error, the provider's setting stands in.
+    return null;
+  }
+  if (!options || typeof options !== 'object') return null;
+  return (options as ClientOptions).pauseCameraInBackground === true;
+}

package/src/native.ts

@@ -10,7 +10,7 @@ import { iosUnsupported, logError, nativeMissing } from './errors';
 import type { AudioDeviceType, DeviceKind, MediaDevice } from '@voltkit-rtc/client';
 
 /** The version of this package: what getDiagnostics() reports, and what the native side was built from. */
-export const SDK_VERSION = '0.1.0';
+export const SDK_VERSION = '0.1.2';
 
 /** The native module, or null where there is none (iOS, Expo Go, an app not rebuilt). */
 export function nativeModule(): Spec | null {

package/src/platform/common.ts

@@ -89,7 +89,7 @@ export function localStream(client: { readonly local: unknown }): MediaStreamLik
   return (client.local as MediaStreamLike | null | undefined) ?? null;
 }
 
-/** getDiagnostics().userAgent: `ReactNative android 37; react-native-webrtc 155.0.1; @voltkit-rtc/react-native 0.1.0`. */
+/** getDiagnostics().userAgent: `ReactNative android 37; react-native-webrtc 155.0.1; @voltkit-rtc/react-native 0.1.2`. */
 export function describePlatform(): string {
   return `ReactNative ${Platform.OS} ${String(Platform.Version)}; react-native-webrtc ${webrtcVersion() ?? 'unknown'}; @voltkit-rtc/react-native ${SDK_VERSION}`;
 }

package/src/provider.tsx

@@ -68,7 +68,9 @@ export function VoltkitProvider({
     // eslint-disable-next-line react-hooks/exhaustive-deps
     [webrtc, wsUrl, token],
   );
-  const pauseCamera = options?.pauseCameraInBackground !== false;
+  // The call service reads the setting from the client it runs for (an app-made client has its own); this stands in
+  // when the client's options cannot be read.
+  const pauseCamera = options?.pauseCameraInBackground === true;
 
   return (
     <ReactVoltkitProvider