tirtc-react-native 2.3.1 → 2.4.0-alpha.3

package/lib/typescript/specs/NativeTiRtc.d.ts

@@ -43,6 +43,29 @@ export type NativeVideoInputOptions = Readonly<{
     bitrateKbps: number;
     cameraFacing: 'front' | 'back';
 }>;
+export type NativeRecordingOptions = Readonly<{
+    videoStreamId: number;
+    audioStreamId: number | null;
+}>;
+export type NativeRecordingStartResult = Readonly<{
+    code: number;
+    taskId: NativeObjectId | null;
+}>;
+export type NativeMp4Result = Readonly<{
+    code: number;
+    fileId: NativeObjectId | null;
+    filePath: string | null;
+    durationMs: number | null;
+}>;
+export type NativeSnapshotResult = Readonly<{
+    code: number;
+    fileId: NativeObjectId | null;
+    filePath: string | null;
+}>;
+export type NativeGalleryResult = Readonly<{
+    code: number;
+    uri: string | null;
+}>;
 export type NativeStateResult = Readonly<{
     code: number;
     state: string | null;
@@ -60,6 +83,31 @@ export type NativeLoggingUploadResult = Readonly<{
     code: number;
     logId: string | null;
 }>;
+export type NativeStoreRecordingRange = Readonly<{
+    startTimeMs: number;
+    endTimeMs: number;
+}>;
+export type NativeStoreRecordingRangesResult = Readonly<{
+    code: number;
+    recordings: ReadonlyArray<NativeStoreRecordingRange>;
+}>;
+export type NativeStoreRecordingDay = Readonly<{
+    date: string;
+    hasRecording: boolean;
+}>;
+export type NativeStoreRecordingDaysResult = Readonly<{
+    code: number;
+    days: ReadonlyArray<NativeStoreRecordingDay>;
+}>;
+export type NativeStoreReplayInfo = Readonly<{
+    code: number;
+    speed: number;
+    currentTimeMs: number | null;
+}>;
+export type NativeStoreTaskStartResult = Readonly<{
+    code: number;
+    taskId: NativeObjectId | null;
+}>;
 export type NativeTiRtcEvent = Readonly<{
     type: string;
     objectId: NativeObjectId;
@@ -168,6 +216,40 @@ interface Spec extends TurboModule {
     errorToString(code: number): string;
     writeLog(level: number, tag: string, message: string): void;
     uploadLogs(): Promise<NativeLoggingUploadResult>;
+    storeInitialize(options: NativeInitOptions): Promise<number>;
+    storeShutdown(): number;
+    storeCreate(token: string): NativeCreateResult;
+    storeUpdateToken(id: NativeObjectId, token: string): number;
+    storeListRecordings(id: NativeObjectId, startTimeMs: number, endTimeMs: number): Promise<NativeStoreRecordingRangesResult>;
+    storeListRecordingDays(id: NativeObjectId, startDate: string, endDate: string, timeZoneId: string): Promise<NativeStoreRecordingDaysResult>;
+    storeCreateReplay(id: NativeObjectId): NativeCreateResult;
+    storeExportRecording(id: NativeObjectId, startTimeMs: number, endTimeMs: number, videoChannelId: number, audioChannelId: number | null): NativeStoreTaskStartResult;
+    storeExportProgress(id: NativeObjectId): number;
+    storeExportResult(id: NativeObjectId): Promise<NativeMp4Result>;
+    storeExportStop(id: NativeObjectId): number;
+    storeDispose(id: NativeObjectId): number;
+    storeReplayGetInfo(id: NativeObjectId): NativeStoreReplayInfo;
+    storeReplayPlay(id: NativeObjectId, startTimeMs: number, endTimeMs: number, initialTimeMs: number | null): number;
+    storeReplayPause(id: NativeObjectId): number;
+    storeReplayResume(id: NativeObjectId): number;
+    storeReplaySeek(id: NativeObjectId, timeMs: number): number;
+    storeReplaySetSpeed(id: NativeObjectId, speed: number): number;
+    storeReplayStartRecording(id: NativeObjectId, videoChannelId: number, audioChannelId: number | null): NativeStoreTaskStartResult;
+    storeRecordingTaskStop(id: NativeObjectId): Promise<NativeMp4Result>;
+    storeReplayStop(id: NativeObjectId): number;
+    storeReplayDispose(id: NativeObjectId): number;
+    storeCreateAudioOutput(): NativeCreateResult;
+    storeAudioOutputGetState(id: NativeObjectId): NativeStateResult;
+    storeAudioOutputSetVolume(id: NativeObjectId, volumePercent: number): number;
+    storeAudioOutputAttach(outputId: NativeObjectId, replayId: NativeObjectId, channelId: number): number;
+    storeAudioOutputDetach(outputId: NativeObjectId): number;
+    storeAudioOutputDispose(id: NativeObjectId): number;
+    storeCreateVideoOutput(): NativeCreateResult;
+    storeVideoOutputGetState(id: NativeObjectId): NativeStateResult;
+    storeVideoOutputAttach(outputId: NativeObjectId, replayId: NativeObjectId, channelId: number): number;
+    storeVideoOutputDetach(outputId: NativeObjectId): number;
+    storeVideoOutputTakeSnapshot(id: NativeObjectId): Promise<NativeSnapshotResult>;
+    storeVideoOutputDispose(id: NativeObjectId): number;
     createConn(): NativeCreateResult;
     connGetState(id: NativeObjectId): NativeStateResult;
     connConnect(id: NativeObjectId, remoteId: string, token: string): number;
@@ -179,6 +261,11 @@ interface Spec extends TurboModule {
     connSubscribeAudio(id: NativeObjectId, streamId: number): number;
     connUnsubscribeAudio(id: NativeObjectId, streamId: number): number;
     connRequestKeyFrame(id: NativeObjectId, streamId: number): number;
+    connStartRecording(id: NativeObjectId, options: NativeRecordingOptions): NativeRecordingStartResult;
+    recordingTaskStop(id: NativeObjectId): Promise<NativeMp4Result>;
+    mediaFileMoveToGallery(id: NativeObjectId, fileName: string | null): Promise<NativeGalleryResult>;
+    mediaFileDelete(id: NativeObjectId): Promise<number>;
+    mediaFileRelease(id: NativeObjectId): void;
     connGetMetricsSnapshot(id: NativeObjectId): NativeConnMetricsResult;
     connDispose(id: NativeObjectId): number;
     createAudioOutput(): NativeCreateResult;
@@ -200,6 +287,7 @@ interface Spec extends TurboModule {
     videoOutputGetMetricsSnapshot(id: NativeObjectId): NativeVideoOutputMetricsResult;
     videoOutputResetMetricsSession(id: NativeObjectId): number;
     videoOutputGetDebugSnapshot(id: NativeObjectId): NativeVideoOutputDebugSnapshotResult;
+    videoOutputTakeSnapshot(id: NativeObjectId): Promise<NativeSnapshotResult>;
     videoOutputDispose(id: NativeObjectId): number;
     createAudioInput(): NativeCreateResult;
     audioInputGetState(id: NativeObjectId): NativeStateResult;

package/lib/typescript/store.d.ts

@@ -0,0 +1,202 @@
+import * as React from 'react';
+import { type ViewProps } from 'react-native';
+import { NativeTiRtc, type NativeTiRtcEvent } from './native';
+import { type NativeIdentity } from './native_object_id';
+import { type Resp, type TiRtcGalleryAsset } from './recording';
+export declare const TISTORE_ERROR_OK: 0;
+export declare const TISTORE_ERROR_INVALID_ARGUMENT: 6000;
+export declare const TISTORE_ERROR_NOT_INITIALIZED: 6001;
+export declare const TISTORE_ERROR_TOKEN_EXPIRED: 6014;
+export declare const TISTORE_ERROR_ALREADY_INITIALIZED: 6022;
+export declare const TISTORE_ERROR_PERMISSION_DENIED: 6024;
+export declare const TISTORE_ERROR_IN_USE: 6026;
+export declare const TISTORE_ERROR_NOT_STARTED: 6027;
+export declare const TISTORE_ERROR_NOT_BOUND: 6029;
+export declare const TISTORE_ERROR_NOT_CONFIGURED: 6030;
+export declare const TISTORE_ERROR_RESOURCE_EXHAUSTED: 6043;
+export declare const TISTORE_ERROR_FILE_WRITE_FAILED: 6046;
+export declare const TISTORE_ERROR_UNSUPPORTED_FORMAT: 6113;
+export declare const TISTORE_ERROR_IO_FAILED: 6114;
+export declare const TISTORE_ERROR_CANCELLED: 6115;
+export declare const TISTORE_ERROR_RANGE_TOO_LARGE: 6117;
+export declare const TISTORE_ERROR_NO_FRAME: 6118;
+export declare const TISTORE_ERROR_NO_RECORDABLE_MEDIA: 6119;
+export declare const TISTORE_ERROR_RECORDING_OVERRUN: 6120;
+export declare const TISTORE_ERROR_RECORDING_UNREADABLE: 6122;
+export declare const TISTORE_ERROR_STORE_UNAVAILABLE: 6123;
+export declare const TISTORE_ERROR_STOPPED: 6124;
+export type TiStoreRecordingRange = Readonly<{
+    startTimeMs: number;
+    endTimeMs: number;
+}>;
+export type TiStoreRecordingRangesResult = Readonly<{
+    code: number;
+    recordings: ReadonlyArray<TiStoreRecordingRange>;
+}>;
+export type TiStoreRecordingDay = Readonly<{
+    date: string;
+    hasRecording: boolean;
+}>;
+export type TiStoreRecordingDaysResult = Readonly<{
+    code: number;
+    days: ReadonlyArray<TiStoreRecordingDay>;
+}>;
+export declare const TiStoreReplaySpeed: {
+    readonly x1: "x1";
+    readonly x2: "x2";
+    readonly x4: "x4";
+    readonly x8: "x8";
+};
+export type TiStoreReplaySpeed = (typeof TiStoreReplaySpeed)[keyof typeof TiStoreReplaySpeed];
+export declare const TiStoreAudioOutputState: {
+    readonly idle: "idle";
+    readonly buffering: "buffering";
+    readonly playing: "playing";
+    readonly failed: "failed";
+    readonly paused: "paused";
+    readonly completed: "completed";
+};
+export type TiStoreAudioOutputState = (typeof TiStoreAudioOutputState)[keyof typeof TiStoreAudioOutputState];
+export declare const TiStoreVideoOutputState: {
+    readonly idle: "idle";
+    readonly buffering: "buffering";
+    readonly rendering: "rendering";
+    readonly failed: "failed";
+    readonly paused: "paused";
+    readonly completed: "completed";
+};
+export type TiStoreVideoOutputState = (typeof TiStoreVideoOutputState)[keyof typeof TiStoreVideoOutputState];
+export type TiStoreStartRecordingOptions = Readonly<{
+    videoChannelId: number;
+    audioChannelId?: number;
+}>;
+export type TiStoreExportOptions = Readonly<{
+    startTimeMs: number;
+    endTimeMs: number;
+    videoChannelId: number;
+    audioChannelId?: number;
+}>;
+export type TiStoreGalleryAsset = TiRtcGalleryAsset;
+export interface TiStoreRecordingFile {
+    readonly path: string;
+    readonly durationMs: number;
+    moveToGallery(fileName?: string): Promise<Resp<TiStoreGalleryAsset>>;
+    delete(): Promise<number>;
+}
+export interface TiStoreSnapshotFile {
+    readonly path: string;
+    moveToGallery(fileName?: string): Promise<Resp<TiStoreGalleryAsset>>;
+    delete(): Promise<number>;
+}
+export declare class TiStore {
+    private token;
+    private identity;
+    private disposed;
+    onTokenExpired: (() => void) | null;
+    constructor(token: string);
+    static init(options: Readonly<{
+        appId: string;
+        endpoint?: string;
+        consoleLogEnabled?: boolean;
+    }>): Promise<number>;
+    static shutdown(): number;
+    static errorToString(code: number): string;
+    updateToken(token: string): number;
+    listRecordings(startTimeMs: number, endTimeMs: number): Promise<TiStoreRecordingRangesResult>;
+    listRecordingDays(startDate: string, endDate: string, timeZoneId?: string): Promise<TiStoreRecordingDaysResult>;
+    createReplay(): TiStoreReplay;
+    exportRecording(options: TiStoreExportOptions, onProgress?: (progress: number) => void): Resp<TiStoreExportTask>;
+    dispose(): number;
+    private ensureIdentity;
+}
+export declare class TiStoreReplay {
+    private readonly store;
+    private identity;
+    private disposed;
+    private currentSpeed;
+    private currentTime;
+    onTimeChanged: ((timeMs: number) => void) | null;
+    onError: ((code: number) => void) | null;
+    onCompleted: (() => void) | null;
+    constructor(store: TiStore);
+    get speed(): TiStoreReplaySpeed;
+    get currentTimeMs(): number | null;
+    play(startTimeMs: number, endTimeMs: number, initialTimeMs?: number): number;
+    pause(): number;
+    resume(): number;
+    seek(timeMs: number): number;
+    setSpeed(speed: TiStoreReplaySpeed): number;
+    startRecording(options: TiStoreStartRecordingOptions): Resp<TiStoreRecordingTask>;
+    stop(): number;
+    dispose(): number;
+    private command;
+    private ensureIdentity;
+    private handleEvent;
+}
+declare abstract class StoreOutputBase {
+    protected identity: NativeIdentity | null;
+    protected disposed: boolean;
+    protected bound: boolean;
+    protected abstract create(): ReturnType<typeof NativeTiRtc.storeCreateAudioOutput>;
+    protected ensureIdentity(): NativeIdentity | number;
+    protected abstract handleEvent(event: NativeTiRtcEvent): void;
+    protected releaseIdentity(): void;
+}
+export declare class TiStoreAudioOutput extends StoreOutputBase {
+    private currentState;
+    onStateChanged: ((state: TiStoreAudioOutputState) => void) | null;
+    onError: ((code: number) => void) | null;
+    protected create(): Readonly<{
+        code: number;
+        objectId: import("./specs/NativeTiRtc").NativeObjectId;
+        generation: number;
+        message: string | null;
+    }>;
+    get state(): TiStoreAudioOutputState;
+    attach(replay: TiStoreReplay, channelId: number): number;
+    setVolume(volumePercent: number): number;
+    detach(): number;
+    dispose(): number;
+    protected handleEvent(event: NativeTiRtcEvent): void;
+}
+export type TiStoreVideoOutputViewProps = ViewProps & Readonly<{
+    output: TiStoreVideoOutput;
+    resizeMode?: 'contain' | 'cover' | 'stretch';
+}>;
+export declare class TiStoreVideoOutput extends StoreOutputBase {
+    private currentState;
+    onStateChanged: ((state: TiStoreVideoOutputState) => void) | null;
+    onError: ((code: number) => void) | null;
+    protected create(): Readonly<{
+        code: number;
+        objectId: import("./specs/NativeTiRtc").NativeObjectId;
+        generation: number;
+        message: string | null;
+    }>;
+    get state(): TiStoreVideoOutputState;
+    view(props?: Omit<TiStoreVideoOutputViewProps, 'output'>): React.ReactElement;
+    attach(replay: TiStoreReplay, channelId: number): number;
+    takeSnapshot(): Promise<Resp<TiStoreSnapshotFile>>;
+    detach(): number;
+    dispose(): number;
+    protected handleEvent(event: NativeTiRtcEvent): void;
+}
+export declare function TiStoreVideoOutputView(props: TiStoreVideoOutputViewProps): React.ReactElement;
+export declare class TiStoreRecordingTask {
+    private readonly taskId;
+    private readonly owner;
+    private stopPromise;
+    constructor(taskId: number, owner: TiStoreReplay);
+    stop(): Promise<Resp<TiStoreRecordingFile>>;
+}
+export declare class TiStoreExportTask {
+    private readonly taskId;
+    private readonly owner;
+    private readonly onProgress?;
+    private resultPromise;
+    constructor(taskId: number, owner: TiStore, onProgress?: ((progress: number) => void) | undefined);
+    get progress(): number;
+    get result(): Promise<Resp<TiStoreRecordingFile>>;
+    stop(): Promise<Resp<TiStoreRecordingFile>>;
+}
+export {};

package/lib/typescript/video_input.d.ts

@@ -33,6 +33,7 @@ export declare class TiRtcVideoInput {
     preview(props?: VideoInputPreviewPropsWithoutOwner): React.ReactElement;
     dispose(): Promise<number>;
     private enqueue;
+    private logged;
     private ensureIdentity;
     private adoptIdentity;
     private refreshActualConfig;

package/lib/typescript/video_output.d.ts

@@ -1,5 +1,6 @@
 import * as React from 'react';
 import { TiRtcConn } from './conn';
+import { type Resp, type TiRtcSnapshotFile } from './recording';
 import type { TiRtcOnVideoOutputError, TiRtcOnVideoOutputRenderSizeChanged, TiRtcOnVideoOutputStateChanged, TiRtcSize, TiRtcVideoOutputDebugSnapshotResult, TiRtcVideoOutputMetricsResult, TiRtcVideoOutputOptions, TiRtcVideoOutputState, TiRtcVideoOutputViewProps } from './types';
 type VideoOutputViewPropsWithoutOwner = Omit<TiRtcVideoOutputViewProps, 'output'>;
 export declare class TiRtcVideoOutput {
@@ -8,10 +9,12 @@ export declare class TiRtcVideoOutput {
     private createCode;
     private currentState;
     private currentRenderSize;
+    private snapshotInFlight;
     private options;
     onStateChanged: TiRtcOnVideoOutputStateChanged | null;
     onRenderSizeChanged: TiRtcOnVideoOutputRenderSizeChanged | null;
     onError: TiRtcOnVideoOutputError | null;
+    takeSnapshot(): Promise<Resp<TiRtcSnapshotFile>>;
     constructor();
     get state(): TiRtcVideoOutputState;
     get renderSize(): TiRtcSize | null;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tirtc-react-native",
-  "version": "2.3.1",
+  "version": "2.4.0-alpha.3",
   "description": "TiRTC React Native SDK",
   "homepage": "https://tange.ai/",
   "repository": {

package/src/audio_input.ts

@@ -2,21 +2,17 @@ import {
   isPlainObject,
   isUInt8,
   normalizeCreateResult,
-  returnReleasedIfDisposed,
+  returnNotInitializedIfDisposed,
   TIRTC_ERROR_INVALID_ARGUMENT,
   TIRTC_ERROR_OK,
-  TIRTC_HOST_ERROR_OBJECT_RELEASED,
+  TIRTC_ERROR_NOT_INITIALIZED,
 } from './errors';
 import {registerNativeEventHandler, unregisterNativeEventHandler} from './events';
 import {clearNativeIdentity, readNativeIdentity, setNativeIdentity, type NativeIdentity} from './native_object_id';
 import {NativeTiRtc, type NativeTiRtcEvent} from './native';
+import {logRtcOutcome, logRtcState} from './logging_internal';
 import {TiRtcConn} from './conn';
-import type {
-  TiRtcAudioInputOptions,
-  TiRtcInputState,
-  TiRtcOnInputError,
-  TiRtcOnInputStateChanged,
-} from './types';
+import type {TiRtcAudioInputOptions, TiRtcInputState, TiRtcOnInputError, TiRtcOnInputStateChanged} from './types';
 
 export class TiRtcAudioInput {
   private identity: NativeIdentity | null = null;
@@ -40,8 +36,12 @@ export class TiRtcAudioInput {
     const result = normalizeCreateResult(NativeTiRtc.createAudioInput());
     this.createCode = result.code;
     if (result.code === TIRTC_ERROR_OK) {
-      this.adoptIdentity({objectId: result.objectId, generation: result.generation});
+      this.adoptIdentity({
+        objectId: result.objectId,
+        generation: result.generation,
+      });
     }
+    logRtcOutcome('audio_input_create', result.code);
   }
 
   get state(): TiRtcInputState {
@@ -87,32 +87,41 @@ export class TiRtcAudioInput {
     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);
-    });
+    return this.logged(
+      'audio_input_attach',
+      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);
-    });
+    return this.logged(
+      'audio_input_start',
+      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);
-    });
+    return this.logged(
+      'audio_input_stop',
+      this.enqueue(async () => {
+        if (this.identity === null) {
+          return TIRTC_ERROR_OK;
+        }
+        return NativeTiRtc.audioInputStop(this.identity.objectId);
+      }),
+    );
   }
 
   detach(connection: TiRtcConn): Promise<number> {
@@ -120,47 +129,53 @@ export class TiRtcAudioInput {
     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);
-    });
+    return this.logged(
+      'audio_input_detach',
+      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);
+    return this.logged(
+      'audio_input_dispose',
+      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);
+    const released = returnNotInitializedIfDisposed(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 TIRTC_ERROR_NOT_INITIALIZED;
       }
       return operation();
     });
@@ -168,8 +183,15 @@ export class TiRtcAudioInput {
     return next;
   }
 
+  private logged(operation: string, result: Promise<number>): Promise<number> {
+    return result.then((code) => {
+      logRtcOutcome(operation, code);
+      return code;
+    });
+  }
+
   private ensureIdentity(): NativeIdentity | number {
-    const released = returnReleasedIfDisposed(this.disposed);
+    const released = returnNotInitializedIfDisposed(this.disposed);
     if (released !== null) {
       return released;
     }
@@ -196,10 +218,14 @@ export class TiRtcAudioInput {
       return;
     }
     if (event.type === 'audioInputStateChanged' && event.state !== undefined) {
-      this.currentState = event.state as TiRtcInputState;
+      const nextState = event.state as TiRtcInputState;
+      if (this.currentState !== nextState) logRtcState('audio_input_state', nextState);
+      this.currentState = nextState;
       this.onStateChanged?.(this.currentState);
     } else if (event.type === 'audioInputError') {
-      this.onError?.(event.code ?? TIRTC_ERROR_INVALID_ARGUMENT, event.message ?? null);
+      const code = event.code ?? TIRTC_ERROR_INVALID_ARGUMENT;
+      logRtcOutcome('audio_input', code);
+      this.onError?.(code, event.message ?? null);
     }
   }
 }