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

package/src/store.ts

@@ -0,0 +1,760 @@
+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 TISTORE_ERROR_OK = 0 as const;
+export const TISTORE_ERROR_INVALID_ARGUMENT = 6000 as const;
+export const TISTORE_ERROR_NOT_INITIALIZED = 6001 as const;
+export const TISTORE_ERROR_TOKEN_EXPIRED = 6014 as const;
+export const TISTORE_ERROR_ALREADY_INITIALIZED = 6022 as const;
+export const TISTORE_ERROR_PERMISSION_DENIED = 6024 as const;
+export const TISTORE_ERROR_IN_USE = 6026 as const;
+export const TISTORE_ERROR_NOT_STARTED = 6027 as const;
+export const TISTORE_ERROR_NOT_BOUND = 6029 as const;
+export const TISTORE_ERROR_NOT_CONFIGURED = 6030 as const;
+export const TISTORE_ERROR_RESOURCE_EXHAUSTED = 6043 as const;
+export const TISTORE_ERROR_FILE_WRITE_FAILED = 6046 as const;
+export const TISTORE_ERROR_UNSUPPORTED_FORMAT = 6113 as const;
+export const TISTORE_ERROR_IO_FAILED = 6114 as const;
+export const TISTORE_ERROR_CANCELLED = 6115 as const;
+export const TISTORE_ERROR_RANGE_TOO_LARGE = 6117 as const;
+export const TISTORE_ERROR_NO_FRAME = 6118 as const;
+export const TISTORE_ERROR_NO_RECORDABLE_MEDIA = 6119 as const;
+export const TISTORE_ERROR_RECORDING_OVERRUN = 6120 as const;
+export const TISTORE_ERROR_RECORDING_UNREADABLE = 6122 as const;
+export const TISTORE_ERROR_STORE_UNAVAILABLE = 6123 as const;
+export const TISTORE_ERROR_STOPPED = 6124 as const;
+
+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 const TiStoreReplaySpeed = {
+  x1: 'x1',
+  x2: 'x2',
+  x4: 'x4',
+  x8: 'x8',
+} as const;
+export type TiStoreReplaySpeed = (typeof TiStoreReplaySpeed)[keyof typeof TiStoreReplaySpeed];
+const storeLogTag = 'TIRTC_REACT_NATIVE_STORE';
+
+function logStoreOutcome(operation: string, code: number, details = ''): void {
+  const message = `[${operation}] outcome=${code === TISTORE_ERROR_OK ? 'ok' : 'failed'} error_code=${code}${details}`;
+  if (code === TISTORE_ERROR_OK) TiRtcLogging.i(storeLogTag, message);
+  else TiRtcLogging.e(storeLogTag, message);
+}
+
+export const TiStoreAudioOutputState = {
+  idle: 'idle',
+  buffering: 'buffering',
+  playing: 'playing',
+  failed: 'failed',
+  paused: 'paused',
+  completed: 'completed',
+} as const;
+export type TiStoreAudioOutputState = (typeof TiStoreAudioOutputState)[keyof typeof TiStoreAudioOutputState];
+export const TiStoreVideoOutputState = {
+  idle: 'idle',
+  buffering: 'buffering',
+  rendering: 'rendering',
+  failed: 'failed',
+  paused: 'paused',
+  completed: 'completed',
+} as const;
+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>;
+}
+class RecordingFile extends NativeMediaFileBase implements TiStoreRecordingFile {
+  constructor(
+    path: string,
+    readonly durationMs: number,
+    id: number,
+  ) {
+    super(path, id, 'video');
+  }
+}
+class SnapshotFile extends NativeMediaFileBase implements TiStoreSnapshotFile {
+  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: TiStoreReplaySpeed): number | null {
+  switch (speed) {
+    case TiStoreReplaySpeed.x1:
+      return 0;
+    case TiStoreReplaySpeed.x2:
+      return 1;
+    case TiStoreReplaySpeed.x4:
+      return 2;
+    case TiStoreReplaySpeed.x8:
+      return 3;
+    default:
+      return null;
+  }
+}
+function speedFromNative(speed: number): TiStoreReplaySpeed | null {
+  switch (speed) {
+    case 0:
+      return TiStoreReplaySpeed.x1;
+    case 1:
+      return TiStoreReplaySpeed.x2;
+    case 2:
+      return TiStoreReplaySpeed.x4;
+    case 3:
+      return TiStoreReplaySpeed.x8;
+    default:
+      return null;
+  }
+}
+function audioStateFromNative(state: unknown): TiStoreAudioOutputState {
+  switch (state) {
+    case TiStoreAudioOutputState.idle:
+    case TiStoreAudioOutputState.buffering:
+    case TiStoreAudioOutputState.playing:
+    case TiStoreAudioOutputState.failed:
+    case TiStoreAudioOutputState.paused:
+    case TiStoreAudioOutputState.completed:
+      return state;
+    default:
+      return TiStoreAudioOutputState.failed;
+  }
+}
+function videoStateFromNative(state: unknown): TiStoreVideoOutputState {
+  switch (state) {
+    case TiStoreVideoOutputState.idle:
+    case TiStoreVideoOutputState.buffering:
+    case TiStoreVideoOutputState.rendering:
+    case TiStoreVideoOutputState.failed:
+    case TiStoreVideoOutputState.paused:
+    case TiStoreVideoOutputState.completed:
+      return state;
+    default:
+      return TiStoreVideoOutputState.failed;
+  }
+}
+
+export class TiStore {
+  private identity: NativeIdentity | null = null;
+  private disposed = false;
+  onTokenExpired: (() => void) | null = null;
+  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) {
+      logStoreOutcome('store_initialize', TISTORE_ERROR_INVALID_ARGUMENT);
+      return Promise.resolve(TISTORE_ERROR_INVALID_ARGUMENT);
+    }
+    return NativeTiRtc.storeInitialize({
+      appId: options.appId,
+      endpoint: options.endpoint ?? '',
+      consoleLogEnabled: options.consoleLogEnabled ?? false,
+    }).then((code) => {
+      logStoreOutcome('store_initialize', code);
+      return code;
+    });
+  }
+  static shutdown(): number {
+    const nativeCode = NativeTiRtc.storeShutdown();
+    const code = nativeCode === TISTORE_ERROR_NOT_INITIALIZED ? TISTORE_ERROR_OK : nativeCode;
+    logStoreOutcome('store_shutdown', code);
+    return code;
+  }
+  static errorToString(code: number): string {
+    return NativeTiRtc.errorToString(code);
+  }
+
+  updateToken(token: string): number {
+    if (token.length === 0) return TISTORE_ERROR_INVALID_ARGUMENT;
+    const identity = this.ensureIdentity();
+    if (typeof identity === 'number') return identity;
+    const code = NativeTiRtc.storeUpdateToken(identity.objectId, token);
+    if (code === 0) this.token = token;
+    logStoreOutcome('store_update_token', code);
+    return code;
+  }
+  listRecordings(startTimeMs: number, endTimeMs: number): Promise<TiStoreRecordingRangesResult> {
+    if (!validTime(startTimeMs) || !validTime(endTimeMs) || endTimeMs <= startTimeMs) {
+      return Promise.resolve({
+        code: TISTORE_ERROR_INVALID_ARGUMENT,
+        recordings: [],
+      });
+    }
+    const identity = this.ensureIdentity();
+    if (typeof identity === 'number') {
+      logStoreOutcome('recording_list', identity);
+      return Promise.resolve({code: identity, recordings: []});
+    }
+    TiRtcLogging.i(storeLogTag, `[recording_list] outcome=started range_duration_ms=${endTimeMs - startTimeMs}`);
+    return NativeTiRtc.storeListRecordings(identity.objectId, startTimeMs, endTimeMs).then((result) => {
+      logStoreOutcome('recording_list', result.code, ` recording_count=${result.recordings.length}`);
+      return result;
+    });
+  }
+  listRecordingDays(
+    startDate: string,
+    endDate: string,
+    timeZoneId = 'Asia/Shanghai',
+  ): Promise<TiStoreRecordingDaysResult> {
+    if (
+      typeof startDate !== 'string' ||
+      typeof endDate !== 'string' ||
+      typeof timeZoneId !== 'string' ||
+      timeZoneId.length === 0
+    ) {
+      return Promise.resolve({code: TISTORE_ERROR_INVALID_ARGUMENT, days: []});
+    }
+    const identity = this.ensureIdentity();
+    if (typeof identity === 'number') {
+      logStoreOutcome('recording_days_list', identity);
+      return Promise.resolve({code: identity, days: []});
+    }
+    TiRtcLogging.i(storeLogTag, '[recording_days_list] outcome=started');
+    return NativeTiRtc.storeListRecordingDays(
+      identity.objectId,
+      startDate,
+      endDate,
+      timeZoneId,
+    ).then((result) => {
+      logStoreOutcome('recording_days_list', result.code, ` day_count=${result.days.length}`);
+      return result;
+    });
+  }
+  createReplay(): TiStoreReplay {
+    return new TiStoreReplay(this);
+  }
+  exportRecording(options: TiStoreExportOptions, onProgress?: (progress: number) => void): Resp<TiStoreExportTask> {
+    if (
+      !validTime(options.startTimeMs) ||
+      !validTime(options.endTimeMs) ||
+      options.endTimeMs <= options.startTimeMs ||
+      !isUInt8(options.videoChannelId) ||
+      (options.audioChannelId !== undefined && !isUInt8(options.audioChannelId))
+    ) {
+      return recordingFailure(TISTORE_ERROR_INVALID_ARGUMENT);
+    }
+    const identity = this.ensureIdentity();
+    if (typeof identity === 'number') return recordingFailure(identity);
+    const result = NativeTiRtc.storeExportRecording(
+      identity.objectId,
+      options.startTimeMs,
+      options.endTimeMs,
+      options.videoChannelId,
+      options.audioChannelId ?? null,
+    );
+    logStoreOutcome('export_start', result.code, ` range_duration_ms=${options.endTimeMs - options.startTimeMs}`);
+    return result.code === 0 && result.taskId !== null
+      ? success(new TiStoreExportTask(result.taskId, this, onProgress))
+      : recordingFailure(result.code);
+  }
+  dispose(): number {
+    if (this.disposed) return 0;
+    if (this.identity === null) {
+      this.disposed = true;
+      this.token = '';
+      this.onTokenExpired = null;
+      return 0;
+    }
+    const identity = this.identity;
+    const code = NativeTiRtc.storeDispose(identity.objectId);
+    if (code === 0) {
+      unregisterNativeEventHandler(identity);
+      clearNativeIdentity(this);
+      this.identity = null;
+      this.disposed = true;
+      this.token = '';
+      this.onTokenExpired = null;
+    }
+    return code;
+  }
+  private ensureIdentity(): NativeIdentity | number {
+    if (this.disposed) return TISTORE_ERROR_NOT_INITIALIZED;
+    if (this.identity !== null) return this.identity;
+    if (this.token.length === 0) return TISTORE_ERROR_INVALID_ARGUMENT;
+    const result = normalizeCreateResult(NativeTiRtc.storeCreate(this.token));
+    if (result.code !== 0) return result.code;
+    this.identity = {
+      objectId: result.objectId,
+      generation: result.generation,
+    };
+    setNativeIdentity(this, this.identity);
+    registerNativeEventHandler(this.identity, (event) => {
+      if (event.type === 'storeTokenExpired') this.onTokenExpired?.();
+    });
+    return this.identity;
+  }
+}
+
+function nativeStoreIdentity(store: TiStore): NativeIdentity | number {
+  return (store as unknown as {ensureIdentity(): NativeIdentity | number}).ensureIdentity();
+}
+
+export class TiStoreReplay {
+  private identity: NativeIdentity | null = null;
+  private disposed = false;
+  private currentSpeed: TiStoreReplaySpeed = '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 store: TiStore) {}
+  get speed(): TiStoreReplaySpeed {
+    if (this.identity !== null) {
+      const info = NativeTiRtc.storeReplayGetInfo(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.storeReplayGetInfo(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 TISTORE_ERROR_INVALID_ARGUMENT;
+    const identity = this.ensureIdentity();
+    const code =
+      typeof identity === 'number'
+        ? identity
+        : NativeTiRtc.storeReplayPlay(identity.objectId, startTimeMs, endTimeMs, initialTimeMs ?? null);
+    logStoreOutcome('replay_play', code, ` range_duration_ms=${endTimeMs - startTimeMs}`);
+    return code;
+  }
+  pause(): number {
+    const code = this.command(NativeTiRtc.storeReplayPause);
+    logStoreOutcome('replay_pause', code);
+    return code;
+  }
+  resume(): number {
+    const code = this.command(NativeTiRtc.storeReplayResume);
+    logStoreOutcome('replay_resume', code);
+    return code;
+  }
+  seek(timeMs: number): number {
+    if (!validTime(timeMs)) return TISTORE_ERROR_INVALID_ARGUMENT;
+    const identity = this.ensureIdentity();
+    const code = typeof identity === 'number' ? identity : NativeTiRtc.storeReplaySeek(identity.objectId, timeMs);
+    logStoreOutcome('replay_seek', code);
+    return code;
+  }
+  setSpeed(speed: TiStoreReplaySpeed): number {
+    const index = speedToNative(speed);
+    if (index === null) return TISTORE_ERROR_INVALID_ARGUMENT;
+    const identity = this.ensureIdentity();
+    if (typeof identity === 'number') return identity;
+    const code = NativeTiRtc.storeReplaySetSpeed(identity.objectId, index);
+    if (code === 0) this.currentSpeed = speed;
+    logStoreOutcome('replay_speed', code, ` speed=${speed}`);
+    return code;
+  }
+  startRecording(options: TiStoreStartRecordingOptions): Resp<TiStoreRecordingTask> {
+    if (
+      !isUInt8(options.videoChannelId) ||
+      (options.audioChannelId !== undefined && !isUInt8(options.audioChannelId))
+    ) {
+      return recordingFailure(TISTORE_ERROR_INVALID_ARGUMENT);
+    }
+    const identity = this.ensureIdentity();
+    if (typeof identity === 'number') return recordingFailure(identity);
+    const result = NativeTiRtc.storeReplayStartRecording(
+      identity.objectId,
+      options.videoChannelId,
+      options.audioChannelId ?? null,
+    );
+    logStoreOutcome('replay_recording_start', result.code);
+    return result.code === 0 && result.taskId !== null
+      ? success(new TiStoreRecordingTask(result.taskId, this))
+      : recordingFailure(result.code);
+  }
+  stop(): number {
+    const code = this.command(NativeTiRtc.storeReplayStop);
+    if (code === 0) this.currentTime = null;
+    logStoreOutcome('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.storeReplayDispose(identity.objectId);
+    if (code === 0) {
+      unregisterNativeEventHandler(identity);
+      clearNativeIdentity(this);
+      this.identity = null;
+      this.disposed = true;
+      this.onTimeChanged = null;
+      this.onError = null;
+      this.onCompleted = null;
+    }
+    logStoreOutcome('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 TISTORE_ERROR_NOT_INITIALIZED;
+    if (this.identity !== null) return this.identity;
+    const store = nativeStoreIdentity(this.store);
+    if (typeof store === 'number') return store;
+    const result = normalizeCreateResult(NativeTiRtc.storeCreateReplay(store.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 === 'storeReplayTimeChanged' && event.timestampMs !== undefined) {
+      this.currentTime = event.timestampMs;
+      this.onTimeChanged?.(event.timestampMs);
+    } else if (event.type === 'storeReplayCompleted') this.onCompleted?.();
+    else if (event.type === 'storeReplayError') this.onError?.(event.code ?? TISTORE_ERROR_STORE_UNAVAILABLE);
+  }
+}
+
+function nativeReplayIdentity(replay: TiStoreReplay): NativeIdentity | number {
+  return (replay as unknown as {ensureIdentity(): NativeIdentity | number}).ensureIdentity();
+}
+
+abstract class StoreOutputBase {
+  protected identity: NativeIdentity | null = null;
+  protected disposed = false;
+  protected bound = false;
+  protected abstract create(): ReturnType<typeof NativeTiRtc.storeCreateAudioOutput>;
+  protected ensureIdentity(): NativeIdentity | number {
+    if (this.disposed) return TISTORE_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 TiStoreAudioOutput extends StoreOutputBase {
+  private currentState: TiStoreAudioOutputState = 'idle';
+  onStateChanged: ((state: TiStoreAudioOutputState) => void) | null = null;
+  onError: ((code: number) => void) | null = null;
+  protected create() {
+    return NativeTiRtc.storeCreateAudioOutput();
+  }
+  get state(): TiStoreAudioOutputState {
+    if (this.identity !== null)
+      this.currentState = audioStateFromNative(
+        NativeTiRtc.storeAudioOutputGetState(this.identity.objectId).state ?? this.currentState,
+      );
+    return this.currentState;
+  }
+  attach(replay: TiStoreReplay, channelId: number): number {
+    if (!isUInt8(channelId)) return TISTORE_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.storeAudioOutputAttach(output.objectId, replayId.objectId, channelId);
+    if (code === 0) this.bound = true;
+    logStoreOutcome('audio_output_attach', code);
+    return code;
+  }
+  setVolume(volumePercent: number): number {
+    if (!isFiniteSafeInteger(volumePercent) || volumePercent < 0 || volumePercent > 100)
+      return TISTORE_ERROR_INVALID_ARGUMENT;
+    const output = this.ensureIdentity();
+    return typeof output === 'number' ? output : NativeTiRtc.storeAudioOutputSetVolume(output.objectId, volumePercent);
+  }
+  detach(): number {
+    if (this.identity === null) return 0;
+    const code = NativeTiRtc.storeAudioOutputDetach(this.identity.objectId);
+    if (code === 0) {
+      this.bound = false;
+      this.currentState = TiStoreAudioOutputState.idle;
+    }
+    logStoreOutcome('audio_output_detach', code);
+    return code;
+  }
+  dispose(): number {
+    if (this.disposed) return 0;
+    if (this.bound) return TISTORE_ERROR_IN_USE;
+    if (this.identity === null) {
+      this.disposed = true;
+      this.currentState = TiStoreAudioOutputState.idle;
+      this.onStateChanged = null;
+      this.onError = null;
+      return 0;
+    }
+    const code = NativeTiRtc.storeAudioOutputDispose(this.identity.objectId);
+    if (code === 0) {
+      this.releaseIdentity();
+      this.currentState = TiStoreAudioOutputState.idle;
+      this.onStateChanged = null;
+      this.onError = null;
+    }
+    logStoreOutcome('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 ?? TISTORE_ERROR_IO_FAILED);
+  }
+}
+
+export type TiStoreVideoOutputViewProps = ViewProps &
+  Readonly<{
+    output: TiStoreVideoOutput;
+    resizeMode?: 'contain' | 'cover' | 'stretch';
+  }>;
+export class TiStoreVideoOutput extends StoreOutputBase {
+  private currentState: TiStoreVideoOutputState = 'idle';
+  onStateChanged: ((state: TiStoreVideoOutputState) => void) | null = null;
+  onError: ((code: number) => void) | null = null;
+  protected create() {
+    return NativeTiRtc.storeCreateVideoOutput();
+  }
+  get state(): TiStoreVideoOutputState {
+    if (this.identity !== null)
+      this.currentState = videoStateFromNative(
+        NativeTiRtc.storeVideoOutputGetState(this.identity.objectId).state ?? this.currentState,
+      );
+    return this.currentState;
+  }
+  view(props: Omit<TiStoreVideoOutputViewProps, 'output'> = {}): React.ReactElement {
+    this.ensureIdentity();
+    return React.createElement(TiStoreVideoOutputView, {
+      ...props,
+      output: this,
+    });
+  }
+  attach(replay: TiStoreReplay, channelId: number): number {
+    if (!isUInt8(channelId)) return TISTORE_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.storeVideoOutputAttach(output.objectId, replayId.objectId, channelId);
+    if (code === 0) this.bound = true;
+    logStoreOutcome('video_output_attach', code);
+    return code;
+  }
+  async takeSnapshot(): Promise<Resp<TiStoreSnapshotFile>> {
+    const output = this.ensureIdentity();
+    if (typeof output === 'number') return recordingFailure(output);
+    const result = await NativeTiRtc.storeVideoOutputTakeSnapshot(output.objectId);
+    logStoreOutcome('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.storeVideoOutputDetach(this.identity.objectId);
+    if (code === 0) {
+      this.bound = false;
+      this.currentState = TiStoreVideoOutputState.idle;
+    }
+    logStoreOutcome('video_output_detach', code);
+    return code;
+  }
+  dispose(): number {
+    if (this.disposed) return 0;
+    if (this.bound) return TISTORE_ERROR_IN_USE;
+    if (this.identity === null) {
+      this.disposed = true;
+      this.currentState = TiStoreVideoOutputState.idle;
+      this.onStateChanged = null;
+      this.onError = null;
+      return 0;
+    }
+    const code = NativeTiRtc.storeVideoOutputDispose(this.identity.objectId);
+    if (code === 0) {
+      this.releaseIdentity();
+      this.currentState = TiStoreVideoOutputState.idle;
+      this.onStateChanged = null;
+      this.onError = null;
+    }
+    logStoreOutcome('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 ?? TISTORE_ERROR_IO_FAILED);
+  }
+}
+
+export function TiStoreVideoOutputView(props: TiStoreVideoOutputViewProps): 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: TiStoreVideoOutput): NativeIdentity | null {
+  const [, update] = React.useReducer((value: number) => value + 1, 0);
+  React.useEffect(() => subscribeNativeIdentity(owner, update), [owner]);
+  return readNativeIdentity(owner);
+}
+
+export class TiStoreRecordingTask {
+  private stopPromise: Promise<Resp<TiStoreRecordingFile>> | null = null;
+  constructor(
+    private readonly taskId: number,
+    private readonly owner: TiStoreReplay,
+  ) {}
+  stop(): Promise<Resp<TiStoreRecordingFile>> {
+    void this.owner;
+    return (this.stopPromise ??= NativeTiRtc.storeRecordingTaskStop(this.taskId).then((result) => {
+      logStoreOutcome('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 TiStoreExportTask {
+  private resultPromise: Promise<Resp<TiStoreRecordingFile>>;
+  constructor(
+    private readonly taskId: number,
+    private readonly owner: TiStore,
+    private readonly onProgress?: (progress: number) => void,
+  ) {
+    this.resultPromise = NativeTiRtc.storeExportResult(taskId).then((result) => {
+      logStoreOutcome('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.storeExportProgress(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.storeExportProgress(this.taskId);
+  }
+  get result(): Promise<Resp<TiStoreRecordingFile>> {
+    return this.resultPromise;
+  }
+  stop(): Promise<Resp<TiStoreRecordingFile>> {
+    const code = NativeTiRtc.storeExportStop(this.taskId);
+    logStoreOutcome('export_stop', code);
+    return this.resultPromise;
+  }
+}