agora-appbuilder-core 4.1.22-beta.2 → 4.1.22-beta.3

package/template/bridge/rtc/webNg/RtcSurfaceView.tsx

@@ -1,25 +1,30 @@
 /*
 ********************************************
  Copyright © 2021 Agora Lab, Inc., all rights reserved.
- AppBuilder and all associated components, source code, APIs, services, and documentation 
- (the “Materials”) are owned by Agora Lab, Inc. and its licensors. The Materials may not be 
- accessed, used, modified, or distributed for any purpose without a license from Agora Lab, Inc.  
- Use without a license or in violation of any license terms and conditions (including use for 
- any purpose competitive to Agora Lab, Inc.’s business) is strictly prohibited. For more 
- information visit https://appbuilder.agora.io. 
+ AppBuilder and all associated components, source code, APIs, services, and documentation
+ (the “Materials”) are owned by Agora Lab, Inc. and its licensors. The Materials may not be
+ accessed, used, modified, or distributed for any purpose without a license from Agora Lab, Inc.
+ Use without a license or in violation of any license terms and conditions (including use for
+ any purpose competitive to Agora Lab, Inc.’s business) is strictly prohibited. For more
+ information visit https://appbuilder.agora.io.
 *********************************************
 */
 
 import {ILocalVideoTrack, IRemoteVideoTrack} from 'agora-rtc-sdk-ng';
-import React, {useEffect} from 'react';
+import React, {useEffect, useRef} from 'react';
 import {StyleProp, StyleSheet, ViewProps, ViewStyle} from 'react-native';
 import {RenderModeType} from './Types';
 import {LogSource, logger} from '../../../src/logger/AppBuilderLogger';
+import {getScreenshareMediaHealthOutcome} from './screenshareMediaHealth';
+
+let screenshareRenderInstanceCounter = 0;
 
 export interface RtcSurfaceViewProps extends ViewProps {
   canvas: {
     renderMode?: RenderModeType;
     uid?: number;
+    isScreenshare?: boolean;
+    screenshareSurface?: 'min' | 'max' | 'unknown';
   };
 }
 
