tirtc-react-native 2.2.0

package/src/audio_output.ts

@@ -0,0 +1,202 @@
+import {
+  isFiniteSafeInteger,
+  isPositiveInt32,
+  isUInt8,
+  normalizeCreateResult,
+  returnReleasedIfDisposed,
+  TIRTC_ERROR_INVALID_ARGUMENT,
+  TIRTC_ERROR_OK,
+} from './errors';
+import {registerNativeEventHandler, unregisterNativeEventHandler} from './events';
+import {readNativeIdentity, clearNativeIdentity, setNativeIdentity, type NativeIdentity} from './native_object_id';
+import {NativeTiRtc, type NativeTiRtcEvent} from './native';
+import {TiRtcConn} from './conn';
+import type {
+  TiRtcAudioOutputDebugSnapshotResult,
+  TiRtcAudioOutputMetricsResult,
+  TiRtcAudioOutputOptions,
+  TiRtcAudioOutputState,
+  TiRtcOnAudioOutputError,
+  TiRtcOnAudioOutputStateChanged,
+} from './types';
+
+export class TiRtcAudioOutput {
+  private identity: NativeIdentity | null = null;
+  private disposed = false;
+  private createCode: number = TIRTC_ERROR_OK;
+  private currentState: TiRtcAudioOutputState = 'idle';
+  private options: Required<Omit<TiRtcAudioOutputOptions, 'maxBufferWatermarkMs'>> &
+    Pick<TiRtcAudioOutputOptions, 'maxBufferWatermarkMs'> = {
+      agcLevel: 'disabled',
+      ansLevel: 'disabled',
+      bufferStrategy: 'automatic',
+      maxBufferWatermarkMs: undefined,
+    };
+
+  onStateChanged: TiRtcOnAudioOutputStateChanged | null = null;
+  onError: TiRtcOnAudioOutputError | null = null;
+
+  constructor() {
+    const result = normalizeCreateResult(NativeTiRtc.createAudioOutput());
+    this.createCode = result.code;
+    if (result.code === TIRTC_ERROR_OK) {
+      this.adoptIdentity({objectId: result.objectId, generation: result.generation});
+    }
+  }
+
+  get state(): TiRtcAudioOutputState {
+    if (this.identity !== null && !this.disposed) {
+      const result = NativeTiRtc.audioOutputGetState(this.identity.objectId);
+      if (result.state !== null) {
+        this.currentState = result.state as TiRtcAudioOutputState;
+      }
+    }
+    return this.currentState;
+  }
+
+  configure(options: TiRtcAudioOutputOptions): number {
+    const normalized = {
+      agcLevel: options.agcLevel ?? 'disabled',
+      ansLevel: options.ansLevel ?? 'disabled',
+      bufferStrategy: options.bufferStrategy ?? 'automatic',
+      maxBufferWatermarkMs: options.maxBufferWatermarkMs,
+    };
+    if (
+      normalized.maxBufferWatermarkMs !== undefined
+      && !isPositiveInt32(normalized.maxBufferWatermarkMs)
+    ) {
+      return TIRTC_ERROR_INVALID_ARGUMENT;
+    }
+    const identity = this.ensureIdentity();
+    if (typeof identity === 'number') {
+      return identity;
+    }
+    const code = NativeTiRtc.audioOutputConfigure(identity.objectId, {
+      ...normalized,
+      maxBufferWatermarkMs: normalized.maxBufferWatermarkMs ?? null,
+    });
+    if (code === TIRTC_ERROR_OK) {
+      this.options = normalized;
+    }
+    return code;
+  }
+
+  attach(connection: TiRtcConn, streamId: number): number {
+    const connIdentity = readNativeIdentity(connection);
+    if (!isUInt8(streamId)) {
+      return TIRTC_ERROR_INVALID_ARGUMENT;
+    }
+    if (connIdentity === null) {
+      return TIRTC_ERROR_INVALID_ARGUMENT;
+    }
+    const identity = this.ensureIdentity();
+    if (typeof identity === 'number') {
+      return identity;
+    }
+    return NativeTiRtc.audioOutputAttach(identity.objectId, connIdentity.objectId, streamId);
+  }
+
+  detach(): number {
+    const released = returnReleasedIfDisposed(this.disposed);
+    if (released !== null) {
+      return released;
+    }
+    return this.identity === null ? TIRTC_ERROR_OK : NativeTiRtc.audioOutputDetach(this.identity.objectId);
+  }
+
+  setVolume(volumePercent: number): number {
+    if (!isFiniteSafeInteger(volumePercent) || volumePercent < 0 || volumePercent > 100) {
+      return TIRTC_ERROR_INVALID_ARGUMENT;
+    }
+    const identity = this.ensureIdentity();
+    if (typeof identity === 'number') {
+      return identity;
+    }
+    return NativeTiRtc.audioOutputSetVolume(identity.objectId, volumePercent);
+  }
+
+  getMetricsSnapshot(): TiRtcAudioOutputMetricsResult {
+    const identity = this.ensureIdentity();
+    if (typeof identity === 'number') {
+      return {code: identity, snapshot: null};
+    }
+    return NativeTiRtc.audioOutputGetMetricsSnapshot(identity.objectId);
+  }
+
+  resetMetricsSession(): number {
+    const identity = this.ensureIdentity();
+    if (typeof identity === 'number') {
+      return identity;
+    }
+    return NativeTiRtc.audioOutputResetMetricsSession(identity.objectId);
+  }
+
+  getDebugSnapshot(): TiRtcAudioOutputDebugSnapshotResult {
+    const identity = this.ensureIdentity();
+    if (typeof identity === 'number') {
+      return {code: identity, snapshot: null};
+    }
+    return NativeTiRtc.audioOutputGetDebugSnapshot(identity.objectId);
+  }
+
+  dispose(): number {
+    if (this.disposed) {
+      return TIRTC_ERROR_OK;
+    }
+    if (this.identity === null) {
+      this.disposed = true;
+      this.clearCallbacks();
+      this.currentState = 'idle';
+      return TIRTC_ERROR_OK;
+    }
+    const identity = this.identity;
+    const code = NativeTiRtc.audioOutputDispose(identity.objectId);
+    if (code === TIRTC_ERROR_OK) {
+      this.disposed = true;
+      this.identity = null;
+      unregisterNativeEventHandler(identity);
+      clearNativeIdentity(this);
+      this.clearCallbacks();
+      this.currentState = 'idle';
+    }
+    return code;
+  }
+
+  private ensureIdentity(): NativeIdentity | number {
+    const released = returnReleasedIfDisposed(this.disposed);
+    if (released !== null) {
+      return released;
+    }
+    if (this.identity !== null) {
+      return this.identity;
+    }
+    return this.createCode;
+  }
+
+  private adoptIdentity(identity: NativeIdentity): void {
+    this.identity = identity;
+    setNativeIdentity(this, identity);
+    registerNativeEventHandler(identity, (event) => this.handleEvent(event));
+    NativeTiRtc.audioOutputConfigure(identity.objectId, {
+      ...this.options,
+      maxBufferWatermarkMs: this.options.maxBufferWatermarkMs ?? null,
+    });
+  }
+
+  private clearCallbacks(): void {
+    this.onStateChanged = null;
+    this.onError = null;
+  }
+
+  private handleEvent(event: NativeTiRtcEvent): void {
+    if (this.disposed) {
+      return;
+    }
+    if (event.type === 'audioOutputStateChanged' && event.state !== undefined) {
+      this.currentState = event.state as TiRtcAudioOutputState;
+      this.onStateChanged?.(this.currentState);
+    } else if (event.type === 'audioOutputError') {
+      this.onError?.(event.code ?? TIRTC_ERROR_INVALID_ARGUMENT);
+    }
+  }
+}

