@ermis-network/ermis-chat-sdk 1.0.0

package/src/media_stream_sender.ts

@@ -0,0 +1,400 @@
+import { base64Encode, createPacketWithHeader } from './utils';
+import { AudioConfig, INodeCall, TransceiverState, VideoConfig } from './types';
+
+export class MediaStreamSender {
+  private videoEncoder: VideoEncoder | null = null;
+  private audioEncoder: AudioEncoder | null = null;
+  private videoReader: ReadableStreamDefaultReader<VideoFrame> | null = null;
+
+  private localStream: MediaStream | null = null;
+
+  private videoConfig: VideoConfig | null = null;
+  private audioConfig: AudioConfig | null = null;
+
+  private videoConfigSent: boolean = false;
+  private audioConfigSent: boolean = false;
+
+  private hasVideo: boolean = false;
+  private hasAudio: boolean = false;
+
+  private forceKeyFrame: boolean = false;
+
+  private nodeCall: INodeCall;
+
+  constructor(nodeCall: INodeCall) {
+    this.nodeCall = nodeCall;
+  }
+
+  /**
+   * Bắt đầu xử lý MediaStream
+   */
+  public async connect(address: string): Promise<void> {
+    try {
+      await this.nodeCall.connect(address);
+      await this.sendConnected();
+      await this.sendConfigs();
+    } catch (error) {
+      console.error('Error starting MediaStreamSender:', error);
+    }
+  }
+
+  public async sendConfigs(): Promise<void> {
+    try {
+      await this.sendTransceiverState(this.hasAudio, this.hasVideo);
+      await this.sendAudioConfig();
+
+      const videoTrack = this.localStream?.getVideoTracks()[0];
+      if (videoTrack) {
+        await this.sendVideoConfig();
+      }
+    } catch (error) {
+      console.error('Error sending configs:', error);
+    }
+  }
+
+  /**
+   * Dừng và reset encoders
+   */
+  public stop = (): void => {
+    if (this.videoReader) {
+      try {
+        this.videoReader.cancel('Stream stopped').catch(() => {});
+      } catch (e) {}
+      this.videoReader = null;
+    }
+
+    if (this.videoEncoder) {
+      try {
+        if (this.videoEncoder.state !== 'closed') {
+          this.videoEncoder.reset(); // Xả frame
+          this.videoEncoder.close();
+        }
+      } catch (e) {}
+      this.videoEncoder = null;
+    }
+
+    // Reset and close audio encoder
+    if (this.audioEncoder) {
+      try {
+        if (this.audioEncoder.state !== 'closed') {
+          this.audioEncoder.reset();
+          this.audioEncoder.close();
+        }
+      } catch (e) {}
+      this.audioEncoder = null;
+    }
+
+    // Reset configs and flags
+    this.videoConfig = null;
+    this.audioConfig = null;
+
+    this.videoConfigSent = false;
+    this.audioConfigSent = false;
+    this.hasVideo = false;
+    this.hasAudio = false;
+
+    if (this.localStream) {
+      this.localStream.getTracks().forEach((track) => track.stop());
+      this.localStream = null;
+    }
+  };
+
+  public initAudioEncoder = (audioTrack: MediaStreamTrack): void => {
+    this.localStream = new MediaStream([audioTrack]);
+    this.audioConfigSent = false;
+    this.hasAudio = !!audioTrack;
+
+    const audioEncoder = new AudioEncoder({
+      output: (chunk, metadata) => {
+        if (metadata?.decoderConfig && !this.audioConfigSent) {
+          let description: string | undefined = undefined;
+          if (metadata.decoderConfig.description) {
+            description = base64Encode(metadata.decoderConfig.description as ArrayBuffer);
+          }
+
+          this.audioConfig = {
+            codec: metadata.decoderConfig.codec ?? 'opus',
+            sampleRate: metadata.decoderConfig.sampleRate ?? 48000,
+            numberOfChannels: metadata.decoderConfig.numberOfChannels ?? 1,
+            ...(description && { description }),
+          };
+        }
+
+        if (chunk && this.isReadyToSendData('audio')) {
+          const data = new ArrayBuffer(chunk.byteLength);
+          chunk.copyTo(data);
+          // const timestamp = Math.floor(chunk.timestamp / 1000);
+          const timestamp = chunk.timestamp;
+
+          const packet = createPacketWithHeader(data, timestamp, 'audio', null);
+          this.sendPacketOrQueue(packet, 'audio', null);
+        }
+      },
+      error: (e) => console.error('AudioEncoder error:', e),
+    });
+
+    audioEncoder.configure({
+      codec: 'mp4a.40.2',
+      sampleRate: 48000,
+      numberOfChannels: 1,
+      bitrate: 128000,
+    });
+
+    this.audioEncoder = audioEncoder;
+    this.processAudioFrames(audioTrack);
+  };
+
+  public initVideoEncoder(videoTrack: MediaStreamTrack): void {
+    if (this.localStream) {
+      this.localStream.addTrack(videoTrack);
+    }
+
+    this.videoConfigSent = false;
+    this.hasVideo = !!videoTrack;
+
+    const settings = videoTrack.getSettings();
+    const videoWidth = settings.width || 1280;
+    const videoHeight = settings.height || 720;
+
+    const videoEncoder = new VideoEncoder({
+      output: async (chunk, metadata) => {
+        if (metadata?.decoderConfig && !this.videoConfigSent) {
+          let description: string | undefined = undefined;
+          if (metadata.decoderConfig.description) {
+            description = base64Encode(metadata.decoderConfig.description as ArrayBuffer);
+          }
+
+          this.videoConfig = {
+            codec: metadata.decoderConfig.codec ?? 'hev1.1.6.L93.B0',
+            codedWidth: metadata.decoderConfig.codedWidth ?? videoWidth,
+            codedHeight: metadata.decoderConfig.codedHeight ?? videoHeight,
+            frameRate: 30.0,
+            orientation: 0,
+            ...(description && { description }),
+          };
+
+          await this.sendVideoConfig();
+        }
+
+        if (chunk && this.isReadyToSendData('video')) {
+          const data = new ArrayBuffer(chunk.byteLength);
+          chunk.copyTo(data);
+          const frameType = chunk.type === 'key' ? 'video-key' : 'video-delta';
+          // const timestamp = Math.floor(chunk.timestamp / 1000);
+          const timestamp = chunk.timestamp;
+
+          const packet = createPacketWithHeader(data, timestamp, frameType, null);
+          this.sendPacketOrQueue(packet, 'video', frameType);
+        }
+      },
+      error: (e) => console.error('VideoEncoder error:', e),
+    });
+
+    videoEncoder.configure({
+      codec: 'hev1.1.6.L93.B0',
+      width: videoWidth,
+      height: videoHeight,
+      bitrate: 500_000,
+      framerate: 30,
+      latencyMode: 'realtime',
+      hardwareAcceleration: 'prefer-hardware',
+    });
+
+    this.videoEncoder = videoEncoder;
+    this.processVideoFrames(videoTrack);
+  }
+
+  public initEncoders = (stream: MediaStream): void => {
+    const videoTrack = stream.getVideoTracks()[0];
+    const audioTrack = stream.getAudioTracks()[0];
+
+    if (audioTrack) {
+      this.initAudioEncoder(audioTrack);
+    }
+
+    if (videoTrack) {
+      this.initVideoEncoder(videoTrack);
+    }
+  };
+
+  public sendTransceiverState = async (audioEnable: boolean, videoEnable: boolean) => {
+    const state: TransceiverState = {
+      audio_enable: !!audioEnable,
+      video_enable: !!videoEnable,
+    };
+    const configPacket = createPacketWithHeader(null, null, 'transciverState', state);
+    await this.nodeCall.sendControlFrame(configPacket);
+  };
+
+  public async replaceVideoTrack(track: MediaStreamTrack): Promise<void> {
+    // 1. Dừng reader của track cũ (quan trọng)
+    if (this.videoReader) {
+      try {
+        // Việc gọi cancel sẽ làm Promise tại dòng await read() bên dưới throw lỗi hoặc trả về done
+        await this.videoReader.cancel('Replacing track');
+      } catch (e) {
+        // Bỏ qua lỗi khi cancel
+      }
+      this.videoReader = null;
+    }
+
+    if (track) {
+      this.processVideoFrames(track);
+    }
+  }
+
+  public async replaceAudioTrack(track: MediaStreamTrack): Promise<void> {
+    if (track) {
+      this.processAudioFrames(track);
+    }
+  }
+
+  /**
+   * Yêu cầu gửi keyframe ngay lập tức (được gọi khi nhận REQUEST_KEY_FRAME từ receiver)
+   */
+  public requestKeyFrame = (): void => {
+    console.log('📥 KeyFrame requested');
+    this.forceKeyFrame = true;
+  };
+
+  // ================= PRIVATE METHODS =================
+
+  private processVideoFrames = async (videoTrack: MediaStreamTrack) => {
+    try {
+      // @ts-ignore: MediaStreamTrackProcessor is explicitly defined in WebCodecs types
+      const videoProcessor = new MediaStreamTrackProcessor({ track: videoTrack });
+      this.videoReader = videoProcessor.readable.getReader();
+
+      let frameCounter = 0;
+      while (true) {
+        if (!this.videoReader) break;
+
+        const { done, value: frame } = await this.videoReader.read();
+        if (done) break;
+
+        if (!this.videoEncoder) {
+          frame?.close();
+          break;
+        }
+
+        if (frame) {
+          frameCounter += 1;
+          const keyFrame = frameCounter % 60 === 0 || this.forceKeyFrame;
+          if (this.forceKeyFrame) {
+            console.log('📤 Sending forced KeyFrame');
+            this.forceKeyFrame = false;
+          }
+          try {
+            this.videoEncoder.encode(frame, { keyFrame });
+          } catch (err) {
+            console.error('Encode error:', err);
+          } finally {
+            frame.close();
+          }
+        }
+      }
+    } catch (error: any) {
+      console.error(`Error processing video frames: ${error.message}`);
+    } finally {
+      if (this.videoReader) {
+        try {
+          this.videoReader.releaseLock();
+        } catch (e) {}
+        // this.videoReader = null;
+      }
+    }
+  };
+
+  private processAudioFrames = async (audioTrack: MediaStreamTrack) => {
+    // @ts-ignore
+    const audioProcessor = new MediaStreamTrackProcessor({ track: audioTrack });
+    const audioReader = audioProcessor.readable.getReader();
+
+    try {
+      while (true) {
+        const { done, value: frame } = await audioReader.read();
+        if (done) break;
+
+        if (!this.audioEncoder) {
+          frame?.close();
+          break;
+        }
+
+        if (frame) {
+          try {
+            this.audioEncoder.encode(frame);
+          } catch (err) {
+            console.error('Audio Encoding error:', err);
+          } finally {
+            frame.close();
+          }
+        }
+      }
+    } catch (error: any) {
+      console.error(`Error processing audio frames: ${error.message}`);
+    }
+  };
+
+  private isReadyToSendData = (type: 'video' | 'audio'): boolean => {
+    const videoReady = !this.hasVideo || this.videoConfigSent;
+    const audioReady = !this.hasAudio || this.audioConfigSent;
+    const allConfigsSent = videoReady && audioReady;
+
+    if (type === 'video') {
+      return allConfigsSent && this.videoConfigSent;
+    } else if (type === 'audio') {
+      return allConfigsSent && this.audioConfigSent;
+    }
+
+    return false;
+  };
+
+  private sendVideoConfig = async () => {
+    if (this.videoConfig && !this.videoConfigSent) {
+      try {
+        const configPacket = createPacketWithHeader(null, null, 'videoConfig', this.videoConfig);
+        await this.nodeCall.sendControlFrame(configPacket);
+        this.videoConfigSent = true;
+      } catch (error) {
+        console.error('Error sending video config:', error);
+      }
+    }
+  };
+
+  private sendAudioConfig = async () => {
+    if (this.audioConfig && !this.audioConfigSent) {
+      try {
+        const configPacket = createPacketWithHeader(null, null, 'audioConfig', this.audioConfig);
+        await this.nodeCall.sendControlFrame(configPacket);
+        this.audioConfigSent = true;
+      } catch (error) {
+        console.error('Error sending audio config:', error);
+      }
+    }
+  };
+
+  public sendConnected = async () => {
+    const configPacket = createPacketWithHeader(null, null, 'connected', null);
+    await this.nodeCall.sendControlFrame(configPacket);
+  };
+
+  private sendPacketOrQueue = async (
+    packet: Uint8Array,
+    type: 'video' | 'audio',
+    frameType: 'video-key' | 'video-delta' | null,
+  ) => {
+    if (!this.isReadyToSendData(type)) {
+      return;
+    }
+
+    if (type === 'audio') {
+      await this.nodeCall.sendAudioFrame(packet);
+    } else if (type === 'video') {
+      if (frameType === 'video-key') {
+        await this.nodeCall.beginWithGop(packet);
+      } else if (frameType === 'video-delta') {
+        await this.nodeCall.sendFrame(packet);
+      }
+    }
+  };
+}

