werift 0.20.0 → 0.21.0

package/src/transport/dtls.ts

@@ -1,8 +1,8 @@
 import { Certificate, PrivateKey } from "@fidm/x509";
 import debug from "debug";
-import Event from "rx.mini";
 import { setTimeout } from "timers/promises";
 import { v4 } from "uuid";
+import { Event } from "../imports/common";
 
 import {
   DtlsClient,
@@ -18,7 +18,7 @@ import {
 } from "../../../dtls/src/cipher/const";
 import { CipherContext } from "../../../dtls/src/context/cipher";
 import type { Profile } from "../../../dtls/src/context/srtp";
-import type { Connection } from "../../../ice/src";
+import type { IceConnection } from "../../../ice/src";
 import {
   type RtcpPacket,
   RtcpPacketConverter,
@@ -51,18 +51,18 @@ export class RTCDtlsTransport {
 
   readonly onStateChange = new Event<[DtlsState]>();
 
-  localCertificate?: RTCCertificate;
-  localCertificatePromise?: Promise<RTCCertificate>;
+  static localCertificate?: RTCCertificate;
+  static localCertificatePromise?: Promise<RTCCertificate>;
   private remoteParameters?: RTCDtlsParameters;
 
   constructor(
     readonly config: PeerConfig,
     readonly iceTransport: RTCIceTransport,
     readonly router: RtpRouter,
-    readonly certificates: RTCCertificate[],
+    public localCertificate?: RTCCertificate,
     private readonly srtpProfiles: Profile[] = [],
   ) {
-    this.localCertificate = this.certificates[0];
+    this.localCertificate ??= RTCDtlsTransport.localCertificate;
   }
 
   get localParameters() {
@@ -72,7 +72,7 @@ export class RTCDtlsTransport {
     );
   }
 
-  async setupCertificate() {
+  static async SetupCertificate() {
     if (this.localCertificate) {
       return this.localCertificate;
     }
@@ -106,8 +106,12 @@ export class RTCDtlsTransport {
   }
 
   async start() {
-    if (this.state !== "new") throw new Error();
-    if (this.remoteParameters?.fingerprints.length === 0) throw new Error();
+    if (this.state !== "new") {
+      throw new Error("state must be new");
+    }
+    if (this.remoteParameters?.fingerprints.length === 0) {
+      throw new Error("remote fingerprint not exist");
+    }
 
     if (this.role === "auto") {
       if (this.iceTransport.role === "controlling") {
@@ -119,7 +123,7 @@ export class RTCDtlsTransport {
 
     this.setState("connecting");
 
-    await new Promise<void>(async (r) => {
+    await new Promise<void>(async (r, f) => {
       if (this.role === "server") {
         this.dtls = new DtlsServer({
           cert: this.localCertificate?.certPem,
@@ -153,9 +157,10 @@ export class RTCDtlsTransport {
         this.setState("closed");
       });
       this.dtls.onConnect.once(r);
-      this.dtls.onError.subscribe((error) => {
+      this.dtls.onError.once((error) => {
         this.setState("failed");
         log("dtls failed", error);
+        f(error);
       });
 
       if (this.dtls instanceof DtlsClient) {
@@ -163,6 +168,7 @@ export class RTCDtlsTransport {
         this.dtls.connect().catch((error) => {
           this.setState("failed");
           log("dtls connect failed", error);
+          f(error);
         });
       }
     });
@@ -354,10 +360,12 @@ export class RTCDtlsParameters {
 }
 
 class IceTransport implements Transport {
-  constructor(private ice: Connection) {
+  constructor(private ice: IceConnection) {
     ice.onData.subscribe((buf) => {
       if (isDtls(buf)) {
-        if (this.onData) this.onData(buf);
+        if (this.onData) {
+          this.onData(buf);
+        }
       }
     });
   }
@@ -372,4 +380,4 @@ class IceTransport implements Transport {
   }
 }
 
-const createIceTransport = (ice: Connection) => new IceTransport(ice);
+const createIceTransport = (ice: IceConnection) => new IceTransport(ice);

package/src/transport/ice.ts

@@ -1,30 +1,36 @@
 import debug from "debug";
-import Event from "rx.mini";
 import { v4 } from "uuid";
-
-import { Candidate, Connection, type IceOptions } from "../../../ice/src";
+import { Event } from "../imports/common";
+
+import {
+  Candidate,
+  Connection,
+  type IceConnection,
+  type IceOptions,
+} from "../../../ice/src";
 import { candidateFromSdp, candidateToSdp } from "../sdp";
 
 const log = debug("werift:packages/webrtc/src/transport/ice.ts");
 
 export class RTCIceTransport {
   readonly id = v4();
-  connection: Connection;
+  connection: IceConnection;
   state: RTCIceConnectionState = "new";
+  private waitStart?: Event<[]>;
+  private renominating = false;
 
   readonly onStateChange = new Event<[RTCIceConnectionState]>();
+  readonly onIceCandidate = new Event<[IceCandidate | undefined]>();
+  readonly onNegotiationNeeded = new Event<[]>();
 
-  private waitStart?: Event<[]>;
-
-  constructor(private gather: RTCIceGatherer) {
-    this.connection = this.gather.connection;
+  constructor(private iceGather: RTCIceGatherer) {
+    this.connection = this.iceGather.connection;
     this.connection.stateChanged.subscribe((state) => {
       this.setState(state);
     });
-  }
-
-  get iceGather() {
-    return this.gather;
+    this.iceGather.onIceCandidate = (candidate) => {
+      this.onIceCandidate.execute(candidate);
+    };
   }
 
   get role() {
@@ -32,21 +38,30 @@ export class RTCIceTransport {
     else return "controlled";
   }
 
+  get gatheringState() {
+    return this.iceGather.gatheringState;
+  }
+
+  get localCandidates() {
+    return this.iceGather.localCandidates;
+  }
+
+  get localParameters() {
+    return this.iceGather.localParameters;
+  }
+
   private setState(state: RTCIceConnectionState) {
     if (state !== this.state) {
       this.state = state;
 
-      if (this.onStateChange.ended) return;
-
-      if (state === "closed") {
-        this.onStateChange.execute(state);
-        this.onStateChange.complete();
-      } else {
-        this.onStateChange.execute(state);
-      }
+      this.onStateChange.execute(state);
     }
   }
 
+  gather() {
+    return this.iceGather.gather();
+  }
+
   addRemoteCandidate = (candidate?: IceCandidate) => {
     if (!this.connection.remoteCandidatesEnd) {
       if (!candidate) {
@@ -57,25 +72,47 @@ export class RTCIceTransport {
     }
   };
 
-  setRemoteParams(remoteParameters: RTCIceParameters) {
+  setRemoteParams(remoteParameters: RTCIceParameters, renomination = false) {
+    if (renomination) {
+      this.renominating = true;
+    }
     if (
       this.connection.remoteUsername &&
       this.connection.remotePassword &&
       (this.connection.remoteUsername !== remoteParameters.usernameFragment ||
         this.connection.remotePassword !== remoteParameters.password)
     ) {
-      log("restartIce", remoteParameters);
-      this.connection.resetNominatedPair();
+      if (this.renominating) {
+        log("renomination", remoteParameters);
+        this.connection.resetNominatedPair();
+        this.renominating = false;
+      } else {
+        log("restart", remoteParameters);
+        this.restart();
+      }
     }
     this.connection.setRemoteParams(remoteParameters);
   }
 
+  restart() {
+    this.connection.restart();
+    this.setState("new");
+    this.iceGather.gatheringState = "new";
+    this.waitStart = undefined;
+    this.onNegotiationNeeded.execute();
+  }
+
   async start() {
-    if (this.state === "closed") throw new Error("RTCIceTransport is closed");
-    if (!this.connection.remotePassword || !this.connection.remoteUsername)
+    if (this.state === "closed") {
+      throw new Error("RTCIceTransport is closed");
+    }
+    if (!this.connection.remotePassword || !this.connection.remoteUsername) {
       throw new Error("remoteParams missing");
+    }
 
-    if (this.waitStart) await this.waitStart.asPromise();
+    if (this.waitStart) {
+      await this.waitStart.asPromise();
+    }
     this.waitStart = new Event();
 
     this.setState("checking");
@@ -87,7 +124,9 @@ export class RTCIceTransport {
       throw error;
     }
 
+    this.waitStart.execute();
     this.waitStart.complete();
+    this.waitStart = undefined;
   }
 
   async stop() {
@@ -95,6 +134,9 @@ export class RTCIceTransport {
       this.setState("closed");
       await this.connection.close();
     }
+    this.onStateChange.complete();
+    this.onIceCandidate.complete();
+    this.onNegotiationNeeded.complete();
   }
 }
 
@@ -115,20 +157,21 @@ export type IceGathererState = (typeof IceGathererStates)[number];
 export class RTCIceGatherer {
   onIceCandidate: (candidate: IceCandidate | undefined) => void = () => {};
   gatheringState: IceGathererState = "new";
+  readonly connection: IceConnection;
 
   readonly onGatheringStateChange = new Event<[IceGathererState]>();
-  readonly connection: Connection;
 
   constructor(private options: Partial<IceOptions> = {}) {
     this.connection = new Connection(false, this.options);
+    this.connection.onIceCandidate.subscribe((candidate) => {
+      this.onIceCandidate(candidateFromIce(candidate));
+    });
   }
 
   async gather() {
     if (this.gatheringState === "new") {
       this.setState("gathering");
-      await this.connection.gatherCandidates((candidate) => {
-        this.onIceCandidate(candidateFromIce(candidate));
-      });
+      await this.connection.gatherCandidates();
       this.onIceCandidate(undefined);
       this.setState("complete");
     }
@@ -140,7 +183,7 @@ export class RTCIceGatherer {
 
   get localParameters() {
     const params = new RTCIceParameters({
-      usernameFragment: this.connection.localUserName,
+      usernameFragment: this.connection.localUsername,
       password: this.connection.localPassword,
     });
 
@@ -164,6 +207,8 @@ export function candidateFromIce(c: Candidate) {
     c.priority,
     c.transport,
     c.type,
+    c.generation,
+    c.ufrag,
   );
   candidate.relatedAddress = c.relatedAddress;
   candidate.relatedPort = c.relatedPort;
@@ -183,6 +228,8 @@ export function candidateToIce(x: IceCandidate) {
     x.relatedAddress,
     x.relatedPort,
     x.tcpType,
+    x.generation,
+    x.ufrag,
   );
 }
 
@@ -190,6 +237,7 @@ export class RTCIceCandidate {
   candidate!: string;
   sdpMid?: string;
   sdpMLineIndex?: number;
+  usernameFragment?: string;
 
   constructor(props: Partial<RTCIceCandidate>) {
     Object.assign(this, props);
@@ -204,6 +252,7 @@ export class RTCIceCandidate {
       candidate: this.candidate,
       sdpMid: this.sdpMid,
       sdpMLineIndex: this.sdpMLineIndex,
+      usernameFragment: this.usernameFragment,
     };
   }
 }
@@ -228,6 +277,8 @@ export class IceCandidate {
     public priority: number,
     public protocol: string,
     public type: string,
+    public generation?: number,
+    public ufrag?: string,
   ) {}
 
   toJSON(): RTCIceCandidate {
@@ -235,6 +286,7 @@ export class IceCandidate {
       candidate: candidateToSdp(this),
       sdpMLineIndex: this.sdpMLineIndex,
       sdpMid: this.sdpMid,
+      usernameFragment: this.ufrag,
     });
   }
 

package/src/transport/sctp.ts

@@ -1,7 +1,7 @@
 import { jspack } from "@shinyoshiaki/jspack";
 import debug from "debug";
-import { Event } from "rx.mini";
 import * as uuid from "uuid";
+import { Event } from "../imports/common";
 
 import { SCTP, SCTP_STATE, type Transport } from "../../../sctp/src";
 import {