agora-appbuilder-core 4.1.23 → 4.1.24-beta.2

package/template/src/subComponents/screenshare/__tests__/ScreenshareConfigure.test.tsx

@@ -0,0 +1,245 @@
+import React from 'react';
+import TestRenderer, {act} from 'react-test-renderer';
+import {beforeEach, describe, expect, it, jest} from '@jest/globals';
+
+let mockContent: any;
+let mockLayout: any;
+let mockScreenContext: any;
+
+const mockDispatch = jest.fn();
+const mockSetPinnedLayout = jest.fn();
+const mockChangeLayout = jest.fn();
+
+jest.mock('../../../../agora-rn-uikit', () => {
+  const ReactModule = require('react');
+  return {
+    DispatchContext: ReactModule.createContext({dispatch: jest.fn()}),
+    PropsContext: ReactModule.createContext({
+      rtcProps: {
+        channel: 'channel',
+        appId: 'app-id',
+        screenShareUid: 101,
+        screenShareToken: 'screen-token',
+        encryption: {},
+      },
+    }),
+  };
+});
+
+jest.mock('../useScreenshare', () => {
+  const ReactModule = require('react');
+  return {
+    ScreenshareContext: ReactModule.createContext({
+      isScreenshareActive: false,
+      operationState: 'inactive',
+      startScreenshare: jest.fn(),
+      stopScreenshare: jest.fn(),
+    }),
+  };
+});
+
+jest.mock('customization-api', () => ({
+  controlMessageEnum: {kickScreenshare: 'kickScreenshare'},
+  useContent: () => mockContent,
+  useLayout: () => mockLayout,
+  useRtc: () => ({
+    RtcEngineUnsafe: {
+      addListener: jest.fn(),
+      registerScreenShareStoppedCallback: jest.fn(),
+      startScreenshare: jest.fn(),
+      stopScreenshare: jest.fn(),
+    },
+  }),
+}));
+
+jest.mock('../../../pages/video-call/DefaultLayouts', () => ({
+  getGridLayoutName: () => 'grid',
+  getPinnedLayoutName: () => 'pinned',
+  useChangeDefaultLayout: () => mockChangeLayout,
+  useSetPinnedLayout: () => mockSetPinnedLayout,
+}));
+
+jest.mock('../../../components/contexts/ScreenShareContext', () => ({
+  useScreenContext: () => mockScreenContext,
+}));
+
+jest.mock('../../../rtm-events-api', () => ({
+  __esModule: true,
+  default: {
+    on: jest.fn(() => jest.fn()),
+    send: jest.fn(async () => true),
+  },
+  PersistanceLevel: {Sender: 'sender'},
+}));
+
+jest.mock('../../../rtm-events', () => ({
+  EventActions: {
+    SCREENSHARE_STARTED: 'screenshare-started',
+    SCREENSHARE_STOPPED: 'screenshare-stopped',
+  },
+  EventNames: {SCREENSHARE_ATTRIBUTE: 'screenshare-attribute'},
+}));
+
+jest.mock('../../recording/useRecordingLayoutQuery', () => ({
+  __esModule: true,
+  default: () => ({
+    executeNormalQuery: jest.fn(),
+    executePresenterQuery: jest.fn(),
+  }),
+}));
+
+jest.mock('../../../logger/AppBuilderLogger', () => ({
+  LogSource: {Internals: 'Internals'},
+  logger: {
+    debug: jest.fn(),
+    error: jest.fn(),
+    log: jest.fn(),
+  },
+}));
+
+jest.mock('../../../utils/useString', () => ({
+  useString: () => () => 'Screen share error',
+}));
+
+jest.mock('../../../../react-native-toast-message', () => ({
+  __esModule: true,
+  default: {show: jest.fn()},
+}));
+
+jest.mock('../../../utils/getUniqueID', () => ({
+  __esModule: true,
+  default: () => 'test-id',
+}));
+
+jest.mock('../../../utils', () => ({
+  filterObject: (value: Record<string, any>, predicate: Function) =>
+    Object.fromEntries(Object.entries(value).filter(entry => predicate(entry))),
+}));
+
+import {DispatchContext} from '../../../../agora-rn-uikit';
+import {ScreenshareConfigure} from '../ScreenshareConfigure.tsx';
+
+const activeScreenShare = {
+  101: {name: 'Screen 101', isActive: true, ts: 1000},
+};
+
+const renderConfigurator = (version: number) => (
+  <DispatchContext.Provider value={{dispatch: mockDispatch} as any}>
+    <ScreenshareConfigure isRecordingActive={false}>
+      <React.Fragment key={version} />
+    </ScreenshareConfigure>
+  </DispatchContext.Provider>
+);
+
+const updateConfigurator = async (
+  renderer: TestRenderer.ReactTestRenderer,
+  version: number,
+) => {
+  await act(async () => {
+    renderer.update(renderConfigurator(version));
+  });
+};
+
+describe('ScreenshareConfigure interruption recovery', () => {
+  beforeEach(() => {
+    jest.clearAllMocks();
+    mockContent = {
+      activeUids: [101, 100, 200],
+      pinnedUid: 101,
+      secondaryPinnedUid: 100,
+      defaultContent: {
+        101: {name: 'Screen 101', parentUid: 100, video: 1},
+        100: {name: 'User 100', video: 1},
+        200: {name: 'User 200', video: 1},
+      },
+    };
+    mockLayout = {currentLayout: 'pinned'};
+    mockScreenContext = {
+      screenShareData: activeScreenShare,
+      setScreenShareData: jest.fn(),
+    };
+  });
+
+  it('restores the primary pin only after the interrupted screen republishes video', async () => {
+    let renderer!: TestRenderer.ReactTestRenderer;
+    await act(async () => {
+      renderer = TestRenderer.create(renderConfigurator(0));
+    });
+    mockDispatch.mockClear();
+    mockSetPinnedLayout.mockClear();
+
+    mockContent = {...mockContent, activeUids: [100, 200]};
+    mockLayout = {currentLayout: 'grid'};
+    await updateConfigurator(renderer, 1);
+    expect(mockDispatch).not.toHaveBeenCalledWith({
+      type: 'UserPin',
+      value: [101],
+    });
+
+    mockContent = {
+      ...mockContent,
+      activeUids: [100, 200, 101],
+      defaultContent: {
+        ...mockContent.defaultContent,
+        101: {...mockContent.defaultContent[101], video: 0},
+      },
+    };
+    await updateConfigurator(renderer, 2);
+    expect(mockDispatch).not.toHaveBeenCalledWith({
+      type: 'UserPin',
+      value: [101],
+    });
+
+    mockContent = {
+      ...mockContent,
+      defaultContent: {
+        ...mockContent.defaultContent,
+        101: {...mockContent.defaultContent[101], video: 1},
+      },
+    };
+    await updateConfigurator(renderer, 3);
+
+    expect(mockDispatch).toHaveBeenCalledWith({
+      type: 'UserPin',
+      value: [101],
+    });
+    expect(mockDispatch).not.toHaveBeenCalledWith(
+      expect.objectContaining({type: 'UserSecondaryPin'}),
+    );
+    expect(mockSetPinnedLayout).toHaveBeenCalledTimes(1);
+
+    renderer.unmount();
+  });
+
+  it('does not restore the interrupted screen after the user pins another tile', async () => {
+    let renderer!: TestRenderer.ReactTestRenderer;
+    await act(async () => {
+      renderer = TestRenderer.create(renderConfigurator(0));
+    });
+    mockDispatch.mockClear();
+    mockSetPinnedLayout.mockClear();
+
+    mockContent = {...mockContent, activeUids: [100, 200]};
+    mockLayout = {currentLayout: 'grid'};
+    await updateConfigurator(renderer, 1);
+
+    mockContent = {
+      ...mockContent,
+      activeUids: [100, 200, 101],
+      pinnedUid: 200,
+      defaultContent: {
+        ...mockContent.defaultContent,
+        101: {...mockContent.defaultContent[101], video: 1},
+      },
+    };
+    await updateConfigurator(renderer, 2);
+
+    expect(mockDispatch).not.toHaveBeenCalledWith({
+      type: 'UserPin',
+      value: [101],
+    });
+    expect(mockSetPinnedLayout).not.toHaveBeenCalled();
+
+    renderer.unmount();
+  });
+});