package/src/shims/empty.ts

@@ -0,0 +1 @@
+export default null;

package/src/signal_message.ts

@@ -0,0 +1,96 @@
+/**
+ * Convert duration in seconds to mm:ss format.
+ */
+function formatDuration(durationSec: string): string {
+  const sec = parseInt(durationSec, 10);
+  if (isNaN(sec) || sec < 0) return durationSec;
+  const minutes = Math.floor(sec / 60);
+  const seconds = sec % 60;
+  return `${minutes}:${seconds.toString().padStart(2, '0')}`;
+}
+
+/**
+ * Resolve a user ID to a display name using the provided map.
+ * Falls back to the raw userId if no entry is found.
+ */
+function resolveUser(userId: string, userMap: Record<string, string>): string {
+  return userMap[userId] ?? userId;
+}
+
+/**
+ * Parse a raw signal message string into a human-readable English sentence.
+ *
+ * Signal messages represent call events. The raw format is:
+ * `"<formatId> <userID> [<param1> <param2> ...]"`
+ *
+ * @param value   - Raw signal message string from the server
+ * @param userMap - Mapping of user IDs → display names
+ * @returns         Parsed English text, or the original string if unknown
+ */
+export function parseSignalMessage(
+  value: string,
+  userMap: Record<string, string>,
+): string {
+  if (!value || typeof value !== 'string') return value ?? '';
+
+  const trimmed = value.trim();
+  if (!trimmed) return '';
+
+  const parts = trimmed.split(' ');
+  const formatId = parts[0];
+  const userId = parts[1] ?? '';
+  const userName = userId ? resolveUser(userId, userMap) : 'User';
+
+  switch (formatId) {
+    // 1: Audio call started
+    case '1':
+      return `📞 ${userName} started an audio call.`;
+
+    // 2: Audio call missed
+    case '2':
+      return `📞 Missed audio call from ${userName}.`;
+
+    // 3: Audio call ended (caller_id ender_id duration)
+    case '3': {
+      const enderId = parts[2] ?? '';
+      const duration = parts[3] ?? '0';
+      const enderName = enderId ? resolveUser(enderId, userMap) : 'User';
+      return `📞 Audio call by ${userName}, ended by ${enderName}. Duration: ${formatDuration(duration)}.`;
+    }
+
+    // 4: Video call started
+    case '4':
+      return `📹 ${userName} started a video call.`;
+
+    // 5: Video call missed
+    case '5':
+      return `📹 Missed video call from ${userName}.`;
+
+    // 6: Video call ended (caller_id ender_id duration)
+    case '6': {
+      const enderId = parts[2] ?? '';
+      const duration = parts[3] ?? '0';
+      const enderName = enderId ? resolveUser(enderId, userMap) : 'User';
+      return `📹 Video call by ${userName}, ended by ${enderName}. Duration: ${formatDuration(duration)}.`;
+    }
+
+    // 7: Audio call rejected
+    case '7':
+      return `📞 Audio call from ${userName} was rejected.`;
+
+    // 8: Video call rejected
+    case '8':
+      return `📹 Video call from ${userName} was rejected.`;
+
+    // 9: Audio call busy
+    case '9':
+      return `📞 Audio call from ${userName} — recipient was busy.`;
+
+    // 10: Video call busy
+    case '10':
+      return `📹 Video call from ${userName} — recipient was busy.`;
+
+    default:
+      return trimmed;
+  }
+}

