tirtc-react-native 2.2.0

package/lib/typescript/types.d.ts

@@ -0,0 +1,281 @@
+import type { ViewProps } from 'react-native';
+import type { TiRtcVideoInput } from './video_input';
+import type { TiRtcVideoOutput } from './video_output';
+export type TiRtcSize = Readonly<{
+    width: number;
+    height: number;
+}>;
+export declare const TiRtcOutputBufferStrategy: {
+    readonly automatic: "automatic";
+    readonly noBuffer: "noBuffer";
+};
+export type TiRtcOutputBufferStrategy = (typeof TiRtcOutputBufferStrategy)[keyof typeof TiRtcOutputBufferStrategy];
+export declare const TiRtcConnState: {
+    readonly idle: "idle";
+    readonly connecting: "connecting";
+    readonly connected: "connected";
+    readonly disconnected: "disconnected";
+};
+export type TiRtcConnState = (typeof TiRtcConnState)[keyof typeof TiRtcConnState];
+export declare const TiRtcInputState: {
+    readonly idle: "idle";
+    readonly running: "running";
+    readonly stopped: "stopped";
+    readonly failed: "failed";
+};
+export type TiRtcInputState = (typeof TiRtcInputState)[keyof typeof TiRtcInputState];
+export declare const TiRtcAudioCodec: {
+    readonly g711a: "g711a";
+    readonly aac: "aac";
+    readonly pcm: "pcm";
+    readonly opus: "opus";
+    readonly amr: "amr";
+};
+export type TiRtcAudioCodec = (typeof TiRtcAudioCodec)[keyof typeof TiRtcAudioCodec];
+export declare const TiRtcAudioSampleRate: {
+    readonly rate8k: "rate8k";
+    readonly rate16k: "rate16k";
+};
+export type TiRtcAudioSampleRate = (typeof TiRtcAudioSampleRate)[keyof typeof TiRtcAudioSampleRate];
+export declare const TiRtcAudioChannelCount: {
+    readonly mono: "mono";
+};
+export type TiRtcAudioChannelCount = (typeof TiRtcAudioChannelCount)[keyof typeof TiRtcAudioChannelCount];
+export declare const TiRtcAudioAecMode: {
+    readonly disabled: "disabled";
+    readonly enabled: "enabled";
+};
+export type TiRtcAudioAecMode = (typeof TiRtcAudioAecMode)[keyof typeof TiRtcAudioAecMode];
+export declare const TiRtcAudioAgcLevel: {
+    readonly disabled: "disabled";
+    readonly low: "low";
+    readonly medium: "medium";
+    readonly high: "high";
+};
+export type TiRtcAudioAgcLevel = (typeof TiRtcAudioAgcLevel)[keyof typeof TiRtcAudioAgcLevel];
+export declare const TiRtcAudioAnsLevel: {
+    readonly disabled: "disabled";
+    readonly low: "low";
+    readonly medium: "medium";
+    readonly high: "high";
+};
+export type TiRtcAudioAnsLevel = (typeof TiRtcAudioAnsLevel)[keyof typeof TiRtcAudioAnsLevel];
+export declare const TiRtcVideoCodec: {
+    readonly h264: "h264";
+    readonly h265: "h265";
+    readonly mjpeg: "mjpeg";
+};
+export type TiRtcVideoCodec = (typeof TiRtcVideoCodec)[keyof typeof TiRtcVideoCodec];
+export declare const TiRtcVideoEncoderCodec: {
+    readonly h264: "h264";
+    readonly mjpeg: "mjpeg";
+};
+export type TiRtcVideoEncoderCodec = (typeof TiRtcVideoEncoderCodec)[keyof typeof TiRtcVideoEncoderCodec];
+export declare const TiRtcVideoFrameRate: {
+    readonly fps10: "fps10";
+    readonly fps15: "fps15";
+    readonly fps30: "fps30";
+};
+export type TiRtcVideoFrameRate = (typeof TiRtcVideoFrameRate)[keyof typeof TiRtcVideoFrameRate];
+export declare const TiRtcCameraFacing: {
+    readonly front: "front";
+    readonly back: "back";
+};
+export type TiRtcCameraFacing = (typeof TiRtcCameraFacing)[keyof typeof TiRtcCameraFacing];
+export declare const TiRtcVideoDecoderPreference: {
+    readonly auto: "auto";
+    readonly software: "software";
+    readonly hardware: "hardware";
+};
+export type TiRtcVideoDecoderPreference = (typeof TiRtcVideoDecoderPreference)[keyof typeof TiRtcVideoDecoderPreference];
+export declare const TiRtcVideoDecoderBackend: {
+    readonly unknown: "unknown";
+    readonly software: "software";
+    readonly hardware: "hardware";
+};
+export type TiRtcVideoDecoderBackend = (typeof TiRtcVideoDecoderBackend)[keyof typeof TiRtcVideoDecoderBackend];
+export declare const TiRtcVideoBitstreamFormat: {
+    readonly unknown: "unknown";
+    readonly h264AnnexB: "h264AnnexB";
+    readonly h265AnnexB: "h265AnnexB";
+    readonly mjpegJfif: "mjpegJfif";
+};
+export type TiRtcVideoBitstreamFormat = (typeof TiRtcVideoBitstreamFormat)[keyof typeof TiRtcVideoBitstreamFormat];
+export declare const TiRtcAudioOutputState: {
+    readonly idle: "idle";
+    readonly buffering: "buffering";
+    readonly playing: "playing";
+    readonly failed: "failed";
+};
+export type TiRtcAudioOutputState = (typeof TiRtcAudioOutputState)[keyof typeof TiRtcAudioOutputState];
+export declare const TiRtcVideoOutputState: {
+    readonly idle: "idle";
+    readonly buffering: "buffering";
+    readonly rendering: "rendering";
+    readonly failed: "failed";
+};
+export type TiRtcVideoOutputState = (typeof TiRtcVideoOutputState)[keyof typeof TiRtcVideoOutputState];
+export type TiRtcInitOptions = Readonly<{
+    appId?: string;
+    endpoint?: string;
+    consoleLogEnabled?: boolean;
+}>;
+export type TiRtcAudioOutputOptions = Readonly<{
+    agcLevel?: TiRtcAudioAgcLevel;
+    ansLevel?: TiRtcAudioAnsLevel;
+    bufferStrategy?: TiRtcOutputBufferStrategy;
+    maxBufferWatermarkMs?: number;
+}>;
+export type TiRtcVideoOutputOptions = Readonly<{
+    decoderPreference?: TiRtcVideoDecoderPreference;
+    bufferStrategy?: TiRtcOutputBufferStrategy;
+    maxBufferWatermarkMs?: number;
+}>;
+/**
+ * Props for the public remote video Fabric surface.
+ *
+ * Pass the owning `TiRtcVideoOutput` instance, not a native id. The component
+ * renders an inert React Native `View` until the output has a live native
+ * identity, and returns to that placeholder after the owner is disposed.
+ */
+export type TiRtcVideoOutputViewProps = ViewProps & Readonly<{
+    /** Video output owner whose attached stream should render in this surface. */
+    output: TiRtcVideoOutput;
+    /** Surface scaling mode. Defaults to `contain`. */
+    resizeMode?: 'contain' | 'cover' | 'stretch';
+}>;
+export type TiRtcAudioInputOptions = Readonly<{
+    codec?: TiRtcAudioCodec;
+    sampleRate?: TiRtcAudioSampleRate;
+    channels?: TiRtcAudioChannelCount;
+    aecMode?: TiRtcAudioAecMode;
+    agcLevel?: TiRtcAudioAgcLevel;
+    ansLevel?: TiRtcAudioAnsLevel;
+}>;
+export type TiRtcVideoInputOptions = Readonly<{
+    codec?: TiRtcVideoEncoderCodec;
+    width?: number;
+    height?: number;
+    frameRate?: TiRtcVideoFrameRate;
+    bitrateKbps?: number;
+    cameraFacing?: TiRtcCameraFacing;
+}>;
+/**
+ * Props for the public local camera preview Fabric surface.
+ *
+ * Pass the owning `TiRtcVideoInput` instance, not a native id. The component
+ * renders an inert React Native `View` until the input has a live native
+ * identity, and returns to that placeholder after the owner is disposed.
+ */
+export type TiRtcVideoInputPreviewProps = ViewProps & Readonly<{
+    /** Video input owner whose local capture preview should render here. */
+    input: TiRtcVideoInput;
+    /** Surface scaling mode. Defaults to `contain`. */
+    resizeMode?: 'contain' | 'cover' | 'stretch';
+}>;
+export type TiRtcOnConnStateChanged = (state: TiRtcConnState, errorCode: number) => void;
+export type TiRtcOnConnCommand = (commandId: number, data: Uint8Array) => void;
+export type TiRtcOnConnStreamMessage = (streamId: number, timestampMs: number, data: Uint8Array) => void;
+export type TiRtcOnAudioOutputStateChanged = (state: TiRtcAudioOutputState) => void;
+export type TiRtcOnAudioOutputError = (code: number) => void;
+export type TiRtcOnVideoOutputStateChanged = (state: TiRtcVideoOutputState) => void;
+export type TiRtcOnVideoOutputRenderSizeChanged = (size: TiRtcSize) => void;
+export type TiRtcOnVideoOutputError = (code: number) => void;
+export type TiRtcOnInputStateChanged = (state: TiRtcInputState) => void;
+export type TiRtcOnInputError = (code: number, message: string | null) => void;
+export type TiRtcOnVideoInputActualConfigChanged = (size: TiRtcSize, fps: number) => void;
+export type TiRtcConnMetricsResult = Readonly<{
+    code: number;
+    snapshot: TiRtcConnMetricsSnapshot | null;
+}>;
+export type TiRtcConnMetricsSnapshot = Readonly<{
+    hasConnectStart: boolean;
+    hasConnected: boolean;
+    connectStartMonotonicMs: number;
+    connectedMonotonicMs: number;
+    isReady: boolean;
+    connectDurationMs: number | null;
+}>;
+export type TiRtcOutputStartupMetrics = Readonly<{
+    hasConnectStart: boolean;
+    hasConnected: boolean;
+    hasFirstPacket: boolean;
+    hasFirstOutput: boolean;
+    connectStartMonotonicMs: number;
+    connectedMonotonicMs: number;
+    firstPacketMonotonicMs: number;
+    firstOutputMonotonicMs: number;
+    firstPacketAfterConnectedMs: number;
+    firstOutputAfterConnectedMs: number;
+    timeToFirstOutputMs: number;
+}>;
+export type TiRtcOutputStutterMetrics = Readonly<{
+    stutterThresholdMs: number;
+    outputDurationMs: number;
+    stutterTotalMs: number;
+    stutterCount: number;
+    stutterPeakMs: number;
+    stutterAverageMs: number;
+    stutterRatePercent: number;
+}>;
+export type TiRtcAudioOutputMetricsResult = Readonly<{
+    code: number;
+    snapshot: TiRtcAudioOutputMetricsSnapshot | null;
+}>;
+export type TiRtcAudioOutputMetricsSnapshot = Readonly<{
+    startup: TiRtcOutputStartupMetrics;
+    stutter: TiRtcOutputStutterMetrics;
+    estimatedOutputLatencyMs: number;
+    audioCodec: TiRtcAudioCodec | null;
+    audioSampleRateHz: number;
+    audioChannels: number;
+    audioInputBitrateKbps: number;
+    audioInputPacketRate: number;
+    audioRenderCallbackRate: number;
+    statsRefreshIntervalMs: number;
+    statsUpdatedAtMonotonicMs: number;
+}>;
+export type TiRtcVideoOutputMetricsResult = Readonly<{
+    code: number;
+    snapshot: TiRtcVideoOutputMetricsSnapshot | null;
+}>;
+export type TiRtcVideoOutputMetricsSnapshot = Readonly<{
+    startup: TiRtcOutputStartupMetrics;
+    stutter: TiRtcOutputStutterMetrics;
+    estimatedOutputLatencyMs: number;
+    videoCodec: TiRtcVideoCodec | null;
+    videoWidth: number;
+    videoHeight: number;
+    decoderBackend: TiRtcVideoDecoderBackend;
+    videoInputBitrateKbps: number;
+    videoInputFps: number;
+    videoDecodedFps: number;
+    videoRenderFps: number;
+    statsRefreshIntervalMs: number;
+    statsUpdatedAtMonotonicMs: number;
+}>;
+export type TiRtcAudioOutputDebugSnapshotResult = Readonly<{
+    code: number;
+    snapshot: TiRtcAudioOutputDebugSnapshot | null;
+}>;
+export type TiRtcAudioOutputDebugSnapshot = Readonly<{
+    codec: TiRtcAudioCodec | null;
+    sampleRateHz: number;
+    channels: number;
+}>;
+export type TiRtcVideoOutputDebugSnapshotResult = Readonly<{
+    code: number;
+    snapshot: TiRtcVideoOutputDebugSnapshot | null;
+}>;
+export type TiRtcVideoOutputDebugSnapshot = Readonly<{
+    codec: TiRtcVideoCodec | null;
+    bitstreamFormat: TiRtcVideoBitstreamFormat;
+    width: number;
+    height: number;
+    decoderPreference: TiRtcVideoDecoderPreference;
+    resolvedDecoderBackend: TiRtcVideoDecoderBackend;
+}>;
+export type TiRtcLoggingUploadResult = Readonly<{
+    code: number;
+    logId: string | null;
+}>;

