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

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 NativeTiCloudStorageRecordingRange = Readonly<{
+    startTimeMs: number;
+    endTimeMs: number;
+}>;
+export type NativeTiCloudStorageRecordingRangesResult = Readonly<{
+    code: number;
+    recordings: ReadonlyArray<NativeTiCloudStorageRecordingRange>;
+}>;
+export type NativeTiCloudStorageRecordingDay = Readonly<{
+    date: string;
+    hasRecording: boolean;
+}>;
+export type NativeTiCloudStorageRecordingDaysResult = Readonly<{
+    code: number;
+    days: ReadonlyArray<NativeTiCloudStorageRecordingDay>;
+}>;
+export type NativeTiCloudStorageReplayInfo = Readonly<{
+    code: number;
+    speed: number;
+    currentTimeMs: number | null;
+}>;
+export type NativeTiCloudStorageTaskStartResult = 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>;
+    tiCloudStorageInitialize(options: NativeInitOptions): Promise<number>;
+    tiCloudStorageShutdown(): number;
+    tiCloudStorageCreate(token: string): NativeCreateResult;
+    tiCloudStorageUpdateToken(id: NativeObjectId, token: string): number;
+    tiCloudStorageListRecordings(id: NativeObjectId, startTimeMs: number, endTimeMs: number): Promise<NativeTiCloudStorageRecordingRangesResult>;
+    tiCloudStorageListRecordingDays(id: NativeObjectId, startDate: string, endDate: string, timeZoneId: string): Promise<NativeTiCloudStorageRecordingDaysResult>;
+    tiCloudStorageCreateReplay(id: NativeObjectId): NativeCreateResult;
+    tiCloudStorageExportRecording(id: NativeObjectId, startTimeMs: number, endTimeMs: number, videoChannelId: number, audioChannelId: number | null): NativeTiCloudStorageTaskStartResult;
+    tiCloudStorageExportProgress(id: NativeObjectId): number;
+    tiCloudStorageExportResult(id: NativeObjectId): Promise<NativeMp4Result>;
+    tiCloudStorageExportStop(id: NativeObjectId): number;
+    tiCloudStorageDispose(id: NativeObjectId): number;
+    tiCloudStorageReplayGetInfo(id: NativeObjectId): NativeTiCloudStorageReplayInfo;
+    tiCloudStorageReplayPlay(id: NativeObjectId, startTimeMs: number, endTimeMs: number, initialTimeMs: number | null): number;
+    tiCloudStorageReplayPause(id: NativeObjectId): number;
+    tiCloudStorageReplayResume(id: NativeObjectId): number;
+    tiCloudStorageReplaySeek(id: NativeObjectId, timeMs: number): number;
+    tiCloudStorageReplaySetSpeed(id: NativeObjectId, speed: number): number;
+    tiCloudStorageReplayStartRecording(id: NativeObjectId, videoChannelId: number, audioChannelId: number | null): NativeTiCloudStorageTaskStartResult;
+    tiCloudStorageRecordingTaskStop(id: NativeObjectId): Promise<NativeMp4Result>;
+    tiCloudStorageReplayStop(id: NativeObjectId): number;
+    tiCloudStorageReplayDispose(id: NativeObjectId): number;
+    tiCloudStorageCreateAudioOutput(): NativeCreateResult;
+    tiCloudStorageAudioOutputGetState(id: NativeObjectId): NativeStateResult;
+    tiCloudStorageAudioOutputSetVolume(id: NativeObjectId, volumePercent: number): number;
+    tiCloudStorageAudioOutputAttach(outputId: NativeObjectId, replayId: NativeObjectId, channelId: number): number;
+    tiCloudStorageAudioOutputDetach(outputId: NativeObjectId): number;
+    tiCloudStorageAudioOutputDispose(id: NativeObjectId): number;
+    tiCloudStorageCreateVideoOutput(): NativeCreateResult;
+    tiCloudStorageVideoOutputGetState(id: NativeObjectId): NativeStateResult;
+    tiCloudStorageVideoOutputAttach(outputId: NativeObjectId, replayId: NativeObjectId, channelId: number): number;
+    tiCloudStorageVideoOutputDetach(outputId: NativeObjectId): number;
+    tiCloudStorageVideoOutputTakeSnapshot(id: NativeObjectId): Promise<NativeSnapshotResult>;
+    tiCloudStorageVideoOutputDispose(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/storage.d.ts

@@ -0,0 +1,204 @@
+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 TI_CLOUD_STORAGE_ERROR_OK: 0;
+export declare const TI_CLOUD_STORAGE_ERROR_INVALID_ARGUMENT: 6000;
+export declare const TI_CLOUD_STORAGE_ERROR_NOT_INITIALIZED: 6001;
+export declare const TI_CLOUD_STORAGE_ERROR_TOKEN_EXPIRED: 6014;
+export declare const TI_CLOUD_STORAGE_ERROR_ALREADY_INITIALIZED: 6022;
+export declare const TI_CLOUD_STORAGE_ERROR_PERMISSION_DENIED: 6024;
+export declare const TI_CLOUD_STORAGE_ERROR_IN_USE: 6026;
+export declare const TI_CLOUD_STORAGE_ERROR_NOT_STARTED: 6027;
+export declare const TI_CLOUD_STORAGE_ERROR_NOT_BOUND: 6029;
+export declare const TI_CLOUD_STORAGE_ERROR_NOT_CONFIGURED: 6030;
+export declare const TI_CLOUD_STORAGE_ERROR_RESOURCE_EXHAUSTED: 6043;
+export declare const TI_CLOUD_STORAGE_ERROR_FILE_WRITE_FAILED: 6046;
+export declare const TI_CLOUD_STORAGE_ERROR_UNSUPPORTED_FORMAT: 6113;
+export declare const TI_CLOUD_STORAGE_ERROR_IO_FAILED: 6114;
+export declare const TI_CLOUD_STORAGE_ERROR_CANCELLED: 6115;
+export declare const TI_CLOUD_STORAGE_ERROR_RANGE_TOO_LARGE: 6117;
+export declare const TI_CLOUD_STORAGE_ERROR_NO_FRAME: 6118;
+export declare const TI_CLOUD_STORAGE_ERROR_NO_RECORDABLE_MEDIA: 6119;
+export declare const TI_CLOUD_STORAGE_ERROR_RECORDING_OVERRUN: 6120;
+export declare const TI_CLOUD_STORAGE_ERROR_RECORDING_UNREADABLE: 6122;
+export declare const TI_CLOUD_STORAGE_ERROR_UNAVAILABLE: 6123;
+export declare const TI_CLOUD_STORAGE_ERROR_STOPPED: 6124;
+export type TiCloudStorageRecordingRange = Readonly<{
+    startTimeMs: number;
+    endTimeMs: number;
+}>;
+export type TiCloudStorageRecordingRangesResult = Readonly<{
+    code: number;
+    recordings: ReadonlyArray<TiCloudStorageRecordingRange>;
+}>;
+export type TiCloudStorageRecordingDay = Readonly<{
+    date: string;
+    hasRecording: boolean;
+}>;
+export type TiCloudStorageRecordingDaysResult = Readonly<{
+    code: number;
+    days: ReadonlyArray<TiCloudStorageRecordingDay>;
+}>;
+export declare const TiCloudStorageReplaySpeed: {
+    readonly x0_125: "x0_125";
+    readonly x0_25: "x0_25";
+    readonly x0_5: "x0_5";
+    readonly x1: "x1";
+    readonly x2: "x2";
+    readonly x4: "x4";
+    readonly x8: "x8";
+};
+export type TiCloudStorageReplaySpeed = (typeof TiCloudStorageReplaySpeed)[keyof typeof TiCloudStorageReplaySpeed];
+export declare const TiCloudStorageAudioOutputState: {
+    readonly idle: "idle";
+    readonly buffering: "buffering";
+    readonly playing: "playing";
+    readonly failed: "failed";
+    readonly paused: "paused";
+    readonly completed: "completed";
+};
+export type TiCloudStorageAudioOutputState = (typeof TiCloudStorageAudioOutputState)[keyof typeof TiCloudStorageAudioOutputState];
+export declare const TiCloudStorageVideoOutputState: {
+    readonly idle: "idle";
+    readonly buffering: "buffering";
+    readonly rendering: "rendering";
+    readonly failed: "failed";
+    readonly paused: "paused";
+    readonly completed: "completed";
+};
+export type TiCloudStorageVideoOutputState = (typeof TiCloudStorageVideoOutputState)[keyof typeof TiCloudStorageVideoOutputState];
+export type TiCloudStorageStartRecordingOptions = Readonly<{
+    videoChannelId: number;
+    audioChannelId?: number;
+}>;
+export type TiCloudStorageExportOptions = Readonly<{
+    startTimeMs: number;
+    endTimeMs: number;
+    videoChannelId: number;
+    audioChannelId?: number;
+}>;
+export type TiCloudStorageGalleryAsset = TiRtcGalleryAsset;
+export interface TiCloudStorageRecordingFile {
+    readonly path: string;
+    readonly durationMs: number;
+    moveToGallery(fileName?: string): Promise<Resp<TiCloudStorageGalleryAsset>>;
+    delete(): Promise<number>;
+}
+export interface TiCloudStorageSnapshotFile {
+    readonly path: string;
+    moveToGallery(fileName?: string): Promise<Resp<TiCloudStorageGalleryAsset>>;
+    delete(): Promise<number>;
+}
+export declare class TiCloudStorage {
+    private token;
+    private identity;
+    private disposed;
+    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<TiCloudStorageRecordingRangesResult>;
+    listRecordingDays(startDate: string, endDate: string, timeZoneId?: string): Promise<TiCloudStorageRecordingDaysResult>;
+    createReplay(): TiCloudStorageReplay;
+    exportRecording(options: TiCloudStorageExportOptions, onProgress?: (progress: number) => void): Resp<TiCloudStorageExportTask>;
+    dispose(): number;
+    private ensureIdentity;
+}
+export declare class TiCloudStorageReplay {
+    private readonly cloudStorage;
+    private identity;
+    private disposed;
+    private currentSpeed;
+    private currentTime;
+    onTimeChanged: ((timeMs: number) => void) | null;
+    onError: ((code: number) => void) | null;
+    onCompleted: (() => void) | null;
+    constructor(cloudStorage: TiCloudStorage);
+    get speed(): TiCloudStorageReplaySpeed;
+    get currentTimeMs(): number | null;
+    play(startTimeMs: number, endTimeMs: number, initialTimeMs?: number): number;
+    pause(): number;
+    resume(): number;
+    seek(timeMs: number): number;
+    setSpeed(speed: TiCloudStorageReplaySpeed): number;
+    startRecording(options: TiCloudStorageStartRecordingOptions): Resp<TiCloudStorageRecordingTask>;
+    stop(): number;
+    dispose(): number;
+    private command;
+    private ensureIdentity;
+    private handleEvent;
+}
+declare abstract class TiCloudStorageOutputBase {
+    protected identity: NativeIdentity | null;
+    protected disposed: boolean;
+    protected bound: boolean;
+    protected abstract create(): ReturnType<typeof NativeTiRtc.tiCloudStorageCreateAudioOutput>;
+    protected ensureIdentity(): NativeIdentity | number;
+    protected abstract handleEvent(event: NativeTiRtcEvent): void;
+    protected releaseIdentity(): void;
+}
+export declare class TiCloudStorageAudioOutput extends TiCloudStorageOutputBase {
+    private currentState;
+    onStateChanged: ((state: TiCloudStorageAudioOutputState) => void) | null;
+    onError: ((code: number) => void) | null;
+    protected create(): Readonly<{
+        code: number;
+        objectId: import("./specs/NativeTiRtc").NativeObjectId;
+        generation: number;
+        message: string | null;
+    }>;
+    get state(): TiCloudStorageAudioOutputState;
+    attach(replay: TiCloudStorageReplay, channelId: number): number;
+    setVolume(volumePercent: number): number;
+    detach(): number;
+    dispose(): number;
+    protected handleEvent(event: NativeTiRtcEvent): void;
+}
+export type TiCloudStorageVideoOutputViewProps = ViewProps & Readonly<{
+    output: TiCloudStorageVideoOutput;
+    resizeMode?: 'contain' | 'cover' | 'stretch';
+}>;
+export declare class TiCloudStorageVideoOutput extends TiCloudStorageOutputBase {
+    private currentState;
+    onStateChanged: ((state: TiCloudStorageVideoOutputState) => void) | null;
+    onError: ((code: number) => void) | null;
+    protected create(): Readonly<{
+        code: number;
+        objectId: import("./specs/NativeTiRtc").NativeObjectId;
+        generation: number;
+        message: string | null;
+    }>;
+    get state(): TiCloudStorageVideoOutputState;
+    view(props?: Omit<TiCloudStorageVideoOutputViewProps, 'output'>): React.ReactElement;
+    attach(replay: TiCloudStorageReplay, channelId: number): number;
+    takeSnapshot(): Promise<Resp<TiCloudStorageSnapshotFile>>;
+    detach(): number;
+    dispose(): number;
+    protected handleEvent(event: NativeTiRtcEvent): void;
+}
+export declare function TiCloudStorageVideoOutputView(props: TiCloudStorageVideoOutputViewProps): React.ReactElement;
+export declare class TiCloudStorageRecordingTask {
+    private readonly taskId;
+    private readonly owner;
+    private stopPromise;
+    constructor(taskId: number, owner: TiCloudStorageReplay);
+    stop(): Promise<Resp<TiCloudStorageRecordingFile>>;
+}
+export declare class TiCloudStorageExportTask {
+    private readonly taskId;
+    private readonly owner;
+    private readonly onProgress?;
+    private resultPromise;
+    constructor(taskId: number, owner: TiCloudStorage, onProgress?: ((progress: number) => void) | undefined);
+    get progress(): number;
+    get result(): Promise<Resp<TiCloudStorageRecordingFile>>;
+    stop(): Promise<Resp<TiCloudStorageRecordingFile>>;
+}
+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.4",
   "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);
     }
   }
 }