package/src/system_message.ts

@@ -0,0 +1,117 @@
+/**
+ * Duration lookup: milliseconds → human-readable text.
+ */
+const DURATION_MAP: Record<string, string> = {
+  '10000': '10 seconds',
+  '30000': '30 seconds',
+  '60000': '1 minute',
+  '300000': '5 minutes',
+  '900000': '15 minutes',
+  '3600000': '60 minutes',
+};
+
+/**
+ * Resolve a user ID to a display name using the provided map.
+ * Falls back to the raw userId if no entry is found.
+ */
+function resolveUser(userId: string, userMap: Record<string, string>): string {
+  return userMap[userId] ?? userId;
+}
+
+/**
+ * Parse a raw system message string into a human-readable English sentence.
+ *
+ * The raw format is: `"<formatId> <userID> [<param1> <param2> ...]"`
+ *
+ * @param value   - Raw system message string from the server
+ * @param userMap - Mapping of user IDs → display names
+ * @returns         Parsed English text, or the original string if the format is unknown
+ */
+export function parseSystemMessage(
+  value: string,
+  userMap: Record<string, string>,
+): string {
+  if (!value || typeof value !== 'string') return value ?? '';
+
+  const trimmed = value.trim();
+  if (!trimmed) return '';
+
+  const parts = trimmed.split(' ');
+  const formatId = parts[0];
+  const userId = parts[1] ?? '';
+  const userName = userId ? resolveUser(userId, userMap) : 'User';
+
+  switch (formatId) {
+    // 1: userName changed the channel name to channelName (may contain spaces)
+    case '1': {
+      const channelName = parts.slice(2).join(' ');
+      return `${userName} changed the channel name to ${channelName}.`;
+    }
+
+    // 2–13, 16–17: single-user actions
+    case '2':
+      return `${userName} changed the channel avatar.`;
+    case '3':
+      return `${userName} changed the channel description.`;
+    case '4':
+      return `${userName} was removed from the channel.`;
+    case '5':
+      return `${userName} was banned.`;
+    case '6':
+      return `${userName} was unbanned.`;
+    case '7':
+      return `${userName} was promoted to moderator.`;
+    case '8':
+      return `${userName} was demoted from moderator.`;
+    case '9':
+      return `${userName}'s permissions were updated.`;
+    case '10':
+      return `${userName} joined the channel.`;
+    case '11':
+      return `${userName} declined the channel invitation.`;
+    case '12':
+      return `${userName} left the channel.`;
+    case '13':
+      return `${userName} cleared the chat history.`;
+
+    // 14: channel type change (true = public, false = private)
+    case '14': {
+      const rawType = parts[2] ?? '';
+      const channelType = rawType === 'true' ? 'public' : 'private';
+      return `${userName} changed the channel to ${channelType}.`;
+    }
+
+    // 15: cooldown toggle / duration
+    case '15': {
+      const duration = parts[2] ?? '0';
+      if (duration === '0') {
+        return `${userName} disabled cooldown.`;
+      }
+      const durationText = DURATION_MAP[duration] ?? `${duration}ms`;
+      return `${userName} enabled cooldown for ${durationText}.`;
+    }
+
+    case '16':
+      return `${userName} updated the banned words.`;
+    case '17':
+      return `${userName} was added to the channel.`;
+
+    // 18: admin transfer (two user IDs)
+    case '18': {
+      const oldUserId = parts[1] ?? '';
+      const newUserId = parts[2] ?? '';
+      const oldUserName = oldUserId ? resolveUser(oldUserId, userMap) : 'User';
+      const newUserName = newUserId ? resolveUser(newUserId, userMap) : 'User';
+      return `Admin ${oldUserName} left and assigned ${newUserName} as the new admin.`;
+    }
+
+    // 19–20: pin / unpin (userId + msgID)
+    case '19':
+      return `${userName} pinned a message.`;
+    case '20':
+      return `${userName} unpinned a message.`;
+
+    default:
+      return trimmed;
+  }
+}