package/template/src/subComponents/screenshare/__tests__/screenshareInterruptionRecovery.test.ts

@@ -0,0 +1,119 @@
+import {
+  captureScreenshareRecoveryCandidate,
+  getScreenshareRecoveryDecision,
+} from '../screenshareInterruptionRecovery';
+
+const activeScreen = {
+  101: {name: 'Screen', isActive: true, ts: 1000},
+};
+
+describe('screen-share RTC interruption recovery', () => {
+  it('captures a candidate only when the active pinned screen UID disappears', () => {
+    expect(
+      captureScreenshareRecoveryCandidate({
+        previousActiveUids: [101, 100, 200],
+        currentActiveUids: [100, 200],
+        previousPinnedUid: 101,
+        previousLayout: 'pinned',
+        screenShareData: activeScreen,
+        detectedAt: 2000,
+      }),
+    ).toEqual({
+      uid: 101,
+      previousPinnedUid: 101,
+      previousLayout: 'pinned',
+      screenshareStartedAt: 1000,
+      activeScreenshareUidsAtDetection: [101],
+      detectedAt: 2000,
+      joinedLogged: false,
+    });
+  });
+
+  it('does not capture an unpinned screen interruption', () => {
+    expect(
+      captureScreenshareRecoveryCandidate({
+        previousActiveUids: [200, 101, 100],
+        currentActiveUids: [200, 100],
+        previousPinnedUid: 200,
+        previousLayout: 'pinned',
+        screenShareData: activeScreen,
+        detectedAt: 2000,
+      }),
+    ).toBeNull();
+  });
+
+  it('waits for both same-UID join and video publication before restore', () => {
+    const candidate = {
+      uid: 101,
+      previousPinnedUid: 101,
+      previousLayout: 'pinned',
+      screenshareStartedAt: 1000,
+      activeScreenshareUidsAtDetection: [101],
+      detectedAt: 2000,
+      joinedLogged: false,
+    };
+
+    expect(
+      getScreenshareRecoveryDecision({
+        candidate,
+        activeUids: [100, 200],
+        isVideoPublished: false,
+        screenShareData: activeScreen,
+      }),
+    ).toBe('waiting_for_join');
+    expect(
+      getScreenshareRecoveryDecision({
+        candidate,
+        activeUids: [100, 200, 101],
+        isVideoPublished: false,
+        screenShareData: activeScreen,
+      }),
+    ).toBe('waiting_for_video');
+    expect(
+      getScreenshareRecoveryDecision({
+        candidate,
+        activeUids: [100, 200, 101],
+        isVideoPublished: true,
+        screenShareData: activeScreen,
+      }),
+    ).toBe('restore');
+  });
+
+  it.each([
+    [
+      'cancel_stopped',
+      {101: {name: 'Screen', isActive: false, ts: 1000}},
+      undefined,
+    ],
+    [
+      'cancel_replaced',
+      {
+        ...activeScreen,
+        201: {name: 'New screen', isActive: true, ts: 1001},
+      },
+      undefined,
+    ],
+    ['cancel_user_override', activeScreen, 200],
+  ])(
+    'returns %s when recovery is no longer authoritative',
+    (expected, screenShareData, pinnedUid) => {
+      expect(
+        getScreenshareRecoveryDecision({
+          candidate: {
+            uid: 101,
+            previousPinnedUid: 101,
+            previousLayout: 'pinned',
+            screenshareStartedAt: 1000,
+            activeScreenshareUidsAtDetection: [101],
+            detectedAt: 2000,
+            joinedLogged: false,
+          },
+          activeUids: [100, 101, 200],
+          pinnedUid,
+          isVideoPublished: true,
+          screenShareData,
+        }),
+      ).toBe(expected);
+    },
+  );
+});

