@voltkit-rtc/react-native 0.1.1 → 0.1.3

package/src/local-media.ts

@@ -293,8 +293,13 @@ function localActions(client: StreamClient | null): LocalActions {
 
 // ----------------------------------------------------------------------------------------------------- publish
 
-/** Clients with a publish() between asking for permissions and publishing. */
-const publishing = new WeakSet<StreamClient>();
+/** The publish() between asking for the permissions and publishing, per client: the one start under way. */
+const publishing = new WeakMap<StreamClient, object>();
+
+const mayPublish = (client: StreamClient): boolean => {
+  const role = client.info?.role;
+  return role === 'host' || role === 'cohost';
+};
 
 async function publishDevices(client: StreamClient, options: LocalPublishOptions): Promise<void> {
   // facingMode is a capture choice, not a publish option.
@@ -302,45 +307,112 @@ async function publishDevices(client: StreamClient, options: LocalPublishOptions
   if (audio === false && video === false) throw new TypeError('publish: ask for audio, video or both');
   // Everything that would refuse the publish is checked before a permission is asked for or a device opens.
   if (client.connectionState !== 'connected') throw new RpcError('not-connected', 'connect before publishing');
-  const role = client.info?.role;
-  if (role !== 'host' && role !== 'cohost') throw new RpcError('forbidden', 'only hosts and cohosts can publish');
-  if (publishing.has(client) || localStream(client)?.getTracks().some((track) => track.readyState === 'live')) {
+  if (!mayPublish(client)) throw new RpcError('forbidden', 'only hosts and cohosts can publish');
+  // What is on air goes on as it is, and only the rest is asked for and opened (0.1.3, decision D2): a retry after the
+  // server took the microphone and refused the camera sends the camera alone. Everything asked for on air already, or
+  // a start under way: unpublish first.
+  const onAir = (kind: 'audio' | 'video') => localStream(client)?.getTracks().some((track) => track.kind === kind && track.readyState === 'live') ?? false;
+  const wantAudio = audio !== false && !onAir('audio');
+  const wantVideo = video !== false && !onAir('video');
+  if (publishing.has(client) || (!wantAudio && !wantVideo)) {
     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);
+  const start = {};
+  publishing.set(client, start);
+  const ended = () => {
+    if (publishing.get(client) === start) publishing.delete(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`. It is over from that moment: a Go live right
+  // after the Stop is the user's last word and its own start, not this one's double tap (RN012-3).
+  let stopped = false;
+  const unwatch = client.on('localStreamChanged', (local) => {
+    if (local !== null) return;
+    stopped = true;
+    ended();
+  });
+  const stoppedError = () => new RpcError('unpublished', 'unpublish() ran while the camera and microphone were opening');
+  const demotedError = () => new RpcError('forbidden', 'the role changed while the camera and microphone were opening: only hosts and cohosts can publish');
   try {
+    let permissions = client.mediaPermissions;
+    if ((wantAudio && !permissions.audio) || (wantVideo && !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 (wantAudio && !permissions.audio) throw new RpcError('media-disabled', 'audio is switched off for this project');
+    if (wantVideo && !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');
+    if (wantVideo) kinds.push('camera');
+    if (wantAudio) kinds.push('microphone');
     const statuses = await requestMediaPermissions(kinds);
     for (const kind of kinds) {
       const status = statuses[kind];
       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), the user tapped Stop, or a demotion came (RN012-2: a viewer's camera light never comes on). 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);
+    if (!mayPublish(client)) throw demotedError();
+    const constraints = captureConstraints({ ...options, audio: wantAudio ? audio : false, video: wantVideo ? video : false }, 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), while 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();
+    }
+    // Demoted while the devices were opening: closed again at once, nothing is published.
+    if (!mayPublish(client)) {
+      release();
+      throw demotedError();
+    }
+    try {
+      // With the constraints, a reconnect that finds the devices gone opens them again.
+      await client.publish(stream, constraints, publishOptions);
+    } catch (error) {
+      // Only what the client let go of. A microphone it kept on air (the server took it, then refused the camera)
+      // stays live, in a stream the client holds now: stopped here, it stayed on air as a dead track with micEnabled
+      // saying true (the R012-2 class), and the stream is never released under a track the client keeps. By kind:
+      // behind a video processor `local` holds the picture, not the camera.
+      const kept = localStream(client)?.getTracks().filter((track) => track.readyState === 'live').map((track) => track.kind) ?? [];
+      if (kept.length === 0) release();
+      else {
+        const book = streamBook();
+        for (const track of (stream as unknown as StreamLike).getTracks()) if (!kept.includes(track.kind)) book.stop(track);
+      }
       throw error;
     }
   } finally {
-    publishing.delete(client);
+    if (typeof unwatch === 'function') unwatch();
+    ended();
+  }
+}
+
+/**
+ * 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;
   }
 }
 

package/src/native-session.tsx

@@ -83,11 +83,35 @@ class CallServices {
   private watching: (() => void) | null = null;
   private state: CallServiceState | null = null;
   private readonly listeners = new Set<() => void>();
+  /** A call gone: decided after this turn of the JavaScript thread (see `set`). */
+  private settling: Promise<void> | null = null;
 
   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();
+    if (want) {
+      this.wants.set(key, { want, report });
+      this.reconcile();
+      return;
+    }
+    this.wants.delete(key);
+    // React replaces a screen's provider by another's in one commit: the old effect's cleanup first, the new effect
+    // right after. Decided at once, the stop would be on its way to Android when the new provider registers the same
+    // live client, and the service would bounce (RN012-1); in the background, where Android lets it stop but not start
+    // again, the call would then be cut. So a call gone is decided once the turn is over.
+    this.settling ??= Promise.resolve().then(() => {
+      this.settling = null;
+      this.reconcile();
+    });
+  }
+
+  /** Each live call told in turn: an app's listener that throws (RN012-5) or a close that throws never silences the next call. */
+  private each(wants: Want[], tell: (want: Want) => void, context: string): void {
+    for (const want of wants) {
+      try {
+        tell(want);
+      } catch (err) {
+        logError(context, err);
+      }
+    }
   }
 
   /** Something a call publishes may have changed: decide again. */
@@ -172,7 +196,8 @@ class CallServices {
   private run(module: Spec, what: 'start' | 'update' | 'stop', options: NativeCallServiceOptions | null): void {
     this.inFlight = what;
     const key = options ? JSON.stringify(options) : null;
-    const call = what === 'stop' ? module.stopCallService() : what === 'start' ? module.startCallService(options!) : module.updateCallService(options!);
+    // Called now; a module that throws instead of rejecting (its bridge gone) is a rejection all the same.
+    const call = (async () => (what === 'stop' ? module.stopCallService() : what === 'start' ? module.startCallService(options!) : module.updateCallService(options!)))();
     call.then(
       (status) => {
         this.running = status.running;
@@ -187,7 +212,7 @@ class CallServices {
         }
         this.failed = key;
         const error = callServiceFailed(describeError(err));
-        for (const want of this.live()) want.report(error);
+        this.each(this.live(), (want) => want.report(error), 'onError threw');
       },
     ).finally(() => {
       this.inFlight = null;
@@ -232,22 +257,26 @@ class CallServices {
         this.publish({ running: true, types: [...types] });
         return;
       case 'stopped':
+        // The service's real state, whatever stopped it: a stop of ours, asked when no call was live and run by Android
+        // later, when a call may be live again (a screen's provider replaced by another holding the same client,
+        // RN012-1), or something outside (an app's own stopService). The calls decide again: a live call gets it back
+        // now while the app is visible, as after a join; in the background it waits for the front, as every start does.
+        // Until 0.1.2 a live call here was held as a failure until the next front, and the first background stay would
+        // have cut the call.
         this.running = false;
         this.applied = null;
-        // Stopped from outside while a call is live: started again when the app next comes to the front, not now.
-        if (this.live().length > 0) this.failed = JSON.stringify(merged(this.live()));
         this.publish({ running: false, types: [] });
         this.reconcile();
         return;
       case 'leave':
       case 'taskRemoved':
-        for (const want of this.live()) want.leave();
+        this.each(this.live(), (want) => want.leave(), 'a call could not be closed');
         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);
+        this.each(this.live(), (want) => want.report(error), 'onError threw');
         return;
       }
       default:

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.1';
+export const SDK_VERSION = '0.1.3';
 
 /** 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.1`. */
+/** getDiagnostics().userAgent: `ReactNative android 37; react-native-webrtc 155.0.1; @voltkit-rtc/react-native 0.1.3`. */
 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

@@ -56,8 +56,16 @@ export function VoltkitProvider({
   });
 
   const wanted = Boolean(client || (wsUrl && token));
+  // Said once per ask: StrictMode runs an effect twice on mount (development only), and onError heard
+  // webrtc-missing twice (RN012-4). Asked for a client anew (a new token after none), it is said again.
+  const said = useRef(false);
   useEffect(() => {
-    if (!wanted) return;
+    if (!wanted) {
+      said.current = false;
+      return;
+    }
+    if (said.current) return;
+    said.current = true;
     if (!webrtc) errors.current?.(webrtcMissing());
     else if (Platform.OS === 'android' && !nativeModule()) errors.current?.(nativeMissing('Background calls, audio routing and native timers'));
   }, [webrtc, wanted]);