agora-appbuilder-core 4.1.20 → 4.1.21

package/template/src/subComponents/caption/sttSessionId.web.ts

@@ -0,0 +1,21 @@
+import RTMEngine from '../../rtm/RTMEngine';
+import getUniqueID from '../../utils/getUniqueID';
+import {createSTTSessionCoordinator} from './sttSessionCoordinator';
+
+export {
+  createSTTSessionCoordinator,
+  STT_SESSION_ID_KEY,
+} from './sttSessionCoordinator';
+
+const coordinator = createSTTSessionCoordinator({
+  getClient: () => RTMEngine.getInstance().engine,
+  createId: getUniqueID,
+  wait: milliseconds =>
+    new Promise(resolve => setTimeout(resolve, milliseconds)),
+});
+
+export const ensureSTTSessionId = coordinator.ensureSTTSessionId;
+export const isOnlyLocalRTMParticipant = coordinator.isOnlyLocalRTMParticipant;
+export const clearSTTSessionIdIfLast = coordinator.clearSTTSessionIdIfLast;
+export const cleanupSTTSessionOnEnd = coordinator.cleanupSTTSessionOnEnd;
+export const resetSTTSessionIdCache = coordinator.resetSTTSessionIdCache;

package/template/src/subComponents/caption/useSTTAPI.tsx

@@ -1,10 +1,12 @@
 import React, {useContext} from 'react';
 import StorageContext from '../../components/StorageContext';
 import {useRoomInfo} from '../../components/room-info/useRoomInfo';
-import {LanguageTranslationConfig} from './useCaption';
+import {type LanguageTranslationConfig} from './useCaption';
 import {PropsContext, useLocalUid} from '../../../agora-rn-uikit';
 import {logger, LogSource} from '../../logger/AppBuilderLogger';
 import getUniqueID from '../../utils/getUniqueID';