package/template/src/subComponents/screenshare/screenshareInterruptionRecovery.ts

@@ -0,0 +1,118 @@
+import {UidType} from '../../../agora-rn-uikit';
+import {ScreenShareObjectInterface} from '../../components/contexts/ScreenShareContext';
+
+export interface ScreenshareRecoveryCandidate {
+  uid: UidType;
+  previousPinnedUid: UidType;
+  previousLayout: string;
+  screenshareStartedAt: number;
+  activeScreenshareUidsAtDetection: UidType[];
+  detectedAt: number;
+  joinedLogged: boolean;
+}
+
+interface CaptureRecoveryCandidateArgs {
+  previousActiveUids: UidType[];
+  currentActiveUids: UidType[];
+  previousPinnedUid?: UidType;
+  previousLayout: string;
+  screenShareData: ScreenShareObjectInterface;
+  detectedAt: number;
+}
+
+export const captureScreenshareRecoveryCandidate = ({
+  previousActiveUids,
+  currentActiveUids,
+  previousPinnedUid,
+  previousLayout,
+  screenShareData,
+  detectedAt,
+}: CaptureRecoveryCandidateArgs): ScreenshareRecoveryCandidate | null => {
+  // Recovery applies only when the tile that disappeared was the pinned tile,
+  // was present in the previous RTC render list, and is still logically active
+  // according to screen-share signaling. Intentional stops therefore do not
+  // create recovery candidates.
+  if (
+    !previousPinnedUid ||
+    !previousActiveUids.includes(previousPinnedUid) ||
+    currentActiveUids.includes(previousPinnedUid) ||
+    !screenShareData?.[previousPinnedUid]?.isActive
+  ) {
+    return null;
+  }
+
+  return {
+    uid: previousPinnedUid,
+    previousPinnedUid,
+    previousLayout,
+    screenshareStartedAt: screenShareData[previousPinnedUid]?.ts || 0,
+    // Remember every share that already existed so a newly started share can
+    // be distinguished from recovery of this interrupted UID.
+    activeScreenshareUidsAtDetection: Object.entries(screenShareData)
+      .filter(([, share]) => share?.isActive)
+      .map(([uid]) => Number(uid)),
+    detectedAt,
+    joinedLogged: false,
+  };
+};
+
+export type ScreenshareRecoveryDecision =
+  | 'waiting_for_join'
+  | 'waiting_for_video'
+  | 'restore'
+  | 'cancel_stopped'
+  | 'cancel_replaced'
+  | 'cancel_user_override';
+
+interface GetRecoveryDecisionArgs {
+  candidate: ScreenshareRecoveryCandidate;
+  activeUids: UidType[];
+  pinnedUid?: UidType;
+  isVideoPublished: boolean;
+  screenShareData: ScreenShareObjectInterface;
+}
+
+export const getScreenshareRecoveryDecision = ({
+  candidate,
+  activeUids,
+  pinnedUid,
+  isVideoPublished,
+  screenShareData,
+}: GetRecoveryDecisionArgs): ScreenshareRecoveryDecision => {
+  const recoveredShare = screenShareData?.[candidate.uid];
+  // RTM or local cleanup marked the share inactive, so RTC rejoin events must
+  // not resurrect a screen share that was intentionally stopped.
+  if (!recoveredShare?.isActive) {
+    return 'cancel_stopped';
+  }
+
+  // A screen UID that became active after interruption represents a newer
+  // share and takes precedence over restoring the old pinned tile.
+  const newerActiveShareExists = Object.entries(screenShareData || {}).some(
+    ([uid, share]) =>
+      share?.isActive &&
+      !candidate.activeScreenshareUidsAtDetection.includes(Number(uid)),
+  );
+  if (newerActiveShareExists) {
+    return 'cancel_replaced';
+  }
+  // The same UID can be reused for a later share. Its start timestamp prevents
+  // that new session from being mistaken for recovery of the old one.
+  if (recoveredShare.ts !== candidate.screenshareStartedAt) {
+    return 'cancel_replaced';
+  }
+
+  // Respect a pin selected by the user while recovery was pending.
+  if (pinnedUid && pinnedUid !== candidate.uid) {
+    return 'cancel_user_override';
+  }
+  // Joining and publishing are separate RTC events. Wait for both so the
+  // layout never restores a tile before its video is available.
+  if (!activeUids.includes(candidate.uid)) {
+    return 'waiting_for_join';
+  }
+  if (!isVideoPublished) {
+    return 'waiting_for_video';
+  }
+  return 'restore';
+};