tirtc-react-native 2.5.0-alpha.1 → 2.5.2

package/src/storage.ts

@@ -12,7 +12,14 @@ import {
 import {registerNativeEventHandler, unregisterNativeEventHandler} from './events';
 import {TiRtcLogging} from './logging';
 import {logBuildIdentity} from './logging_internal';
-import {NativeTiRtc, NativeTiRtcVideoOutputView, type NativeTiRtcEvent} from './native';
+import {
+  NativeTiRtc,
+  NativeTiRtcVideoOutputView,
+  type NativeTiRtcEvent,
+  type NativeTiCloudStorageExportProgress,
+  type NativeTiCloudStorageExportReport,
+  type NativeTiCloudStorageRecordingGap,
+} from './native';
 import {
   clearNativeIdentity,
   readNativeIdentity,
@@ -21,6 +28,12 @@ import {
   type NativeIdentity,
 } from './native_object_id';
 import {NativeMediaFileBase, recordingFailure, type Resp, type TiRtcGalleryAsset} from './recording';
+import {
+  createRawDumpFromNative,
+  normalizeRawDumpIds,
+  TiRawDump,
+  type TiCloudStorageRawDumpOptions,
+} from './raw_dump';
 
 export const TI_CLOUD_STORAGE_ERROR_OK = 0 as const;
 export const TI_CLOUD_STORAGE_ERROR_INVALID_ARGUMENT = 6000 as const;
@@ -66,6 +79,70 @@ export type TiCloudStorageRecordingDaysResult = Readonly<{
   days: ReadonlyArray<TiCloudStorageRecordingDay>;
 }>;
 
+export const TiCloudStorageRecordingTrackKind = {video: 'video', audio: 'audio'} as const;
+export type TiCloudStorageRecordingTrackKind =
+  (typeof TiCloudStorageRecordingTrackKind)[keyof typeof TiCloudStorageRecordingTrackKind];
+export type TiCloudStorageRecordingTrack = Readonly<{
+  kind: TiCloudStorageRecordingTrackKind;
+  channelId: number;
+}>;
+export const TiCloudStorageRecordingGapReason = {
+  unknown: 'unknown',
+  notFound: 'notFound',
+  downloadFailed: 'downloadFailed',
+  integrityFailed: 'integrityFailed',
+  mediaUnreadable: 'mediaUnreadable',
+  noKeyFrame: 'noKeyFrame',
+  noRecording: 'noRecording',
+  decryptionFailed: 'decryptionFailed',
+  unsupportedMedia: 'unsupportedMedia',
+  trackUnavailable: 'trackUnavailable',
+} as const;
+export type TiCloudStorageRecordingGapReason =
+  (typeof TiCloudStorageRecordingGapReason)[keyof typeof TiCloudStorageRecordingGapReason];
+export type TiCloudStorageRecordingGap = Readonly<{
+  range: TiCloudStorageRecordingRange;
+  tracks: ReadonlyArray<TiCloudStorageRecordingTrack>;
+  reasons: ReadonlyArray<TiCloudStorageRecordingGapReason>;
+}>;
+export type TiCloudStorageExportProgress = Readonly<{
+  fraction: number;
+  coveredDurationMs: number;
+}>;
+export type TiCloudStorageExportSegment = Readonly<{
+  sourceRange: TiCloudStorageRecordingRange;
+  outputStartMs: number;
+  outputEndMs: number;
+}>;
+export const TiCloudStorageExportTermination = {
+  exhausted: 'exhausted',
+  interrupted: 'interrupted',
+  cancelled: 'cancelled',
+  failed: 'failed',
+} as const;
+export type TiCloudStorageExportTermination =
+  (typeof TiCloudStorageExportTermination)[keyof typeof TiCloudStorageExportTermination];
+export type TiCloudStorageExportReport = Readonly<{
+  requestedRange: TiCloudStorageRecordingRange;
+  coveredDurationMs: number;
+  segments: ReadonlyArray<TiCloudStorageExportSegment>;
+  gaps: ReadonlyArray<TiCloudStorageRecordingGap>;
+  unprocessedRanges: ReadonlyArray<TiCloudStorageRecordingRange>;
+  complete: boolean;
+  termination: TiCloudStorageExportTermination;
+  cause: number;
+}>;
+export type TiCloudStorageExportOutcome = Readonly<{
+  code: number;
+  file: TiCloudStorageRecordingFile | null;
+  report: TiCloudStorageExportReport | null;
+}>;
+export type TiCloudStorageExportObserver = Readonly<{
+  onProgress?: (progress: number) => void;
+  onProgressDetail?: (progress: TiCloudStorageExportProgress) => void;
+  onRecordingGap?: (gap: TiCloudStorageRecordingGap) => void;
+}>;
+
 export const TiCloudStorageReplaySpeed = {
   x0_125: 'x0_125',
   x0_25: 'x0_25',
@@ -147,6 +224,37 @@ function success<T>(data: T): Resp<T> {
 function validTime(value: number): boolean {
   return isFiniteSafeInteger(value) && value >= 0;
 }
+
+function recordingGapFromNative(value: NativeTiCloudStorageRecordingGap): TiCloudStorageRecordingGap {
+  const kinds = [TiCloudStorageRecordingTrackKind.video, TiCloudStorageRecordingTrackKind.audio] as const;
+  const reasons = Object.values(TiCloudStorageRecordingGapReason);
+  return {
+    range: value.range,
+    tracks: value.tracks.flatMap((track) => {
+      const kind = kinds[track.kind - 1];
+      return kind === undefined ? [] : [{kind, channelId: track.channelId}];
+    }),
+    reasons: value.reasons.map((reason) => reasons[reason] ?? TiCloudStorageRecordingGapReason.unknown),
+  };
+}
+
+function exportProgressFromNative(value: NativeTiCloudStorageExportProgress): TiCloudStorageExportProgress {
+  return {fraction: value.fraction, coveredDurationMs: value.coveredDurationMs};
+}
+
+function exportReportFromNative(value: NativeTiCloudStorageExportReport): TiCloudStorageExportReport {
+  const terminations = Object.values(TiCloudStorageExportTermination);
+  return {
+    requestedRange: value.requestedRange,
+    coveredDurationMs: value.coveredDurationMs,
+    segments: value.segments,
+    gaps: value.gaps.map(recordingGapFromNative),
+    unprocessedRanges: value.unprocessedRanges,
+    complete: value.complete,
+    termination: terminations[value.termination] ?? TiCloudStorageExportTermination.failed,
+    cause: value.cause,
+  };
+}
 function speedToNative(speed: TiCloudStorageReplaySpeed): number | null {
   switch (speed) {
     case TiCloudStorageReplaySpeed.x0_125:
@@ -217,6 +325,7 @@ function videoStateFromNative(state: unknown): TiCloudStorageVideoOutputState {
 export class TiCloudStorage {
   private identity: NativeIdentity | null = null;
   private disposed = false;
+  private pendingAsyncOperations = 0;
   constructor(private token: string) {}
 
   static init(
@@ -272,10 +381,12 @@ export class TiCloudStorage {
       return Promise.resolve({code: identity, recordings: []});
     }
     TiRtcLogging.i(tiCloudStorageLogTag, `[recording_list] outcome=started range_duration_ms=${endTimeMs - startTimeMs}`);
-    return NativeTiRtc.tiCloudStorageListRecordings(identity.objectId, startTimeMs, endTimeMs).then((result) => {
-      tiCloudStorageLogOutcome('recording_list', result.code, ` recording_count=${result.recordings.length}`);
-      return result;
-    });
+    return this.trackAsyncOperation(() =>
+      NativeTiRtc.tiCloudStorageListRecordings(identity.objectId, startTimeMs, endTimeMs).then((result) => {
+        tiCloudStorageLogOutcome('recording_list', result.code, ` recording_count=${result.recordings.length}`);
+        return result;
+      }),
+    );
   }
   listRecordingDays(
     startDate: string,
@@ -296,20 +407,25 @@ export class TiCloudStorage {
       return Promise.resolve({code: identity, days: []});
     }
     TiRtcLogging.i(tiCloudStorageLogTag, '[recording_days_list] outcome=started');
-    return NativeTiRtc.tiCloudStorageListRecordingDays(
-      identity.objectId,
-      startDate,
-      endDate,
-      timeZoneId,
-    ).then((result) => {
-      tiCloudStorageLogOutcome('recording_days_list', result.code, ` day_count=${result.days.length}`);
-      return result;
-    });
+    return this.trackAsyncOperation(() =>
+      NativeTiRtc.tiCloudStorageListRecordingDays(
+        identity.objectId,
+        startDate,
+        endDate,
+        timeZoneId,
+      ).then((result) => {
+        tiCloudStorageLogOutcome('recording_days_list', result.code, ` day_count=${result.days.length}`);
+        return result;
+      }),
+    );
   }
   createReplay(): TiCloudStorageReplay {
     return new TiCloudStorageReplay(this);
   }
-  exportRecording(options: TiCloudStorageExportOptions, onProgress?: (progress: number) => void): Resp<TiCloudStorageExportTask> {
+  exportRecording(
+    options: TiCloudStorageExportOptions,
+    observer?: ((progress: number) => void) | TiCloudStorageExportObserver,
+  ): Resp<TiCloudStorageExportTask> {
     if (
       !validTime(options.startTimeMs) ||
       !validTime(options.endTimeMs) ||
@@ -330,11 +446,12 @@ export class TiCloudStorage {
     );
     tiCloudStorageLogOutcome('export_start', result.code, ` range_duration_ms=${options.endTimeMs - options.startTimeMs}`);
     return result.code === 0 && result.taskId !== null
-      ? success(new TiCloudStorageExportTask(result.taskId, this, onProgress))
+      ? success(new TiCloudStorageExportTask(result.taskId, result.generation, this, observer))
       : recordingFailure(result.code);
   }
   dispose(): number {
     if (this.disposed) return 0;
+    if (this.pendingAsyncOperations > 0) return TI_CLOUD_STORAGE_ERROR_IN_USE;
     if (this.identity === null) {
       this.disposed = true;
       this.token = '';
@@ -351,6 +468,17 @@ export class TiCloudStorage {
     }
     return code;
   }
+  private trackAsyncOperation<T>(operation: () => Promise<T>): Promise<T> {
+    this.pendingAsyncOperations += 1;
+    try {
+      return operation().finally(() => {
+        this.pendingAsyncOperations -= 1;
+      });
+    } catch (error) {
+      this.pendingAsyncOperations -= 1;
+      return Promise.reject(error);
+    }
+  }
   private ensureIdentity(): NativeIdentity | number {
     if (this.disposed) return TI_CLOUD_STORAGE_ERROR_NOT_INITIALIZED;
     if (this.identity !== null) return this.identity;
@@ -373,11 +501,13 @@ function tiCloudStorageNativeIdentity(cloudStorage: TiCloudStorage): NativeIdent
 export class TiCloudStorageReplay {
   private identity: NativeIdentity | null = null;
   private disposed = false;
+  private inCallback = false;
   private currentSpeed: TiCloudStorageReplaySpeed = 'x1';
   private currentTime: number | null = null;
   onTimeChanged: ((timeMs: number) => void) | null = null;
   onError: ((code: number) => void) | null = null;
   onCompleted: (() => void) | null = null;
+  onRecordingGap: ((gap: TiCloudStorageRecordingGap) => void) | null = null;
   constructor(private readonly cloudStorage: TiCloudStorage) {}
   get speed(): TiCloudStorageReplaySpeed {
     if (this.identity !== null) {
@@ -394,6 +524,7 @@ export class TiCloudStorageReplay {
     return this.currentTime;
   }
   play(startTimeMs: number, endTimeMs: number, initialTimeMs?: number): number {
+    if (this.inCallback) return TI_CLOUD_STORAGE_ERROR_IN_USE;
     if (
       !validTime(startTimeMs) ||
       !validTime(endTimeMs) ||
@@ -421,6 +552,7 @@ export class TiCloudStorageReplay {
     return code;
   }
   seek(timeMs: number): number {
+    if (this.inCallback) return TI_CLOUD_STORAGE_ERROR_IN_USE;
     if (!validTime(timeMs)) return TI_CLOUD_STORAGE_ERROR_INVALID_ARGUMENT;
     const identity = this.ensureIdentity();
     const code = typeof identity === 'number' ? identity : NativeTiRtc.tiCloudStorageReplaySeek(identity.objectId, timeMs);
@@ -456,19 +588,38 @@ export class TiCloudStorageReplay {
       ? success(new TiCloudStorageRecordingTask(result.taskId, this))
       : recordingFailure(result.code);
   }
+  async startRawDump(options: TiCloudStorageRawDumpOptions): Promise<Resp<TiRawDump>> {
+    if (options === null || typeof options !== 'object')
+      return recordingFailure(TI_CLOUD_STORAGE_ERROR_INVALID_ARGUMENT);
+    const audio = normalizeRawDumpIds(options.audioChannelIds ?? [], 255);
+    const video = normalizeRawDumpIds(options.videoChannelIds ?? [], 255);
+    if (audio === null || video === null || (audio.length === 0 && video.length === 0))
+      return recordingFailure(TI_CLOUD_STORAGE_ERROR_INVALID_ARGUMENT);
+    const identity = this.ensureIdentity();
+    if (typeof identity === 'number') return recordingFailure(identity);
+    const result = await NativeTiRtc.tiCloudStorageReplayStartRawDump(
+      identity.objectId, audio, video,
+    );
+    return result.code === 0 && result.dumpId !== null
+      ? {success: true, code: null, message: null, data: createRawDumpFromNative(result.dumpId)}
+      : recordingFailure(result.code);
+  }
   stop(): number {
+    if (this.inCallback) return TI_CLOUD_STORAGE_ERROR_IN_USE;
     const code = this.command(NativeTiRtc.tiCloudStorageReplayStop);
     if (code === 0) this.currentTime = null;
     tiCloudStorageLogOutcome('replay_stop', code);
     return code;
   }
   dispose(): number {
+    if (this.inCallback) return TI_CLOUD_STORAGE_ERROR_IN_USE;
     if (this.disposed) return 0;
     if (this.identity === null) {
       this.disposed = true;
       this.onTimeChanged = null;
       this.onError = null;
       this.onCompleted = null;
+      this.onRecordingGap = null;
       return 0;
     }
     const identity = this.identity;
@@ -481,6 +632,7 @@ export class TiCloudStorageReplay {
       this.onTimeChanged = null;
       this.onError = null;
       this.onCompleted = null;
+      this.onRecordingGap = null;
     }
     tiCloudStorageLogOutcome('replay_dispose', code);
     return code;
@@ -505,11 +657,18 @@ export class TiCloudStorageReplay {
     return this.identity;
   }
   private handleEvent(event: NativeTiRtcEvent): void {
-    if (event.type === 'tiCloudStorageReplayTimeChanged' && event.timestampMs !== undefined) {
-      this.currentTime = event.timestampMs;
-      this.onTimeChanged?.(event.timestampMs);
-    } else if (event.type === 'tiCloudStorageReplayCompleted') this.onCompleted?.();
-    else if (event.type === 'tiCloudStorageReplayError') this.onError?.(event.code ?? TI_CLOUD_STORAGE_ERROR_UNAVAILABLE);
+    this.inCallback = true;
+    try {
+      if (event.type === 'tiCloudStorageReplayTimeChanged' && event.timestampMs !== undefined) {
+        this.currentTime = event.timestampMs;
+        this.onTimeChanged?.(event.timestampMs);
+      } else if (event.type === 'tiCloudStorageReplayCompleted') this.onCompleted?.();
+      else if (event.type === 'tiCloudStorageReplayError') this.onError?.(event.code ?? TI_CLOUD_STORAGE_ERROR_UNAVAILABLE);
+      else if (event.type === 'tiCloudStorageReplayRecordingGap' && event.recordingGap !== undefined)
+        this.onRecordingGap?.(recordingGapFromNative(event.recordingGap));
+    } finally {
+      this.inCallback = false;
+    }
   }
 }
 
@@ -736,40 +895,98 @@ export class TiCloudStorageRecordingTask {
 
 export class TiCloudStorageExportTask {
   private resultPromise: Promise<Resp<TiCloudStorageRecordingFile>>;
+  private completionPromise: Promise<TiCloudStorageExportOutcome>;
+  private readonly identity: NativeIdentity;
+  private currentProgressDetail: TiCloudStorageExportProgress = {fraction: 0, coveredDurationMs: 0};
+  private currentReport: TiCloudStorageExportReport | null = null;
+  private readonly observer: TiCloudStorageExportObserver;
+  private terminal = false;
+
   constructor(
     private readonly taskId: number,
+    generation: number,
     private readonly owner: TiCloudStorage,
-    private readonly onProgress?: (progress: number) => void,
+    observer?: ((progress: number) => void) | TiCloudStorageExportObserver,
   ) {
-    this.resultPromise = NativeTiRtc.tiCloudStorageExportResult(taskId).then((result) => {
+    this.identity = {objectId: taskId, generation};
+    this.observer = typeof observer === 'function' ? {onProgress: observer} : (observer ?? {});
+    registerNativeEventHandler(this.identity, (event) => this.handleEvent(event));
+    this.completionPromise = NativeTiRtc.tiCloudStorageExportResult(taskId).then((result) => {
+      if (result.progressDetail != null) {
+        const progress = exportProgressFromNative(result.progressDetail);
+        this.currentProgressDetail = {
+          fraction: Math.max(this.currentProgressDetail.fraction, progress.fraction),
+          coveredDurationMs: Math.max(this.currentProgressDetail.coveredDurationMs, progress.coveredDurationMs),
+        };
+      }
+      this.terminal = true;
+      unregisterNativeEventHandler(this.identity);
       tiCloudStorageLogOutcome('export_terminal', result.code, ` duration_ms=${result.durationMs ?? 0}`);
-      return result.code === 0 && result.fileId !== null && result.filePath !== null && result.durationMs !== null
-        ? success(new RecordingFile(result.filePath, result.durationMs, result.fileId))
-        : recordingFailure(result.code);
+      const file =
+        result.fileId !== null && result.filePath !== null && result.durationMs !== null
+          ? new RecordingFile(result.filePath, result.durationMs, result.fileId)
+          : null;
+      this.currentReport = result.report === null ? null : exportReportFromNative(result.report);
+      if (this.currentReport !== null) {
+        this.currentProgressDetail = {
+          fraction: this.currentProgressDetail.fraction,
+          coveredDurationMs: this.currentReport.coveredDurationMs,
+        };
+      }
+      return {code: result.code, file, report: this.currentReport};
     });
-    if (onProgress !== undefined) {
-      let lastProgress = -1;
-      const timer = setInterval(() => {
-        const progress = NativeTiRtc.tiCloudStorageExportProgress(taskId);
-        if (progress !== lastProgress) {
-          lastProgress = progress;
-          onProgress(progress);
-        }
-      }, 100);
-      const clear = () => clearInterval(timer);
-      void this.resultPromise.then(clear, clear);
-    }
+    this.resultPromise = this.completionPromise.then((outcome) =>
+      outcome.code === TI_CLOUD_STORAGE_ERROR_OK && outcome.file !== null
+        ? success(outcome.file)
+        : recordingFailure(outcome.code),
+    );
   }
   get progress(): number {
     void this.owner;
-    return NativeTiRtc.tiCloudStorageExportProgress(this.taskId);
+    return this.progressDetail.fraction;
+  }
+  get progressDetail(): TiCloudStorageExportProgress {
+    if (this.terminal) return this.currentProgressDetail;
+    const value = exportProgressFromNative(NativeTiRtc.tiCloudStorageExportProgressDetail(this.taskId));
+    this.currentProgressDetail = {
+      fraction: Math.max(this.currentProgressDetail.fraction, value.fraction),
+      coveredDurationMs: Math.max(this.currentProgressDetail.coveredDurationMs, value.coveredDurationMs),
+    };
+    return this.currentProgressDetail;
+  }
+  get report(): TiCloudStorageExportReport | null {
+    return this.currentReport;
+  }
+  get completion(): Promise<TiCloudStorageExportOutcome> {
+    return this.completionPromise;
   }
   get result(): Promise<Resp<TiCloudStorageRecordingFile>> {
     return this.resultPromise;
   }
+  cancel(): number {
+    if (this.terminal) return TI_CLOUD_STORAGE_ERROR_OK;
+    const code = NativeTiRtc.tiCloudStorageExportCancel(this.taskId);
+    tiCloudStorageLogOutcome('export_cancel', code);
+    return code;
+  }
   stop(): Promise<Resp<TiCloudStorageRecordingFile>> {
+    if (this.terminal) return this.resultPromise;
     const code = NativeTiRtc.tiCloudStorageExportStop(this.taskId);
     tiCloudStorageLogOutcome('export_stop', code);
     return this.resultPromise;
   }
+  private handleEvent(event: NativeTiRtcEvent): void {
+    if (this.terminal) return;
+    if (event.type === 'tiCloudStorageExportProgress' && event.exportProgress !== undefined) {
+      const progress = exportProgressFromNative(event.exportProgress);
+      this.currentProgressDetail = {
+        fraction: Math.max(this.currentProgressDetail.fraction, progress.fraction),
+        coveredDurationMs: Math.max(this.currentProgressDetail.coveredDurationMs, progress.coveredDurationMs),
+      };
+      this.observer.onProgress?.(this.currentProgressDetail.fraction);
+      this.observer.onProgressDetail?.(this.currentProgressDetail);
+    } else if (event.type === 'tiCloudStorageExportRecordingGap' && event.recordingGap !== undefined) {
+      this.observer.onRecordingGap?.(recordingGapFromNative(event.recordingGap));
+    }
+  }
 }

package/src/types.ts

@@ -84,13 +84,6 @@ export const TiRtcVideoCodec = {
 } as const;
 export type TiRtcVideoCodec = (typeof TiRtcVideoCodec)[keyof typeof TiRtcVideoCodec];
 
-export const TiRtcVideoEncoderCodec = {
-  h264: 'h264',
-  mjpeg: 'mjpeg',
-} as const;
-export type TiRtcVideoEncoderCodec =
-  (typeof TiRtcVideoEncoderCodec)[keyof typeof TiRtcVideoEncoderCodec];
-
 export const TiRtcVideoFrameRate = {
   fps10: 'fps10',
   fps15: 'fps15',
@@ -183,6 +176,9 @@ export type TiRtcVideoOutputViewProps = ViewProps &
   }>;
 
 export type TiRtcAudioInputOptions = Readonly<{
+  /** Nano audio media: 1 PCM, 2 G711A, 3 AAC, 4 Opus, 5 AMR. Omitted or -1 uses codec. */
+  media?: number;
+  /** @deprecated Use media. The legacy default is g711a. */
   codec?: TiRtcAudioCodec;
   sampleRate?: TiRtcAudioSampleRate;
   channels?: TiRtcAudioChannelCount;
@@ -192,7 +188,8 @@ export type TiRtcAudioInputOptions = Readonly<{
 }>;
 
 export type TiRtcVideoInputOptions = Readonly<{
-  codec?: TiRtcVideoEncoderCodec;
+  /** Nano video media: 66 H.264 (default) or 65 MJPEG. */
+  media?: number;
   width?: number;
   height?: number;
   frameRate?: TiRtcVideoFrameRate;

package/src/video_input.ts

@@ -43,7 +43,7 @@ export class TiRtcVideoInput {
   private currentOutputSize: TiRtcSize | null = null;
   private currentOutputFps: number | null = null;
   private options: Required<TiRtcVideoInputOptions> = {
-    codec: 'h264',
+    media: 66,
     width: 640,
     height: 480,
     frameRate: 'fps15',
@@ -92,7 +92,7 @@ export class TiRtcVideoInput {
       return Promise.resolve(TIRTC_ERROR_INVALID_ARGUMENT);
     }
     const normalized = {
-      codec: options.codec ?? 'h264',
+      media: options.media === undefined ? 66 : options.media,
       width: options.width ?? 640,
       height: options.height ?? 480,
       frameRate: options.frameRate ?? 'fps15',
@@ -100,12 +100,16 @@ export class TiRtcVideoInput {
       cameraFacing: options.cameraFacing ?? 'front',
     };
     if (
+      !Number.isInteger(normalized.media) ||
+      ![65, 66].includes(normalized.media) ||
       !isPositiveInt32Size(normalized.width) ||
       !isPositiveInt32Size(normalized.height) ||
       !Number.isSafeInteger(normalized.bitrateKbps) ||
       normalized.bitrateKbps < 0 ||
       normalized.bitrateKbps > 4294967295
     ) {
+      logRtcOutcome('video_input_set_options', TIRTC_ERROR_INVALID_ARGUMENT,
+        ` nano_media=${typeof normalized.media === 'number' ? normalized.media : typeof normalized.media}`);
       return Promise.resolve(TIRTC_ERROR_INVALID_ARGUMENT);
     }
     return this.enqueue(async () => {
@@ -114,6 +118,8 @@ export class TiRtcVideoInput {
         return identity;
       }
       const code = await NativeTiRtc.videoInputSetOptions(identity.objectId, normalized);
+      logRtcOutcome('video_input_set_options', code,
+        ` nano_media=${normalized.media} width=${normalized.width} height=${normalized.height} fps=${['fps10', 'fps15', 'fps30'].includes(normalized.frameRate) ? normalized.frameRate : 'invalid'}`);
       if (code === TIRTC_ERROR_OK) {
         this.options = normalized;
       }
@@ -122,16 +128,20 @@ export class TiRtcVideoInput {
   }
 
   start(): Promise<number> {
-    return this.logged(
-      'video_input_start',
-      this.enqueue(async () => {
-        const identity = this.ensureIdentity();
-        if (typeof identity === 'number') {
-          return identity;
-        }
-        return NativeTiRtc.videoInputStart(identity.objectId);
-      }),
-    );
+    return this.enqueue(async () => {
+      const identity = this.ensureIdentity();
+      if (typeof identity === 'number') {
+        logRtcOutcome('video_input_start', identity);
+        return identity;
+      }
+      const wasRunning = this.state === 'running';
+      const code = await NativeTiRtc.videoInputStart(identity.objectId);
+      if (code !== TIRTC_ERROR_OK || !wasRunning) {
+        logRtcOutcome('video_input_start', code,
+          ` object_id=${identity.objectId} nano_media=${this.options.media} width=${this.options.width} height=${this.options.height} fps=${this.options.frameRate}`);
+      }
+      return code;
+    });
   }
 
   attach(connection: TiRtcConn, streamId: number): Promise<number> {