package/src/token_manager.ts

@@ -0,0 +1,48 @@
+import { ExtendableGenerics, DefaultGenerics, UserResponse } from './types';
+
+/**
+ * TokenManager
+ *
+ * Manages token storage and retrieval for the chat client.
+ */
+export class TokenManager<ErmisChatGenerics extends ExtendableGenerics = DefaultGenerics> {
+  loadTokenPromise: Promise<string> | null;
+  token?: string;
+  user?: UserResponse<ErmisChatGenerics>;
+
+  constructor() {
+    this.loadTokenPromise = null;
+  }
+
+  /**
+   * Set the static string token.
+   */
+  setTokenOrProvider = async (tokenOrProvider: string | null, user: UserResponse<ErmisChatGenerics>) => {
+    this.user = user;
+
+    if (typeof tokenOrProvider === 'string') {
+      this.token = tokenOrProvider;
+    }
+
+    this.loadTokenPromise = Promise.resolve(this.token as string);
+  };
+
+  /**
+   * Resets the token manager.
+   */
+  reset = () => {
+    this.token = undefined;
+    this.user = undefined;
+    this.loadTokenPromise = null;
+  };
+
+  /**
+   * Resolves when token is ready.
+   */
+  tokenReady = () => this.loadTokenPromise;
+
+  /** Returns the current token */
+  getToken = () => {
+    return this.token;
+  };
+}