@@ -30,28 +35,210 @@ export interface StyleProps {
 interface SurfaceViewInterface extends RtcSurfaceViewProps, StyleProps {}
 
 const RtcSurfaceView = (props: SurfaceViewInterface) => {
-  const {uid, renderMode} = props.canvas;
+  const {
+    uid,
+    renderMode,
+    isScreenshare = false,
+    screenshareSurface = renderMode === RenderModeType.RenderModeHidden
+      ? 'min'
+      : 'max',
+  } = props.canvas;
+  const renderInstanceIdRef = useRef<string | null>(null);
+  if (!renderInstanceIdRef.current) {
+    renderInstanceIdRef.current = `screenshare-render-${++screenshareRenderInstanceCounter}`;
+  }
+  const renderInstanceId = renderInstanceIdRef.current;
   const stream: ILocalVideoTrack | IRemoteVideoTrack =
     uid === 0
-      ? window.engine.localStream.video
+      ? window.engine?.localStream?.video
       : uid === 1
-      ? window.engine.screenStream.video
-      : window.engine.remoteStreams.get(uid)?.video;
+      ? window.engine?.screenStream?.video
+      : window.engine?.remoteStreams?.get?.(uid)?.video;
   useEffect(
     function () {
+      if (isScreenshare && uid !== undefined && uid !== 1) {
+        window.engine?.registerRemoteScreenshareUid?.(uid);
+      }
       if (stream?.play) {
-        if (renderMode === RenderModeType.RenderModeFit) {
-          stream.play(String(uid), {fit: 'contain'});
-        } else {
-          stream.play(String(uid));
+        try {
+          if (renderMode === RenderModeType.RenderModeFit) {
+            stream.play(String(uid), {fit: 'contain'});
+          } else {
+            stream.play(String(uid));
+          }
+          if (isScreenshare) {
+            logger.log(
+              LogSource.AgoraSDK,
+              'API',
+              '[SCREENSHARE_JOURNEY] screen share video surface mounted and track.play invoked',
+              {
+                action: 'monitor',
+                stage: 'video_play',
+                outcome: 'invoked',
+                screenShareUid: uid,
+                role: uid === 1 ? 'sender' : 'viewer',
+                screenshareSurface,
+                renderInstanceId,
+              },
+            );
+          }
+        } catch (error) {
+          if (isScreenshare) {
+            logger.error(
+              LogSource.AgoraSDK,
+              'API',
+              '[SCREENSHARE_JOURNEY] screen share video track play failed',
+              {
+                action: 'monitor',
+                stage: 'video_play',
+                outcome: 'failure',
+                screenShareUid: uid,
+                role: uid === 1 ? 'sender' : 'viewer',
+                screenshareSurface,
+                renderInstanceId,
+                sdkErrorName: (error as Error)?.name,
+                sdkErrorMessage:
+                  (error as Error)?.message || String(error || ''),
+              },
+            );
+          }
         }
       }
+      let healthTimer: ReturnType<typeof setInterval> | undefined;
+      let consecutiveUnhealthySamples = 0;
+      let lastLoggedOutcome: string | undefined;
+      if (isScreenshare && stream) {
+        const checkHealth = () => {
+          const diagnostics =
+            window.engine?.getScreenshareMediaDiagnostics?.(uid);
+          if (!diagnostics) {
+            return;
+          }
+          const stats: any = diagnostics?.stats || {};
+          const videoElement = document
+            .getElementById(String(uid))
+            ?.querySelector('video');
+          const isSender = diagnostics.role === 'sender';
+          const outcome = getScreenshareMediaHealthOutcome({
+            trackReadyState: diagnostics.mediaTrack?.readyState,
+            bitrate: isSender ? stats.sendBitrate : stats.receiveBitrate,
+            frameRate: isSender
+              ? stats.sendFrameRate || stats.captureFrameRate
+              : stats.renderFrameRate ||
+                stats.decodeFrameRate ||
+                stats.receiveFrameRate,
+            width: isSender
+              ? stats.sendResolutionWidth || stats.captureResolutionWidth
+              : stats.receiveResolutionWidth,
+            height: isSender
+              ? stats.sendResolutionHeight || stats.captureResolutionHeight
+              : stats.receiveResolutionHeight,
+            videoElementPresent: Boolean(videoElement),
+            renderedWidth: videoElement?.videoWidth,
+            renderedHeight: videoElement?.videoHeight,
+          });
+          consecutiveUnhealthySamples =
+            outcome === 'healthy' ? 0 : consecutiveUnhealthySamples + 1;
+          const reportableOutcome =
+            outcome === 'healthy'
+              ? lastLoggedOutcome && lastLoggedOutcome !== 'healthy'
+                ? 'recovered'
+                : 'healthy'
+              : consecutiveUnhealthySamples >= 2
+              ? outcome
+              : 'checking';
+          if (
+            reportableOutcome !== 'checking' &&
+            reportableOutcome !== lastLoggedOutcome
+          ) {
+            logger[
+              reportableOutcome === 'healthy' ||
+              reportableOutcome === 'recovered'
+                ? 'log'
+                : 'warn'
+            ](
+              LogSource.AgoraSDK,
+              'API',
+              `[SCREENSHARE_JOURNEY] screen share media health ${reportableOutcome}`,
+              {
+                action: 'monitor',
+                stage: 'media_health',
+                outcome: reportableOutcome,
+                role: diagnostics.role,
+                screenshareSessionId: diagnostics.screenshareSessionId,
+                screenShareUid: diagnostics.screenShareUid,
+                screenshareSurface,
+                renderInstanceId,
+                stats,
+                mediaTrack: diagnostics.mediaTrack
+                  ? {
+                      readyState: diagnostics.mediaTrack.readyState,
+                      enabled: diagnostics.mediaTrack.enabled,
+                      muted: diagnostics.mediaTrack.muted,
+                    }
+                  : null,
+                render: {
+                  videoElementPresent: Boolean(videoElement),
+                  readyState: videoElement?.readyState,
+                  paused: videoElement?.paused,
+                  videoWidth: videoElement?.videoWidth,
+                  videoHeight: videoElement?.videoHeight,
+                },
+              },
+            );
+            lastLoggedOutcome = reportableOutcome;
+          }
+        };
+        healthTimer = setInterval(checkHealth, 5000);
+        return () => {
+          clearInterval(healthTimer);
+          let mediaTrack: MediaStreamTrack | null = null;
+          try {
+            mediaTrack = stream?.getMediaStreamTrack?.() || null;
+          } catch (_) {}
+          logger.log(
+            LogSource.AgoraSDK,
+            'Event',
+            '[SCREENSHARE_JOURNEY] screen share video render unmounted',
+            {
+              action: 'stop',
+              stage: 'video_render_cleanup',
+              outcome: 'unmounted',
+              role: uid === 1 ? 'sender' : 'viewer',
+              screenshareSessionId:
+                uid === 1
+                  ? window.engine?.getScreenshareMediaDiagnostics?.(uid)
+                      ?.screenshareSessionId || 'unknown-session'
+                  : 'remote-session-by-screen-uid',
+              screenShareUid: uid,
+              screenshareSurface,
+              renderInstanceId,
+              playbackCleanup: 'track_playback_stopped',
+              mediaTrack: mediaTrack
+                ? {
+                    readyState: mediaTrack.readyState,
+                    enabled: mediaTrack.enabled,
+                    muted: mediaTrack.muted,
+                  }
+                : null,
+            },
+          );
+          stream?.stop?.();
+        };
+      }
       return () => {
         console.log(`unmounting stream ${uid}`, stream);
         stream && stream.stop();
       };
     },
-    [uid, renderMode, stream],
+    [
+      uid,
+      renderMode,
+      stream,
+      isScreenshare,
+      screenshareSurface,
+      renderInstanceId,
+    ],
   );
 
   return stream ? (

package/template/bridge/rtc/webNg/__tests__/screenshareLifecycle.test.ts

@@ -0,0 +1,358 @@
+const mockCreateScreenVideoTrack = jest.fn();
+
+jest.mock('agora-rtc-sdk-ng', () => ({
+  __esModule: true,
+  default: {
+    createScreenVideoTrack: mockCreateScreenVideoTrack,
+    setArea: jest.fn(),
+    setLogLevel: jest.fn(),
+    enableLogUpload: jest.fn(),
+    disableLogUpload: jest.fn(),
+  },
+}));
+
+jest.mock('react-native-agora', () => ({}));
+
+jest.mock('../../../../agora-rn-uikit', () => ({
+  ChannelProfileType: {
+    ChannelProfileCommunication: 0,
+    ChannelProfileLiveBroadcasting: 1,
+  },
+  ClientRoleType: {
+    ClientRoleBroadcaster: 1,
+    ClientRoleAudience: 2,
+  },
+}));
+
+jest.mock('../../../../src/logger/AppBuilderLogger', () => ({
+  LogSource: {AgoraSDK: 'AgoraSDK'},
+  logger: {
+    log: jest.fn(),
+    debug: jest.fn(),
+    error: jest.fn(),
+  },
+}));
+
+type Deferred<T> = {
+  promise: Promise<T>;
+  resolve: (value: T) => void;
+  reject: (reason: unknown) => void;
+};
+
+const deferred = <T>(): Deferred<T> => {
+  let resolve!: (value: T) => void;
+  let reject!: (reason: unknown) => void;
+  const promise = new Promise<T>((res, rej) => {
+    resolve = res;
+    reject = rej;
+  });
+  return {promise, resolve, reject};
+};
+
+const createTrack = () => {
+  const handlers: Record<string, () => Promise<void>> = {};
+  return {
+    handlers,
+    track: {
+      on: jest.fn((event: string, handler: () => Promise<void>) => {
+        handlers[event] = handler;
+      }),
+      stop: jest.fn(),
+      close: jest.fn(),
+      getMediaStreamTrack: jest.fn(() => ({
+        readyState: 'ended',
+        enabled: true,
+        muted: false,
+        label: 'screen',
+        getSettings: () => ({}),
+      })),
+    },
+  };
+};
+
+describe('web RTC screen-share lifecycle', () => {
+  let RtcEngine: any;
+  let engine: any;
+  let screenClient: any;
+
+  const callScreenshare = (action: 'start' | 'stop', sessionId = 'session-1') =>
+    engine.startScreenshare(
+      'token',
+      'channel',
+      null,
+      101,
+      'app-id',
+      engine,
+      null,
+      {encoderConfig: '1080p_2'},
+      'auto',
+      {
+        action,
+        screenshareAttemptId: `${action}-request`,
+        screenshareSessionId: sessionId,
+        screenShareUid: 101,
+        stopOrigin: 'toolbar',
+      },
+    );
+
+  beforeAll(() => {
+    (global as any).window = {};
+    RtcEngine = require('../RtcEngine').default;
+  });
+
+  beforeEach(() => {
+    jest.clearAllMocks();
+    engine = new RtcEngine();
+    engine.initialize({appId: 'app-id'});
+    screenClient = {
+      uid: 101,
+      join: jest.fn().mockResolvedValue(101),
+      publish: jest.fn().mockResolvedValue(undefined),
+      leave: jest.fn().mockResolvedValue(undefined),
+      setEncryptionConfig: jest.fn().mockResolvedValue(undefined),
+    };
+    engine.screenClient = screenClient;
+    engine.client = {off: jest.fn()};
+  });
+
+  it('rejects a second Start before it can open another picker', async () => {
+    const picker = deferred<any>();
+    const {track} = createTrack();
+    mockCreateScreenVideoTrack.mockReturnValueOnce(picker.promise);
+
+    const firstStart = callScreenshare('start');
+    await expect(
+      callScreenshare('start', 'duplicate-session'),
+    ).rejects.toMatchObject({code: 'SCREENSHARE_OPERATION_IN_PROGRESS'});
+
+    expect(mockCreateScreenVideoTrack).toHaveBeenCalledTimes(1);
+    picker.resolve(track);
+    await firstStart;
+    expect(screenClient.join).toHaveBeenCalledTimes(1);
+    expect(screenClient.publish).toHaveBeenCalledTimes(1);
+  });
+
+  it('executes an explicit Stop as a no-op when RTC is inactive', async () => {
+    const stopped = jest.fn();
+    engine.eventsMap.set('onScreenshareStopped', stopped);
+
+    await callScreenshare('stop');
+
+    expect(mockCreateScreenVideoTrack).not.toHaveBeenCalled();
+    expect(screenClient.join).not.toHaveBeenCalled();
+    expect(screenClient.leave).not.toHaveBeenCalled();
+    expect(stopped).toHaveBeenCalledTimes(1);
+  });
+
+  it('cleans only locally created tracks when Start fails', async () => {
+    const {track} = createTrack();
+    mockCreateScreenVideoTrack.mockResolvedValueOnce(track);
+    screenClient.join.mockRejectedValueOnce(
+      Object.assign(new Error('already connected'), {
+        code: 'INVALID_OPERATION',
+      }),
+    );
+
+    await expect(callScreenshare('start')).rejects.toMatchObject({
+      code: 'INVALID_OPERATION',
+    });
+
+    expect(track.stop).toHaveBeenCalledTimes(1);
+    expect(track.close).toHaveBeenCalledTimes(1);
+    expect(screenClient.leave).not.toHaveBeenCalled();
+    expect(engine.screenStream).toEqual({});
+  });
+
+  it('leaves and closes local tracks when publish fails', async () => {
+    const {track} = createTrack();
+    mockCreateScreenVideoTrack.mockResolvedValueOnce(track);
+    screenClient.publish.mockRejectedValueOnce(new Error('publish failed'));
+
+    await expect(callScreenshare('start')).rejects.toThrow('publish failed');
+
+    expect(track.stop).toHaveBeenCalledTimes(1);
+    expect(track.close).toHaveBeenCalledTimes(1);
+    expect(screenClient.leave).toHaveBeenCalledTimes(1);
+    expect(engine.screenStream).toEqual({});
+  });
+
+  it('preserves the publish error and attempts every cleanup operation when a track cleanup throws', async () => {
+    const {track} = createTrack();
+    const publishError = new Error('publish failed');
+    track.stop.mockImplementationOnce(() => {
+      throw new Error('track stop failed');
+    });
+    mockCreateScreenVideoTrack.mockResolvedValueOnce(track);
+    screenClient.publish.mockRejectedValueOnce(publishError);
+
+    await expect(callScreenshare('start')).rejects.toBe(publishError);
+
+    expect(track.stop).toHaveBeenCalledTimes(1);
+    expect(track.close).toHaveBeenCalledTimes(1);
+    expect(screenClient.leave).toHaveBeenCalledTimes(1);
+    expect(engine.screenStream).toEqual({});
+    expect(engine.inScreenshare).toBe(false);
+  });
+
+  it('returns to inactive after picker cancellation so a later Start can run', async () => {
+    mockCreateScreenVideoTrack.mockRejectedValueOnce(
+      Object.assign(new Error('permission denied'), {
+        code: 'PERMISSION_DENIED',
+      }),
+    );
+
+    await expect(callScreenshare('start')).rejects.toMatchObject({
+      code: 'PERMISSION_DENIED',
+    });
+
+    const {track} = createTrack();
+    mockCreateScreenVideoTrack.mockResolvedValueOnce(track);
+    await callScreenshare('start', 'session-2');
+
+    expect(mockCreateScreenVideoTrack).toHaveBeenCalledTimes(2);
+    expect(screenClient.join).toHaveBeenCalledTimes(1);
+    expect(screenClient.publish).toHaveBeenCalledTimes(1);
+    expect(screenClient.leave).not.toHaveBeenCalled();
+  });
+
+  it('does not publish a pending Start after end-call release', async () => {
+    const picker = deferred<any>();
+    const {track} = createTrack();
+    mockCreateScreenVideoTrack.mockReturnValueOnce(picker.promise);
+
+    const pendingStart = callScreenshare('start');
+    await engine.release('end_call_cleanup');
+    picker.resolve(track);
+
+    await expect(pendingStart).rejects.toMatchObject({
+      code: 'SCREENSHARE_START_CANCELLED',
+    });
+    expect(track.stop).toHaveBeenCalledTimes(1);
+    expect(track.close).toHaveBeenCalledTimes(1);
+    expect(screenClient.join).not.toHaveBeenCalled();
+    expect(screenClient.publish).not.toHaveBeenCalled();
+  });
+
+  it('ignores a stale track-ended callback after app cleanup', async () => {
+    const {track, handlers} = createTrack();
+    const stopped = jest.fn();
+    engine.eventsMap.set('onScreenshareStopped', stopped);
+    mockCreateScreenVideoTrack.mockResolvedValueOnce(track);
+
+    await callScreenshare('start');
+    await callScreenshare('stop');
+    await handlers['track-ended']();
+
+    expect(screenClient.leave).toHaveBeenCalledTimes(1);
+    expect(track.stop).toHaveBeenCalledTimes(1);
+    expect(track.close).toHaveBeenCalledTimes(1);
+    expect(stopped).toHaveBeenCalledTimes(1);
+  });
+
+  it('joins an existing cleanup when Stop is requested twice', async () => {
+    const {track} = createTrack();
+    const leave = deferred<void>();
+    const stopped = jest.fn();
+    engine.eventsMap.set('onScreenshareStopped', stopped);
+    mockCreateScreenVideoTrack.mockResolvedValueOnce(track);
+    screenClient.leave.mockReturnValueOnce(leave.promise);
+
+    await callScreenshare('start');
+    const firstStop = callScreenshare('stop');
+    const secondStop = callScreenshare('stop');
+    leave.resolve(undefined);
+    await Promise.all([firstStop, secondStop]);
+
+    expect(screenClient.leave).toHaveBeenCalledTimes(1);
+    expect(track.stop).toHaveBeenCalledTimes(1);
+    expect(track.close).toHaveBeenCalledTimes(1);
+    expect(stopped).toHaveBeenCalledTimes(1);
+  });
+
+  it('attempts leave and the stopped callback when track cleanup fails', async () => {
+    const {track} = createTrack();
+    const stopped = jest.fn();
+    engine.eventsMap.set('onScreenshareStopped', stopped);
+    mockCreateScreenVideoTrack.mockResolvedValueOnce(track);
+    track.stop.mockImplementationOnce(() => {
+      throw new Error('track stop failed');
+    });
+
+    await callScreenshare('start');
+    await expect(callScreenshare('stop')).resolves.toBeUndefined();
+
+    expect(track.close).toHaveBeenCalledTimes(1);
+    expect(screenClient.leave).toHaveBeenCalledTimes(1);
+    expect(stopped).toHaveBeenCalledTimes(1);
+    expect(engine.inScreenshare).toBe(false);
+  });
+
+  it('handles leave rejection from native track-ended without rejecting the SDK callback', async () => {
+    const {track, handlers} = createTrack();
+    const stopped = jest.fn();
+    engine.eventsMap.set('onScreenshareStopped', stopped);
+    mockCreateScreenVideoTrack.mockResolvedValueOnce(track);
+    screenClient.leave.mockRejectedValueOnce(new Error('leave failed'));
+
+    await callScreenshare('start');
+    await expect(handlers['track-ended']()).resolves.toBeUndefined();
+
+    expect(screenClient.leave).toHaveBeenCalledTimes(1);
+    expect(stopped).toHaveBeenCalledTimes(1);
+    expect(engine.inScreenshare).toBe(false);
+    const {logger} = require('../../../../src/logger/AppBuilderLogger');
+    const journeyMessages = logger.log.mock.calls
+      .map((call: unknown[]) => call[2])
+      .filter((message: unknown) =>
+        String(message).includes('[SCREENSHARE_JOURNEY]'),
+      );
+    expect(journeyMessages[journeyMessages.length - 1]).toBe(
+      '----- [SCREENSHARE_JOURNEY] SCREEN SHARE SESSION END | sessionId=session-1 -----',
+    );
+  });
+
+  it('writes the session end boundary after release cleanup logs', async () => {
+    const {track} = createTrack();
+    const stopped = jest.fn();
+    engine.eventsMap.set('onScreenshareStopped', stopped);
+    mockCreateScreenVideoTrack.mockResolvedValueOnce(track);
+
+    await callScreenshare('start');
+    await engine.release('end_call_cleanup');
+
+    const {logger} = require('../../../../src/logger/AppBuilderLogger');
+    const journeyMessages = logger.log.mock.calls
+      .map((call: unknown[]) => call[2])
+      .filter((message: unknown) =>
+        String(message).includes('[SCREENSHARE_JOURNEY]'),
+      );
+    expect(journeyMessages[journeyMessages.length - 1]).toBe(
+      '----- [SCREENSHARE_JOURNEY] SCREEN SHARE SESSION END | sessionId=session-1 -----',
+    );
+  });
+
+  it('logs a receiver screen-share termination once for an RTC event', () => {
+    const remoteTrack = createTrack().track;
+    engine.remoteStreams.set(202, {video: remoteTrack});
+    engine.registerRemoteScreenshareUid(202);
+
+    engine.logRemoteScreenshareTermination(202, 'user-unpublished', 'video');
+    engine.logRemoteScreenshareTermination(202, 'user-left');
+
+    const {logger} = require('../../../../src/logger/AppBuilderLogger');
+    const terminationLogs = logger.log.mock.calls.filter((call: unknown[]) =>
+      String(call[2]).includes(
+        'receiver detected screen share stopped through RTC',
+      ),
+    );
+    expect(terminationLogs).toHaveLength(1);
+    expect(terminationLogs[0][2]).toContain('user-unpublished');
+    expect(terminationLogs[0][3]).toMatchObject({
+      action: 'stop',
+      stage: 'receiver_rtc_termination',
+      role: 'viewer',
+      screenShareUid: 202,
+      sdkEvent: 'user-unpublished',
+    });
+  });
+});

package/template/bridge/rtc/webNg/__tests__/screenshareMediaHealth.test.ts

@@ -0,0 +1,49 @@
+import {getScreenshareMediaHealthOutcome} from '../screenshareMediaHealth';
+
+describe('screen-share media health classification', () => {
+  it('classifies flowing and rendered video as healthy', () => {
+    expect(
+      getScreenshareMediaHealthOutcome({
+        trackReadyState: 'live',
+        bitrate: 900000,
+        frameRate: 15,
+        width: 1920,
+        height: 1080,
+        videoElementPresent: true,
+        renderedWidth: 1920,
+        renderedHeight: 1080,
+      }),
+    ).toBe('healthy');
+  });
+
+  it('classifies zero bitrate or frames as suspected blank video', () => {
+    expect(
+      getScreenshareMediaHealthOutcome({
+        trackReadyState: 'live',
+        bitrate: 0,
+        frameRate: 0,
+        width: 1920,
+        height: 1080,
+      }),
+    ).toBe('suspected_blank');
+  });
+
+  it('classifies a missing render element as suspected blank video', () => {
+    expect(
+      getScreenshareMediaHealthOutcome({
+        trackReadyState: 'live',
+        bitrate: 900000,
+        frameRate: 15,
+        width: 1920,
+        height: 1080,
+        videoElementPresent: false,
+      }),
+    ).toBe('suspected_blank');
+  });
+
+  it('reports an ended source track separately', () => {
+    expect(getScreenshareMediaHealthOutcome({trackReadyState: 'ended'})).toBe(
+      'track_ended',
+    );
+  });
+});