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

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

@@ -55,6 +55,11 @@ import {
   getScreenshareStopDecision,
 } from './screenshareOperation';
 import {createScreenshareRecordingLayoutReconciler} from './screenshareRecordingLayoutReconciler';
+import {
+  captureScreenshareRecoveryCandidate,
+  getScreenshareRecoveryDecision,
+  ScreenshareRecoveryCandidate,
+} from './screenshareInterruptionRecovery';
 
 type ScreenshareAction = 'start' | 'stop';
 
@@ -93,6 +98,14 @@ export const ScreenshareConfigure = (props: {
   const changeLayout = useChangeDefaultLayout();
   const {currentLayout} = useLayout();
   const currentLayoutRef = useRef({currentLayout: currentLayout});
+  const recoveryCandidateRef = useRef<ScreenshareRecoveryCandidate | null>(
+    null,
+  );
+  const previousLayoutStateRef = useRef({
+    activeUids,
+    pinnedUid,
+    currentLayout,
+  });
 
   const updateOperationState = (state: ScreenshareOperationState) => {
     operationStateRef.current = state;
@@ -201,6 +214,142 @@ export const ScreenshareConfigure = (props: {
     }
   };
 
+  useEffect(() => {
+    const previousLayoutState = previousLayoutStateRef.current;
+    const existingCandidate = recoveryCandidateRef.current;
+    // Detect when the previously pinned screen-share UID disappears from the
+    // RTC render list while RTM still says the logical share is active.
+    const capturedCandidate = captureScreenshareRecoveryCandidate({
+      previousActiveUids: previousLayoutState.activeUids,
+      currentActiveUids: activeUids,
+      previousPinnedUid: previousLayoutState.pinnedUid,
+      previousLayout: previousLayoutState.currentLayout,
+      screenShareData,
+      detectedAt: Date.now(),
+    });
+
+    if (!existingCandidate && capturedCandidate) {
+      recoveryCandidateRef.current = capturedCandidate;
+      logger.log(
+        LogSource.Internals,
+        'SCREENSHARE',
+        `${SCREENSHARE_JOURNEY} pinned screen share removed by RTC; waiting for same UID to recover`,
+        {
+          action: 'recover',
+          stage: 'rtc_interruption',
+          outcome: 'started',
+          screenshareSessionId:
+            activeScreenshareSessionIdRef.current || 'unknown-session',
+          screenShareUid: capturedCandidate.uid,
+          previousPinnedUid: capturedCandidate.previousPinnedUid,
+          previousLayout: capturedCandidate.previousLayout,
+        },
+      );
+    }
+
+    const candidate = recoveryCandidateRef.current;
+    if (candidate) {
+      // Recovery is driven by render state: first wait for the same UID to
+      // rejoin, then wait for its video to be published before restoring it.
+      const decision = getScreenshareRecoveryDecision({
+        candidate,
+        activeUids,
+        pinnedUid,
+        isVideoPublished: defaultContent?.[candidate.uid]?.video === 1,
+        screenShareData,
+      });
+
+      if (decision === 'waiting_for_video' && !candidate.joinedLogged) {
+        // The RTC user is back, but restoring now could show a blank tile.
+        candidate.joinedLogged = true;
+        logger.log(
+          LogSource.Internals,
+          'SCREENSHARE',
+          `${SCREENSHARE_JOURNEY} interrupted screen share UID rejoined; waiting for video publication`,
+          {
+            action: 'recover',
+            stage: 'rtc_rejoin',
+            outcome: 'waiting',
+            screenshareSessionId:
+              activeScreenshareSessionIdRef.current || 'unknown-session',
+            screenShareUid: candidate.uid,
+            elapsedMs: Date.now() - candidate.detectedAt,
+          },
+        );
+      } else if (decision === 'restore') {
+        // Restore only the layout state that existed before interruption. A
+        // newer user pin or screen-share session cancels this path below.
+        isPinned.current = candidate.uid;
+        dispatch({type: 'UserPin', value: [candidate.uid]});
+        if (
+          candidate.previousLayout === getPinnedLayoutName() &&
+          currentLayout !== getPinnedLayoutName()
+        ) {
+          setPinnedLayout();
+        }
+        recoveryCandidateRef.current = null;
+        logger.log(
+          LogSource.Internals,
+          'SCREENSHARE',
+          `${SCREENSHARE_JOURNEY} interrupted screen share video republished; previous pin restored`,
+          {
+            action: 'recover',
+            stage: 'layout_restore',
+            outcome: 'success',
+            screenshareSessionId:
+              activeScreenshareSessionIdRef.current || 'unknown-session',
+            screenShareUid: candidate.uid,
+            restoredPinnedUid: candidate.previousPinnedUid,
+            restoredLayout: candidate.previousLayout,
+            elapsedMs: Date.now() - candidate.detectedAt,
+          },
+        );
+      } else if (decision.startsWith('cancel_')) {
+        // An authoritative stop, replacement share, or user layout choice
+        // takes precedence over automatic interruption recovery.
+        recoveryCandidateRef.current = null;
+        logger.log(
+          LogSource.Internals,
+          'SCREENSHARE',
+          `${SCREENSHARE_JOURNEY} interrupted screen share pin restoration skipped`,
+          {
+            action: 'recover',
+            stage: 'layout_restore',
+            outcome: 'skipped',
+            screenshareSessionId:
+              activeScreenshareSessionIdRef.current || 'unknown-session',
+            screenShareUid: candidate.uid,
+            skipReason: decision,
+            currentPinnedUid: pinnedUid,
+            currentLayout,
+            elapsedMs: Date.now() - candidate.detectedAt,
+          },
+        );
+      }
+    }
+
+    previousLayoutStateRef.current = {
+      activeUids,
+      pinnedUid,
+      currentLayout,
+    };
+  }, [
+    activeUids,
+    currentLayout,
+    defaultContent,
+    dispatch,
+    pinnedUid,
+    screenShareData,
+    setPinnedLayout,
+  ]);
+
+  useEffect(
+    () => () => {
+      recoveryCandidateRef.current = null;
+    },
+    [],
+  );
+
   useEffect(() => {
     const unsubKickScreenshare = events.on(
       controlMessageEnum.kickScreenshare,
@@ -452,63 +601,80 @@ export const ScreenshareConfigure = (props: {
     );
   }, []);
 
-  const executeRecordingQuery = async (
-    isScreenActive: boolean,
+  const executeStartRecordingLayoutQuery = async (
     screenshareAttemptId: string,
     screenshareSessionId: string,
     stopOrigin: ScreenshareStopOrigin,
     stopActorUid?: UidType,
   ) => {
-    const action: ScreenshareAction = isScreenActive ? 'start' : 'stop';
-    if (isScreenActive) {
-      // If recording is going on, set the presenter query
-      logger.log(
-        LogSource.Internals,
-        'SCREENSHARE',
-        `${SCREENSHARE_JOURNEY} screen share start recording presenter layout query started`,
-        {
-          action,
-          stage: 'recording_layout',
-          outcome: 'started',
-          screenshareAttemptId,
-          screenshareSessionId,
-          recordingActive: props.isRecordingActive,
-          screenShareUid,
-          stopOrigin,
-          stopActorUid,
-        },
-      );
-      await executePresenterQuery(screenShareUid);
-      recordingLayoutReconcilerRef.current.markApplied(
+    logger.log(
+      LogSource.Internals,
+      'SCREENSHARE',
+      `${SCREENSHARE_JOURNEY} screen share start recording presenter layout query started`,
+      {
+        action: 'start',
+        stage: 'recording_layout',
+        outcome: 'started',
+        screenshareAttemptId,
         screenshareSessionId,
-        recordingActiveRef.current,
-      );
-    } else {
-      logger.log(
-        LogSource.Internals,
-        'SCREENSHARE',
-        `${SCREENSHARE_JOURNEY} screen share stop recording normal layout query started`,
-        {
-          action,
-          stage: 'recording_layout',
-          outcome: 'started',
-          screenshareAttemptId,
-          screenshareSessionId,
-          recordingActive: props.isRecordingActive,
-          screenShareUid,
-          stopOrigin,
-          stopActorUid,
-        },
-      );
-      // If no recording is going on, set the normal query
-      await executeNormalQuery();
-    }
+        recordingActive: props.isRecordingActive,
+        screenShareUid,
+        stopOrigin,
+        stopActorUid,
+      },
+    );
+    await executePresenterQuery(screenShareUid);
+    recordingLayoutReconcilerRef.current.markApplied(
+      screenshareSessionId,
+      recordingActiveRef.current,
+    );
+    logger.log(
+      LogSource.Internals,
+      'SCREENSHARE',
+      `${SCREENSHARE_JOURNEY} screen share start recording layout query completed successfully`,
+      {
+        action: 'start',
+        stage: 'recording_layout',
+        outcome: 'success',
+        screenshareAttemptId,
+        screenshareSessionId,
+        recordingActive: props.isRecordingActive,
+        screenShareUid,
+        stopOrigin,
+        stopActorUid,
+      },
+    );
+  };
+
+  const executeStopRecordingLayoutQuery = async (
+    screenshareAttemptId: string,
+    screenshareSessionId: string,
+    stopOrigin: ScreenshareStopOrigin,
+    stopActorUid?: UidType,
+  ) => {
+    logger.log(
+      LogSource.Internals,
+      'SCREENSHARE',
+      `${SCREENSHARE_JOURNEY} screen share stop recording normal layout query started`,
+      {
+        action: 'stop',
+        stage: 'recording_layout',
+        outcome: 'started',
+        screenshareAttemptId,
+        screenshareSessionId,
+        recordingActive: props.isRecordingActive,
+        screenShareUid,
+        stopOrigin,
+        stopActorUid,
+      },
+    );
+    await executeNormalQuery();
     logger.log(
       LogSource.Internals,
       'SCREENSHARE',
-      `${SCREENSHARE_JOURNEY} screen share ${action} recording layout query completed successfully`,
+      `${SCREENSHARE_JOURNEY} screen share stop recording layout query completed successfully`,
       {
-        action,
+        action: 'stop',
         stage: 'recording_layout',
         outcome: 'success',
         screenshareAttemptId,
@@ -744,8 +910,9 @@ export const ScreenshareConfigure = (props: {
       return;
     }
     updateOperationState('stopping');
-    const stopped = await userScreenshare(
-      false,
+    // Run only the stop workflow. RTC cleanup will invoke
+    // ScreenshareStoppedCallback to update local, RTM, and layout state.
+    const stopped = await executeStopScreenshareWorkflow(
       screenshareAttemptId,
       screenshareSessionId,
       stopOrigin,
@@ -839,8 +1006,9 @@ export const ScreenshareConfigure = (props: {
       },
     );
     logStartRequested();
-    const started = await userScreenshare(
-      true,
+    // Run only the start workflow. Stop requests received while this is
+    // pending are queued above and executed after startup completes.
+    const started = await executeStartScreenshareWorkflow(
       screenshareAttemptId,
       screenshareSessionId,
       'unknown',
@@ -891,24 +1059,22 @@ export const ScreenshareConfigure = (props: {
   };
   stopScreenshareRef.current = stopScreenshare;
 
-  const userScreenshare = async (
-    isActive: boolean,
+  const executeStartScreenshareWorkflow = async (
     screenshareAttemptId: string,
     screenshareSessionId: string,
     stopOrigin: ScreenshareStopOrigin,
     stopActorUid?: UidType,
   ) => {
     const startedAt = Date.now();
-    const action: ScreenshareAction = isActive ? 'start' : 'stop';
     let stage = 'recording_layout';
     let recordingLayoutFailed = false;
     let rtcOperationSucceeded = false;
     logger.log(
       LogSource.Internals,
       'SCREENSHARE',
-      `${SCREENSHARE_JOURNEY} screen share ${action} workflow started`,
+      `${SCREENSHARE_JOURNEY} screen share start workflow started`,
       {
-        action,
+        action: 'start',
         stage: 'journey',
         outcome: 'started',
         screenshareAttemptId,
@@ -923,8 +1089,7 @@ export const ScreenshareConfigure = (props: {
     try {
       if (props.isRecordingActive) {
         try {
-          await executeRecordingQuery(
-            isActive,
+          await executeStartRecordingLayoutQuery(
             screenshareAttemptId,
             screenshareSessionId,
             stopOrigin,
@@ -935,10 +1100,10 @@ export const ScreenshareConfigure = (props: {
           logger.error(
             LogSource.Internals,
             'SCREENSHARE',
-            `${SCREENSHARE_JOURNEY} screen share ${action} recording layout query failed; continuing screen share ${action}`,
+            `${SCREENSHARE_JOURNEY} screen share start recording layout query failed; continuing screen share start`,
             recordingError,
             {
-              action,
+              action: 'start',
               stage,
               outcome: 'partial_failure',
               screenshareAttemptId,
@@ -955,9 +1120,9 @@ export const ScreenshareConfigure = (props: {
         logger.log(
           LogSource.Internals,
           'SCREENSHARE',
-          `${SCREENSHARE_JOURNEY} screen share ${action} recording layout query skipped because recording is inactive`,
+          `${SCREENSHARE_JOURNEY} screen share start recording layout query skipped because recording is inactive`,
           {
-            action,
+            action: 'start',
             stage,
             outcome: 'skipped',
             screenshareAttemptId,
@@ -973,9 +1138,9 @@ export const ScreenshareConfigure = (props: {
       logger.log(
         LogSource.Internals,
         'SCREENSHARE',
-        `${SCREENSHARE_JOURNEY} screen share ${action} calling RtcEngine.startScreenshare`,
+        `${SCREENSHARE_JOURNEY} screen share start calling RtcEngine.startScreenshare`,
         {
-          action,
+          action: 'start',
           stage,
           outcome: 'started',
           screenshareAttemptId,
@@ -987,6 +1152,7 @@ export const ScreenshareConfigure = (props: {
         },
       );
       // @ts-ignore
+      // The RTC start API only creates, joins, and publishes screen tracks.
       await rtc.RtcEngineUnsafe.startScreenshare(
         screenShareToken,
         channel,
@@ -998,7 +1164,6 @@ export const ScreenshareConfigure = (props: {
         {encoderConfig: '1080p_2', optimizationMode: 'detail'},
         'auto',
         {
-          action,
           screenshareAttemptId,
           screenshareSessionId,
           recordingActive: props.isRecordingActive,
@@ -1011,9 +1176,9 @@ export const ScreenshareConfigure = (props: {
       logger.log(
         LogSource.Internals,
         'SCREENSHARE',
-        `${SCREENSHARE_JOURNEY} screen share ${action} RtcEngine.startScreenshare completed successfully`,
+        `${SCREENSHARE_JOURNEY} screen share start RtcEngine.startScreenshare completed successfully`,
         {
-          action,
+          action: 'start',
           stage,
           outcome: 'success',
           screenshareAttemptId,
@@ -1025,99 +1190,299 @@ export const ScreenshareConfigure = (props: {
         },
       );
 
-      if (isActive) {
-        activeScreenshareSessionIdRef.current = screenshareSessionId;
+      activeScreenshareSessionIdRef.current = screenshareSessionId;
+      pendingScreenshareSessionIdRef.current = null;
+      updateOperationState('active');
+      setScreenshareActive(true);
+      stage = 'local_active_state';
+      logger.log(
+        LogSource.Internals,
+        'SCREENSHARE',
+        `${SCREENSHARE_JOURNEY} screen share start local active state set to active`,
+        {
+          action: 'start',
+          stage,
+          outcome: 'success',
+          screenshareAttemptId,
+          screenshareSessionId,
+          recordingActive: props.isRecordingActive,
+          screenShareUid,
+          stopOrigin,
+          stopActorUid,
+        },
+      );
+      stage = 'screenshare_context';
+      setScreenShareData(prevState => {
+        return {
+          ...prevState,
+          [screenShareUid]: {
+            name: defaultContentRef.current.defaultContent[screenShareUid]
+              ?.name,
+            isActive: true,
+            ts: timeNow(),
+          },
+        };
+      });
+      logger.log(
+        LogSource.Internals,
+        'SCREENSHARE',
+        `${SCREENSHARE_JOURNEY} screen share start local context set to active`,
+        {
+          action: 'start',
+          stage,
+          outcome: 'success',
+          screenshareAttemptId,
+          screenshareSessionId,
+          recordingActive: props.isRecordingActive,
+          screenShareUid,
+          stopOrigin,
+          stopActorUid,
+        },
+      );
+      stage = 'rtm_event';
+      const rtmEventSent = await events.send(
+        EventNames.SCREENSHARE_ATTRIBUTE,
+        JSON.stringify({
+          action: EventActions.SCREENSHARE_STARTED,
+          value: timeNow(),
+          screenUidOfUser: screenShareUid,
+        }),
+        PersistanceLevel.Sender,
+      );
+      logger.log(
+        LogSource.Internals,
+        'SCREENSHARE',
+        `${SCREENSHARE_JOURNEY} screen share start RTM event ${
+          rtmEventSent
+            ? 'sent to remote users'
+            : 'failed to send to remote users'
+        }`,
+        {
+          action: 'start',
+          stage,
+          outcome: rtmEventSent ? 'success' : 'failure',
+          screenshareAttemptId,
+          screenshareSessionId,
+          recordingActive: props.isRecordingActive,
+          screenShareUid,
+          stopOrigin,
+          stopActorUid,
+        },
+      );
+      logger.log(
+        LogSource.Internals,
+        'SCREENSHARE',
+        `${SCREENSHARE_JOURNEY} screen share start workflow ${
+          recordingLayoutFailed
+            ? 'completed with recording layout failure'
+            : 'completed successfully'
+        }`,
+        {
+          action: 'start',
+          stage: 'complete',
+          outcome: recordingLayoutFailed ? 'partial_success' : 'success',
+          screenshareAttemptId,
+          screenshareSessionId,
+          recordingActive: props.isRecordingActive,
+          screenShareUid,
+          stopOrigin,
+          stopActorUid,
+          elapsedMs: Date.now() - startedAt,
+        },
+      );
+      return true;
+    } catch (e) {
+      const userCancelOrPermissionDenied = isUserCancelOrPermissionDenied(e);
+      logger.error(
+        LogSource.Internals,
+        'SCREENSHARE',
+        `${SCREENSHARE_JOURNEY} screen share start workflow failed at ${stage}: ${
+          userCancelOrPermissionDenied
+            ? 'user cancelled picker or permission was denied'
+            : 'unexpected failure'
+        }`,
+        {
+          action: 'start',
+          stage,
+          outcome: userCancelOrPermissionDenied
+            ? 'user_cancel_or_permission_denied'
+            : 'failure',
+          screenshareAttemptId,
+          screenshareSessionId,
+          recordingActive: props.isRecordingActive,
+          screenShareUid,
+          stopOrigin,
+          stopActorUid,
+          elapsedMs: Date.now() - startedAt,
+          ...getScreenshareError(e),
+        },
+      );
+      Toast.show({
+        leadingIconName: 'alert',
+        type: 'error',
+        text1: toastHeading,
+        text2: toastSubHeading,
+        visibilityTime: 1000 * 10,
+        primaryBtn: null,
+        secondaryBtn: null,
+      });
+      if (!rtcOperationSucceeded) {
         pendingScreenshareSessionIdRef.current = null;
-        updateOperationState('active');
-        setScreenshareActive(true);
-        stage = 'local_active_state';
+        activeScreenshareSessionIdRef.current = null;
+        setScreenshareActive(false);
+        updateOperationState('inactive');
         logger.log(
           LogSource.Internals,
           'SCREENSHARE',
-          `${SCREENSHARE_JOURNEY} screen share start local active state set to active`,
+          getScreenshareSessionBoundaryMessage('end', screenshareSessionId),
           {
-            action,
-            stage,
-            outcome: 'success',
+            action: 'start',
+            stage: 'session_boundary',
+            outcome: 'ended_with_start_failure',
             screenshareAttemptId,
             screenshareSessionId,
             recordingActive: props.isRecordingActive,
             screenShareUid,
             stopOrigin,
             stopActorUid,
+            operationState: operationStateRef.current,
           },
         );
-        // 1. Set local state
-        stage = 'screenshare_context';
-        setScreenShareData(prevState => {
-          return {
-            ...prevState,
-            [screenShareUid]: {
-              name: defaultContentRef.current.defaultContent[screenShareUid]
-                ?.name,
-              isActive: true,
-              ts: timeNow(),
-            },
-          };
-        });
-        logger.log(
-          LogSource.Internals,
-          'SCREENSHARE',
-          `${SCREENSHARE_JOURNEY} screen share start local context set to active`,
-          {
-            action,
-            stage,
-            outcome: 'success',
+      }
+      return rtcOperationSucceeded;
+    }
+  };
+
+  const executeStopScreenshareWorkflow = async (
+    screenshareAttemptId: string,
+    screenshareSessionId: string,
+    stopOrigin: ScreenshareStopOrigin,
+    stopActorUid?: UidType,
+  ) => {
+    const startedAt = Date.now();
+    let stage = 'recording_layout';
+    let recordingLayoutFailed = false;
+    let rtcOperationSucceeded = false;
+    logger.log(
+      LogSource.Internals,
+      'SCREENSHARE',
+      `${SCREENSHARE_JOURNEY} screen share stop workflow started`,
+      {
+        action: 'stop',
+        stage: 'journey',
+        outcome: 'started',
+        screenshareAttemptId,
+        screenshareSessionId,
+        recordingActive: props.isRecordingActive,
+        screenShareUid,
+        stopOrigin,
+        stopActorUid,
+        channel,
+      },
+    );
+    try {
+      if (props.isRecordingActive) {
+        try {
+          await executeStopRecordingLayoutQuery(
             screenshareAttemptId,
             screenshareSessionId,
-            recordingActive: props.isRecordingActive,
-            screenShareUid,
             stopOrigin,
             stopActorUid,
-          },
-        );
-        // 2. Inform everyone in the channel screenshare is actice
-        stage = 'rtm_event';
-        const rtmEventSent = await events.send(
-          EventNames.SCREENSHARE_ATTRIBUTE,
-          JSON.stringify({
-            action: EventActions.SCREENSHARE_STARTED,
-            value: timeNow(),
-            screenUidOfUser: screenShareUid,
-          }),
-          PersistanceLevel.Sender,
-        );
+          );
+        } catch (recordingError) {
+          recordingLayoutFailed = true;
+          logger.error(
+            LogSource.Internals,
+            'SCREENSHARE',
+            `${SCREENSHARE_JOURNEY} screen share stop recording layout query failed; continuing screen share stop`,
+            recordingError,
+            {
+              action: 'stop',
+              stage,
+              outcome: 'partial_failure',
+              screenshareAttemptId,
+              screenshareSessionId,
+              recordingActive: props.isRecordingActive,
+              screenShareUid,
+              stopOrigin,
+              stopActorUid,
+              ...getScreenshareError(recordingError),
+            },
+          );
+        }
+      } else {
         logger.log(
           LogSource.Internals,
           'SCREENSHARE',
-          `${SCREENSHARE_JOURNEY} screen share start RTM event ${
-            rtmEventSent
-              ? 'sent to remote users'
-              : 'failed to send to remote users'
-          }`,
+          `${SCREENSHARE_JOURNEY} screen share stop recording layout query skipped because recording is inactive`,
           {
-            action,
+            action: 'stop',
             stage,
-            outcome: rtmEventSent ? 'success' : 'failure',
+            outcome: 'skipped',
             screenshareAttemptId,
             screenshareSessionId,
-            recordingActive: props.isRecordingActive,
+            recordingActive: false,
             screenShareUid,
             stopOrigin,
             stopActorUid,
           },
         );
       }
+      stage = 'rtc_operation';
       logger.log(
         LogSource.Internals,
         'SCREENSHARE',
-        `${SCREENSHARE_JOURNEY} screen share ${action} workflow ${
+        `${SCREENSHARE_JOURNEY} screen share stop calling RtcEngine.stopScreenshare`,
+        {
+          action: 'stop',
+          stage,
+          outcome: 'started',
+          screenshareAttemptId,
+          screenshareSessionId,
+          recordingActive: props.isRecordingActive,
+          screenShareUid,
+          stopOrigin,
+          stopActorUid,
+        },
+      );
+      // @ts-ignore
+      // The RTC stop API performs idempotent track/client cleanup and then
+      // invokes ScreenshareStoppedCallback for application-state cleanup.
+      await rtc.RtcEngineUnsafe.stopScreenshare({
+        screenshareAttemptId,
+        screenshareSessionId,
+        recordingActive: props.isRecordingActive,
+        screenShareUid,
+        stopOrigin,
+        stopActorUid,
+      });
+      rtcOperationSucceeded = true;
+      logger.log(
+        LogSource.Internals,
+        'SCREENSHARE',
+        `${SCREENSHARE_JOURNEY} screen share stop RtcEngine.stopScreenshare completed successfully`,
+        {
+          action: 'stop',
+          stage,
+          outcome: 'success',
+          screenshareAttemptId,
+          screenshareSessionId,
+          recordingActive: props.isRecordingActive,
+          screenShareUid,
+          stopOrigin,
+          stopActorUid,
+        },
+      );
+      logger.log(
+        LogSource.Internals,
+        'SCREENSHARE',
+        `${SCREENSHARE_JOURNEY} screen share stop workflow ${
           recordingLayoutFailed
             ? 'completed with recording layout failure'
             : 'completed successfully'
         }`,
         {
-          action,
+          action: 'stop',
           stage: 'complete',
           outcome: recordingLayoutFailed ? 'partial_success' : 'success',
           screenshareAttemptId,
@@ -1135,13 +1500,13 @@ export const ScreenshareConfigure = (props: {
       logger.error(
         LogSource.Internals,
         'SCREENSHARE',
-        `${SCREENSHARE_JOURNEY} screen share ${action} workflow failed at ${stage}: ${
+        `${SCREENSHARE_JOURNEY} screen share stop workflow failed at ${stage}: ${
           userCancelOrPermissionDenied
             ? 'user cancelled picker or permission was denied'
             : 'unexpected failure'
         }`,
         {
-          action,
+          action: 'stop',
           stage,
           outcome: userCancelOrPermissionDenied
             ? 'user_cancel_or_permission_denied'
@@ -1165,29 +1530,6 @@ export const ScreenshareConfigure = (props: {
         primaryBtn: null,
         secondaryBtn: null,
       });
-      if (isActive && !rtcOperationSucceeded) {
-        pendingScreenshareSessionIdRef.current = null;
-        activeScreenshareSessionIdRef.current = null;
-        setScreenshareActive(false);
-        updateOperationState('inactive');
-        logger.log(
-          LogSource.Internals,
-          'SCREENSHARE',
-          getScreenshareSessionBoundaryMessage('end', screenshareSessionId),
-          {
-            action: 'start',
-            stage: 'session_boundary',
-            outcome: 'ended_with_start_failure',
-            screenshareAttemptId,
-            screenshareSessionId,
-            recordingActive: props.isRecordingActive,
-            screenShareUid,
-            stopOrigin,
-            stopActorUid,
-            operationState: operationStateRef.current,
-          },
-        );
-      }
       return rtcOperationSucceeded;
     }
   };