tirtc-react-native 2.2.0

package/src/native_object_id.ts

@@ -0,0 +1,63 @@
+import {isPositiveInt32} from './errors';
+
+export type NativeIdentity = Readonly<{
+  objectId: number;
+  generation: number;
+}>;
+
+type NativeIdentityListener = () => void;
+
+const nativeIdentities = new WeakMap<object, NativeIdentity>();
+const identityListeners = new WeakMap<object, Set<NativeIdentityListener>>();
+
+export function isNativeIdentity(value: unknown): value is NativeIdentity {
+  return (
+    typeof value === 'object'
+    && value !== null
+    && isPositiveInt32((value as NativeIdentity).objectId)
+    && isPositiveInt32((value as NativeIdentity).generation)
+  );
+}
+
+export function setNativeIdentity(owner: object, identity: NativeIdentity): void {
+  nativeIdentities.set(owner, identity);
+  emitNativeIdentityChanged(owner);
+}
+
+export function clearNativeIdentity(owner: object): void {
+  nativeIdentities.delete(owner);
+  emitNativeIdentityChanged(owner);
+}
+
+export function readNativeIdentity(owner: unknown): NativeIdentity | null {
+  if (typeof owner !== 'object' || owner === null) {
+    return null;
+  }
+  return nativeIdentities.get(owner) ?? null;
+}
+
+export function readNativeObjectId(owner: unknown): number | null {
+  return readNativeIdentity(owner)?.objectId ?? null;
+}
+
+export function subscribeNativeIdentity(owner: object, listener: NativeIdentityListener): () => void {
+  let listeners = identityListeners.get(owner);
+  if (listeners === undefined) {
+    listeners = new Set();
+    identityListeners.set(owner, listeners);
+  }
+  listeners.add(listener);
+  return () => {
+    listeners?.delete(listener);
+  };
+}
+
+function emitNativeIdentityChanged(owner: object): void {
+  const listeners = identityListeners.get(owner);
+  if (listeners === undefined) {
+    return;
+  }
+  for (const listener of Array.from(listeners)) {
+    listener();
+  }
+}

package/src/runtime.ts

@@ -0,0 +1,32 @@
+import {isPlainObject, TIRTC_ERROR_INVALID_ARGUMENT} from './errors';
+import {NativeTiRtc} from './native';
+import type {TiRtcInitOptions} from './types';
+
+export class TiRtc {
+  private constructor() {}
+
+  static initialize(config: TiRtcInitOptions): Promise<number> {
+    if (!isPlainObject(config)) {
+      return Promise.resolve(TIRTC_ERROR_INVALID_ARGUMENT);
+    }
+    return NativeTiRtc.initialize({
+      appId: typeof config.appId === 'string' ? config.appId : '',
+      endpoint: typeof config.endpoint === 'string' ? config.endpoint : '',
+      consoleLogEnabled: typeof config.consoleLogEnabled === 'boolean'
+        ? config.consoleLogEnabled
+        : false,
+    });
+  }
+
+  static shutdown(): number {
+    return NativeTiRtc.shutdown();
+  }
+
+  static errorToString(code: number): string {
+    return NativeTiRtc.errorToString(code);
+  }
+
+  static formatError(code: number): string {
+    return `error ${TiRtc.errorToString(code)} (${code})`;
+  }
+}

package/src/specs/NativeTiRtc.ts