package/lib/typescript/video_input.d.ts

@@ -0,0 +1,50 @@
+import * as React from 'react';
+import { TiRtcConn } from './conn';
+import type { TiRtcInputState, TiRtcOnInputError, TiRtcOnInputStateChanged, TiRtcOnVideoInputActualConfigChanged, TiRtcSize, TiRtcVideoInputOptions, TiRtcVideoInputPreviewProps } from './types';
+type VideoInputPreviewPropsWithoutOwner = Omit<TiRtcVideoInputPreviewProps, 'input'>;
+export declare class TiRtcVideoInput {
+    private identity;
+    private disposed;
+    private createCode;
+    private queue;
+    private currentState;
+    private currentOutputSize;
+    private currentOutputFps;
+    private options;
+    onStateChanged: TiRtcOnInputStateChanged | null;
+    onActualConfigChanged: TiRtcOnVideoInputActualConfigChanged | null;
+    onError: TiRtcOnInputError | null;
+    constructor();
+    get state(): TiRtcInputState;
+    get outputSize(): TiRtcSize | null;
+    get outputFps(): number | null;
+    setOptions(options: TiRtcVideoInputOptions): Promise<number>;
+    start(): Promise<number>;
+    attach(connection: TiRtcConn, streamId: number): Promise<number>;
+    detach(connection: TiRtcConn): Promise<number>;
+    stop(): Promise<number>;
+    /**
+     * Creates a React element bound to this input owner.
+     *
+     * The returned element renders a placeholder until this input has a live
+     * native identity. Configure and start the input before expecting camera
+     * frames, and dispose the input when capture is no longer needed.
+     */
+    preview(props?: VideoInputPreviewPropsWithoutOwner): React.ReactElement;
+    dispose(): Promise<number>;
+    private enqueue;
+    private ensureIdentity;
+    private adoptIdentity;
+    private refreshActualConfig;
+    private clearCallbacks;
+    private handleEvent;
+}
+/**
+ * Renders the local preview surface for a `TiRtcVideoInput`.
+ *
+ * The component observes the owner identity and never accepts raw native ids.
+ * If the owner is not created, has been disposed, or is not a `TiRtcVideoInput`,
+ * it renders a regular `View` with the remaining props.
+ */
+export declare function TiRtcVideoInputPreview(props: TiRtcVideoInputPreviewProps): React.ReactElement;
+export {};