package/src/conn.ts

@@ -0,0 +1,222 @@
+import {
+  fromNativeBytes,
+  isUInt8,
+  isUInt32,
+  normalizeCreateResult,
+  returnReleasedIfDisposed,
+  TIRTC_ERROR_INVALID_ARGUMENT,
+  TIRTC_ERROR_OK,
+} from './errors';
+import {registerNativeEventHandler, unregisterNativeEventHandler} from './events';
+import {clearNativeIdentity, setNativeIdentity, type NativeIdentity} from './native_object_id';
+import {NativeTiRtc, type NativeTiRtcEvent} from './native';
+import {toNativeBytes} from './errors';
+import type {
+  TiRtcConnMetricsResult,
+  TiRtcConnState,
+  TiRtcOnConnCommand,
+  TiRtcOnConnStateChanged,
+  TiRtcOnConnStreamMessage,
+} from './types';
+
+export class TiRtcConn {
+  private identity: NativeIdentity | null = null;
+  private disposed = false;
+  private createCode: number = TIRTC_ERROR_OK;
+  private currentState: TiRtcConnState = 'idle';
+
+  constructor() {
+    const result = normalizeCreateResult(NativeTiRtc.createConn());
+    this.createCode = result.code;
+    if (result.code === TIRTC_ERROR_OK) {
+      this.adoptIdentity({objectId: result.objectId, generation: result.generation});
+    }
+  }
+
+  onStateChanged: TiRtcOnConnStateChanged | null = null;
+  onCommand: TiRtcOnConnCommand | null = null;
+  onStreamMessage: TiRtcOnConnStreamMessage | null = null;
+
+  get state(): TiRtcConnState {
+    if (this.identity !== null && !this.disposed) {
+      const result = NativeTiRtc.connGetState(this.identity.objectId);
+      if (result.state !== null) {
+        this.currentState = result.state as TiRtcConnState;
+      }
+    }
+    return this.currentState;
+  }
+
+  connect(remoteId: string, token: string): number {
+    if (typeof remoteId !== 'string' || typeof token !== 'string') {
+      return TIRTC_ERROR_INVALID_ARGUMENT;
+    }
+    const identity = this.ensureIdentity();
+    if (typeof identity === 'number') {
+      return identity;
+    }
+    return NativeTiRtc.connConnect(identity.objectId, remoteId, token);
+  }
+
+  disconnect(): number {
+    const released = returnReleasedIfDisposed(this.disposed);
+    if (released !== null) {
+      return released;
+    }
+    return this.identity === null ? TIRTC_ERROR_OK : NativeTiRtc.connDisconnect(this.identity.objectId);
+  }
+
+  sendCommand(commandId: number, data: Uint8Array): number {
+    if (!isUInt32(commandId)) {
+      return TIRTC_ERROR_INVALID_ARGUMENT;
+    }
+    const nativeBytes = toNativeBytes(data);
+    if (nativeBytes === null) {
+      return TIRTC_ERROR_INVALID_ARGUMENT;
+    }
+    const identity = this.ensureIdentity();
+    if (typeof identity === 'number') {
+      return identity;
+    }
+    return NativeTiRtc.connSendCommand(identity.objectId, commandId, nativeBytes);
+  }
+
+  sendStreamMessage(streamId: number, timestampMs: number, data: Uint8Array): number {
+    if (!isUInt8(streamId) || !isUInt32(timestampMs)) {
+      return TIRTC_ERROR_INVALID_ARGUMENT;
+    }
+    const nativeBytes = toNativeBytes(data);
+    if (nativeBytes === null) {
+      return TIRTC_ERROR_INVALID_ARGUMENT;
+    }
+    const identity = this.ensureIdentity();
+    if (typeof identity === 'number') {
+      return identity;
+    }
+    return NativeTiRtc.connSendStreamMessage(
+      identity.objectId,
+      streamId,
+      timestampMs,
+      nativeBytes,
+    );
+  }
+
+  subscribeVideo(streamId: number): number {
+    return this.callWithStream(streamId, (identity) =>
+      NativeTiRtc.connSubscribeVideo(identity.objectId, streamId));
+  }
+
+  unsubscribeVideo(streamId: number): number {
+    return this.callWithStream(streamId, (identity) =>
+      NativeTiRtc.connUnsubscribeVideo(identity.objectId, streamId));
+  }
+
+  subscribeAudio(streamId: number): number {
+    return this.callWithStream(streamId, (identity) =>
+      NativeTiRtc.connSubscribeAudio(identity.objectId, streamId));
+  }
+
+  unsubscribeAudio(streamId: number): number {
+    return this.callWithStream(streamId, (identity) =>
+      NativeTiRtc.connUnsubscribeAudio(identity.objectId, streamId));
+  }
+
+  requestKeyFrame(streamId: number): number {
+    return this.callWithStream(streamId, (identity) =>
+      NativeTiRtc.connRequestKeyFrame(identity.objectId, streamId));
+  }
+
+  getMetricsSnapshot(): TiRtcConnMetricsResult {
+    const identity = this.ensureIdentity();
+    if (typeof identity === 'number') {
+      return {code: identity, snapshot: null};
+    }
+    return NativeTiRtc.connGetMetricsSnapshot(identity.objectId);
+  }
+
+  dispose(): number {
+    if (this.disposed) {
+      return TIRTC_ERROR_OK;
+    }
+    if (this.identity === null) {
+      this.disposed = true;
+      this.clearCallbacks();
+      return TIRTC_ERROR_OK;
+    }
+    const identity = this.identity;
+    const code = NativeTiRtc.connDispose(identity.objectId);
+    if (code === TIRTC_ERROR_OK) {
+      this.disposed = true;
+      this.identity = null;
+      unregisterNativeEventHandler(identity);
+      clearNativeIdentity(this);
+      this.clearCallbacks();
+      this.currentState = 'disconnected';
+    }
+    return code;
+  }
+
+  private callWithStream(streamId: number, operation: (identity: NativeIdentity) => number): number {
+    if (!isUInt8(streamId)) {
+      return TIRTC_ERROR_INVALID_ARGUMENT;
+    }
+    const identity = this.ensureIdentity();
+    if (typeof identity === 'number') {
+      return identity;
+    }
+    return operation(identity);
+  }
+
+  private ensureIdentity(): NativeIdentity | number {
+    const released = returnReleasedIfDisposed(this.disposed);
+    if (released !== null) {
+      return released;
+    }
+    if (this.identity !== null) {
+      return this.identity;
+    }
+    return this.createCode;
+  }
+
+  private adoptIdentity(identity: NativeIdentity): void {
+    this.identity = identity;
+    setNativeIdentity(this, identity);
+    registerNativeEventHandler(identity, (event) => this.handleEvent(event));
+  }
+
+  private clearCallbacks(): void {
+    this.onStateChanged = null;
+    this.onCommand = null;
+    this.onStreamMessage = null;
+  }
+
+  private handleEvent(event: NativeTiRtcEvent): void {
+    if (this.disposed) {
+      return;
+    }
+    switch (event.type) {
+      case 'connStateChanged':
+        if (event.state !== undefined && event.errorCode !== undefined) {
+          this.currentState = event.state as TiRtcConnState;
+          this.onStateChanged?.(this.currentState, event.errorCode);
+        }
+        break;
+      case 'connCommand':
+        if (event.commandId !== undefined) {
+          this.onCommand?.(event.commandId, fromNativeBytes(event.data));
+        }
+        break;
+      case 'connStreamMessage':
+        if (event.streamId !== undefined && event.timestampMs !== undefined) {
+          this.onStreamMessage?.(
+            event.streamId,
+            event.timestampMs,
+            fromNativeBytes(event.data),
+          );
+        }
+        break;
+      default:
+        break;
+    }
+  }
+}