@@ -0,0 +1,256 @@
+import type {TurboModule, CodegenTypes} from 'react-native';
+import {TurboModuleRegistry} from 'react-native';
+
+export type NativeObjectId = number;
+export type NativeBytes = ReadonlyArray<number>;
+
+export type NativeCreateResult = Readonly<{
+  code: number;
+  objectId: NativeObjectId;
+  generation: number;
+  message: string | null;
+}>;
+
+export type NativeInitOptions = Readonly<{
+  appId: string;
+  endpoint: string;
+  consoleLogEnabled: boolean;
+}>;
+
+export type NativeSize = Readonly<{
+  width: number;
+  height: number;
+}>;
+
+export type NativeAudioOutputOptions = Readonly<{
+  agcLevel: 'disabled' | 'low' | 'medium' | 'high';
+  ansLevel: 'disabled' | 'low' | 'medium' | 'high';
+  bufferStrategy: 'automatic' | 'noBuffer';
+  maxBufferWatermarkMs: number | null;
+}>;
+
+export type NativeVideoOutputOptions = Readonly<{
+  decoderPreference: 'auto' | 'software' | 'hardware';
+  bufferStrategy: 'automatic' | 'noBuffer';
+  maxBufferWatermarkMs: number | null;
+}>;
+
+export type NativeAudioInputOptions = Readonly<{
+  codec: 'g711a' | 'aac' | 'pcm' | 'opus' | 'amr';
+  sampleRate: 'rate8k' | 'rate16k';
+  channels: 'mono';
+  aecMode: 'disabled' | 'enabled';
+  agcLevel: 'disabled' | 'low' | 'medium' | 'high';
+  ansLevel: 'disabled' | 'low' | 'medium' | 'high';
+}>;
+
+export type NativeVideoInputOptions = Readonly<{
+  codec: 'h264' | 'mjpeg';
+  width: number;
+  height: number;
+  frameRate: 'fps10' | 'fps15' | 'fps30';
+  bitrateKbps: number;
+  cameraFacing: 'front' | 'back';
+}>;
+
+export type NativeStateResult = Readonly<{
+  code: number;
+  state: string | null;
+}>;
+
+export type NativeSizeResult = Readonly<{
+  code: number;
+  size: NativeSize | null;
+}>;
+
+export type NativeVideoInputActualConfigResult = Readonly<{
+  code: number;
+  size: NativeSize | null;
+  fps: number | null;
+}>;
+
+export type NativeLoggingUploadResult = Readonly<{
+  code: number;
+  logId: string | null;
+}>;
+
+export type NativeTiRtcEvent = Readonly<{
+  type: string;
+  objectId: NativeObjectId;
+  generation: number;
+  state?: string;
+  errorCode?: number;
+  code?: number;
+  message?: string | null;
+  commandId?: number;
+  streamId?: number;
+  timestampMs?: number;
+  data?: NativeBytes;
+  size?: NativeSize;
+  fps?: number;
+}>;
+
+type NativeConnMetricsResult = Readonly<{
+  code: number;
+  snapshot: Readonly<{
+    hasConnectStart: boolean;
+    hasConnected: boolean;
+    connectStartMonotonicMs: number;
+    connectedMonotonicMs: number;
+    isReady: boolean;
+    connectDurationMs: number | null;
+  }> | null;
+}>;
+
+type NativeOutputStartupMetrics = Readonly<{
+  hasConnectStart: boolean;
+  hasConnected: boolean;
+  hasFirstPacket: boolean;
+  hasFirstOutput: boolean;
+  connectStartMonotonicMs: number;
+  connectedMonotonicMs: number;
+  firstPacketMonotonicMs: number;
+  firstOutputMonotonicMs: number;
+  firstPacketAfterConnectedMs: number;
+  firstOutputAfterConnectedMs: number;
+  timeToFirstOutputMs: number;
+}>;
+
+type NativeOutputStutterMetrics = Readonly<{
+  stutterThresholdMs: number;
+  outputDurationMs: number;
+  stutterTotalMs: number;
+  stutterCount: number;
+  stutterPeakMs: number;
+  stutterAverageMs: number;
+  stutterRatePercent: number;
+}>;
+
+type NativeAudioOutputMetricsResult = Readonly<{
+  code: number;
+  snapshot: Readonly<{
+    startup: NativeOutputStartupMetrics;
+    stutter: NativeOutputStutterMetrics;
+    estimatedOutputLatencyMs: number;
+    audioCodec: 'g711a' | 'aac' | 'pcm' | 'opus' | 'amr' | null;
+    audioSampleRateHz: number;
+    audioChannels: number;
+    audioInputBitrateKbps: number;
+    audioInputPacketRate: number;
+    audioRenderCallbackRate: number;
+    statsRefreshIntervalMs: number;
+    statsUpdatedAtMonotonicMs: number;
+  }> | null;
+}>;
+
+type NativeVideoOutputMetricsResult = Readonly<{
+  code: number;
+  snapshot: Readonly<{
+    startup: NativeOutputStartupMetrics;
+    stutter: NativeOutputStutterMetrics;
+    estimatedOutputLatencyMs: number;
+    videoCodec: 'h264' | 'h265' | 'mjpeg' | null;
+    videoWidth: number;
+    videoHeight: number;
+    decoderBackend: 'unknown' | 'software' | 'hardware';
+    videoInputBitrateKbps: number;
+    videoInputFps: number;
+    videoDecodedFps: number;
+    videoRenderFps: number;
+    statsRefreshIntervalMs: number;
+    statsUpdatedAtMonotonicMs: number;
+  }> | null;
+}>;
+
+type NativeAudioOutputDebugSnapshotResult = Readonly<{
+  code: number;
+  snapshot: Readonly<{
+    codec: 'g711a' | 'aac' | 'pcm' | 'opus' | 'amr' | null;
+    sampleRateHz: number;
+    channels: number;
+  }> | null;
+}>;
+
+type NativeVideoOutputDebugSnapshotResult = Readonly<{
+  code: number;
+  snapshot: Readonly<{
+    codec: 'h264' | 'h265' | 'mjpeg' | null;
+    bitstreamFormat: 'unknown' | 'h264AnnexB' | 'h265AnnexB' | 'mjpegJfif';
+    width: number;
+    height: number;
+    decoderPreference: 'auto' | 'software' | 'hardware';
+    resolvedDecoderBackend: 'unknown' | 'software' | 'hardware';
+  }> | null;
+}>;
+
+interface Spec extends TurboModule {
+  readonly onTiRtcEvent: CodegenTypes.EventEmitter<NativeTiRtcEvent>;
+
+  initialize(options: NativeInitOptions): Promise<number>;
+  shutdown(): number;
+  errorToString(code: number): string;
+  writeLog(level: number, tag: string, message: string): void;
+  uploadLogs(): Promise<NativeLoggingUploadResult>;
+
+  createConn(): NativeCreateResult;
+  connGetState(id: NativeObjectId): NativeStateResult;
+  connConnect(id: NativeObjectId, remoteId: string, token: string): number;
+  connDisconnect(id: NativeObjectId): number;
+  connSendCommand(id: NativeObjectId, commandId: number, data: NativeBytes): number;
+  connSendStreamMessage(
+    id: NativeObjectId,
+    streamId: number,
+    timestampMs: number,
+    data: NativeBytes,
+  ): number;
+  connSubscribeVideo(id: NativeObjectId, streamId: number): number;
+  connUnsubscribeVideo(id: NativeObjectId, streamId: number): number;
+  connSubscribeAudio(id: NativeObjectId, streamId: number): number;
+  connUnsubscribeAudio(id: NativeObjectId, streamId: number): number;
+  connRequestKeyFrame(id: NativeObjectId, streamId: number): number;
+  connGetMetricsSnapshot(id: NativeObjectId): NativeConnMetricsResult;
+  connDispose(id: NativeObjectId): number;
+
+  createAudioOutput(): NativeCreateResult;
+  audioOutputGetState(id: NativeObjectId): NativeStateResult;
+  audioOutputConfigure(id: NativeObjectId, options: NativeAudioOutputOptions): number;
+  audioOutputSetVolume(id: NativeObjectId, volumePercent: number): number;
+  audioOutputAttach(id: NativeObjectId, connId: NativeObjectId, streamId: number): number;
+  audioOutputDetach(id: NativeObjectId): number;
+  audioOutputGetMetricsSnapshot(id: NativeObjectId): NativeAudioOutputMetricsResult;
+  audioOutputResetMetricsSession(id: NativeObjectId): number;
+  audioOutputGetDebugSnapshot(id: NativeObjectId): NativeAudioOutputDebugSnapshotResult;
+  audioOutputDispose(id: NativeObjectId): number;
+
+  createVideoOutput(): NativeCreateResult;
+  videoOutputGetState(id: NativeObjectId): NativeStateResult;
+  videoOutputGetRenderSize(id: NativeObjectId): NativeSizeResult;
+  videoOutputSetOptions(id: NativeObjectId, options: NativeVideoOutputOptions): number;
+  videoOutputAttach(id: NativeObjectId, connId: NativeObjectId, streamId: number): number;
+  videoOutputDetach(id: NativeObjectId): number;
+  videoOutputGetMetricsSnapshot(id: NativeObjectId): NativeVideoOutputMetricsResult;
+  videoOutputResetMetricsSession(id: NativeObjectId): number;
+  videoOutputGetDebugSnapshot(id: NativeObjectId): NativeVideoOutputDebugSnapshotResult;
+  videoOutputDispose(id: NativeObjectId): number;
+
+  createAudioInput(): NativeCreateResult;
+  audioInputGetState(id: NativeObjectId): NativeStateResult;
+  audioInputSetOptions(id: NativeObjectId, options: NativeAudioInputOptions): Promise<number>;
+  audioInputAttach(id: NativeObjectId, connId: NativeObjectId, streamId: number): Promise<number>;
+  audioInputStart(id: NativeObjectId): Promise<number>;
+  audioInputStop(id: NativeObjectId): Promise<number>;
+  audioInputDetach(id: NativeObjectId, connId: NativeObjectId): Promise<number>;
+  audioInputDispose(id: NativeObjectId): Promise<number>;
+
+  createVideoInput(): NativeCreateResult;
+  videoInputGetState(id: NativeObjectId): NativeStateResult;
+  videoInputGetActualConfig(id: NativeObjectId): NativeVideoInputActualConfigResult;
+  videoInputSetOptions(id: NativeObjectId, options: NativeVideoInputOptions): Promise<number>;
+  videoInputAttach(id: NativeObjectId, connId: NativeObjectId, streamId: number): Promise<number>;
+  videoInputStart(id: NativeObjectId): Promise<number>;
+  videoInputStop(id: NativeObjectId): Promise<number>;
+  videoInputDetach(id: NativeObjectId, connId: NativeObjectId): Promise<number>;
+  videoInputDispose(id: NativeObjectId): Promise<number>;
+}
+
+export default TurboModuleRegistry.getEnforcing<Spec>('TiRtc');