package/lib/typescript/video_output.d.ts

@@ -0,0 +1,46 @@
+import * as React from 'react';
+import { TiRtcConn } from './conn';
+import type { TiRtcOnVideoOutputError, TiRtcOnVideoOutputRenderSizeChanged, TiRtcOnVideoOutputStateChanged, TiRtcSize, TiRtcVideoOutputDebugSnapshotResult, TiRtcVideoOutputMetricsResult, TiRtcVideoOutputOptions, TiRtcVideoOutputState, TiRtcVideoOutputViewProps } from './types';
+type VideoOutputViewPropsWithoutOwner = Omit<TiRtcVideoOutputViewProps, 'output'>;
+export declare class TiRtcVideoOutput {
+    private identity;
+    private disposed;
+    private createCode;
+    private currentState;
+    private currentRenderSize;
+    private options;
+    onStateChanged: TiRtcOnVideoOutputStateChanged | null;
+    onRenderSizeChanged: TiRtcOnVideoOutputRenderSizeChanged | null;
+    onError: TiRtcOnVideoOutputError | null;
+    constructor();
+    get state(): TiRtcVideoOutputState;
+    get renderSize(): TiRtcSize | null;
+    setOptions(options: TiRtcVideoOutputOptions): number;
+    attach(connection: TiRtcConn, streamId: number): number;
+    detach(): number;
+    /**
+     * Creates a React element bound to this output owner.
+     *
+     * The returned element renders a placeholder until this output has a live
+     * native identity. Attach the output to a connection before expecting remote
+     * frames, and dispose the output when the render surface is no longer needed.
+     */
+    view(props?: VideoOutputViewPropsWithoutOwner): React.ReactElement;
+    getMetricsSnapshot(): TiRtcVideoOutputMetricsResult;
+    resetMetricsSession(): number;
+    getDebugSnapshot(): TiRtcVideoOutputDebugSnapshotResult;
+    dispose(): number;
+    private ensureIdentity;
+    private adoptIdentity;
+    private clearCallbacks;
+    private handleEvent;
+}
+/**
+ * Renders the remote video stream attached to a `TiRtcVideoOutput`.
+ *
+ * The component observes the owner identity and never accepts raw native ids.
+ * If the owner is not created, has been disposed, or is not a `TiRtcVideoOutput`,
+ * it renders a regular `View` with the remaining props.
+ */
+export declare function TiRtcVideoOutputView(props: TiRtcVideoOutputViewProps): React.ReactElement;
+export {};

