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

package/src/video_input.ts

@@ -6,10 +6,10 @@ import {
   isPositiveInt32Size,
   isUInt8,
   normalizeCreateResult,
-  returnReleasedIfDisposed,
+  returnNotInitializedIfDisposed,
   TIRTC_ERROR_INVALID_ARGUMENT,
   TIRTC_ERROR_OK,
-  TIRTC_HOST_ERROR_OBJECT_RELEASED,
+  TIRTC_ERROR_NOT_INITIALIZED,
 } from './errors';
 import {registerNativeEventHandler, unregisterNativeEventHandler} from './events';
 import {
@@ -20,6 +20,7 @@ import {
   type NativeIdentity,
 } from './native_object_id';
 import {NativeTiRtc, NativeTiRtcVideoInputPreview, type NativeTiRtcEvent} from './native';
+import {logRtcOutcome, logRtcState} from './logging_internal';
 import {TiRtcConn} from './conn';
 import type {
   TiRtcInputState,
@@ -58,8 +59,12 @@ export class TiRtcVideoInput {
     const result = normalizeCreateResult(NativeTiRtc.createVideoInput());
     this.createCode = result.code;
     if (result.code === TIRTC_ERROR_OK) {
-      this.adoptIdentity({objectId: result.objectId, generation: result.generation});
+      this.adoptIdentity({
+        objectId: result.objectId,
+        generation: result.generation,
+      });
     }
+    logRtcOutcome('video_input_create', result.code);
   }
 
   get state(): TiRtcInputState {
@@ -94,11 +99,13 @@ export class TiRtcVideoInput {
       bitrateKbps: options.bitrateKbps ?? 0,
       cameraFacing: options.cameraFacing ?? 'front',
     };
-    if (!isPositiveInt32Size(normalized.width)
-      || !isPositiveInt32Size(normalized.height)
-      || !Number.isSafeInteger(normalized.bitrateKbps)
-      || normalized.bitrateKbps < 0
-      || normalized.bitrateKbps > 4294967295) {
+    if (
+      !isPositiveInt32Size(normalized.width) ||
+      !isPositiveInt32Size(normalized.height) ||
+      !Number.isSafeInteger(normalized.bitrateKbps) ||
+      normalized.bitrateKbps < 0 ||
+      normalized.bitrateKbps > 4294967295
+    ) {
       return Promise.resolve(TIRTC_ERROR_INVALID_ARGUMENT);
     }
     return this.enqueue(async () => {
@@ -115,13 +122,16 @@ export class TiRtcVideoInput {
   }
 
   start(): Promise<number> {
-    return this.enqueue(async () => {
-      const identity = this.ensureIdentity();
-      if (typeof identity === 'number') {
-        return identity;
-      }
-      return NativeTiRtc.videoInputStart(identity.objectId);
-    });
+    return this.logged(
+      'video_input_start',
+      this.enqueue(async () => {
+        const identity = this.ensureIdentity();
+        if (typeof identity === 'number') {
+          return identity;
+        }
+        return NativeTiRtc.videoInputStart(identity.objectId);
+      }),
+    );
   }
 
   attach(connection: TiRtcConn, streamId: number): Promise<number> {
@@ -132,13 +142,16 @@ export class TiRtcVideoInput {
     if (connIdentity === null) {
       return Promise.resolve(TIRTC_ERROR_INVALID_ARGUMENT);
     }
-    return this.enqueue(async () => {
-      const identity = this.ensureIdentity();
-      if (typeof identity === 'number') {
-        return identity;
-      }
-      return NativeTiRtc.videoInputAttach(identity.objectId, connIdentity.objectId, streamId);
-    });
+    return this.logged(
+      'video_input_attach',
+      this.enqueue(async () => {
+        const identity = this.ensureIdentity();
+        if (typeof identity === 'number') {
+          return identity;
+        }
+        return NativeTiRtc.videoInputAttach(identity.objectId, connIdentity.objectId, streamId);
+      }),
+    );
   }
 
   detach(connection: TiRtcConn): Promise<number> {
@@ -146,21 +159,27 @@ export class TiRtcVideoInput {
     if (connIdentity === null) {
       return Promise.resolve(TIRTC_ERROR_INVALID_ARGUMENT);
     }
-    return this.enqueue(async () => {
-      if (this.identity === null) {
-        return TIRTC_ERROR_OK;
-      }
-      return NativeTiRtc.videoInputDetach(this.identity.objectId, connIdentity.objectId);
-    });
+    return this.logged(
+      'video_input_detach',
+      this.enqueue(async () => {
+        if (this.identity === null) {
+          return TIRTC_ERROR_OK;
+        }
+        return NativeTiRtc.videoInputDetach(this.identity.objectId, connIdentity.objectId);
+      }),
+    );
   }
 
   stop(): Promise<number> {
-    return this.enqueue(async () => {
-      if (this.identity === null) {
-        return TIRTC_ERROR_OK;
-      }
-      return NativeTiRtc.videoInputStop(this.identity.objectId);
-    });
+    return this.logged(
+      'video_input_stop',
+      this.enqueue(async () => {
+        if (this.identity === null) {
+          return TIRTC_ERROR_OK;
+        }
+        return NativeTiRtc.videoInputStop(this.identity.objectId);
+      }),
+    );
   }
 
   /**
@@ -181,39 +200,42 @@ export class TiRtcVideoInput {
     if (this.disposed) {
       return Promise.resolve(TIRTC_ERROR_OK);
     }
-    return this.enqueue(async () => {
-      if (this.identity === null) {
-        this.disposed = true;
-        this.clearCallbacks();
-        this.currentState = 'stopped';
-        this.currentOutputSize = null;
-        this.currentOutputFps = null;
-        return TIRTC_ERROR_OK;
-      }
-      const identity = this.identity;
-      const code = await NativeTiRtc.videoInputDispose(identity.objectId);
-      if (code === TIRTC_ERROR_OK) {
-        this.disposed = true;
-        this.identity = null;
-        unregisterNativeEventHandler(identity);
-        clearNativeIdentity(this);
-        this.clearCallbacks();
-        this.currentState = 'stopped';
-        this.currentOutputSize = null;
-        this.currentOutputFps = null;
-      }
-      return code;
-    }, true);
+    return this.logged(
+      'video_input_dispose',
+      this.enqueue(async () => {
+        if (this.identity === null) {
+          this.disposed = true;
+          this.clearCallbacks();
+          this.currentState = 'stopped';
+          this.currentOutputSize = null;
+          this.currentOutputFps = null;
+          return TIRTC_ERROR_OK;
+        }
+        const identity = this.identity;
+        const code = await NativeTiRtc.videoInputDispose(identity.objectId);
+        if (code === TIRTC_ERROR_OK) {
+          this.disposed = true;
+          this.identity = null;
+          unregisterNativeEventHandler(identity);
+          clearNativeIdentity(this);
+          this.clearCallbacks();
+          this.currentState = 'stopped';
+          this.currentOutputSize = null;
+          this.currentOutputFps = null;
+        }
+        return code;
+      }, true),
+    );
   }
 
   private enqueue(operation: () => Promise<number>, allowDisposed = false): Promise<number> {
-    const released = returnReleasedIfDisposed(this.disposed);
+    const released = returnNotInitializedIfDisposed(this.disposed);
     if (released !== null && !allowDisposed) {
       return Promise.resolve(released);
     }
     const next = this.queue.then(async () => {
       if (this.disposed && !allowDisposed) {
-        return TIRTC_HOST_ERROR_OBJECT_RELEASED;
+        return TIRTC_ERROR_NOT_INITIALIZED;
       }
       return operation();
     });
@@ -221,8 +243,15 @@ export class TiRtcVideoInput {
     return next;
   }
 
+  private logged(operation: string, result: Promise<number>): Promise<number> {
+    return result.then((code) => {
+      logRtcOutcome(operation, code);
+      return code;
+    });
+  }
+
   private ensureIdentity(): NativeIdentity | number {
-    const released = returnReleasedIfDisposed(this.disposed);
+    const released = returnNotInitializedIfDisposed(this.disposed);
     if (released !== null) {
       return released;
     }
@@ -261,7 +290,9 @@ export class TiRtcVideoInput {
     switch (event.type) {
       case 'videoInputStateChanged':
         if (event.state !== undefined) {
-          this.currentState = event.state as TiRtcInputState;
+          const nextState = event.state as TiRtcInputState;
+          if (this.currentState !== nextState) logRtcState('video_input_state', nextState);
+          this.currentState = nextState;
           this.onStateChanged?.(this.currentState);
         }
         break;
@@ -273,7 +304,11 @@ export class TiRtcVideoInput {
         }
         break;
       case 'videoInputError':
-        this.onError?.(event.code ?? TIRTC_ERROR_INVALID_ARGUMENT, event.message ?? null);
+        {
+          const code = event.code ?? TIRTC_ERROR_INVALID_ARGUMENT;
+          logRtcOutcome('video_input', code);
+          this.onError?.(code, event.message ?? null);
+        }
         break;
       default:
         break;

package/src/video_output.ts

@@ -5,8 +5,9 @@ import {
   isPositiveInt32,
   isUInt8,
   normalizeCreateResult,
-  returnReleasedIfDisposed,
+  returnNotInitializedIfDisposed,
   TIRTC_ERROR_INVALID_ARGUMENT,
+  TIRTC_ERROR_IN_USE,
   TIRTC_ERROR_OK,
 } from './errors';
 import {registerNativeEventHandler, unregisterNativeEventHandler} from './events';
@@ -18,7 +19,9 @@ import {
   type NativeIdentity,
 } from './native_object_id';
 import {NativeTiRtc, NativeTiRtcVideoOutputView, type NativeTiRtcEvent} from './native';
+import {logRtcOutcome, logRtcState} from './logging_internal';
 import {TiRtcConn} from './conn';
+import {recordingFailure, takeSnapshot, type Resp, type TiRtcSnapshotFile} from './recording';
 import type {
   TiRtcOnVideoOutputError,
   TiRtcOnVideoOutputRenderSizeChanged,
@@ -39,23 +42,46 @@ export class TiRtcVideoOutput {
   private createCode: number = TIRTC_ERROR_OK;
   private currentState: TiRtcVideoOutputState = 'idle';
   private currentRenderSize: TiRtcSize | null = null;
+  private snapshotInFlight = false;
   private options: Required<Omit<TiRtcVideoOutputOptions, 'maxBufferWatermarkMs'>> &
     Pick<TiRtcVideoOutputOptions, 'maxBufferWatermarkMs'> = {
-      decoderPreference: 'auto',
-      bufferStrategy: 'automatic',
-      maxBufferWatermarkMs: undefined,
-    };
+    decoderPreference: 'auto',
+    bufferStrategy: 'automatic',
+    maxBufferWatermarkMs: undefined,
+  };
 
   onStateChanged: TiRtcOnVideoOutputStateChanged | null = null;
   onRenderSizeChanged: TiRtcOnVideoOutputRenderSizeChanged | null = null;
   onError: TiRtcOnVideoOutputError | null = null;
 
+  async takeSnapshot(): Promise<Resp<TiRtcSnapshotFile>> {
+    const identity = this.ensureIdentity();
+    if (typeof identity === 'number') {
+      return recordingFailure(identity);
+    }
+    if (this.snapshotInFlight) {
+      return recordingFailure(TIRTC_ERROR_IN_USE);
+    }
+    this.snapshotInFlight = true;
+    try {
+      const result = await takeSnapshot(identity.objectId);
+      logRtcOutcome('video_output_snapshot', result.code ?? TIRTC_ERROR_OK);
+      return result;
+    } finally {
+      this.snapshotInFlight = false;
+    }
+  }
+
   constructor() {
     const result = normalizeCreateResult(NativeTiRtc.createVideoOutput());
     this.createCode = result.code;
     if (result.code === TIRTC_ERROR_OK) {
-      this.adoptIdentity({objectId: result.objectId, generation: result.generation});
+      this.adoptIdentity({
+        objectId: result.objectId,
+        generation: result.generation,
+      });
     }
+    logRtcOutcome('video_output_create', result.code);
   }
 
   get state(): TiRtcVideoOutputState {
@@ -81,10 +107,7 @@ export class TiRtcVideoOutput {
       bufferStrategy: options.bufferStrategy ?? 'automatic',
       maxBufferWatermarkMs: options.maxBufferWatermarkMs,
     };
-    if (
-      normalized.maxBufferWatermarkMs !== undefined
-      && !isPositiveInt32(normalized.maxBufferWatermarkMs)
-    ) {
+    if (normalized.maxBufferWatermarkMs !== undefined && !isPositiveInt32(normalized.maxBufferWatermarkMs)) {
       return TIRTC_ERROR_INVALID_ARGUMENT;
     }
     const identity = this.ensureIdentity();
@@ -113,15 +136,20 @@ export class TiRtcVideoOutput {
     if (typeof identity === 'number') {
       return identity;
     }
-    return NativeTiRtc.videoOutputAttach(identity.objectId, connIdentity.objectId, streamId);
+    const code = NativeTiRtc.videoOutputAttach(identity.objectId, connIdentity.objectId, streamId);
+    logRtcOutcome('video_output_attach', code);
+    return code;
   }
 
   detach(): number {
-    const released = returnReleasedIfDisposed(this.disposed);
+    const released = returnNotInitializedIfDisposed(this.disposed);
     if (released !== null) {
       return released;
     }
-    return this.identity === null ? TIRTC_ERROR_OK : NativeTiRtc.videoOutputDetach(this.identity.objectId);
+    const code = this.identity === null ? TIRTC_ERROR_OK : NativeTiRtc.videoOutputDetach(this.identity.objectId);
+    if (code === TIRTC_ERROR_OK) this.currentState = 'idle';
+    logRtcOutcome('video_output_detach', code);
+    return code;
   }
 
   /**
@@ -166,6 +194,9 @@ export class TiRtcVideoOutput {
     if (this.disposed) {
       return TIRTC_ERROR_OK;
     }
+    if (this.snapshotInFlight) {
+      return TIRTC_ERROR_IN_USE;
+    }
     if (this.identity === null) {
       this.disposed = true;
       this.clearCallbacks();
@@ -184,11 +215,12 @@ export class TiRtcVideoOutput {
       this.currentState = 'idle';
       this.currentRenderSize = null;
     }
+    logRtcOutcome('video_output_dispose', code);
     return code;
   }
 
   private ensureIdentity(): NativeIdentity | number {
-    const released = returnReleasedIfDisposed(this.disposed);
+    const released = returnNotInitializedIfDisposed(this.disposed);
     if (released !== null) {
       return released;
     }
@@ -221,7 +253,9 @@ export class TiRtcVideoOutput {
     switch (event.type) {
       case 'videoOutputStateChanged':
         if (event.state !== undefined) {
-          this.currentState = event.state as TiRtcVideoOutputState;
+          const nextState = event.state as TiRtcVideoOutputState;
+          if (this.currentState !== nextState) logRtcState('video_output_state', nextState);
+          this.currentState = nextState;
           this.onStateChanged?.(this.currentState);
         }
         break;
@@ -232,7 +266,11 @@ export class TiRtcVideoOutput {
         }
         break;
       case 'videoOutputError':
-        this.onError?.(event.code ?? TIRTC_ERROR_INVALID_ARGUMENT);
+        {
+          const code = event.code ?? TIRTC_ERROR_INVALID_ARGUMENT;
+          logRtcOutcome('video_output', code);
+          this.onError?.(code);
+        }
         break;
       default:
         break;