package/src/specs/TiRtcVideoInputPreviewNativeComponent.ts

@@ -0,0 +1,14 @@
+import {codegenNativeComponent, type CodegenTypes, type ViewProps} from 'react-native';
+
+export interface NativeTiRtcVideoInputPreviewProps extends ViewProps {
+  readonly nativeObjectId: CodegenTypes.Int32;
+  readonly generation: CodegenTypes.Int32;
+  readonly resizeMode?: CodegenTypes.WithDefault<
+    'contain' | 'cover' | 'stretch',
+    'contain'
+  >;
+}
+
+export default codegenNativeComponent<NativeTiRtcVideoInputPreviewProps>(
+  'TiRtcVideoInputPreview',
+);

package/src/specs/TiRtcVideoOutputViewNativeComponent.ts

@@ -0,0 +1,12 @@
+import {codegenNativeComponent, type CodegenTypes, type ViewProps} from 'react-native';
+
+export interface NativeTiRtcVideoOutputViewProps extends ViewProps {
+  readonly nativeObjectId: CodegenTypes.Int32;
+  readonly generation: CodegenTypes.Int32;
+  readonly resizeMode?: CodegenTypes.WithDefault<
+    'contain' | 'cover' | 'stretch',
+    'contain'
+  >;
+}
+
+export default codegenNativeComponent<NativeTiRtcVideoOutputViewProps>('TiRtcVideoOutputView');