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

package/src/storage.ts

@@ -0,0 +1,769 @@
+import * as React from 'react';
+import {View, type ViewProps} from 'react-native';
+
+import {
+  isFiniteSafeInteger,
+  isPlainObject,
+  isUInt8,
+  normalizeCreateResult,
+  TIRTC_ERROR_INVALID_ARGUMENT,
+  TIRTC_ERROR_OK,
+} from './errors';
+import {registerNativeEventHandler, unregisterNativeEventHandler} from './events';
+import {TiRtcLogging} from './logging';
+import {NativeTiRtc, NativeTiRtcVideoOutputView, type NativeTiRtcEvent} from './native';
+import {
+  clearNativeIdentity,
+  readNativeIdentity,
+  setNativeIdentity,
+  subscribeNativeIdentity,
+  type NativeIdentity,
+} from './native_object_id';
+import {NativeMediaFileBase, recordingFailure, type Resp, type TiRtcGalleryAsset} from './recording';
+
+export const TI_CLOUD_STORAGE_ERROR_OK = 0 as const;
+export const TI_CLOUD_STORAGE_ERROR_INVALID_ARGUMENT = 6000 as const;
+export const TI_CLOUD_STORAGE_ERROR_NOT_INITIALIZED = 6001 as const;
+export const TI_CLOUD_STORAGE_ERROR_TOKEN_EXPIRED = 6014 as const;
+export const TI_CLOUD_STORAGE_ERROR_ALREADY_INITIALIZED = 6022 as const;
+export const TI_CLOUD_STORAGE_ERROR_PERMISSION_DENIED = 6024 as const;
+export const TI_CLOUD_STORAGE_ERROR_IN_USE = 6026 as const;
+export const TI_CLOUD_STORAGE_ERROR_NOT_STARTED = 6027 as const;
+export const TI_CLOUD_STORAGE_ERROR_NOT_BOUND = 6029 as const;
+export const TI_CLOUD_STORAGE_ERROR_NOT_CONFIGURED = 6030 as const;
+export const TI_CLOUD_STORAGE_ERROR_RESOURCE_EXHAUSTED = 6043 as const;
+export const TI_CLOUD_STORAGE_ERROR_FILE_WRITE_FAILED = 6046 as const;
+export const TI_CLOUD_STORAGE_ERROR_UNSUPPORTED_FORMAT = 6113 as const;
+export const TI_CLOUD_STORAGE_ERROR_IO_FAILED = 6114 as const;
+export const TI_CLOUD_STORAGE_ERROR_CANCELLED = 6115 as const;
+export const TI_CLOUD_STORAGE_ERROR_RANGE_TOO_LARGE = 6117 as const;
+export const TI_CLOUD_STORAGE_ERROR_NO_FRAME = 6118 as const;
+export const TI_CLOUD_STORAGE_ERROR_NO_RECORDABLE_MEDIA = 6119 as const;
+export const TI_CLOUD_STORAGE_ERROR_RECORDING_OVERRUN = 6120 as const;
+export const TI_CLOUD_STORAGE_ERROR_RECORDING_UNREADABLE = 6122 as const;
+export const TI_CLOUD_STORAGE_ERROR_UNAVAILABLE = 6123 as const;
+export const TI_CLOUD_STORAGE_ERROR_STOPPED = 6124 as const;
+
+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 const TiCloudStorageReplaySpeed = {
+  x0_125: 'x0_125',
+  x0_25: 'x0_25',
+  x0_5: 'x0_5',
+  x1: 'x1',
+  x2: 'x2',
+  x4: 'x4',
+  x8: 'x8',
+} as const;
+export type TiCloudStorageReplaySpeed = (typeof TiCloudStorageReplaySpeed)[keyof typeof TiCloudStorageReplaySpeed];
+const tiCloudStorageLogTag = 'TIRTC_REACT_NATIVE_CLOUD_STORAGE';
+
+function tiCloudStorageLogOutcome(operation: string, code: number, details = ''): void {
+  const message = `[${operation}] outcome=${code === TI_CLOUD_STORAGE_ERROR_OK ? 'ok' : 'failed'} error_code=${code}${details}`;
+  if (code === TI_CLOUD_STORAGE_ERROR_OK) TiRtcLogging.i(tiCloudStorageLogTag, message);
+  else TiRtcLogging.e(tiCloudStorageLogTag, message);
+}
+
+export const TiCloudStorageAudioOutputState = {
+  idle: 'idle',
+  buffering: 'buffering',
+  playing: 'playing',
+  failed: 'failed',
+  paused: 'paused',
+  completed: 'completed',
+} as const;
+export type TiCloudStorageAudioOutputState = (typeof TiCloudStorageAudioOutputState)[keyof typeof TiCloudStorageAudioOutputState];
+export const TiCloudStorageVideoOutputState = {
+  idle: 'idle',
+  buffering: 'buffering',
+  rendering: 'rendering',
+  failed: 'failed',
+  paused: 'paused',
+  completed: 'completed',
+} as const;
+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>;
+}
+class RecordingFile extends NativeMediaFileBase implements TiCloudStorageRecordingFile {
+  constructor(
+    path: string,
+    readonly durationMs: number,
+    id: number,
+  ) {
+    super(path, id, 'video');
+  }
+}
+class SnapshotFile extends NativeMediaFileBase implements TiCloudStorageSnapshotFile {
+  constructor(path: string, id: number) {
+    super(path, id, 'image');
+  }
+}
+
+function success<T>(data: T): Resp<T> {
+  return {success: true, code: null, message: null, data};
+}
+function validTime(value: number): boolean {
+  return isFiniteSafeInteger(value) && value >= 0;
+}
+function speedToNative(speed: TiCloudStorageReplaySpeed): number | null {
+  switch (speed) {
+    case TiCloudStorageReplaySpeed.x0_125:
+      return 6;
+    case TiCloudStorageReplaySpeed.x0_25:
+      return 5;
+    case TiCloudStorageReplaySpeed.x0_5:
+      return 4;
+    case TiCloudStorageReplaySpeed.x1:
+      return 0;
+    case TiCloudStorageReplaySpeed.x2:
+      return 1;
+    case TiCloudStorageReplaySpeed.x4:
+      return 2;
+    case TiCloudStorageReplaySpeed.x8:
+      return 3;
+    default:
+      return null;
+  }
+}
+function speedFromNative(speed: number): TiCloudStorageReplaySpeed | null {
+  switch (speed) {
+    case 6:
+      return TiCloudStorageReplaySpeed.x0_125;
+    case 5:
+      return TiCloudStorageReplaySpeed.x0_25;
+    case 4:
+      return TiCloudStorageReplaySpeed.x0_5;
+    case 0:
+      return TiCloudStorageReplaySpeed.x1;
+    case 1:
+      return TiCloudStorageReplaySpeed.x2;
+    case 2:
+      return TiCloudStorageReplaySpeed.x4;
+    case 3:
+      return TiCloudStorageReplaySpeed.x8;
+    default:
+      return null;
+  }
+}
+function audioStateFromNative(state: unknown): TiCloudStorageAudioOutputState {
+  switch (state) {
+    case TiCloudStorageAudioOutputState.idle:
+    case TiCloudStorageAudioOutputState.buffering:
+    case TiCloudStorageAudioOutputState.playing:
+    case TiCloudStorageAudioOutputState.failed:
+    case TiCloudStorageAudioOutputState.paused:
+    case TiCloudStorageAudioOutputState.completed:
+      return state;
+    default:
+      return TiCloudStorageAudioOutputState.failed;
+  }
+}
+function videoStateFromNative(state: unknown): TiCloudStorageVideoOutputState {
+  switch (state) {
+    case TiCloudStorageVideoOutputState.idle:
+    case TiCloudStorageVideoOutputState.buffering:
+    case TiCloudStorageVideoOutputState.rendering:
+    case TiCloudStorageVideoOutputState.failed:
+    case TiCloudStorageVideoOutputState.paused:
+    case TiCloudStorageVideoOutputState.completed:
+      return state;
+    default:
+      return TiCloudStorageVideoOutputState.failed;
+  }
+}
+
+export class TiCloudStorage {
+  private identity: NativeIdentity | null = null;
+  private disposed = false;
+  constructor(private token: string) {}
+
+  static init(
+    options: Readonly<{
+      appId: string;
+      endpoint?: string;
+      consoleLogEnabled?: boolean;
+    }>,
+  ): Promise<number> {
+    if (!isPlainObject(options) || typeof options.appId !== 'string' || options.appId.length === 0) {
+      tiCloudStorageLogOutcome('cloud_storage_initialize', TI_CLOUD_STORAGE_ERROR_INVALID_ARGUMENT);
+      return Promise.resolve(TI_CLOUD_STORAGE_ERROR_INVALID_ARGUMENT);
+    }
+    return NativeTiRtc.tiCloudStorageInitialize({
+      appId: options.appId,
+      endpoint: options.endpoint ?? '',
+      consoleLogEnabled: options.consoleLogEnabled ?? false,
+    }).then((code) => {
+      tiCloudStorageLogOutcome('cloud_storage_initialize', code);
+      return code;
+    });
+  }
+  static shutdown(): number {
+    const nativeCode = NativeTiRtc.tiCloudStorageShutdown();
+    const code = nativeCode === TI_CLOUD_STORAGE_ERROR_NOT_INITIALIZED ? TI_CLOUD_STORAGE_ERROR_OK : nativeCode;
+    tiCloudStorageLogOutcome('cloud_storage_shutdown', code);
+    return code;
+  }
+  static errorToString(code: number): string {
+    return NativeTiRtc.errorToString(code);
+  }
+
+  updateToken(token: string): number {
+    if (token.length === 0) return TI_CLOUD_STORAGE_ERROR_INVALID_ARGUMENT;
+    const identity = this.ensureIdentity();
+    if (typeof identity === 'number') return identity;
+    const code = NativeTiRtc.tiCloudStorageUpdateToken(identity.objectId, token);
+    if (code === 0) this.token = token;
+    tiCloudStorageLogOutcome('cloud_storage_update_token', code);
+    return code;
+  }
+  listRecordings(startTimeMs: number, endTimeMs: number): Promise<TiCloudStorageRecordingRangesResult> {
+    if (!validTime(startTimeMs) || !validTime(endTimeMs) || endTimeMs <= startTimeMs) {
+      return Promise.resolve({
+        code: TI_CLOUD_STORAGE_ERROR_INVALID_ARGUMENT,
+        recordings: [],
+      });
+    }
+    const identity = this.ensureIdentity();
+    if (typeof identity === 'number') {
+      tiCloudStorageLogOutcome('recording_list', identity);
+      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;
+    });
+  }
+  listRecordingDays(
+    startDate: string,
+    endDate: string,
+    timeZoneId = 'Asia/Shanghai',
+  ): Promise<TiCloudStorageRecordingDaysResult> {
+    if (
+      typeof startDate !== 'string' ||
+      typeof endDate !== 'string' ||
+      typeof timeZoneId !== 'string' ||
+      timeZoneId.length === 0
+    ) {
+      return Promise.resolve({code: TI_CLOUD_STORAGE_ERROR_INVALID_ARGUMENT, days: []});
+    }
+    const identity = this.ensureIdentity();
+    if (typeof identity === 'number') {
+      tiCloudStorageLogOutcome('recording_days_list', identity);
+      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;
+    });
+  }
+  createReplay(): TiCloudStorageReplay {
+    return new TiCloudStorageReplay(this);
+  }
+  exportRecording(options: TiCloudStorageExportOptions, onProgress?: (progress: number) => void): Resp<TiCloudStorageExportTask> {
+    if (
+      !validTime(options.startTimeMs) ||
+      !validTime(options.endTimeMs) ||
+      options.endTimeMs <= options.startTimeMs ||
+      !isUInt8(options.videoChannelId) ||
+      (options.audioChannelId !== undefined && !isUInt8(options.audioChannelId))
+    ) {
+      return recordingFailure(TI_CLOUD_STORAGE_ERROR_INVALID_ARGUMENT);
+    }
+    const identity = this.ensureIdentity();
+    if (typeof identity === 'number') return recordingFailure(identity);
+    const result = NativeTiRtc.tiCloudStorageExportRecording(
+      identity.objectId,
+      options.startTimeMs,
+      options.endTimeMs,
+      options.videoChannelId,
+      options.audioChannelId ?? null,
+    );
+    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))
+      : recordingFailure(result.code);
+  }
+  dispose(): number {
+    if (this.disposed) return 0;
+    if (this.identity === null) {
+      this.disposed = true;
+      this.token = '';
+      return 0;
+    }
+    const identity = this.identity;
+    const code = NativeTiRtc.tiCloudStorageDispose(identity.objectId);
+    if (code === 0) {
+      unregisterNativeEventHandler(identity);
+      clearNativeIdentity(this);
+      this.identity = null;
+      this.disposed = true;
+      this.token = '';
+    }
+    return code;
+  }
+  private ensureIdentity(): NativeIdentity | number {
+    if (this.disposed) return TI_CLOUD_STORAGE_ERROR_NOT_INITIALIZED;
+    if (this.identity !== null) return this.identity;
+    if (this.token.length === 0) return TI_CLOUD_STORAGE_ERROR_INVALID_ARGUMENT;
+    const result = normalizeCreateResult(NativeTiRtc.tiCloudStorageCreate(this.token));
+    if (result.code !== 0) return result.code;
+    this.identity = {
+      objectId: result.objectId,
+      generation: result.generation,
+    };
+    setNativeIdentity(this, this.identity);
+    return this.identity;
+  }
+}
+
+function tiCloudStorageNativeIdentity(cloudStorage: TiCloudStorage): NativeIdentity | number {
+  return (cloudStorage as unknown as {ensureIdentity(): NativeIdentity | number}).ensureIdentity();
+}
+
+export class TiCloudStorageReplay {
+  private identity: NativeIdentity | null = null;
+  private disposed = 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;
+  constructor(private readonly cloudStorage: TiCloudStorage) {}
+  get speed(): TiCloudStorageReplaySpeed {
+    if (this.identity !== null) {
+      const info = NativeTiRtc.tiCloudStorageReplayGetInfo(this.identity.objectId);
+      if (info.code === 0) this.currentSpeed = speedFromNative(info.speed) ?? this.currentSpeed;
+    }
+    return this.currentSpeed;
+  }
+  get currentTimeMs(): number | null {
+    if (this.identity !== null) {
+      const info = NativeTiRtc.tiCloudStorageReplayGetInfo(this.identity.objectId);
+      if (info.code === 0) this.currentTime = info.currentTimeMs;
+    }
+    return this.currentTime;
+  }
+  play(startTimeMs: number, endTimeMs: number, initialTimeMs?: number): number {
+    if (
+      !validTime(startTimeMs) ||
+      !validTime(endTimeMs) ||
+      endTimeMs <= startTimeMs ||
+      (initialTimeMs !== undefined &&
+        (!validTime(initialTimeMs) || initialTimeMs < startTimeMs || initialTimeMs >= endTimeMs))
+    )
+      return TI_CLOUD_STORAGE_ERROR_INVALID_ARGUMENT;
+    const identity = this.ensureIdentity();
+    const code =
+      typeof identity === 'number'
+        ? identity
+        : NativeTiRtc.tiCloudStorageReplayPlay(identity.objectId, startTimeMs, endTimeMs, initialTimeMs ?? null);
+    tiCloudStorageLogOutcome('replay_play', code, ` range_duration_ms=${endTimeMs - startTimeMs}`);
+    return code;
+  }
+  pause(): number {
+    const code = this.command(NativeTiRtc.tiCloudStorageReplayPause);
+    tiCloudStorageLogOutcome('replay_pause', code);
+    return code;
+  }
+  resume(): number {
+    const code = this.command(NativeTiRtc.tiCloudStorageReplayResume);
+    tiCloudStorageLogOutcome('replay_resume', code);
+    return code;
+  }
+  seek(timeMs: number): number {
+    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);
+    tiCloudStorageLogOutcome('replay_seek', code);
+    return code;
+  }
+  setSpeed(speed: TiCloudStorageReplaySpeed): number {
+    const index = speedToNative(speed);
+    if (index === null) return TI_CLOUD_STORAGE_ERROR_INVALID_ARGUMENT;
+    const identity = this.ensureIdentity();
+    if (typeof identity === 'number') return identity;
+    const code = NativeTiRtc.tiCloudStorageReplaySetSpeed(identity.objectId, index);
+    if (code === 0) this.currentSpeed = speed;
+    tiCloudStorageLogOutcome('replay_speed', code, ` speed=${speed}`);
+    return code;
+  }
+  startRecording(options: TiCloudStorageStartRecordingOptions): Resp<TiCloudStorageRecordingTask> {
+    if (
+      !isUInt8(options.videoChannelId) ||
+      (options.audioChannelId !== undefined && !isUInt8(options.audioChannelId))
+    ) {
+      return recordingFailure(TI_CLOUD_STORAGE_ERROR_INVALID_ARGUMENT);
+    }
+    const identity = this.ensureIdentity();
+    if (typeof identity === 'number') return recordingFailure(identity);
+    const result = NativeTiRtc.tiCloudStorageReplayStartRecording(
+      identity.objectId,
+      options.videoChannelId,
+      options.audioChannelId ?? null,
+    );
+    tiCloudStorageLogOutcome('replay_recording_start', result.code);
+    return result.code === 0 && result.taskId !== null
+      ? success(new TiCloudStorageRecordingTask(result.taskId, this))
+      : recordingFailure(result.code);
+  }
+  stop(): number {
+    const code = this.command(NativeTiRtc.tiCloudStorageReplayStop);
+    if (code === 0) this.currentTime = null;
+    tiCloudStorageLogOutcome('replay_stop', code);
+    return code;
+  }
+  dispose(): number {
+    if (this.disposed) return 0;
+    if (this.identity === null) {
+      this.disposed = true;
+      this.onTimeChanged = null;
+      this.onError = null;
+      this.onCompleted = null;
+      return 0;
+    }
+    const identity = this.identity;
+    const code = NativeTiRtc.tiCloudStorageReplayDispose(identity.objectId);
+    if (code === 0) {
+      unregisterNativeEventHandler(identity);
+      clearNativeIdentity(this);
+      this.identity = null;
+      this.disposed = true;
+      this.onTimeChanged = null;
+      this.onError = null;
+      this.onCompleted = null;
+    }
+    tiCloudStorageLogOutcome('replay_dispose', code);
+    return code;
+  }
+  private command(operation: (id: number) => number): number {
+    const identity = this.ensureIdentity();
+    return typeof identity === 'number' ? identity : operation(identity.objectId);
+  }
+  private ensureIdentity(): NativeIdentity | number {
+    if (this.disposed) return TI_CLOUD_STORAGE_ERROR_NOT_INITIALIZED;
+    if (this.identity !== null) return this.identity;
+    const cloudStorage = tiCloudStorageNativeIdentity(this.cloudStorage);
+    if (typeof cloudStorage === 'number') return cloudStorage;
+    const result = normalizeCreateResult(NativeTiRtc.tiCloudStorageCreateReplay(cloudStorage.objectId));
+    if (result.code !== 0) return result.code;
+    this.identity = {
+      objectId: result.objectId,
+      generation: result.generation,
+    };
+    setNativeIdentity(this, this.identity);
+    registerNativeEventHandler(this.identity, (event) => this.handleEvent(event));
+    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);
+  }
+}
+
+function nativeReplayIdentity(replay: TiCloudStorageReplay): NativeIdentity | number {
+  return (replay as unknown as {ensureIdentity(): NativeIdentity | number}).ensureIdentity();
+}
+
+abstract class TiCloudStorageOutputBase {
+  protected identity: NativeIdentity | null = null;
+  protected disposed = false;
+  protected bound = false;
+  protected abstract create(): ReturnType<typeof NativeTiRtc.tiCloudStorageCreateAudioOutput>;
+  protected ensureIdentity(): NativeIdentity | number {
+    if (this.disposed) return TI_CLOUD_STORAGE_ERROR_NOT_INITIALIZED;
+    if (this.identity !== null) return this.identity;
+    const result = normalizeCreateResult(this.create());
+    if (result.code !== 0) return result.code;
+    this.identity = {
+      objectId: result.objectId,
+      generation: result.generation,
+    };
+    setNativeIdentity(this, this.identity);
+    registerNativeEventHandler(this.identity, (event) => this.handleEvent(event));
+    return this.identity;
+  }
+  protected abstract handleEvent(event: NativeTiRtcEvent): void;
+  protected releaseIdentity(): void {
+    if (this.identity !== null) {
+      unregisterNativeEventHandler(this.identity);
+      clearNativeIdentity(this);
+    }
+    this.identity = null;
+    this.disposed = true;
+  }
+}
+
+export class TiCloudStorageAudioOutput extends TiCloudStorageOutputBase {
+  private currentState: TiCloudStorageAudioOutputState = 'idle';
+  onStateChanged: ((state: TiCloudStorageAudioOutputState) => void) | null = null;
+  onError: ((code: number) => void) | null = null;
+  protected create() {
+    return NativeTiRtc.tiCloudStorageCreateAudioOutput();
+  }
+  get state(): TiCloudStorageAudioOutputState {
+    if (this.identity !== null)
+      this.currentState = audioStateFromNative(
+        NativeTiRtc.tiCloudStorageAudioOutputGetState(this.identity.objectId).state ?? this.currentState,
+      );
+    return this.currentState;
+  }
+  attach(replay: TiCloudStorageReplay, channelId: number): number {
+    if (!isUInt8(channelId)) return TI_CLOUD_STORAGE_ERROR_INVALID_ARGUMENT;
+    const output = this.ensureIdentity();
+    const replayId = nativeReplayIdentity(replay);
+    if (typeof output === 'number') return output;
+    if (typeof replayId === 'number') return replayId;
+    const code = NativeTiRtc.tiCloudStorageAudioOutputAttach(output.objectId, replayId.objectId, channelId);
+    if (code === 0) this.bound = true;
+    tiCloudStorageLogOutcome('audio_output_attach', code);
+    return code;
+  }
+  setVolume(volumePercent: number): number {
+    if (!isFiniteSafeInteger(volumePercent) || volumePercent < 0 || volumePercent > 100)
+      return TI_CLOUD_STORAGE_ERROR_INVALID_ARGUMENT;
+    const output = this.ensureIdentity();
+    return typeof output === 'number' ? output : NativeTiRtc.tiCloudStorageAudioOutputSetVolume(output.objectId, volumePercent);
+  }
+  detach(): number {
+    if (this.identity === null) return 0;
+    const code = NativeTiRtc.tiCloudStorageAudioOutputDetach(this.identity.objectId);
+    if (code === 0) {
+      this.bound = false;
+      this.currentState = TiCloudStorageAudioOutputState.idle;
+    }
+    tiCloudStorageLogOutcome('audio_output_detach', code);
+    return code;
+  }
+  dispose(): number {
+    if (this.disposed) return 0;
+    if (this.bound) return TI_CLOUD_STORAGE_ERROR_IN_USE;
+    if (this.identity === null) {
+      this.disposed = true;
+      this.currentState = TiCloudStorageAudioOutputState.idle;
+      this.onStateChanged = null;
+      this.onError = null;
+      return 0;
+    }
+    const code = NativeTiRtc.tiCloudStorageAudioOutputDispose(this.identity.objectId);
+    if (code === 0) {
+      this.releaseIdentity();
+      this.currentState = TiCloudStorageAudioOutputState.idle;
+      this.onStateChanged = null;
+      this.onError = null;
+    }
+    tiCloudStorageLogOutcome('audio_output_dispose', code);
+    return code;
+  }
+  protected handleEvent(event: NativeTiRtcEvent): void {
+    if (event.type === 'audioOutputStateChanged' && event.state !== undefined) {
+      this.currentState = audioStateFromNative(event.state);
+      this.onStateChanged?.(this.currentState);
+    } else if (event.type === 'audioOutputError') this.onError?.(event.code ?? TI_CLOUD_STORAGE_ERROR_IO_FAILED);
+  }
+}
+
+export type TiCloudStorageVideoOutputViewProps = ViewProps &
+  Readonly<{
+    output: TiCloudStorageVideoOutput;
+    resizeMode?: 'contain' | 'cover' | 'stretch';
+  }>;
+export class TiCloudStorageVideoOutput extends TiCloudStorageOutputBase {
+  private currentState: TiCloudStorageVideoOutputState = 'idle';
+  onStateChanged: ((state: TiCloudStorageVideoOutputState) => void) | null = null;
+  onError: ((code: number) => void) | null = null;
+  protected create() {
+    return NativeTiRtc.tiCloudStorageCreateVideoOutput();
+  }
+  get state(): TiCloudStorageVideoOutputState {
+    if (this.identity !== null)
+      this.currentState = videoStateFromNative(
+        NativeTiRtc.tiCloudStorageVideoOutputGetState(this.identity.objectId).state ?? this.currentState,
+      );
+    return this.currentState;
+  }
+  view(props: Omit<TiCloudStorageVideoOutputViewProps, 'output'> = {}): React.ReactElement {
+    this.ensureIdentity();
+    return React.createElement(TiCloudStorageVideoOutputView, {
+      ...props,
+      output: this,
+    });
+  }
+  attach(replay: TiCloudStorageReplay, channelId: number): number {
+    if (!isUInt8(channelId)) return TI_CLOUD_STORAGE_ERROR_INVALID_ARGUMENT;
+    const output = this.ensureIdentity();
+    const replayId = nativeReplayIdentity(replay);
+    if (typeof output === 'number') return output;
+    if (typeof replayId === 'number') return replayId;
+    const code = NativeTiRtc.tiCloudStorageVideoOutputAttach(output.objectId, replayId.objectId, channelId);
+    if (code === 0) this.bound = true;
+    tiCloudStorageLogOutcome('video_output_attach', code);
+    return code;
+  }
+  async takeSnapshot(): Promise<Resp<TiCloudStorageSnapshotFile>> {
+    const output = this.ensureIdentity();
+    if (typeof output === 'number') return recordingFailure(output);
+    const result = await NativeTiRtc.tiCloudStorageVideoOutputTakeSnapshot(output.objectId);
+    tiCloudStorageLogOutcome('snapshot', result.code);
+    return result.code === 0 && result.fileId !== null && result.filePath !== null
+      ? success(new SnapshotFile(result.filePath, result.fileId))
+      : recordingFailure(result.code);
+  }
+  detach(): number {
+    if (this.identity === null) return 0;
+    const code = NativeTiRtc.tiCloudStorageVideoOutputDetach(this.identity.objectId);
+    if (code === 0) {
+      this.bound = false;
+      this.currentState = TiCloudStorageVideoOutputState.idle;
+    }
+    tiCloudStorageLogOutcome('video_output_detach', code);
+    return code;
+  }
+  dispose(): number {
+    if (this.disposed) return 0;
+    if (this.bound) return TI_CLOUD_STORAGE_ERROR_IN_USE;
+    if (this.identity === null) {
+      this.disposed = true;
+      this.currentState = TiCloudStorageVideoOutputState.idle;
+      this.onStateChanged = null;
+      this.onError = null;
+      return 0;
+    }
+    const code = NativeTiRtc.tiCloudStorageVideoOutputDispose(this.identity.objectId);
+    if (code === 0) {
+      this.releaseIdentity();
+      this.currentState = TiCloudStorageVideoOutputState.idle;
+      this.onStateChanged = null;
+      this.onError = null;
+    }
+    tiCloudStorageLogOutcome('video_output_dispose', code);
+    return code;
+  }
+  protected handleEvent(event: NativeTiRtcEvent): void {
+    if (event.type === 'videoOutputStateChanged' && event.state !== undefined) {
+      this.currentState = videoStateFromNative(event.state);
+      this.onStateChanged?.(this.currentState);
+    } else if (event.type === 'videoOutputError') this.onError?.(event.code ?? TI_CLOUD_STORAGE_ERROR_IO_FAILED);
+  }
+}
+
+export function TiCloudStorageVideoOutputView(props: TiCloudStorageVideoOutputViewProps): React.ReactElement {
+  const {output, resizeMode = 'contain', ...viewProps} = props;
+  const identity = useOwnerIdentity(output);
+  return identity === null
+    ? React.createElement(View, viewProps)
+    : React.createElement(NativeTiRtcVideoOutputView, {
+        ...viewProps,
+        nativeObjectId: identity.objectId,
+        generation: identity.generation,
+        resizeMode,
+      });
+}
+function useOwnerIdentity(owner: TiCloudStorageVideoOutput): NativeIdentity | null {
+  const [, update] = React.useReducer((value: number) => value + 1, 0);
+  React.useEffect(() => subscribeNativeIdentity(owner, update), [owner]);
+  return readNativeIdentity(owner);
+}
+
+export class TiCloudStorageRecordingTask {
+  private stopPromise: Promise<Resp<TiCloudStorageRecordingFile>> | null = null;
+  constructor(
+    private readonly taskId: number,
+    private readonly owner: TiCloudStorageReplay,
+  ) {}
+  stop(): Promise<Resp<TiCloudStorageRecordingFile>> {
+    void this.owner;
+    return (this.stopPromise ??= NativeTiRtc.tiCloudStorageRecordingTaskStop(this.taskId).then((result) => {
+      tiCloudStorageLogOutcome('replay_recording_stop', 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);
+    }));
+  }
+}
+
+export class TiCloudStorageExportTask {
+  private resultPromise: Promise<Resp<TiCloudStorageRecordingFile>>;
+  constructor(
+    private readonly taskId: number,
+    private readonly owner: TiCloudStorage,
+    private readonly onProgress?: (progress: number) => void,
+  ) {
+    this.resultPromise = NativeTiRtc.tiCloudStorageExportResult(taskId).then((result) => {
+      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);
+    });
+    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);
+    }
+  }
+  get progress(): number {
+    void this.owner;
+    return NativeTiRtc.tiCloudStorageExportProgress(this.taskId);
+  }
+  get result(): Promise<Resp<TiCloudStorageRecordingFile>> {
+    return this.resultPromise;
+  }
+  stop(): Promise<Resp<TiCloudStorageRecordingFile>> {
+    const code = NativeTiRtc.tiCloudStorageExportStop(this.taskId);
+    tiCloudStorageLogOutcome('export_stop', code);
+    return this.resultPromise;
+  }
+}