+import {buildSTTRequestBody, type STTMethod} from './sttRequestBody';
+import {ensureSTTSessionId} from './sttSessionId';
 
 export interface STTAPIResponse {
   success: boolean;
@@ -57,7 +59,7 @@ const useSTTAPI = (): IuseSTTAPI => {
   }, [rtcProps]);
 
   const apiCall = async (
-    method: 'startv7' | 'update' | 'stopv7',
+    method: STTMethod,
     botUid: number,
     translationConfig?: LanguageTranslationConfig,
   ): Promise<STTAPIResponse> => {
@@ -68,14 +70,19 @@ const useSTTAPI = (): IuseSTTAPI => {
       // Calculate which user this bot belongs to
       const ownerUid = botUid - 900000000;
 
-      let requestBody: any = {
+      const requestBody = await buildSTTRequestBody({
+        method,
+        botUid,
         passphrase:
           roomIdRef?.current?.host || roomIdRef?.current?.attendee || '',
-        dataStream_uid: botUid,
-        encryption_mode: $config.ENCRYPTION_ENABLED
+        encryptionMode: $config.ENCRYPTION_ENABLED
           ? rtcPropsRef?.current.encryption.mode
           : null,
-      };
+        localUid: localUidRef.current,
+        channelName: rtcPropsRef?.current?.channel || '',
+        translationConfig,
+        resolveSessionId: ensureSTTSessionId,
+      });
 
       console.log(
         `[STT_BOT_SUBSCRIPTION] ${method.toUpperCase()} - Bot UID: ${botUid} will subscribe to User UID: ${ownerUid}`,
@@ -86,33 +93,6 @@ const useSTTAPI = (): IuseSTTAPI => {
           translationConfig,
         },
       );
-      // Add translate_config only for start/update methods
-      if (translationConfig?.source?.[0]) {
-        requestBody.lang = translationConfig.source;
-        // Sanitize payload: remove source language from targets to avoid API errors
-        const sanitizedTargets =
-          translationConfig?.targets?.filter(
-            target => target !== translationConfig?.source[0],
-          ) || [];
-        const shouldTranslate = sanitizedTargets.length > 0;
-        // Add translate_config payload only if targets exist
-        if (shouldTranslate) {
-          requestBody.translate_config = [
-            {
-              source_lang: translationConfig.source[0],
-              target_lang: sanitizedTargets,
-            },
-          ];
-          if (method === 'update') {
-            requestBody.translate = true;
-          }
-        } else if (method === 'update') {
-          // If method is update and no targets are passed
-          requestBody.translate = false;
-        }
-        requestBody.subscribeAudioUids = [`${localUidRef.current}`];
-      }
-
       const response = await fetch(`${STT_API_URL}/${method}`, {
         method: 'POST',
         headers: {

package/template/src/utils/__tests__/useEndCall.test.tsx

@@ -0,0 +1,282 @@
+import React from 'react';
+import TestRenderer, {act} from 'react-test-renderer';
+import {afterEach, beforeEach, describe, expect, it, jest} from '@jest/globals';
+
+jest.mock('customization-implementation', () => ({
+  useCustomization: () => undefined,
+}));
+
+jest.mock('customization-api', () => ({
+  useCaption: jest.fn(),
+  useContent: jest.fn(),
+  useRoomInfo: jest.fn(),
+}));
+
+jest.mock('../../../agora-rn-uikit', () => {
+  const ReactModule = require('react');
+  return {
+    PropsContext: ReactModule.createContext({}),
+    DispatchContext: ReactModule.createContext({}),
+    useLocalUid: jest.fn(() => 123),
+  };
+});
+
+jest.mock('../../components/Router', () => ({
+  useHistory: () => ({}),
+}));
+
+jest.mock('../../subComponents/LocalEndCall', () => ({
+  stopForegroundService: jest.fn(),
+}));
+
+jest.mock('../../rtm/RTMEngine', () => {
+  const unsubscribe = jest.fn();
+  return {
+    __esModule: true,
+    default: {
+      getInstance: () => ({engine: {unsubscribe}}),
+    },
+  };
+});
+
+jest.mock('../../auth/config', () => ({ENABLE_AUTH: true}));
+
+jest.mock('../../auth/AuthProvider', () => ({
+  useAuth: () => ({authLogin: jest.fn()}),
+}));
+
+jest.mock('../../components/chat/chatConfigure', () => ({
+  useChatConfigure: () => ({deleteChatUser: jest.fn()}),
+}));
+
+jest.mock('../common', () => ({
+  isWebInternal: jest.fn(),
+}));
+
+jest.mock('../../subComponents/caption/sttSessionId', () => ({
+  cleanupSTTSessionOnEnd: jest.fn(),
+}));
+
+import {useCaption, useContent, useRoomInfo} from 'customization-api';
+import {DispatchContext, PropsContext} from '../../../agora-rn-uikit';
+import RTMEngine from '../../rtm/RTMEngine';
+import {cleanupSTTSessionOnEnd} from '../../subComponents/caption/sttSessionId';
+import {isWebInternal} from '../common';
+import useEndCall from '../useEndCall';
+
+const mockUseCaption = useCaption as jest.Mock<any>;
+const mockUseContent = useContent as jest.Mock<any>;
+const mockUseRoomInfo = useRoomInfo as jest.Mock<any>;
+const mockCleanupSTTSessionOnEnd = cleanupSTTSessionOnEnd as jest.Mock<any>;
+const mockIsWebInternal = isWebInternal as jest.Mock<any>;
+const mockUnsubscribe = RTMEngine.getInstance().engine
+  .unsubscribe as jest.Mock<any>;
+
+const renderHook = (dispatch: (action: any) => void) => {
+  let endCall!: ReturnType<typeof useEndCall>;
+  let renderer!: TestRenderer.ReactTestRenderer;
+
+  act(() => {
+    renderer = TestRenderer.create(
+      <PropsContext.Provider value={{rtcProps: {channel: 'room'}} as any}>
+        <DispatchContext.Provider value={{dispatch} as any}>
+          {React.createElement(() => {
+            endCall = useEndCall();
+            return null;
+          })}
+        </DispatchContext.Provider>
+      </PropsContext.Provider>,
+    );
+  });
+
+  return {endCall, renderer};
+};
+
+describe('useEndCall STT session cleanup', () => {
+  const mockStopSTT = jest.fn<any>();
+
+  beforeEach(() => {
+    jest.useFakeTimers();
+    jest.clearAllMocks();
+    mockUseCaption.mockReturnValue({
+      isSTTActive: true,
+      stopSTTBotSession: mockStopSTT,
+    });
+    mockUseContent.mockReturnValue({
+      defaultContent: {
+        123: {
+          type: 'rtc',
+          isHost: 'true',
+          offline: false,
+        },
+      },
+    });
+    mockUseRoomInfo.mockReturnValue({data: {isHost: true}});
+    mockStopSTT.mockResolvedValue(undefined);
+    mockUnsubscribe.mockResolvedValue(undefined);
+  });
+
+  afterEach(() => {
+    jest.useRealTimers();
+  });
+
+  it('awaits web cleanup before RTM unsubscribe and end-call dispatch', async () => {
+    const calls: string[] = [];
+    mockIsWebInternal.mockReturnValue(true);
+    mockStopSTT.mockImplementation(async () => {
+      calls.push('stop');
+    });
+    mockCleanupSTTSessionOnEnd.mockImplementation(
+      async (_channel, _uid, _active, stop) => {
+        calls.push('cleanup-start');
+        await stop();
+        calls.push('cleanup-end');
+      },
+    );
+    mockUnsubscribe.mockImplementation(async () => {
+      calls.push('unsubscribe');
+    });
+    const {endCall, renderer} = renderHook(() => calls.push('dispatch'));
+
+    await act(async () => {
+      await endCall();
+    });
+
+    expect(mockCleanupSTTSessionOnEnd).toHaveBeenCalledWith(
+      'room',
+      '123',
+      true,
+      mockStopSTT,
+    );
+    expect(calls).toEqual([
+      'cleanup-start',
+      'stop',
+      'cleanup-end',
+      'unsubscribe',
+    ]);
+
+    act(() => jest.runOnlyPendingTimers());
+    expect(calls).toEqual([
+      'cleanup-start',
+      'stop',
+      'cleanup-end',
+      'unsubscribe',
+      'dispatch',
+    ]);
+    renderer.unmount();
+  });
+
+  it('awaits native cleanup before RTM unsubscribe and end-call dispatch', async () => {
+    const calls: string[] = [];
+    mockIsWebInternal.mockReturnValue(false);
+    mockStopSTT.mockImplementation(async () => {
+      calls.push('stop');
+    });
+    mockCleanupSTTSessionOnEnd.mockImplementation(
+      async (_channel, _uid, _active, stop) => {
+        calls.push('cleanup-start');
+        await stop();
+        calls.push('cleanup-end');
+      },
+    );
+    mockUnsubscribe.mockImplementation(async () => {
+      calls.push('unsubscribe');
+    });
+    const {endCall, renderer} = renderHook(() => calls.push('dispatch'));
+
+    await act(async () => {
+      await endCall();
+    });
+
+    expect(mockCleanupSTTSessionOnEnd).toHaveBeenCalledWith(
+      'room',
+      '123',
+      true,
+      expect.any(Function),
+    );
+    expect(calls).toEqual([
+      'cleanup-start',
+      'stop',
+      'cleanup-end',
+      'unsubscribe',
+    ]);
+
+    act(() => jest.runOnlyPendingTimers());
+    expect(calls).toEqual([
+      'cleanup-start',
+      'stop',
+      'cleanup-end',
+      'unsubscribe',
+      'dispatch',
+    ]);
+    renderer.unmount();
+  });
+
+  it('falls back to the native last-host stop when RTM cleanup fails', async () => {
+    const calls: string[] = [];
+    mockIsWebInternal.mockReturnValue(false);
+    jest.spyOn(console, 'error').mockImplementation(() => {});
+    mockCleanupSTTSessionOnEnd.mockImplementation(async () => {
+      calls.push('cleanup');
+      throw new Error('RTM unavailable');
+    });
+    mockStopSTT.mockImplementation(async () => {
+      calls.push('stop');
+    });
+    mockUnsubscribe.mockImplementation(async () => {
+      calls.push('unsubscribe');
+    });
+    const {endCall, renderer} = renderHook(() => calls.push('dispatch'));
+
+    await act(async () => {
+      await endCall();
+    });
+
+    expect(mockStopSTT).toHaveBeenCalledTimes(1);
+    expect(calls).toEqual(['cleanup', 'stop', 'unsubscribe']);
+
+    act(() => jest.runOnlyPendingTimers());
+    expect(calls).toEqual(['cleanup', 'stop', 'unsubscribe', 'dispatch']);
+    renderer.unmount();
+  });
+
+  it('does not stop native STT twice when metadata removal fails after stop', async () => {
+    mockIsWebInternal.mockReturnValue(false);
+    jest.spyOn(console, 'error').mockImplementation(() => {});
+    mockCleanupSTTSessionOnEnd.mockImplementation(
+      async (_channel, _uid, _active, stop) => {
+        await stop();
+        throw new Error('metadata removal failed');
+      },
+    );
+    const {endCall, renderer} = renderHook(() => {});
+
+    await act(async () => {
+      await endCall();
+    });
+
+    expect(mockStopSTT).toHaveBeenCalledTimes(1);
+    renderer.unmount();
+  });
+
+  it('continues native end-call when RTM cleanup and fallback stop both fail', async () => {
+    const calls: string[] = [];
+    mockIsWebInternal.mockReturnValue(false);
+    jest.spyOn(console, 'error').mockImplementation(() => {});
+    mockCleanupSTTSessionOnEnd.mockRejectedValue(new Error('RTM unavailable'));
+    mockStopSTT.mockRejectedValue(new Error('stop unavailable'));
+    mockUnsubscribe.mockImplementation(async () => {
+      calls.push('unsubscribe');
+    });
+    const {endCall, renderer} = renderHook(() => calls.push('dispatch'));
+
+    await act(async () => {
+      await endCall();
+    });
+
+    expect(calls).toEqual(['unsubscribe']);
+    act(() => jest.runOnlyPendingTimers());
+    expect(calls).toEqual(['unsubscribe', 'dispatch']);
+    renderer.unmount();
+  });
+});

package/template/src/utils/useEndCall.ts

@@ -1,17 +1,15 @@
 import {useContext} from 'react';
 import {useCustomization} from 'customization-implementation';
-import {
-  useCaption,
-  useContent,
-  useRoomInfo,
-} from 'customization-api';
-import {PropsContext, DispatchContext} from '../../agora-rn-uikit';
+import {useCaption, useContent, useRoomInfo} from 'customization-api';
+import {PropsContext, DispatchContext, useLocalUid} from '../../agora-rn-uikit';
 import {useHistory} from '../components/Router';
 import {stopForegroundService} from '../subComponents/LocalEndCall';
 import RTMEngine from '../rtm/RTMEngine';
 import {ENABLE_AUTH} from '../auth/config';
 import {useAuth} from '../auth/AuthProvider';
 import {useChatConfigure} from '../components/chat/chatConfigure';
+import {isWebInternal} from './common';
+import {cleanupSTTSessionOnEnd} from '../subComponents/caption/sttSessionId';
 
 const useEndCall = () => {
   const history = useHistory();
@@ -25,6 +23,7 @@ const useEndCall = () => {
 
   const {rtcProps} = useContext(PropsContext);
   const {dispatch} = useContext(DispatchContext);
+  const localUid = useLocalUid();
 
   const beforeEndCall = useCustomization(
     data =>
@@ -43,31 +42,73 @@ const useEndCall = () => {
       console.log('debugging error on beforeEndCall', error);
     }
 
-    setTimeout(() => {
-      dispatch({
-        type: 'EndCall',
-        value: [],
+    const scheduleEndCall = () => {
+      setTimeout(() => {
+        dispatch({
+          type: 'EndCall',
+          value: [],
+        });
       });
-    });
+    };
+    const isWebCall = isWebInternal();
+
     // stopping foreground servie on end call
     stopForegroundService();
-    // stopping STT on call end,if only last user is remaining in call
-    const usersInCall = Object.entries(defaultContent).filter(
-      item =>
-        item[1].type === 'rtc' && item[1].isHost === 'true' && !item[1].offline,
-    );
-    if (usersInCall.length === 1 && isSTTActive) {
-      console.log('Stopping stt api as only one host is in the call');
-      stopSTTBotSession().catch(error => {
-        console.log('Error stopping stt', error);
-      });
+
+    let nativeStopPromise: Promise<void> | undefined;
+    const stopNativeSTTOnce = (): Promise<void> => {
+      if (!nativeStopPromise) {
+        nativeStopPromise = stopSTTBotSession().catch(error => {
+          nativeStopPromise = undefined;
+          throw error;
+        });
+      }
+      return nativeStopPromise;
+    };
+    const stopSTT = isWebCall ? stopSTTBotSession : stopNativeSTTOnce;
+
+    try {
+      await cleanupSTTSessionOnEnd(
+        rtcProps.channel,
+        String(localUid),
+        isSTTActive,
+        stopSTT,
+      );
+    } catch (error) {
+      console.error(
+        `Failed to clean up the ${isWebCall ? 'web' : 'native'} STT session ID`,
+        error,
+      );
+      if (!isWebCall && isSTTActive) {
+        const usersInCall = Object.entries(defaultContent).filter(
+          item =>
+            item[1].type === 'rtc' &&
+            item[1].isHost === 'true' &&
+            !item[1].offline,
+        );
+        if (usersInCall.length === 1) {
+          try {
+            await stopNativeSTTOnce();
+          } catch (stopError) {
+            console.error(
+              'Failed to stop native STT during fallback',
+              stopError,
+            );
+          }
+        }
+      }
     }
 
     // removing user from chat server
     if ($config.CHAT) {
       deleteChatUser();
     }
-    RTMEngine.getInstance().engine.unsubscribe(rtcProps.channel);
+    try {
+      await RTMEngine.getInstance().engine.unsubscribe(rtcProps.channel);
+    } catch (error) {
+      console.error('Failed to unsubscribe from the RTM channel', error);
+    }
+    scheduleEndCall();
     if (!ENABLE_AUTH) {
       // await authLogout();
       await authLogin();