tirtc-react-native 2.4.2 → 2.5.0

package/lib/typescript/storage.d.ts

@@ -3,6 +3,7 @@ import { type ViewProps } from 'react-native';
 import { NativeTiRtc, type NativeTiRtcEvent } from './native';
 import { type NativeIdentity } from './native_object_id';
 import { type Resp, type TiRtcGalleryAsset } from './recording';
+import { TiRawDump, type TiCloudStorageRawDumpOptions } from './raw_dump';
 export declare const TI_CLOUD_STORAGE_ERROR_OK: 0;
 export declare const TI_CLOUD_STORAGE_ERROR_INVALID_ARGUMENT: 6000;
 export declare const TI_CLOUD_STORAGE_ERROR_NOT_INITIALIZED: 6001;
@@ -27,6 +28,8 @@ export declare const TI_CLOUD_STORAGE_ERROR_UNAVAILABLE: 6123;
 export declare const TI_CLOUD_STORAGE_ERROR_STOPPED: 6124;
 export declare const TI_CLOUD_STORAGE_ERROR_RECORDING_NOT_FOUND: 6134;
 export declare const TI_CLOUD_STORAGE_ERROR_RECORDING_DOWNLOAD_FAILED: 6135;
+export declare const TI_CLOUD_STORAGE_ERROR_NETWORK_UNAVAILABLE: 6136;
+export declare const TI_CLOUD_STORAGE_ERROR_ENDPOINT_DNS_RESOLUTION_FAILED: 6137;
 export type TiCloudStorageRecordingRange = Readonly<{
     startTimeMs: number;
     endTimeMs: number;
@@ -43,6 +46,69 @@ export type TiCloudStorageRecordingDaysResult = Readonly<{
     code: number;
     days: ReadonlyArray<TiCloudStorageRecordingDay>;
 }>;
+export declare const TiCloudStorageRecordingTrackKind: {
+    readonly video: "video";
+    readonly audio: "audio";
+};
+export type TiCloudStorageRecordingTrackKind = (typeof TiCloudStorageRecordingTrackKind)[keyof typeof TiCloudStorageRecordingTrackKind];
+export type TiCloudStorageRecordingTrack = Readonly<{
+    kind: TiCloudStorageRecordingTrackKind;
+    channelId: number;
+}>;
+export declare const TiCloudStorageRecordingGapReason: {
+    readonly unknown: "unknown";
+    readonly notFound: "notFound";
+    readonly downloadFailed: "downloadFailed";
+    readonly integrityFailed: "integrityFailed";
+    readonly mediaUnreadable: "mediaUnreadable";
+    readonly noKeyFrame: "noKeyFrame";
+    readonly noRecording: "noRecording";
+    readonly decryptionFailed: "decryptionFailed";
+    readonly unsupportedMedia: "unsupportedMedia";
+    readonly trackUnavailable: "trackUnavailable";
+};
+export type TiCloudStorageRecordingGapReason = (typeof TiCloudStorageRecordingGapReason)[keyof typeof TiCloudStorageRecordingGapReason];
+export type TiCloudStorageRecordingGap = Readonly<{
+    range: TiCloudStorageRecordingRange;
+    tracks: ReadonlyArray<TiCloudStorageRecordingTrack>;
+    reasons: ReadonlyArray<TiCloudStorageRecordingGapReason>;
+}>;
+export type TiCloudStorageExportProgress = Readonly<{
+    fraction: number;
+    coveredDurationMs: number;
+}>;
+export type TiCloudStorageExportSegment = Readonly<{
+    sourceRange: TiCloudStorageRecordingRange;
+    outputStartMs: number;
+    outputEndMs: number;
+}>;
+export declare const TiCloudStorageExportTermination: {
+    readonly exhausted: "exhausted";
+    readonly interrupted: "interrupted";
+    readonly cancelled: "cancelled";
+    readonly failed: "failed";
+};
+export type TiCloudStorageExportTermination = (typeof TiCloudStorageExportTermination)[keyof typeof TiCloudStorageExportTermination];
+export type TiCloudStorageExportReport = Readonly<{
+    requestedRange: TiCloudStorageRecordingRange;
+    coveredDurationMs: number;
+    segments: ReadonlyArray<TiCloudStorageExportSegment>;
+    gaps: ReadonlyArray<TiCloudStorageRecordingGap>;
+    unprocessedRanges: ReadonlyArray<TiCloudStorageRecordingRange>;
+    complete: boolean;
+    termination: TiCloudStorageExportTermination;
+    cause: number;
+}>;
+export type TiCloudStorageExportOutcome = Readonly<{
+    code: number;
+    file: TiCloudStorageRecordingFile | null;
+    report: TiCloudStorageExportReport | null;
+}>;
+export type TiCloudStorageExportObserver = Readonly<{
+    onProgress?: (progress: number) => void;
+    onProgressDetail?: (progress: TiCloudStorageExportProgress) => void;
+    onRecordingGap?: (gap: TiCloudStorageRecordingGap) => void;
+}>;
 export declare const TiCloudStorageReplaySpeed: {
     readonly x0_125: "x0_125";
     readonly x0_25: "x0_25";
@@ -97,6 +163,7 @@ export declare class TiCloudStorage {
     private token;
     private identity;
     private disposed;
+    private pendingAsyncOperations;
     constructor(token: string);
     static init(options: Readonly<{
         appId: string;
@@ -109,19 +176,22 @@ export declare class TiCloudStorage {
     listRecordings(startTimeMs: number, endTimeMs: number): Promise<TiCloudStorageRecordingRangesResult>;
     listRecordingDays(startDate: string, endDate: string, timeZoneId?: string): Promise<TiCloudStorageRecordingDaysResult>;
     createReplay(): TiCloudStorageReplay;
-    exportRecording(options: TiCloudStorageExportOptions, onProgress?: (progress: number) => void): Resp<TiCloudStorageExportTask>;
+    exportRecording(options: TiCloudStorageExportOptions, observer?: ((progress: number) => void) | TiCloudStorageExportObserver): Resp<TiCloudStorageExportTask>;
     dispose(): number;
+    private trackAsyncOperation;
     private ensureIdentity;
 }
 export declare class TiCloudStorageReplay {
     private readonly cloudStorage;
     private identity;
     private disposed;
+    private inCallback;
     private currentSpeed;
     private currentTime;
     onTimeChanged: ((timeMs: number) => void) | null;
     onError: ((code: number) => void) | null;
     onCompleted: (() => void) | null;
+    onRecordingGap: ((gap: TiCloudStorageRecordingGap) => void) | null;
     constructor(cloudStorage: TiCloudStorage);
     get speed(): TiCloudStorageReplaySpeed;
     get currentTimeMs(): number | null;
@@ -131,6 +201,7 @@ export declare class TiCloudStorageReplay {
     seek(timeMs: number): number;
     setSpeed(speed: TiCloudStorageReplaySpeed): number;
     startRecording(options: TiCloudStorageStartRecordingOptions): Resp<TiCloudStorageRecordingTask>;
+    startRawDump(options: TiCloudStorageRawDumpOptions): Promise<Resp<TiRawDump>>;
     stop(): number;
     dispose(): number;
     private command;
@@ -196,11 +267,21 @@ export declare class TiCloudStorageRecordingTask {
 export declare class TiCloudStorageExportTask {
     private readonly taskId;
     private readonly owner;
-    private readonly onProgress?;
     private resultPromise;
-    constructor(taskId: number, owner: TiCloudStorage, onProgress?: ((progress: number) => void) | undefined);
+    private completionPromise;
+    private readonly identity;
+    private currentProgressDetail;
+    private currentReport;
+    private readonly observer;
+    private terminal;
+    constructor(taskId: number, generation: number, owner: TiCloudStorage, observer?: ((progress: number) => void) | TiCloudStorageExportObserver);
     get progress(): number;
+    get progressDetail(): TiCloudStorageExportProgress;
+    get report(): TiCloudStorageExportReport | null;
+    get completion(): Promise<TiCloudStorageExportOutcome>;
     get result(): Promise<Resp<TiCloudStorageRecordingFile>>;
+    cancel(): number;
     stop(): Promise<Resp<TiCloudStorageRecordingFile>>;
+    private handleEvent;
 }
 export {};

package/lib/typescript/types.d.ts

@@ -66,11 +66,6 @@ export declare const TiRtcVideoCodec: {
     readonly mjpeg: "mjpeg";
 };
 export type TiRtcVideoCodec = (typeof TiRtcVideoCodec)[keyof typeof TiRtcVideoCodec];
-export declare const TiRtcVideoEncoderCodec: {
-    readonly h264: "h264";
-    readonly mjpeg: "mjpeg";
-};
-export type TiRtcVideoEncoderCodec = (typeof TiRtcVideoEncoderCodec)[keyof typeof TiRtcVideoEncoderCodec];
 export declare const TiRtcVideoFrameRate: {
     readonly fps10: "fps10";
     readonly fps15: "fps15";
@@ -145,6 +140,9 @@ export type TiRtcVideoOutputViewProps = ViewProps & Readonly<{
     resizeMode?: 'contain' | 'cover' | 'stretch';
 }>;
 export type TiRtcAudioInputOptions = Readonly<{
+    /** Nano audio media: 1 PCM, 2 G711A, 3 AAC, 4 Opus, 5 AMR. Omitted or -1 uses codec. */
+    media?: number;
+    /** @deprecated Use media. The legacy default is g711a. */
     codec?: TiRtcAudioCodec;
     sampleRate?: TiRtcAudioSampleRate;
     channels?: TiRtcAudioChannelCount;
@@ -153,7 +151,8 @@ export type TiRtcAudioInputOptions = Readonly<{
     ansLevel?: TiRtcAudioAnsLevel;
 }>;
 export type TiRtcVideoInputOptions = Readonly<{
-    codec?: TiRtcVideoEncoderCodec;
+    /** Nano video media: 66 H.264 (default) or 65 MJPEG. */
+    media?: number;
     width?: number;
     height?: number;
     frameRate?: TiRtcVideoFrameRate;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tirtc-react-native",
-  "version": "2.4.2",
+  "version": "2.5.0",
   "description": "TiRTC React Native SDK",
   "homepage": "https://tange.ai/",
   "repository": {
@@ -46,10 +46,10 @@
     "react-native.config.js"
   ],
   "scripts": {
-    "build": "node scripts/clean_generated_lib.mjs && tsc -p tsconfig.build.json && node scripts/write_codegen_component_specs.mjs",
+    "build": "node scripts/clean_generated_lib.mjs && tsc -p tsconfig.build.json && node scripts/freeze_build_identity.mjs && node scripts/write_codegen_component_specs.mjs",
     "lint": "node test/source_guard.mjs",
     "preflight:npm": "node scripts/npm_preflight.mjs",
-    "test": "node test/parity_guard.mjs && node test/package_artifact_guard.mjs && node test/lifecycle_contract_guard.mjs && node test/lifecycle_behavior_guard.mjs && node test/integration_contract_guard.mjs && node test/runner_schema_guard.mjs",
+    "test": "node test/parity_guard.mjs && node test/package_artifact_guard.mjs && node test/lifecycle_contract_guard.mjs && node test/lifecycle_behavior_guard.mjs && node test/integration_contract_guard.mjs && node test/runner_schema_guard.mjs && node --test test/source_fingerprint.test.mjs",
     "test:contract-red": "node test/contract_red_summary.mjs",
     "typecheck": "tsc -p tsconfig.json --noEmit",
     "codegen:check": "node test/codegen_contract_guard.mjs"

package/src/audio_input.ts

@@ -21,6 +21,7 @@ export class TiRtcAudioInput {
   private queue: Promise<unknown> = Promise.resolve();
   private currentState: TiRtcInputState = 'idle';
   private options: Required<TiRtcAudioInputOptions> = {
+    media: -1,
     codec: 'g711a',
     sampleRate: 'rate16k',
     channels: 'mono',
@@ -58,8 +59,20 @@ export class TiRtcAudioInput {
     if (!isPlainObject(options)) {
       return Promise.resolve(TIRTC_ERROR_INVALID_ARGUMENT);
     }
+    const media = options.media === undefined ? -1 : options.media;
+    const source = media === -1 ? (options.codec === undefined ? 'default' : 'legacy') : 'media';
+    const rawLegacy = options.codec === undefined ? 'omitted' :
+      ['g711a', 'aac', 'pcm', 'opus', 'amr'].includes(options.codec) ? options.codec : 'invalid';
+    const legacyCodec = options.codec ?? 'g711a';
+    if (!Number.isInteger(media) || ![-1, 1, 2, 3, 4, 5].includes(media) ||
+        (media === -1 && !['g711a', 'aac', 'pcm', 'opus', 'amr'].includes(legacyCodec))) {
+      logRtcOutcome('audio_input_set_options', TIRTC_ERROR_INVALID_ARGUMENT,
+        ` nano_media=${typeof media === 'number' ? media : typeof media} legacy_codec=${rawLegacy} source=${source}`);
+      return Promise.resolve(TIRTC_ERROR_INVALID_ARGUMENT);
+    }
     const normalized = {
-      codec: options.codec ?? 'g711a',
+      media,
+      codec: media === -1 ? legacyCodec : 'g711a' as const,
       sampleRate: options.sampleRate ?? 'rate16k',
       channels: options.channels ?? 'mono',
       aecMode: options.aecMode ?? 'disabled',
@@ -72,6 +85,8 @@ export class TiRtcAudioInput {
         return identity;
       }
       const code = await NativeTiRtc.audioInputSetOptions(identity.objectId, normalized);
+      logRtcOutcome('audio_input_set_options', code,
+        ` nano_media=${media} legacy_codec=${rawLegacy} source=${source} sample_rate=${['rate8k', 'rate16k'].includes(normalized.sampleRate) ? normalized.sampleRate : 'invalid'} channels=${normalized.channels === 'mono' ? 'mono' : 'invalid'}`);
       if (code === TIRTC_ERROR_OK) {
         this.options = normalized;
       }
@@ -100,16 +115,20 @@ export class TiRtcAudioInput {
   }
 
   start(): Promise<number> {
-    return this.logged(
-      'audio_input_start',
-      this.enqueue(async () => {
-        const identity = this.ensureIdentity();
-        if (typeof identity === 'number') {
-          return identity;
-        }
-        return NativeTiRtc.audioInputStart(identity.objectId);
-      }),
-    );
+    return this.enqueue(async () => {
+      const identity = this.ensureIdentity();
+      if (typeof identity === 'number') {
+        logRtcOutcome('audio_input_start', identity);
+        return identity;
+      }
+      const wasRunning = this.state === 'running';
+      const code = await NativeTiRtc.audioInputStart(identity.objectId);
+      if (code !== TIRTC_ERROR_OK || !wasRunning) {
+        logRtcOutcome('audio_input_start', code,
+          ` object_id=${identity.objectId} nano_media=${this.options.media} legacy_codec=${this.options.codec} sample_rate=${this.options.sampleRate} channels=${this.options.channels}`);
+      }
+      return code;
+    });
   }
 
   stop(): Promise<number> {

package/src/build_identity.ts

@@ -0,0 +1,6 @@
+export const buildIdentity = {
+  releaseVersion: '',
+  buildTimeUtc: '',
+  sourceRevision: '',
+  sourceDirty: -1,
+} as const;

package/src/conn.ts

@@ -27,6 +27,12 @@ import type {
   TiRtcOnConnStateChanged,
   TiRtcOnConnStreamMessage,
 } from './types';
+import {
+  createRawDumpFromNative,
+  normalizeRawDumpIds,
+  TiRawDump,
+  type TiRtcRawDumpOptions,
+} from './raw_dump';
 
 export class TiRtcConn {
   private identity: NativeIdentity | null = null;
@@ -59,6 +65,23 @@ export class TiRtcConn {
     return typeof identity === 'number' ? recordingFailure(identity) : startRecording(identity.objectId, options);
   }
 
+  async startRawDump(options: TiRtcRawDumpOptions): Promise<Resp<TiRawDump>> {
+    if (options === null || typeof options !== 'object') return recordingFailure(TIRTC_ERROR_INVALID_ARGUMENT);
+    const audio = normalizeRawDumpIds(options.audioStreamIds ?? [], 15);
+    const video = normalizeRawDumpIds(options.videoStreamIds ?? [], 15);
+    const uplinkAudio = normalizeRawDumpIds(options.uplinkAudioStreamIds ?? [], 15);
+    if (audio === null || video === null || uplinkAudio === null ||
+        (audio.length === 0 && video.length === 0 && uplinkAudio.length === 0)) {
+      return recordingFailure(TIRTC_ERROR_INVALID_ARGUMENT);
+    }
+    const identity = this.ensureIdentity();
+    if (typeof identity === 'number') return recordingFailure(identity);
+    const result = await NativeTiRtc.connStartRawDump(identity.objectId, audio, video, uplinkAudio);
+    return result.code === 0 && result.dumpId !== null
+      ? {success: true, code: null, message: null, data: createRawDumpFromNative(result.dumpId)}
+      : recordingFailure(result.code);
+  }
+
   get state(): TiRtcConnState {
     if (this.identity !== null && !this.disposed) {
       const result = NativeTiRtc.connGetState(this.identity.objectId);

package/src/events.ts

@@ -16,20 +16,25 @@ function ensureSubscribed(): void {
     return;
   }
   subscription = NativeTiRtc.onTiRtcEvent((event) => {
-    if (!isPositiveInt32(event.objectId) || !isPositiveInt32(event.generation)) {
-      return;
-    }
-    const handler = handlers.get(eventKey({
-      objectId: event.objectId,
-      generation: event.generation,
-    }));
-    if (handler !== undefined) {
-      handler(event);
+    if (event.type === 'tiCloudStorageCallbackReady') {
+      const pending = NativeTiRtc.tiCloudStorageTakeCallback();
+      if (pending === null) return;
+      try {
+        deliver(pending.event);
+      } finally {
+        NativeTiRtc.tiCloudStorageAcknowledgeCallback(pending.deliveryId);
+      }
       return;
     }
+    deliver(event);
   });
 }
 
+function deliver(event: NativeTiRtcEvent): void {
+  if (!isPositiveInt32(event.objectId) || !isPositiveInt32(event.generation)) return;
+  handlers.get(eventKey({objectId: event.objectId, generation: event.generation}))?.(event);
+}
+
 export function registerNativeEventHandler(identity: NativeIdentity, handler: NativeEventHandler): void {
   handlers.set(eventKey(identity), handler);
   ensureSubscribed();

package/src/index.ts

@@ -9,7 +9,6 @@ export {
   TiRtcAudioAgcLevel,
   TiRtcAudioAnsLevel,
   TiRtcVideoCodec,
-  TiRtcVideoEncoderCodec,
   TiRtcVideoFrameRate,
   TiRtcCameraFacing,
   TiRtcVideoDecoderPreference,
@@ -60,6 +59,13 @@ export {TiRtcAudioInput} from './audio_input';
 export {TiRtcVideoInput, TiRtcVideoInputPreview} from './video_input';
 export {TiRtcLogging} from './logging';
 export {TiRtcRecordingTask} from './recording';
+export {TiRawDump} from './raw_dump';
+export type {
+  TiRtcRawDumpOptions,
+  TiCloudStorageRawDumpOptions,
+  TiRawDumpStopReason,
+  TiRawDumpArchive,
+} from './raw_dump';
 export type {
   Resp,
   TiRtcGalleryAsset,
@@ -92,7 +98,12 @@ export {
   TI_CLOUD_STORAGE_ERROR_STOPPED,
   TI_CLOUD_STORAGE_ERROR_RECORDING_NOT_FOUND,
   TI_CLOUD_STORAGE_ERROR_RECORDING_DOWNLOAD_FAILED,
+  TI_CLOUD_STORAGE_ERROR_NETWORK_UNAVAILABLE,
+  TI_CLOUD_STORAGE_ERROR_ENDPOINT_DNS_RESOLUTION_FAILED,
   TiCloudStorageReplaySpeed,
+  TiCloudStorageRecordingTrackKind,
+  TiCloudStorageRecordingGapReason,
+  TiCloudStorageExportTermination,
   TiCloudStorageAudioOutputState,
   TiCloudStorageVideoOutputState,
   TiCloudStorage,
@@ -105,6 +116,13 @@ export {
 } from './storage';
 export type {
   TiCloudStorageRecordingRange,
+  TiCloudStorageRecordingTrack,
+  TiCloudStorageRecordingGap,
+  TiCloudStorageExportProgress,
+  TiCloudStorageExportSegment,
+  TiCloudStorageExportReport,
+  TiCloudStorageExportOutcome,
+  TiCloudStorageExportObserver,
   TiCloudStorageRecordingRangesResult,
   TiCloudStorageRecordingDay,
   TiCloudStorageRecordingDaysResult,

package/src/logging_internal.ts

@@ -1,6 +1,24 @@
 import {TiRtcLogging} from './logging';
+import {NativeTiRtc} from './native';
+import {buildIdentity} from './build_identity';
 
 const rtcLogTag = 'TIRTC_REACT_NATIVE';
+const loggedIdentityProducts = new Set<string>();
+
+export function logBuildIdentity(product: 'rtc' | 'cloud_storage'): void {
+  if (loggedIdentityProducts.has(product)) return;
+  try {
+    const code = NativeTiRtc.writeLog(
+      1,
+      rtcLogTag,
+      '[build_identity] summary: component build identity; component=react_native ' +
+        `product=${product} release_version=${buildIdentity.releaseVersion} ` +
+        `build_time_utc=${buildIdentity.buildTimeUtc} source_revision=${buildIdentity.sourceRevision} ` +
+        `source_dirty=${buildIdentity.sourceDirty}`,
+    );
+    if (code === 0) loggedIdentityProducts.add(product);
+  } catch {}
+}
 
 export function logRtcOutcome(operation: string, code: number, details = ''): void {
   const message = `[${operation}] completed code=${code}${details}`;

package/src/native.ts

@@ -3,4 +3,10 @@ import NativeTiRtcVideoInputPreview from './specs/TiRtcVideoInputPreviewNativeCo
 import NativeTiRtcVideoOutputView from './specs/TiRtcVideoOutputViewNativeComponent';
 
 export {NativeTiRtc, NativeTiRtcVideoOutputView, NativeTiRtcVideoInputPreview};
-export type {NativeTiRtcEvent} from './specs/NativeTiRtc';
+export type {
+  NativeTiRtcEvent,
+  NativeTiCloudStorageExportProgress,
+  NativeTiCloudStorageExportReport,
+  NativeTiCloudStorageRecordingGap,
+  NativeRawDumpArchive,
+} from './specs/NativeTiRtc';

package/src/raw_dump.ts

@@ -0,0 +1,84 @@
+import {isFiniteSafeInteger, TIRTC_ERROR_INVALID_ARGUMENT} from './errors';
+import {NativeTiRtc, type NativeRawDumpArchive} from './native';
+import type {Resp} from './recording';
+
+export type TiRawDumpStopReason =
+  | 'unknown' | 'user' | 'timeLimit' | 'byteLimit' | 'sourceClosed'
+  | 'resourceLimit' | 'writeFailed';
+
+export type TiRtcRawDumpOptions = Readonly<{
+  /** Remote downlink audio stream IDs. */
+  audioStreamIds?: ReadonlyArray<number>;
+  /** Remote downlink video stream IDs. */
+  videoStreamIds?: ReadonlyArray<number>;
+  /** Local uplink audio stream IDs used by TiRtcAudioInput.attach. */
+  uplinkAudioStreamIds?: ReadonlyArray<number>;
+}>;
+
+export type TiCloudStorageRawDumpOptions = Readonly<{
+  audioChannelIds?: ReadonlyArray<number>;
+  videoChannelIds?: ReadonlyArray<number>;
+}>;
+
+export type TiRawDumpArchive = Readonly<{
+  captureId: string; path: string; size: number; sha256: string; capturedDurationMs: number;
+  captureComplete: boolean; stopReason: TiRawDumpStopReason;
+  unsavedPacketCount: number; unsavedByteCount: number; empty: boolean;
+}>;
+
+const reasons: ReadonlyArray<TiRawDumpStopReason> = [
+  'unknown', 'user', 'timeLimit', 'byteLimit', 'sourceClosed', 'resourceLimit', 'writeFailed',
+];
+
+function archiveFromNative(value: NativeRawDumpArchive): TiRawDumpArchive {
+  return {...value, stopReason: reasons[value.stopReason] ?? 'unknown'};
+}
+
+function failure<T>(code: number): Resp<T> {
+  return {success: false, code, message: null, data: null};
+}
+
+export function normalizeRawDumpIds(
+  value: unknown,
+  maximum: number,
+): ReadonlyArray<number> | null {
+  if (!Array.isArray(value)) return null;
+  const result = new Set<number>();
+  for (const item of value) {
+    if (!isFiniteSafeInteger(item) || item < 0 || item > maximum) return null;
+    result.add(item);
+  }
+  return [...result];
+}
+
+export class TiRawDump {
+  private stopPromise: Promise<Resp<TiRawDumpArchive>> | null = null;
+
+  private constructor(private readonly nativeId: number) {}
+
+  stop(): Promise<Resp<TiRawDumpArchive>> {
+    if (this.stopPromise === null) {
+      this.stopPromise = NativeTiRtc.rawDumpStop(this.nativeId).then((result) => {
+        if (result.code !== 0 || result.archive === null) {
+          if (!result.terminal) this.stopPromise = null;
+          return failure<TiRawDumpArchive>(result.code);
+        }
+        const archive = archiveFromNative(result.archive);
+        return {success: true, code: null, message: null, data: archive};
+      }).catch(() => {
+        this.stopPromise = null;
+        return failure<TiRawDumpArchive>(TIRTC_ERROR_INVALID_ARGUMENT);
+      });
+    }
+    return this.stopPromise!;
+  }
+
+  async dispose(): Promise<number> {
+    const result = await this.stop();
+    return result.success ? 0 : result.code ?? TIRTC_ERROR_INVALID_ARGUMENT;
+  }
+}
+
+export function createRawDumpFromNative(nativeId: number): TiRawDump {
+  return Reflect.construct(TiRawDump, [nativeId]) as TiRawDump;
+}

package/src/runtime.ts

@@ -1,6 +1,6 @@
 import {isPlainObject, TIRTC_ERROR_INVALID_ARGUMENT} from './errors';
 import {NativeTiRtc} from './native';
-import {logRtcOutcome} from './logging_internal';
+import {logBuildIdentity, logRtcOutcome} from './logging_internal';
 import type {TiRtcInitOptions} from './types';
 
 export class TiRtc {
@@ -15,6 +15,7 @@ export class TiRtc {
       endpoint: typeof config.endpoint === 'string' ? config.endpoint : '',
       consoleLogEnabled: typeof config.consoleLogEnabled === 'boolean' ? config.consoleLogEnabled : false,
     }).then((code) => {
+      if (code === 0) logBuildIdentity('rtc');
       logRtcOutcome('runtime_initialize', code);
       return code;
     });