package/src/errors.ts

@@ -0,0 +1,81 @@
+export const TIRTC_ERROR_OK = 0;
+export const TIRTC_ERROR_INVALID_ARGUMENT = 6000;
+export const TIRTC_HOST_ERROR_OBJECT_RELEASED = 1008;
+
+export type NativeCreateResultLike = Readonly<{
+  code: number;
+  objectId: number;
+  generation: number;
+  message: string | null;
+}>;
+
+export function returnReleasedIfDisposed(disposed: boolean): number | null {
+  return disposed ? TIRTC_HOST_ERROR_OBJECT_RELEASED : null;
+}
+
+export function normalizeCreateResult(result: NativeCreateResultLike): NativeCreateResultLike {
+  if (
+    result.code === TIRTC_ERROR_OK
+    && isPositiveInt32(result.objectId)
+    && isPositiveInt32(result.generation)
+  ) {
+    return result;
+  }
+  return {
+    code: result.code === TIRTC_ERROR_OK ? TIRTC_ERROR_INVALID_ARGUMENT : result.code,
+    objectId: 0,
+    generation: 0,
+    message: result.message ?? null,
+  };
+}
+
+export function isPlainObject(value: unknown): value is Record<string, unknown> {
+  return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+
+export function isFiniteSafeInteger(value: unknown): value is number {
+  return typeof value === 'number' && Number.isFinite(value) && Number.isSafeInteger(value);
+}
+
+export function isUInt8(value: unknown): value is number {
+  return isFiniteSafeInteger(value) && value >= 0 && value <= 255;
+}
+
+export function isUInt32(value: unknown): value is number {
+  return isFiniteSafeInteger(value) && value >= 0 && value <= 4294967295;
+}
+
+export function isPositiveInt32(value: unknown): value is number {
+  return isFiniteSafeInteger(value) && value >= 1 && value <= 2147483647;
+}
+
+export function isPositiveInt32Size(value: unknown): value is number {
+  return isPositiveInt32(value);
+}
+
+export function toNativeBytes(data: unknown): ReadonlyArray<number> | null {
+  if (!(data instanceof Uint8Array)) {
+    return null;
+  }
+  const out: number[] = [];
+  for (let index = 0; index < data.length; index += 1) {
+    const value = data[index];
+    if (!isUInt8(value)) {
+      return null;
+    }
+    out.push(value);
+  }
+  return out;
+}
+
+export function fromNativeBytes(data: ReadonlyArray<number> | undefined): Uint8Array {
+  if (data === undefined) {
+    return new Uint8Array();
+  }
+  const out = new Uint8Array(data.length);
+  for (let index = 0; index < data.length; index += 1) {
+    const value = data[index];
+    out[index] = isUInt8(value) ? value : 0;
+  }
+  return out;
+}

package/src/events.ts

@@ -0,0 +1,44 @@
+import {NativeTiRtc, type NativeTiRtcEvent} from './native';
+import {isPositiveInt32} from './errors';
+import type {NativeIdentity} from './native_object_id';
+
+type NativeEventHandler = (event: NativeTiRtcEvent) => void;
+
+const handlers = new Map<string, NativeEventHandler>();
+let subscription: {remove: () => void} | null = null;
+
+function eventKey(identity: NativeIdentity): string {
+  return `${identity.objectId}:${identity.generation}`;
+}
+
+function ensureSubscribed(): void {
+  if (subscription !== null) {
+    return;
+  }
+  subscription = NativeTiRtc.onTiRtcEvent((event) => {
+    if (!isPositiveInt32(event.objectId) || !isPositiveInt32(event.generation)) {
+      return;
+    }
+    const handler = handlers.get(eventKey({
+      objectId: event.objectId,
+      generation: event.generation,
+    }));
+    if (handler !== undefined) {
+      handler(event);
+      return;
+    }
+  });
+}
+
+export function registerNativeEventHandler(identity: NativeIdentity, handler: NativeEventHandler): void {
+  handlers.set(eventKey(identity), handler);
+  ensureSubscribed();
+}
+
+export function unregisterNativeEventHandler(identity: NativeIdentity): void {
+  handlers.delete(eventKey(identity));
+  if (handlers.size === 0 && subscription !== null) {
+    subscription.remove();
+    subscription = null;
+  }
+}

package/src/index.ts

@@ -0,0 +1,61 @@
+export {
+  TiRtcOutputBufferStrategy,
+  TiRtcConnState,
+  TiRtcInputState,
+  TiRtcAudioCodec,
+  TiRtcAudioSampleRate,
+  TiRtcAudioChannelCount,
+  TiRtcAudioAecMode,
+  TiRtcAudioAgcLevel,
+  TiRtcAudioAnsLevel,
+  TiRtcVideoCodec,
+  TiRtcVideoEncoderCodec,
+  TiRtcVideoFrameRate,
+  TiRtcCameraFacing,
+  TiRtcVideoDecoderPreference,
+  TiRtcVideoDecoderBackend,
+  TiRtcVideoBitstreamFormat,
+  TiRtcAudioOutputState,
+  TiRtcVideoOutputState,
+} from './types';
+export type {
+  TiRtcSize,
+  TiRtcInitOptions,
+  TiRtcAudioOutputOptions,
+  TiRtcVideoOutputOptions,
+  TiRtcVideoOutputViewProps,
+  TiRtcAudioInputOptions,
+  TiRtcVideoInputOptions,
+  TiRtcVideoInputPreviewProps,
+  TiRtcOnConnStateChanged,
+  TiRtcOnConnCommand,
+  TiRtcOnConnStreamMessage,
+  TiRtcOnAudioOutputStateChanged,
+  TiRtcOnAudioOutputError,
+  TiRtcOnVideoOutputStateChanged,
+  TiRtcOnVideoOutputRenderSizeChanged,
+  TiRtcOnVideoOutputError,
+  TiRtcOnInputStateChanged,
+  TiRtcOnInputError,
+  TiRtcOnVideoInputActualConfigChanged,
+  TiRtcConnMetricsResult,
+  TiRtcConnMetricsSnapshot,
+  TiRtcOutputStartupMetrics,
+  TiRtcOutputStutterMetrics,
+  TiRtcAudioOutputMetricsResult,
+  TiRtcAudioOutputMetricsSnapshot,
+  TiRtcVideoOutputMetricsResult,
+  TiRtcVideoOutputMetricsSnapshot,
+  TiRtcAudioOutputDebugSnapshotResult,
+  TiRtcAudioOutputDebugSnapshot,
+  TiRtcVideoOutputDebugSnapshotResult,
+  TiRtcVideoOutputDebugSnapshot,
+  TiRtcLoggingUploadResult,
+} from './types';
+export {TiRtc} from './runtime';
+export {TiRtcConn} from './conn';
+export {TiRtcAudioOutput} from './audio_output';
+export {TiRtcVideoOutput, TiRtcVideoOutputView} from './video_output';
+export {TiRtcAudioInput} from './audio_input';
+export {TiRtcVideoInput, TiRtcVideoInputPreview} from './video_input';
+export {TiRtcLogging} from './logging';

package/src/logging.ts

@@ -0,0 +1,33 @@
+import {NativeTiRtc} from './native';
+import type {TiRtcLoggingUploadResult} from './types';
+
+const LogLevel = {
+  debug: 0,
+  info: 1,
+  warn: 2,
+  error: 3,
+} as const;
+
+export class TiRtcLogging {
+  private constructor() {}
+
+  static d(tag: string, message: string): void {
+    NativeTiRtc.writeLog(LogLevel.debug, tag, message);
+  }
+
+  static i(tag: string, message: string): void {
+    NativeTiRtc.writeLog(LogLevel.info, tag, message);
+  }
+
+  static w(tag: string, message: string): void {
+    NativeTiRtc.writeLog(LogLevel.warn, tag, message);
+  }
+
+  static e(tag: string, message: string): void {
+    NativeTiRtc.writeLog(LogLevel.error, tag, message);
+  }
+
+  static upload(): Promise<TiRtcLoggingUploadResult> {
+    return NativeTiRtc.uploadLogs();
+  }
+}

package/src/native.ts

@@ -0,0 +1,6 @@
+import NativeTiRtc from './specs/NativeTiRtc';
+import NativeTiRtcVideoInputPreview from './specs/TiRtcVideoInputPreviewNativeComponent';
+import NativeTiRtcVideoOutputView from './specs/TiRtcVideoOutputViewNativeComponent';
+
+export {NativeTiRtc, NativeTiRtcVideoOutputView, NativeTiRtcVideoInputPreview};
+export type {NativeTiRtcEvent} from './specs/NativeTiRtc';