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

package/lib/module/store.js

@@ -0,0 +1,698 @@
+import * as React from 'react';
+import { View } from 'react-native';
+import { isFiniteSafeInteger, isPlainObject, isUInt8, normalizeCreateResult, } from './errors';
+import { registerNativeEventHandler, unregisterNativeEventHandler } from './events';
+import { TiRtcLogging } from './logging';
+import { NativeTiRtc, NativeTiRtcVideoOutputView } from './native';
+import { clearNativeIdentity, readNativeIdentity, setNativeIdentity, subscribeNativeIdentity, } from './native_object_id';
+import { NativeMediaFileBase, recordingFailure } from './recording';
+export const TISTORE_ERROR_OK = 0;
+export const TISTORE_ERROR_INVALID_ARGUMENT = 6000;
+export const TISTORE_ERROR_NOT_INITIALIZED = 6001;
+export const TISTORE_ERROR_TOKEN_EXPIRED = 6014;
+export const TISTORE_ERROR_ALREADY_INITIALIZED = 6022;
+export const TISTORE_ERROR_PERMISSION_DENIED = 6024;
+export const TISTORE_ERROR_IN_USE = 6026;
+export const TISTORE_ERROR_NOT_STARTED = 6027;
+export const TISTORE_ERROR_NOT_BOUND = 6029;
+export const TISTORE_ERROR_NOT_CONFIGURED = 6030;
+export const TISTORE_ERROR_RESOURCE_EXHAUSTED = 6043;
+export const TISTORE_ERROR_FILE_WRITE_FAILED = 6046;
+export const TISTORE_ERROR_UNSUPPORTED_FORMAT = 6113;
+export const TISTORE_ERROR_IO_FAILED = 6114;
+export const TISTORE_ERROR_CANCELLED = 6115;
+export const TISTORE_ERROR_RANGE_TOO_LARGE = 6117;
+export const TISTORE_ERROR_NO_FRAME = 6118;
+export const TISTORE_ERROR_NO_RECORDABLE_MEDIA = 6119;
+export const TISTORE_ERROR_RECORDING_OVERRUN = 6120;
+export const TISTORE_ERROR_RECORDING_UNREADABLE = 6122;
+export const TISTORE_ERROR_STORE_UNAVAILABLE = 6123;
+export const TISTORE_ERROR_STOPPED = 6124;
+export const TiStoreReplaySpeed = {
+    x1: 'x1',
+    x2: 'x2',
+    x4: 'x4',
+    x8: 'x8',
+};
+const storeLogTag = 'TIRTC_REACT_NATIVE_STORE';
+function logStoreOutcome(operation, code, details = '') {
+    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',
+};
+export const TiStoreVideoOutputState = {
+    idle: 'idle',
+    buffering: 'buffering',
+    rendering: 'rendering',
+    failed: 'failed',
+    paused: 'paused',
+    completed: 'completed',
+};
+class RecordingFile extends NativeMediaFileBase {
+    constructor(path, durationMs, id) {
+        super(path, id, 'video');
+        this.durationMs = durationMs;
+    }
+}
+class SnapshotFile extends NativeMediaFileBase {
+    constructor(path, id) {
+        super(path, id, 'image');
+    }
+}
+function success(data) {
+    return { success: true, code: null, message: null, data };
+}
+function validTime(value) {
+    return isFiniteSafeInteger(value) && value >= 0;
+}
+function speedToNative(speed) {
+    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) {
+    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) {
+    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) {
+    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 {
+    constructor(token) {
+        this.token = token;
+        this.identity = null;
+        this.disposed = false;
+        this.onTokenExpired = null;
+    }
+    static init(options) {
+        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() {
+        const nativeCode = NativeTiRtc.storeShutdown();
+        const code = nativeCode === TISTORE_ERROR_NOT_INITIALIZED ? TISTORE_ERROR_OK : nativeCode;
+        logStoreOutcome('store_shutdown', code);
+        return code;
+    }
+    static errorToString(code) {
+        return NativeTiRtc.errorToString(code);
+    }
+    updateToken(token) {
+        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, endTimeMs) {
+        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, endDate, timeZoneId = 'Asia/Shanghai') {
+        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() {
+        return new TiStoreReplay(this);
+    }
+    exportRecording(options, onProgress) {
+        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() {
+        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;
+    }
+    ensureIdentity() {
+        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) {
+    return store.ensureIdentity();
+}
+export class TiStoreReplay {
+    constructor(store) {
+        this.store = store;
+        this.identity = null;
+        this.disposed = false;
+        this.currentSpeed = 'x1';
+        this.currentTime = null;
+        this.onTimeChanged = null;
+        this.onError = null;
+        this.onCompleted = null;
+    }
+    get speed() {
+        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() {
+        if (this.identity !== null) {
+            const info = NativeTiRtc.storeReplayGetInfo(this.identity.objectId);
+            if (info.code === 0)
+                this.currentTime = info.currentTimeMs;
+        }
+        return this.currentTime;
+    }
+    play(startTimeMs, endTimeMs, initialTimeMs) {
+        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() {
+        const code = this.command(NativeTiRtc.storeReplayPause);
+        logStoreOutcome('replay_pause', code);
+        return code;
+    }
+    resume() {
+        const code = this.command(NativeTiRtc.storeReplayResume);
+        logStoreOutcome('replay_resume', code);
+        return code;
+    }
+    seek(timeMs) {
+        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) {
+        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) {
+        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() {
+        const code = this.command(NativeTiRtc.storeReplayStop);
+        if (code === 0)
+            this.currentTime = null;
+        logStoreOutcome('replay_stop', code);
+        return code;
+    }
+    dispose() {
+        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;
+    }
+    command(operation) {
+        const identity = this.ensureIdentity();
+        return typeof identity === 'number' ? identity : operation(identity.objectId);
+    }
+    ensureIdentity() {
+        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;
+    }
+    handleEvent(event) {
+        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) {
+    return replay.ensureIdentity();
+}
+class StoreOutputBase {
+    constructor() {
+        this.identity = null;
+        this.disposed = false;
+        this.bound = false;
+    }
+    ensureIdentity() {
+        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;
+    }
+    releaseIdentity() {
+        if (this.identity !== null) {
+            unregisterNativeEventHandler(this.identity);
+            clearNativeIdentity(this);
+        }
+        this.identity = null;
+        this.disposed = true;
+    }
+}
+export class TiStoreAudioOutput extends StoreOutputBase {
+    constructor() {
+        super(...arguments);
+        this.currentState = 'idle';
+        this.onStateChanged = null;
+        this.onError = null;
+    }
+    create() {
+        return NativeTiRtc.storeCreateAudioOutput();
+    }
+    get state() {
+        if (this.identity !== null)
+            this.currentState = audioStateFromNative(NativeTiRtc.storeAudioOutputGetState(this.identity.objectId).state ?? this.currentState);
+        return this.currentState;
+    }
+    attach(replay, channelId) {
+        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) {
+        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() {
+        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() {
+        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;
+    }
+    handleEvent(event) {
+        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 class TiStoreVideoOutput extends StoreOutputBase {
+    constructor() {
+        super(...arguments);
+        this.currentState = 'idle';
+        this.onStateChanged = null;
+        this.onError = null;
+    }
+    create() {
+        return NativeTiRtc.storeCreateVideoOutput();
+    }
+    get state() {
+        if (this.identity !== null)
+            this.currentState = videoStateFromNative(NativeTiRtc.storeVideoOutputGetState(this.identity.objectId).state ?? this.currentState);
+        return this.currentState;
+    }
+    view(props = {}) {
+        this.ensureIdentity();
+        return React.createElement(TiStoreVideoOutputView, {
+            ...props,
+            output: this,
+        });
+    }
+    attach(replay, channelId) {
+        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() {
+        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() {
+        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() {
+        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;
+    }
+    handleEvent(event) {
+        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) {
+    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) {
+    const [, update] = React.useReducer((value) => value + 1, 0);
+    React.useEffect(() => subscribeNativeIdentity(owner, update), [owner]);
+    return readNativeIdentity(owner);
+}
+export class TiStoreRecordingTask {
+    constructor(taskId, owner) {
+        this.taskId = taskId;
+        this.owner = owner;
+        this.stopPromise = null;
+    }
+    stop() {
+        void this.owner;
+        return (this.stopPromise ?? (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 {
+    constructor(taskId, owner, onProgress) {
+        this.taskId = taskId;
+        this.owner = owner;
+        this.onProgress = onProgress;
+        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() {
+        void this.owner;
+        return NativeTiRtc.storeExportProgress(this.taskId);
+    }
+    get result() {
+        return this.resultPromise;
+    }
+    stop() {
+        const code = NativeTiRtc.storeExportStop(this.taskId);
+        logStoreOutcome('export_stop', code);
+        return this.resultPromise;
+    }
+}
+//# sourceMappingURL=store.js.map