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

package/lib/module/storage.js

@@ -0,0 +1,706 @@
+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 TI_CLOUD_STORAGE_ERROR_OK = 0;
+export const TI_CLOUD_STORAGE_ERROR_INVALID_ARGUMENT = 6000;
+export const TI_CLOUD_STORAGE_ERROR_NOT_INITIALIZED = 6001;
+export const TI_CLOUD_STORAGE_ERROR_TOKEN_EXPIRED = 6014;
+export const TI_CLOUD_STORAGE_ERROR_ALREADY_INITIALIZED = 6022;
+export const TI_CLOUD_STORAGE_ERROR_PERMISSION_DENIED = 6024;
+export const TI_CLOUD_STORAGE_ERROR_IN_USE = 6026;
+export const TI_CLOUD_STORAGE_ERROR_NOT_STARTED = 6027;
+export const TI_CLOUD_STORAGE_ERROR_NOT_BOUND = 6029;
+export const TI_CLOUD_STORAGE_ERROR_NOT_CONFIGURED = 6030;
+export const TI_CLOUD_STORAGE_ERROR_RESOURCE_EXHAUSTED = 6043;
+export const TI_CLOUD_STORAGE_ERROR_FILE_WRITE_FAILED = 6046;
+export const TI_CLOUD_STORAGE_ERROR_UNSUPPORTED_FORMAT = 6113;
+export const TI_CLOUD_STORAGE_ERROR_IO_FAILED = 6114;
+export const TI_CLOUD_STORAGE_ERROR_CANCELLED = 6115;
+export const TI_CLOUD_STORAGE_ERROR_RANGE_TOO_LARGE = 6117;
+export const TI_CLOUD_STORAGE_ERROR_NO_FRAME = 6118;
+export const TI_CLOUD_STORAGE_ERROR_NO_RECORDABLE_MEDIA = 6119;
+export const TI_CLOUD_STORAGE_ERROR_RECORDING_OVERRUN = 6120;
+export const TI_CLOUD_STORAGE_ERROR_RECORDING_UNREADABLE = 6122;
+export const TI_CLOUD_STORAGE_ERROR_UNAVAILABLE = 6123;
+export const TI_CLOUD_STORAGE_ERROR_STOPPED = 6124;
+export const TiCloudStorageReplaySpeed = {
+    x0_125: 'x0_125',
+    x0_25: 'x0_25',
+    x0_5: 'x0_5',
+    x1: 'x1',
+    x2: 'x2',
+    x4: 'x4',
+    x8: 'x8',
+};
+const tiCloudStorageLogTag = 'TIRTC_REACT_NATIVE_CLOUD_STORAGE';
+function tiCloudStorageLogOutcome(operation, code, details = '') {
+    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',
+};
+export const TiCloudStorageVideoOutputState = {
+    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 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) {
+    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) {
+    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) {
+    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 {
+    constructor(token) {
+        this.token = token;
+        this.identity = null;
+        this.disposed = false;
+    }
+    static init(options) {
+        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() {
+        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) {
+        return NativeTiRtc.errorToString(code);
+    }
+    updateToken(token) {
+        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, endTimeMs) {
+        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, endDate, timeZoneId = 'Asia/Shanghai') {
+        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() {
+        return new TiCloudStorageReplay(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(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() {
+        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;
+    }
+    ensureIdentity() {
+        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) {
+    return cloudStorage.ensureIdentity();
+}
+export class TiCloudStorageReplay {
+    constructor(cloudStorage) {
+        this.cloudStorage = cloudStorage;
+        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.tiCloudStorageReplayGetInfo(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.tiCloudStorageReplayGetInfo(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 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() {
+        const code = this.command(NativeTiRtc.tiCloudStorageReplayPause);
+        tiCloudStorageLogOutcome('replay_pause', code);
+        return code;
+    }
+    resume() {
+        const code = this.command(NativeTiRtc.tiCloudStorageReplayResume);
+        tiCloudStorageLogOutcome('replay_resume', code);
+        return code;
+    }
+    seek(timeMs) {
+        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) {
+        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) {
+        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() {
+        const code = this.command(NativeTiRtc.tiCloudStorageReplayStop);
+        if (code === 0)
+            this.currentTime = null;
+        tiCloudStorageLogOutcome('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.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;
+    }
+    command(operation) {
+        const identity = this.ensureIdentity();
+        return typeof identity === 'number' ? identity : operation(identity.objectId);
+    }
+    ensureIdentity() {
+        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;
+    }
+    handleEvent(event) {
+        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) {
+    return replay.ensureIdentity();
+}
+class TiCloudStorageOutputBase {
+    constructor() {
+        this.identity = null;
+        this.disposed = false;
+        this.bound = false;
+    }
+    ensureIdentity() {
+        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;
+    }
+    releaseIdentity() {
+        if (this.identity !== null) {
+            unregisterNativeEventHandler(this.identity);
+            clearNativeIdentity(this);
+        }
+        this.identity = null;
+        this.disposed = true;
+    }
+}
+export class TiCloudStorageAudioOutput extends TiCloudStorageOutputBase {
+    constructor() {
+        super(...arguments);
+        this.currentState = 'idle';
+        this.onStateChanged = null;
+        this.onError = null;
+    }
+    create() {
+        return NativeTiRtc.tiCloudStorageCreateAudioOutput();
+    }
+    get state() {
+        if (this.identity !== null)
+            this.currentState = audioStateFromNative(NativeTiRtc.tiCloudStorageAudioOutputGetState(this.identity.objectId).state ?? this.currentState);
+        return this.currentState;
+    }
+    attach(replay, channelId) {
+        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) {
+        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() {
+        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() {
+        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;
+    }
+    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 ?? TI_CLOUD_STORAGE_ERROR_IO_FAILED);
+    }
+}
+export class TiCloudStorageVideoOutput extends TiCloudStorageOutputBase {
+    constructor() {
+        super(...arguments);
+        this.currentState = 'idle';
+        this.onStateChanged = null;
+        this.onError = null;
+    }
+    create() {
+        return NativeTiRtc.tiCloudStorageCreateVideoOutput();
+    }
+    get state() {
+        if (this.identity !== null)
+            this.currentState = videoStateFromNative(NativeTiRtc.tiCloudStorageVideoOutputGetState(this.identity.objectId).state ?? this.currentState);
+        return this.currentState;
+    }
+    view(props = {}) {
+        this.ensureIdentity();
+        return React.createElement(TiCloudStorageVideoOutputView, {
+            ...props,
+            output: this,
+        });
+    }
+    attach(replay, channelId) {
+        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() {
+        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() {
+        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() {
+        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;
+    }
+    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 ?? TI_CLOUD_STORAGE_ERROR_IO_FAILED);
+    }
+}
+export function TiCloudStorageVideoOutputView(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 TiCloudStorageRecordingTask {
+    constructor(taskId, owner) {
+        this.taskId = taskId;
+        this.owner = owner;
+        this.stopPromise = null;
+    }
+    stop() {
+        void this.owner;
+        return (this.stopPromise ?? (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 {
+    constructor(taskId, owner, onProgress) {
+        this.taskId = taskId;
+        this.owner = owner;
+        this.onProgress = onProgress;
+        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() {
+        void this.owner;
+        return NativeTiRtc.tiCloudStorageExportProgress(this.taskId);
+    }
+    get result() {
+        return this.resultPromise;
+    }
+    stop() {
+        const code = NativeTiRtc.tiCloudStorageExportStop(this.taskId);
+        tiCloudStorageLogOutcome('export_stop', code);
+        return this.resultPromise;
+    }
+}
+//# sourceMappingURL=storage.js.map