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

package/lib/module/{store.js → storage.js}

@@ -6,43 +6,46 @@ 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 = {
+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 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);
+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(storeLogTag, message);
+        TiRtcLogging.e(tiCloudStorageLogTag, message);
 }
-export const TiStoreAudioOutputState = {
+export const TiCloudStorageAudioOutputState = {
     idle: 'idle',
     buffering: 'buffering',
     playing: 'playing',
@@ -50,7 +53,7 @@ export const TiStoreAudioOutputState = {
     paused: 'paused',
     completed: 'completed',
 };
-export const TiStoreVideoOutputState = {
+export const TiCloudStorageVideoOutputState = {
     idle: 'idle',
     buffering: 'buffering',
     rendering: 'rendering',
@@ -77,13 +80,19 @@ function validTime(value) {
 }
 function speedToNative(speed) {
     switch (speed) {
-        case TiStoreReplaySpeed.x1:
+        case TiCloudStorageReplaySpeed.x0_125:
+            return 6;
+        case TiCloudStorageReplaySpeed.x0_25:
+            return 5;
+        case TiCloudStorageReplaySpeed.x0_5:
+            return 4;
+        case TiCloudStorageReplaySpeed.x1:
             return 0;
-        case TiStoreReplaySpeed.x2:
+        case TiCloudStorageReplaySpeed.x2:
             return 1;
-        case TiStoreReplaySpeed.x4:
+        case TiCloudStorageReplaySpeed.x4:
             return 2;
-        case TiStoreReplaySpeed.x8:
+        case TiCloudStorageReplaySpeed.x8:
             return 3;
         default:
             return null;
@@ -91,69 +100,74 @@ function speedToNative(speed) {
 }
 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 TiStoreReplaySpeed.x1;
+            return TiCloudStorageReplaySpeed.x1;
         case 1:
-            return TiStoreReplaySpeed.x2;
+            return TiCloudStorageReplaySpeed.x2;
         case 2:
-            return TiStoreReplaySpeed.x4;
+            return TiCloudStorageReplaySpeed.x4;
         case 3:
-            return TiStoreReplaySpeed.x8;
+            return TiCloudStorageReplaySpeed.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:
+        case TiCloudStorageAudioOutputState.idle:
+        case TiCloudStorageAudioOutputState.buffering:
+        case TiCloudStorageAudioOutputState.playing:
+        case TiCloudStorageAudioOutputState.failed:
+        case TiCloudStorageAudioOutputState.paused:
+        case TiCloudStorageAudioOutputState.completed:
             return state;
         default:
-            return TiStoreAudioOutputState.failed;
+            return TiCloudStorageAudioOutputState.failed;
     }
 }
 function videoStateFromNative(state) {
     switch (state) {
-        case TiStoreVideoOutputState.idle:
-        case TiStoreVideoOutputState.buffering:
-        case TiStoreVideoOutputState.rendering:
-        case TiStoreVideoOutputState.failed:
-        case TiStoreVideoOutputState.paused:
-        case TiStoreVideoOutputState.completed:
+        case TiCloudStorageVideoOutputState.idle:
+        case TiCloudStorageVideoOutputState.buffering:
+        case TiCloudStorageVideoOutputState.rendering:
+        case TiCloudStorageVideoOutputState.failed:
+        case TiCloudStorageVideoOutputState.paused:
+        case TiCloudStorageVideoOutputState.completed:
             return state;
         default:
-            return TiStoreVideoOutputState.failed;
+            return TiCloudStorageVideoOutputState.failed;
     }
 }
-export class TiStore {
+export class TiCloudStorage {
     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);
+            tiCloudStorageLogOutcome('cloud_storage_initialize', TI_CLOUD_STORAGE_ERROR_INVALID_ARGUMENT);
+            return Promise.resolve(TI_CLOUD_STORAGE_ERROR_INVALID_ARGUMENT);
         }
-        return NativeTiRtc.storeInitialize({
+        return NativeTiRtc.tiCloudStorageInitialize({
             appId: options.appId,
             endpoint: options.endpoint ?? '',
             consoleLogEnabled: options.consoleLogEnabled ?? false,
         }).then((code) => {
-            logStoreOutcome('store_initialize', code);
+            tiCloudStorageLogOutcome('cloud_storage_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);
+        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) {
@@ -161,31 +175,31 @@ export class TiStore {
     }
     updateToken(token) {
         if (token.length === 0)
-            return TISTORE_ERROR_INVALID_ARGUMENT;
+            return TI_CLOUD_STORAGE_ERROR_INVALID_ARGUMENT;
         const identity = this.ensureIdentity();
         if (typeof identity === 'number')
             return identity;
-        const code = NativeTiRtc.storeUpdateToken(identity.objectId, token);
+        const code = NativeTiRtc.tiCloudStorageUpdateToken(identity.objectId, token);
         if (code === 0)
             this.token = token;
-        logStoreOutcome('store_update_token', code);
+        tiCloudStorageLogOutcome('cloud_storage_update_token', code);
         return code;
     }
     listRecordings(startTimeMs, endTimeMs) {
         if (!validTime(startTimeMs) || !validTime(endTimeMs) || endTimeMs <= startTimeMs) {
             return Promise.resolve({
-                code: TISTORE_ERROR_INVALID_ARGUMENT,
+                code: TI_CLOUD_STORAGE_ERROR_INVALID_ARGUMENT,
                 recordings: [],
             });
         }
         const identity = this.ensureIdentity();
         if (typeof identity === 'number') {
-            logStoreOutcome('recording_list', identity);
+            tiCloudStorageLogOutcome('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}`);
+        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;
         });
     }
@@ -194,21 +208,21 @@ export class TiStore {
             typeof endDate !== 'string' ||
             typeof timeZoneId !== 'string' ||
             timeZoneId.length === 0) {
-            return Promise.resolve({ code: TISTORE_ERROR_INVALID_ARGUMENT, days: [] });
+            return Promise.resolve({ code: TI_CLOUD_STORAGE_ERROR_INVALID_ARGUMENT, days: [] });
         }
         const identity = this.ensureIdentity();
         if (typeof identity === 'number') {
-            logStoreOutcome('recording_days_list', identity);
+            tiCloudStorageLogOutcome('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}`);
+        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 TiStoreReplay(this);
+        return new TiCloudStorageReplay(this);
     }
     exportRecording(options, onProgress) {
         if (!validTime(options.startTimeMs) ||
@@ -216,15 +230,15 @@ export class TiStore {
             options.endTimeMs <= options.startTimeMs ||
             !isUInt8(options.videoChannelId) ||
             (options.audioChannelId !== undefined && !isUInt8(options.audioChannelId))) {
-            return recordingFailure(TISTORE_ERROR_INVALID_ARGUMENT);
+            return recordingFailure(TI_CLOUD_STORAGE_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}`);
+        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 TiStoreExportTask(result.taskId, this, onProgress))
+            ? success(new TiCloudStorageExportTask(result.taskId, this, onProgress))
             : recordingFailure(result.code);
     }
     dispose() {
@@ -233,29 +247,27 @@ export class TiStore {
         if (this.identity === null) {
             this.disposed = true;
             this.token = '';
-            this.onTokenExpired = null;
             return 0;
         }
         const identity = this.identity;
-        const code = NativeTiRtc.storeDispose(identity.objectId);
+        const code = NativeTiRtc.tiCloudStorageDispose(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;
+            return TI_CLOUD_STORAGE_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));
+            return TI_CLOUD_STORAGE_ERROR_INVALID_ARGUMENT;
+        const result = normalizeCreateResult(NativeTiRtc.tiCloudStorageCreate(this.token));
         if (result.code !== 0)
             return result.code;
         this.identity = {
@@ -263,19 +275,15 @@ export class TiStore {
             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();
+function tiCloudStorageNativeIdentity(cloudStorage) {
+    return cloudStorage.ensureIdentity();
 }
-export class TiStoreReplay {
-    constructor(store) {
-        this.store = store;
+export class TiCloudStorageReplay {
+    constructor(cloudStorage) {
+        this.cloudStorage = cloudStorage;
         this.identity = null;
         this.disposed = false;
         this.currentSpeed = 'x1';
@@ -286,7 +294,7 @@ export class TiStoreReplay {
     }
     get speed() {
         if (this.identity !== null) {
-            const info = NativeTiRtc.storeReplayGetInfo(this.identity.objectId);
+            const info = NativeTiRtc.tiCloudStorageReplayGetInfo(this.identity.objectId);
             if (info.code === 0)
                 this.currentSpeed = speedFromNative(info.speed) ?? this.currentSpeed;
         }
@@ -294,7 +302,7 @@ export class TiStoreReplay {
     }
     get currentTimeMs() {
         if (this.identity !== null) {
-            const info = NativeTiRtc.storeReplayGetInfo(this.identity.objectId);
+            const info = NativeTiRtc.tiCloudStorageReplayGetInfo(this.identity.objectId);
             if (info.code === 0)
                 this.currentTime = info.currentTimeMs;
         }
@@ -306,64 +314,64 @@ export class TiStoreReplay {
             endTimeMs <= startTimeMs ||
             (initialTimeMs !== undefined &&
                 (!validTime(initialTimeMs) || initialTimeMs < startTimeMs || initialTimeMs >= endTimeMs)))
-            return TISTORE_ERROR_INVALID_ARGUMENT;
+            return TI_CLOUD_STORAGE_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}`);
+            : 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.storeReplayPause);
-        logStoreOutcome('replay_pause', code);
+        const code = this.command(NativeTiRtc.tiCloudStorageReplayPause);
+        tiCloudStorageLogOutcome('replay_pause', code);
         return code;
     }
     resume() {
-        const code = this.command(NativeTiRtc.storeReplayResume);
-        logStoreOutcome('replay_resume', code);
+        const code = this.command(NativeTiRtc.tiCloudStorageReplayResume);
+        tiCloudStorageLogOutcome('replay_resume', code);
         return code;
     }
     seek(timeMs) {
         if (!validTime(timeMs))
-            return TISTORE_ERROR_INVALID_ARGUMENT;
+            return TI_CLOUD_STORAGE_ERROR_INVALID_ARGUMENT;
         const identity = this.ensureIdentity();
-        const code = typeof identity === 'number' ? identity : NativeTiRtc.storeReplaySeek(identity.objectId, timeMs);
-        logStoreOutcome('replay_seek', code);
+        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 TISTORE_ERROR_INVALID_ARGUMENT;
+            return TI_CLOUD_STORAGE_ERROR_INVALID_ARGUMENT;
         const identity = this.ensureIdentity();
         if (typeof identity === 'number')
             return identity;
-        const code = NativeTiRtc.storeReplaySetSpeed(identity.objectId, index);
+        const code = NativeTiRtc.tiCloudStorageReplaySetSpeed(identity.objectId, index);
         if (code === 0)
             this.currentSpeed = speed;
-        logStoreOutcome('replay_speed', code, ` speed=${speed}`);
+        tiCloudStorageLogOutcome('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);
+            return recordingFailure(TI_CLOUD_STORAGE_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);
+        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 TiStoreRecordingTask(result.taskId, this))
+            ? success(new TiCloudStorageRecordingTask(result.taskId, this))
             : recordingFailure(result.code);
     }
     stop() {
-        const code = this.command(NativeTiRtc.storeReplayStop);
+        const code = this.command(NativeTiRtc.tiCloudStorageReplayStop);
         if (code === 0)
             this.currentTime = null;
-        logStoreOutcome('replay_stop', code);
+        tiCloudStorageLogOutcome('replay_stop', code);
         return code;
     }
     dispose() {
@@ -377,7 +385,7 @@ export class TiStoreReplay {
             return 0;
         }
         const identity = this.identity;
-        const code = NativeTiRtc.storeReplayDispose(identity.objectId);
+        const code = NativeTiRtc.tiCloudStorageReplayDispose(identity.objectId);
         if (code === 0) {
             unregisterNativeEventHandler(identity);
             clearNativeIdentity(this);
@@ -387,7 +395,7 @@ export class TiStoreReplay {
             this.onError = null;
             this.onCompleted = null;
         }
-        logStoreOutcome('replay_dispose', code);
+        tiCloudStorageLogOutcome('replay_dispose', code);
         return code;
     }
     command(operation) {
@@ -396,13 +404,13 @@ export class TiStoreReplay {
     }
     ensureIdentity() {
         if (this.disposed)
-            return TISTORE_ERROR_NOT_INITIALIZED;
+            return TI_CLOUD_STORAGE_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));
+        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 = {
@@ -414,20 +422,20 @@ export class TiStoreReplay {
         return this.identity;
     }
     handleEvent(event) {
-        if (event.type === 'storeReplayTimeChanged' && event.timestampMs !== undefined) {
+        if (event.type === 'tiCloudStorageReplayTimeChanged' && event.timestampMs !== undefined) {
             this.currentTime = event.timestampMs;
             this.onTimeChanged?.(event.timestampMs);
         }
-        else if (event.type === 'storeReplayCompleted')
+        else if (event.type === 'tiCloudStorageReplayCompleted')
             this.onCompleted?.();
-        else if (event.type === 'storeReplayError')
-            this.onError?.(event.code ?? TISTORE_ERROR_STORE_UNAVAILABLE);
+        else if (event.type === 'tiCloudStorageReplayError')
+            this.onError?.(event.code ?? TI_CLOUD_STORAGE_ERROR_UNAVAILABLE);
     }
 }
 function nativeReplayIdentity(replay) {
     return replay.ensureIdentity();
 }
-class StoreOutputBase {
+class TiCloudStorageOutputBase {
     constructor() {
         this.identity = null;
         this.disposed = false;
@@ -435,7 +443,7 @@ class StoreOutputBase {
     }
     ensureIdentity() {
         if (this.disposed)
-            return TISTORE_ERROR_NOT_INITIALIZED;
+            return TI_CLOUD_STORAGE_ERROR_NOT_INITIALIZED;
         if (this.identity !== null)
             return this.identity;
         const result = normalizeCreateResult(this.create());
@@ -458,7 +466,7 @@ class StoreOutputBase {
         this.disposed = true;
     }
 }
-export class TiStoreAudioOutput extends StoreOutputBase {
+export class TiCloudStorageAudioOutput extends TiCloudStorageOutputBase {
     constructor() {
         super(...arguments);
         this.currentState = 'idle';
@@ -466,65 +474,65 @@ export class TiStoreAudioOutput extends StoreOutputBase {
         this.onError = null;
     }
     create() {
-        return NativeTiRtc.storeCreateAudioOutput();
+        return NativeTiRtc.tiCloudStorageCreateAudioOutput();
     }
     get state() {
         if (this.identity !== null)
-            this.currentState = audioStateFromNative(NativeTiRtc.storeAudioOutputGetState(this.identity.objectId).state ?? this.currentState);
+            this.currentState = audioStateFromNative(NativeTiRtc.tiCloudStorageAudioOutputGetState(this.identity.objectId).state ?? this.currentState);
         return this.currentState;
     }
     attach(replay, channelId) {
         if (!isUInt8(channelId))
-            return TISTORE_ERROR_INVALID_ARGUMENT;
+            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.storeAudioOutputAttach(output.objectId, replayId.objectId, channelId);
+        const code = NativeTiRtc.tiCloudStorageAudioOutputAttach(output.objectId, replayId.objectId, channelId);
         if (code === 0)
             this.bound = true;
-        logStoreOutcome('audio_output_attach', code);
+        tiCloudStorageLogOutcome('audio_output_attach', code);
         return code;
     }
     setVolume(volumePercent) {
         if (!isFiniteSafeInteger(volumePercent) || volumePercent < 0 || volumePercent > 100)
-            return TISTORE_ERROR_INVALID_ARGUMENT;
+            return TI_CLOUD_STORAGE_ERROR_INVALID_ARGUMENT;
         const output = this.ensureIdentity();
-        return typeof output === 'number' ? output : NativeTiRtc.storeAudioOutputSetVolume(output.objectId, volumePercent);
+        return typeof output === 'number' ? output : NativeTiRtc.tiCloudStorageAudioOutputSetVolume(output.objectId, volumePercent);
     }
     detach() {
         if (this.identity === null)
             return 0;
-        const code = NativeTiRtc.storeAudioOutputDetach(this.identity.objectId);
+        const code = NativeTiRtc.tiCloudStorageAudioOutputDetach(this.identity.objectId);
         if (code === 0) {
             this.bound = false;
-            this.currentState = TiStoreAudioOutputState.idle;
+            this.currentState = TiCloudStorageAudioOutputState.idle;
         }
-        logStoreOutcome('audio_output_detach', code);
+        tiCloudStorageLogOutcome('audio_output_detach', code);
         return code;
     }
     dispose() {
         if (this.disposed)
             return 0;
         if (this.bound)
-            return TISTORE_ERROR_IN_USE;
+            return TI_CLOUD_STORAGE_ERROR_IN_USE;
         if (this.identity === null) {
             this.disposed = true;
-            this.currentState = TiStoreAudioOutputState.idle;
+            this.currentState = TiCloudStorageAudioOutputState.idle;
             this.onStateChanged = null;
             this.onError = null;
             return 0;
         }
-        const code = NativeTiRtc.storeAudioOutputDispose(this.identity.objectId);
+        const code = NativeTiRtc.tiCloudStorageAudioOutputDispose(this.identity.objectId);
         if (code === 0) {
             this.releaseIdentity();
-            this.currentState = TiStoreAudioOutputState.idle;
+            this.currentState = TiCloudStorageAudioOutputState.idle;
             this.onStateChanged = null;
             this.onError = null;
         }
-        logStoreOutcome('audio_output_dispose', code);
+        tiCloudStorageLogOutcome('audio_output_dispose', code);
         return code;
     }
     handleEvent(event) {
@@ -533,10 +541,10 @@ export class TiStoreAudioOutput extends StoreOutputBase {
             this.onStateChanged?.(this.currentState);
         }
         else if (event.type === 'audioOutputError')
-            this.onError?.(event.code ?? TISTORE_ERROR_IO_FAILED);
+            this.onError?.(event.code ?? TI_CLOUD_STORAGE_ERROR_IO_FAILED);
     }
 }
-export class TiStoreVideoOutput extends StoreOutputBase {
+export class TiCloudStorageVideoOutput extends TiCloudStorageOutputBase {
     constructor() {
         super(...arguments);
         this.currentState = 'idle';
@@ -544,41 +552,41 @@ export class TiStoreVideoOutput extends StoreOutputBase {
         this.onError = null;
     }
     create() {
-        return NativeTiRtc.storeCreateVideoOutput();
+        return NativeTiRtc.tiCloudStorageCreateVideoOutput();
     }
     get state() {
         if (this.identity !== null)
-            this.currentState = videoStateFromNative(NativeTiRtc.storeVideoOutputGetState(this.identity.objectId).state ?? this.currentState);
+            this.currentState = videoStateFromNative(NativeTiRtc.tiCloudStorageVideoOutputGetState(this.identity.objectId).state ?? this.currentState);
         return this.currentState;
     }
     view(props = {}) {
         this.ensureIdentity();
-        return React.createElement(TiStoreVideoOutputView, {
+        return React.createElement(TiCloudStorageVideoOutputView, {
             ...props,
             output: this,
         });
     }
     attach(replay, channelId) {
         if (!isUInt8(channelId))
-            return TISTORE_ERROR_INVALID_ARGUMENT;
+            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.storeVideoOutputAttach(output.objectId, replayId.objectId, channelId);
+        const code = NativeTiRtc.tiCloudStorageVideoOutputAttach(output.objectId, replayId.objectId, channelId);
         if (code === 0)
             this.bound = true;
-        logStoreOutcome('video_output_attach', code);
+        tiCloudStorageLogOutcome('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);
+        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);
@@ -586,34 +594,34 @@ export class TiStoreVideoOutput extends StoreOutputBase {
     detach() {
         if (this.identity === null)
             return 0;
-        const code = NativeTiRtc.storeVideoOutputDetach(this.identity.objectId);
+        const code = NativeTiRtc.tiCloudStorageVideoOutputDetach(this.identity.objectId);
         if (code === 0) {
             this.bound = false;
-            this.currentState = TiStoreVideoOutputState.idle;
+            this.currentState = TiCloudStorageVideoOutputState.idle;
         }
-        logStoreOutcome('video_output_detach', code);
+        tiCloudStorageLogOutcome('video_output_detach', code);
         return code;
     }
     dispose() {
         if (this.disposed)
             return 0;
         if (this.bound)
-            return TISTORE_ERROR_IN_USE;
+            return TI_CLOUD_STORAGE_ERROR_IN_USE;
         if (this.identity === null) {
             this.disposed = true;
-            this.currentState = TiStoreVideoOutputState.idle;
+            this.currentState = TiCloudStorageVideoOutputState.idle;
             this.onStateChanged = null;
             this.onError = null;
             return 0;
         }
-        const code = NativeTiRtc.storeVideoOutputDispose(this.identity.objectId);
+        const code = NativeTiRtc.tiCloudStorageVideoOutputDispose(this.identity.objectId);
         if (code === 0) {
             this.releaseIdentity();
-            this.currentState = TiStoreVideoOutputState.idle;
+            this.currentState = TiCloudStorageVideoOutputState.idle;
             this.onStateChanged = null;
             this.onError = null;
         }
-        logStoreOutcome('video_output_dispose', code);
+        tiCloudStorageLogOutcome('video_output_dispose', code);
         return code;
     }
     handleEvent(event) {
@@ -622,10 +630,10 @@ export class TiStoreVideoOutput extends StoreOutputBase {
             this.onStateChanged?.(this.currentState);
         }
         else if (event.type === 'videoOutputError')
-            this.onError?.(event.code ?? TISTORE_ERROR_IO_FAILED);
+            this.onError?.(event.code ?? TI_CLOUD_STORAGE_ERROR_IO_FAILED);
     }
 }
-export function TiStoreVideoOutputView(props) {
+export function TiCloudStorageVideoOutputView(props) {
     const { output, resizeMode = 'contain', ...viewProps } = props;
     const identity = useOwnerIdentity(output);
     return identity === null
@@ -642,7 +650,7 @@ function useOwnerIdentity(owner) {
     React.useEffect(() => subscribeNativeIdentity(owner, update), [owner]);
     return readNativeIdentity(owner);
 }
-export class TiStoreRecordingTask {
+export class TiCloudStorageRecordingTask {
     constructor(taskId, owner) {
         this.taskId = taskId;
         this.owner = owner;
@@ -650,21 +658,21 @@ export class TiStoreRecordingTask {
     }
     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 (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 TiStoreExportTask {
+export class TiCloudStorageExportTask {
     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}`);
+        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);
@@ -672,7 +680,7 @@ export class TiStoreExportTask {
         if (onProgress !== undefined) {
             let lastProgress = -1;
             const timer = setInterval(() => {
-                const progress = NativeTiRtc.storeExportProgress(taskId);
+                const progress = NativeTiRtc.tiCloudStorageExportProgress(taskId);
                 if (progress !== lastProgress) {
                     lastProgress = progress;
                     onProgress(progress);
@@ -684,15 +692,15 @@ export class TiStoreExportTask {
     }
     get progress() {
         void this.owner;
-        return NativeTiRtc.storeExportProgress(this.taskId);
+        return NativeTiRtc.tiCloudStorageExportProgress(this.taskId);
     }
     get result() {
         return this.resultPromise;
     }
     stop() {
-        const code = NativeTiRtc.storeExportStop(this.taskId);
-        logStoreOutcome('export_stop', code);
+        const code = NativeTiRtc.tiCloudStorageExportStop(this.taskId);
+        tiCloudStorageLogOutcome('export_stop', code);
         return this.resultPromise;
     }
 }
-//# sourceMappingURL=store.js.map
+//# sourceMappingURL=storage.js.map