agora-appbuilder-core 4.1.23-beta.4 → 4.1.23-beta.5

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agora-appbuilder-core",
-  "version": "4.1.23-beta.4",
+  "version": "4.1.23-beta.5",
   "description": "React Native template for RTE app builder",
   "main": "index.js",
   "files": [

package/template/defaultConfig.js

@@ -77,8 +77,8 @@ const DefaultConfig = {
   CHAT_ORG_NAME: "",
   CHAT_APP_NAME: "",
   CHAT_URL: "",
-  CLI_VERSION: "3.1.23-beta.4",
-  CORE_VERSION: "4.1.23-beta.4",
+  CLI_VERSION: "3.1.23-beta.5",
+  CORE_VERSION: "4.1.23-beta.5",
   DISABLE_LANDSCAPE_MODE: false,
   STT_AUTO_START: false,
   CLOUD_RECORDING_AUTO_START: false,

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

@@ -54,6 +54,7 @@ import {
   getScreenshareStartDecision,
   getScreenshareStopDecision,
 } from './screenshareOperation';
+import {createScreenshareRecordingLayoutReconciler} from './screenshareRecordingLayoutReconciler';
 
 type ScreenshareAction = 'start' | 'stop';
 
@@ -99,6 +100,13 @@ export const ScreenshareConfigure = (props: {
   };
 
   const {executeNormalQuery, executePresenterQuery} = useRecordingLayoutQuery();
+  const recordingActiveRef = useRef(props.isRecordingActive);
+  const executePresenterQueryRef = useRef(executePresenterQuery);
+  const recordingLayoutReconcilerRef = useRef(
+    createScreenshareRecordingLayoutReconciler(),
+  );
+  recordingActiveRef.current = props.isRecordingActive;
+  executePresenterQueryRef.current = executePresenterQuery;
 
   const {channel, appId, screenShareUid, screenShareToken, encryption} =
     useContext(PropsContext).rtcProps;
@@ -471,6 +479,10 @@ export const ScreenshareConfigure = (props: {
         },
       );
       await executePresenterQuery(screenShareUid);
+      recordingLayoutReconcilerRef.current.markApplied(
+        screenshareSessionId,
+        recordingActiveRef.current,
+      );
     } else {
       logger.log(
         LogSource.Internals,
@@ -509,6 +521,112 @@ export const ScreenshareConfigure = (props: {
     );
   };
 
+  useEffect(() => {
+    const screenshareSessionId = activeScreenshareSessionIdRef.current;
+    const reconciliationAttemptId = getUniqueID();
+    const logContext = {
+      action: 'start' as ScreenshareAction,
+      stage: 'recording_layout_reconciliation',
+      screenshareAttemptId: reconciliationAttemptId,
+      screenshareSessionId: screenshareSessionId || 'unknown-session',
+      recordingActive: props.isRecordingActive,
+      screenshareActive: isScreenshareActive,
+      screenShareUid,
+      operationState: operationStateRef.current,
+    };
+
+    recordingLayoutReconcilerRef.current
+      .reconcile({
+        screenshareSessionId,
+        isRecordingActive: props.isRecordingActive,
+        isScreenshareActive,
+        executePresenterQuery: () => {
+          logger.log(
+            LogSource.Internals,
+            'SCREENSHARE',
+            `${SCREENSHARE_JOURNEY} screen share recording presenter layout reconciliation started`,
+            {
+              ...logContext,
+              outcome: 'started',
+              reconciliationReason:
+                'recording_and_published_screenshare_are_active',
+            },
+          );
+          return executePresenterQueryRef.current(screenShareUid);
+        },
+      })
+      .then(result => {
+        if (result === 'applied') {
+          logger.log(
+            LogSource.Internals,
+            'SCREENSHARE',
+            `${SCREENSHARE_JOURNEY} screen share recording presenter layout reconciliation completed successfully`,
+            {
+              ...logContext,
+              outcome: 'success',
+              recordingActiveNow: recordingActiveRef.current,
+              activeScreenshareSessionIdNow:
+                activeScreenshareSessionIdRef.current,
+            },
+          );
+          return;
+        }
+
+        if (result === 'already_applied' || result === 'in_progress') {
+          logger.log(
+            LogSource.Internals,
+            'SCREENSHARE',
+            `${SCREENSHARE_JOURNEY} screen share recording presenter layout reconciliation skipped`,
+            {
+              ...logContext,
+              outcome: 'skipped',
+              duplicateReason:
+                result === 'already_applied'
+                  ? 'presenter_layout_already_applied'
+                  : 'presenter_layout_query_in_progress',
+            },
+          );
+          return;
+        }
+
+        if (
+          isScreenshareActive ||
+          (props.isRecordingActive && operationStateRef.current === 'starting')
+        ) {
+          logger.log(
+            LogSource.Internals,
+            'SCREENSHARE',
+            `${SCREENSHARE_JOURNEY} screen share recording presenter layout reconciliation waiting for both states`,
+            {
+              ...logContext,
+              outcome: 'waiting',
+              waitingReason: !screenshareSessionId
+                ? 'missing_active_screenshare_session'
+                : !props.isRecordingActive
+                ? 'recording_inactive'
+                : 'screenshare_not_published',
+            },
+          );
+        }
+      })
+      .catch(recordingError => {
+        logger.error(
+          LogSource.Internals,
+          'SCREENSHARE',
+          `${SCREENSHARE_JOURNEY} screen share recording presenter layout reconciliation failed; screen share remains active`,
+          recordingError,
+          {
+            ...logContext,
+            outcome: 'failure',
+            recordingActiveNow: recordingActiveRef.current,
+            activeScreenshareSessionIdNow:
+              activeScreenshareSessionIdRef.current,
+            ...getScreenshareError(recordingError),
+          },
+        );
+      });
+  }, [isScreenshareActive, props.isRecordingActive, screenShareUid]);
+
   const stopScreenshare = async (
     stopOrigin: ScreenshareStopOrigin = 'unknown',
     stopActorUid?: UidType,
@@ -1038,17 +1156,15 @@ export const ScreenshareConfigure = (props: {
           ...getScreenshareError(e),
         },
       );
-      if (!userCancelOrPermissionDenied) {
-        Toast.show({
-          leadingIconName: 'alert',
-          type: 'error',
-          text1: toastHeading,
-          text2: toastSubHeading,
-          visibilityTime: 1000 * 10,
-          primaryBtn: null,
-          secondaryBtn: null,
-        });
-      }
+      Toast.show({
+        leadingIconName: 'alert',
+        type: 'error',
+        text1: toastHeading,
+        text2: toastSubHeading,
+        visibilityTime: 1000 * 10,
+        primaryBtn: null,
+        secondaryBtn: null,
+      });
       if (isActive && !rtcOperationSucceeded) {
         pendingScreenshareSessionIdRef.current = null;
         activeScreenshareSessionIdRef.current = null;

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

@@ -0,0 +1,164 @@
+import {createScreenshareRecordingLayoutReconciler} from '../screenshareRecordingLayoutReconciler';
+
+describe('screen-share recording layout reconciler', () => {
+  it('waits until recording and a published screen share are both active', async () => {
+    const executePresenterQuery = jest.fn().mockResolvedValue(undefined);
+    const reconciler = createScreenshareRecordingLayoutReconciler();
+
+    await expect(
+      reconciler.reconcile({
+        screenshareSessionId: 'session-1',
+        isRecordingActive: true,
+        isScreenshareActive: false,
+        executePresenterQuery,
+      }),
+    ).resolves.toBe('not_ready');
+    expect(executePresenterQuery).not.toHaveBeenCalled();
+  });
+
+  it('applies presenter layout once both states are active', async () => {
+    const executePresenterQuery = jest.fn().mockResolvedValue(undefined);
+    const reconciler = createScreenshareRecordingLayoutReconciler();
+
+    await expect(
+      reconciler.reconcile({
+        screenshareSessionId: 'session-1',
+        isRecordingActive: true,
+        isScreenshareActive: true,
+        executePresenterQuery,
+      }),
+    ).resolves.toBe('applied');
+    expect(executePresenterQuery).toHaveBeenCalledTimes(1);
+  });
+
+  it('reconciles when recording becomes active while screen-share publishing is still pending', async () => {
+    const executePresenterQuery = jest.fn().mockResolvedValue(undefined);
+    const reconciler = createScreenshareRecordingLayoutReconciler();
+
+    await expect(
+      reconciler.reconcile({
+        screenshareSessionId: 'session-1',
+        isRecordingActive: false,
+        isScreenshareActive: false,
+        executePresenterQuery,
+      }),
+    ).resolves.toBe('not_ready');
+    await expect(
+      reconciler.reconcile({
+        screenshareSessionId: 'session-1',
+        isRecordingActive: true,
+        isScreenshareActive: false,
+        executePresenterQuery,
+      }),
+    ).resolves.toBe('not_ready');
+    await expect(
+      reconciler.reconcile({
+        screenshareSessionId: 'session-1',
+        isRecordingActive: true,
+        isScreenshareActive: true,
+        executePresenterQuery,
+      }),
+    ).resolves.toBe('applied');
+    expect(executePresenterQuery).toHaveBeenCalledTimes(1);
+  });
+
+  it('does not duplicate a layout query for the same recording and screen-share session', async () => {
+    const executePresenterQuery = jest.fn().mockResolvedValue(undefined);
+    const reconciler = createScreenshareRecordingLayoutReconciler();
+    const args = {
+      screenshareSessionId: 'session-1',
+      isRecordingActive: true,
+      isScreenshareActive: true,
+      executePresenterQuery,
+    };
+
+    await expect(reconciler.reconcile(args)).resolves.toBe('applied');
+    await expect(reconciler.reconcile(args)).resolves.toBe('already_applied');
+    expect(executePresenterQuery).toHaveBeenCalledTimes(1);
+  });
+
+  it('deduplicates a query that is already in progress', async () => {
+    let resolveQuery: () => void = () => {};
+    const executePresenterQuery = jest.fn(
+      () =>
+        new Promise<void>(resolve => {
+          resolveQuery = resolve;
+        }),
+    );
+    const reconciler = createScreenshareRecordingLayoutReconciler();
+    const args = {
+      screenshareSessionId: 'session-1',
+      isRecordingActive: true,
+      isScreenshareActive: true,
+      executePresenterQuery,
+    };
+
+    const firstReconciliation = reconciler.reconcile(args);
+    await expect(reconciler.reconcile(args)).resolves.toBe('in_progress');
+    resolveQuery();
+    await expect(firstReconciliation).resolves.toBe('applied');
+    expect(executePresenterQuery).toHaveBeenCalledTimes(1);
+  });
+
+  it('applies layout again when recording restarts during the same screen-share session', async () => {
+    const executePresenterQuery = jest.fn().mockResolvedValue(undefined);
+    const reconciler = createScreenshareRecordingLayoutReconciler();
+
+    await reconciler.reconcile({
+      screenshareSessionId: 'session-1',
+      isRecordingActive: true,
+      isScreenshareActive: true,
+      executePresenterQuery,
+    });
+    await reconciler.reconcile({
+      screenshareSessionId: 'session-1',
+      isRecordingActive: false,
+      isScreenshareActive: true,
+      executePresenterQuery,
+    });
+    await expect(
+      reconciler.reconcile({
+        screenshareSessionId: 'session-1',
+        isRecordingActive: true,
+        isScreenshareActive: true,
+        executePresenterQuery,
+      }),
+    ).resolves.toBe('applied');
+    expect(executePresenterQuery).toHaveBeenCalledTimes(2);
+  });
+
+  it('retries after a failed layout query', async () => {
+    const layoutError = new Error('layout update failed');
+    const executePresenterQuery = jest
+      .fn()
+      .mockRejectedValueOnce(layoutError)
+      .mockResolvedValueOnce(undefined);
+    const reconciler = createScreenshareRecordingLayoutReconciler();
+    const args = {
+      screenshareSessionId: 'session-1',
+      isRecordingActive: true,
+      isScreenshareActive: true,
+      executePresenterQuery,
+    };
+
+    await expect(reconciler.reconcile(args)).rejects.toBe(layoutError);
+    await expect(reconciler.reconcile(args)).resolves.toBe('applied');
+    expect(executePresenterQuery).toHaveBeenCalledTimes(2);
+  });
+
+  it('honours a presenter layout already applied by the normal start path', async () => {
+    const executePresenterQuery = jest.fn().mockResolvedValue(undefined);
+    const reconciler = createScreenshareRecordingLayoutReconciler();
+
+    reconciler.markApplied('session-1', true);
+    await expect(
+      reconciler.reconcile({
+        screenshareSessionId: 'session-1',
+        isRecordingActive: true,
+        isScreenshareActive: true,
+        executePresenterQuery,
+      }),
+    ).resolves.toBe('already_applied');
+    expect(executePresenterQuery).not.toHaveBeenCalled();
+  });
+});

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

@@ -0,0 +1,72 @@
+export type RecordingLayoutReconciliationResult =
+  | 'applied'
+  | 'already_applied'
+  | 'in_progress'
+  | 'not_ready';
+
+type ReconcileRecordingLayoutArgs = {
+  screenshareSessionId: string | null;
+  isRecordingActive: boolean;
+  isScreenshareActive: boolean;
+  executePresenterQuery: () => Promise<unknown>;
+};
+
+export const createScreenshareRecordingLayoutReconciler = () => {
+  let recordingActivation = 0;
+  let wasRecordingActive = false;
+  const appliedKeys = new Set<string>();
+  const inProgressKeys = new Set<string>();
+
+  const observeRecordingState = (isRecordingActive: boolean) => {
+    if (isRecordingActive && !wasRecordingActive) {
+      recordingActivation += 1;
+    }
+    wasRecordingActive = isRecordingActive;
+    return recordingActivation;
+  };
+
+  const getKey = (screenshareSessionId: string, activation: number) =>
+    `${screenshareSessionId}:${activation}`;
+
+  const markApplied = (
+    screenshareSessionId: string,
+    isRecordingActive: boolean,
+  ) => {
+    const activation = observeRecordingState(isRecordingActive);
+    if (!isRecordingActive) {
+      return;
+    }
+    appliedKeys.add(getKey(screenshareSessionId, activation));
+  };
+
+  const reconcile = async ({
+    screenshareSessionId,
+    isRecordingActive,
+    isScreenshareActive,
+    executePresenterQuery,
+  }: ReconcileRecordingLayoutArgs): Promise<RecordingLayoutReconciliationResult> => {
+    const activation = observeRecordingState(isRecordingActive);
+    if (!screenshareSessionId || !isRecordingActive || !isScreenshareActive) {
+      return 'not_ready';
+    }
+
+    const key = getKey(screenshareSessionId, activation);
+    if (appliedKeys.has(key)) {
+      return 'already_applied';
+    }
+    if (inProgressKeys.has(key)) {
+      return 'in_progress';
+    }
+
+    inProgressKeys.add(key);
+    try {
+      await executePresenterQuery();
+      appliedKeys.add(key);
+      return 'applied';
+    } finally {
+      inProgressKeys.delete(key);
+    }
+  };
+
+  return {markApplied, reconcile};
+};