package/package.json

@@ -0,0 +1,80 @@
+{
+  "name": "tirtc-react-native",
+  "version": "2.2.0",
+  "description": "TiRTC React Native SDK",
+  "homepage": "https://tange.ai/",
+  "repository": {
+    "type": "git",
+    "url": "git+https://gitlab.tange-ai.com/tirtc-nexus/tirtc.git",
+    "directory": "react-native/tirtc"
+  },
+  "bugs": {
+    "url": "https://gitlab.tange-ai.com/tirtc-nexus/tirtc/-/issues"
+  },
+  "keywords": [
+    "tirtc",
+    "react-native",
+    "audio",
+    "video",
+    "webrtc",
+    "new-architecture"
+  ],
+  "main": "./lib/module/index.js",
+  "module": "./lib/module/index.js",
+  "types": "./lib/typescript/index.d.ts",
+  "react-native": "./lib/module/index.js",
+  "source": "src/index.ts",
+  "exports": {
+    ".": {
+      "react-native": "./lib/module/index.js",
+      "import": "./lib/module/index.js",
+      "types": "./lib/typescript/index.d.ts",
+      "default": "./lib/module/index.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "android/build.gradle",
+    "android/src/",
+    "ios/",
+    "src/",
+    "lib/module/",
+    "lib/typescript/",
+    "README.md",
+    "LICENSE",
+    "TiRtcReactNative.podspec",
+    "react-native.config.js"
+  ],
+  "scripts": {
+    "build": "node scripts/clean_generated_lib.mjs && tsc -p tsconfig.build.json && node scripts/write_codegen_component_specs.mjs",
+    "lint": "node test/source_guard.mjs",
+    "preflight:npm": "node scripts/npm_preflight.mjs",
+    "test": "node test/parity_guard.mjs && node test/package_artifact_guard.mjs && node test/lifecycle_contract_guard.mjs && node test/lifecycle_behavior_guard.mjs && node test/integration_contract_guard.mjs && node test/runner_schema_guard.mjs",
+    "test:contract-red": "node test/contract_red_summary.mjs",
+    "typecheck": "tsc -p tsconfig.json --noEmit",
+    "codegen:check": "node test/codegen_contract_guard.mjs"
+  },
+  "peerDependencies": {
+    "react": "*",
+    "react-native": ">=0.80.0"
+  },
+  "devDependencies": {
+    "@types/react": "^19.2.17",
+    "typescript": "^5.9.0"
+  },
+  "codegenConfig": {
+    "name": "TiRtcSpec",
+    "type": "all",
+    "jsSrcsDir": "src/specs",
+    "ios": {
+      "componentProvider": {
+        "TiRtcVideoOutputView": "TiRtcVideoOutputView",
+        "TiRtcVideoInputPreview": "TiRtcVideoInputPreview"
+      }
+    },
+    "android": {
+      "javaPackageName": "com.tange.ai.tirtc.reactnative"
+    }
+  },
+  "license": "BSD-3-Clause"
+}

package/react-native.config.js

@@ -0,0 +1,10 @@
+module.exports = {
+  dependency: {
+    platforms: {
+      ios: {},
+      android: {
+        sourceDir: './android',
+      },
+    },
+  },
+};

package/src/audio_input.ts

@@ -0,0 +1,205 @@
+import {
+  isPlainObject,
+  isUInt8,
+  normalizeCreateResult,
+  returnReleasedIfDisposed,
+  TIRTC_ERROR_INVALID_ARGUMENT,
+  TIRTC_ERROR_OK,
+  TIRTC_HOST_ERROR_OBJECT_RELEASED,
+} from './errors';
+import {registerNativeEventHandler, unregisterNativeEventHandler} from './events';
+import {clearNativeIdentity, readNativeIdentity, setNativeIdentity, type NativeIdentity} from './native_object_id';
+import {NativeTiRtc, type NativeTiRtcEvent} from './native';
+import {TiRtcConn} from './conn';
+import type {
+  TiRtcAudioInputOptions,
+  TiRtcInputState,
+  TiRtcOnInputError,
+  TiRtcOnInputStateChanged,
+} from './types';
+
+export class TiRtcAudioInput {
+  private identity: NativeIdentity | null = null;
+  private disposed = false;
+  private createCode: number = TIRTC_ERROR_OK;
+  private queue: Promise<unknown> = Promise.resolve();
+  private currentState: TiRtcInputState = 'idle';
+  private options: Required<TiRtcAudioInputOptions> = {
+    codec: 'g711a',
+    sampleRate: 'rate16k',
+    channels: 'mono',
+    aecMode: 'disabled',
+    agcLevel: 'disabled',
+    ansLevel: 'disabled',
+  };
+
+  onStateChanged: TiRtcOnInputStateChanged | null = null;
+  onError: TiRtcOnInputError | null = null;
+
+  constructor() {
+    const result = normalizeCreateResult(NativeTiRtc.createAudioInput());
+    this.createCode = result.code;
+    if (result.code === TIRTC_ERROR_OK) {
+      this.adoptIdentity({objectId: result.objectId, generation: result.generation});
+    }
+  }
+
+  get state(): TiRtcInputState {
+    if (this.identity !== null && !this.disposed) {
+      const result = NativeTiRtc.audioInputGetState(this.identity.objectId);
+      if (result.state !== null) {
+        this.currentState = result.state as TiRtcInputState;
+      }
+    }
+    return this.currentState;
+  }
+
+  setOptions(options: TiRtcAudioInputOptions): Promise<number> {
+    if (!isPlainObject(options)) {
+      return Promise.resolve(TIRTC_ERROR_INVALID_ARGUMENT);
+    }
+    const normalized = {
+      codec: options.codec ?? 'g711a',
+      sampleRate: options.sampleRate ?? 'rate16k',
+      channels: options.channels ?? 'mono',
+      aecMode: options.aecMode ?? 'disabled',
+      agcLevel: options.agcLevel ?? 'disabled',
+      ansLevel: options.ansLevel ?? 'disabled',
+    };
+    return this.enqueue(async () => {
+      const identity = this.ensureIdentity();
+      if (typeof identity === 'number') {
+        return identity;
+      }
+      const code = await NativeTiRtc.audioInputSetOptions(identity.objectId, normalized);
+      if (code === TIRTC_ERROR_OK) {
+        this.options = normalized;
+      }
+      return code;
+    });
+  }
+
+  attach(connection: TiRtcConn, streamId: number): Promise<number> {
+    const connIdentity = readNativeIdentity(connection);
+    if (!isUInt8(streamId)) {
+      return Promise.resolve(TIRTC_ERROR_INVALID_ARGUMENT);
+    }
+    if (connIdentity === null) {
+      return Promise.resolve(TIRTC_ERROR_INVALID_ARGUMENT);
+    }
+    return this.enqueue(async () => {
+      const identity = this.ensureIdentity();
+      if (typeof identity === 'number') {
+        return identity;
+      }
+      return NativeTiRtc.audioInputAttach(identity.objectId, connIdentity.objectId, streamId);
+    });
+  }
+
+  start(): Promise<number> {
+    return this.enqueue(async () => {
+      const identity = this.ensureIdentity();
+      if (typeof identity === 'number') {
+        return identity;
+      }
+      return NativeTiRtc.audioInputStart(identity.objectId);
+    });
+  }
+
+  stop(): Promise<number> {
+    return this.enqueue(async () => {
+      if (this.identity === null) {
+        return TIRTC_ERROR_OK;
+      }
+      return NativeTiRtc.audioInputStop(this.identity.objectId);
+    });
+  }
+
+  detach(connection: TiRtcConn): Promise<number> {
+    const connIdentity = readNativeIdentity(connection);
+    if (connIdentity === null) {
+      return Promise.resolve(TIRTC_ERROR_INVALID_ARGUMENT);
+    }
+    return this.enqueue(async () => {
+      if (this.identity === null) {
+        return TIRTC_ERROR_OK;
+      }
+      return NativeTiRtc.audioInputDetach(this.identity.objectId, connIdentity.objectId);
+    });
+  }
+
+  dispose(): Promise<number> {
+    if (this.disposed) {
+      return Promise.resolve(TIRTC_ERROR_OK);
+    }
+    return this.enqueue(async () => {
+      if (this.identity === null) {
+        this.disposed = true;
+        this.clearCallbacks();
+        this.currentState = 'stopped';
+        return TIRTC_ERROR_OK;
+      }
+      const identity = this.identity;
+      const code = await NativeTiRtc.audioInputDispose(identity.objectId);
+      if (code === TIRTC_ERROR_OK) {
+        this.disposed = true;
+        this.identity = null;
+        unregisterNativeEventHandler(identity);
+        clearNativeIdentity(this);
+        this.clearCallbacks();
+        this.currentState = 'stopped';
+      }
+      return code;
+    }, true);
+  }
+
+  private enqueue(operation: () => Promise<number>, allowDisposed = false): Promise<number> {
+    const released = returnReleasedIfDisposed(this.disposed);
+    if (released !== null && !allowDisposed) {
+      return Promise.resolve(released);
+    }
+    const next = this.queue.then(async () => {
+      if (this.disposed && !allowDisposed) {
+        return TIRTC_HOST_ERROR_OBJECT_RELEASED;
+      }
+      return operation();
+    });
+    this.queue = next.catch(() => undefined);
+    return next;
+  }
+
+  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));
+    void NativeTiRtc.audioInputSetOptions(identity.objectId, this.options);
+  }
+
+  private clearCallbacks(): void {
+    this.onStateChanged = null;
+    this.onError = null;
+  }
+
+  private handleEvent(event: NativeTiRtcEvent): void {
+    if (this.disposed) {
+      return;
+    }
+    if (event.type === 'audioInputStateChanged' && event.state !== undefined) {
+      this.currentState = event.state as TiRtcInputState;
+      this.onStateChanged?.(this.currentState);
+    } else if (event.type === 'audioInputError') {
+      this.onError?.(event.code ?? TIRTC_ERROR_INVALID_ARGUMENT, event.message ?? null);
+    }
+  }
+}