feat(external_api) include transcription state in recordingStatusChanged

modules/API/API.js

      * @param {boolean} on - True if recording is on, false otherwise.
      * @param {string} mode - Stream or file or local.
      * @param {string} error - Error type or null if success.
+     * @param {boolean} transcription - True if a transcription is being recorded, false otherwise.
      * @returns {void}
      */
-    notifyRecordingStatusChanged(on, mode, error) {
+    notifyRecordingStatusChanged(on, mode, error, transcription) {
         this._sendEvent({
             name: 'recording-status-changed',
             on,
             mode,
-            error
+            error,
+            transcription
         });
     }
 

react/features/recording/middleware.ts

             (recorderSession: any) => {
                 if (recorderSession) {
                     recorderSession.getID() && dispatch(updateRecordingSessionData(recorderSession));
-                    recorderSession.getError() && _showRecordingErrorNotification(recorderSession, dispatch);
+                    recorderSession.getError() && _showRecordingErrorNotification(recorderSession, dispatch, getState);
                 }
 
                 return;
             dispatch(updateLocalRecordingStatus(true, onlySelf));
             sendAnalytics(createRecordingEvent('started', `local${onlySelf ? '.self' : ''}`));
             if (typeof APP !== 'undefined') {
-                APP.API.notifyRecordingStatusChanged(true, 'local');
+                APP.API.notifyRecordingStatusChanged(
+                    true, 'local', undefined, isRecorderTranscriptionsRunning(getState()));
             }
         } catch (err: any) {
             logger.error('Capture failed', err);
             };
 
             if (typeof APP !== 'undefined') {
-                APP.API.notifyRecordingStatusChanged(false, 'local', err.message);
+                APP.API.notifyRecordingStatusChanged(
+                    false, 'local', err.message, isRecorderTranscriptionsRunning(getState()));
             }
 
             dispatch(showErrorNotification(props, NOTIFICATION_TIMEOUT_TYPE.MEDIUM));
                 dispatch(playSound(RECORDING_OFF_SOUND_ID));
             }
             if (typeof APP !== 'undefined') {
-                APP.API.notifyRecordingStatusChanged(false, 'local');
+                APP.API.notifyRecordingStatusChanged(
+                    false, 'local', undefined, isRecorderTranscriptionsRunning(getState()));
             }
         }
         break;
                     }
 
                     if (typeof APP !== 'undefined') {
-                        APP.API.notifyRecordingStatusChanged(true, mode);
+                        APP.API.notifyRecordingStatusChanged(
+                            true, mode, undefined, isRecorderTranscriptionsRunning(state));
                     }
                 }
             } else if (updatedSessionData?.status === OFF && oldSessionData?.status !== OFF) {
                 }
 
                 if (typeof APP !== 'undefined') {
-                    APP.API.notifyRecordingStatusChanged(false, mode);
+                    APP.API.notifyRecordingStatusChanged(
+                        false, mode, undefined, isRecorderTranscriptionsRunning(state));
                 }
             }
         }
  * in recording session.
  *
  * @private
- * @param {Object} recorderSession - The recorder session model from the
+ * @param {Object} session - The recorder session model from the
  * lib.
  * @param {Dispatch} dispatch - The Redux Dispatch function.
+ * @param {Function} getState - The Redux getState function.
  * @returns {void}
  */
-function _showRecordingErrorNotification(recorderSession: any, dispatch: IStore['dispatch']) {
-    const mode = recorderSession.getMode();
-    const error = recorderSession.getError();
+function _showRecordingErrorNotification(session: any, dispatch: IStore['dispatch'], getState: IStore['getState']) {
+    const mode = session.getMode();
+    const error = session.getError();
     const isStreamMode = mode === JitsiMeetJS.constants.recording.mode.STREAM;
 
     switch (error) {
     }
 
     if (typeof APP !== 'undefined') {
-        APP.API.notifyRecordingStatusChanged(false, mode, error);
+        APP.API.notifyRecordingStatusChanged(false, mode, error, isRecorderTranscriptionsRunning(getState()));
     }
 }

react/features/transcribing/subscriber.ts

 import { showNotification } from '../notifications/actions';
 import { NOTIFICATION_TIMEOUT_TYPE } from '../notifications/constants';
 import { RECORDING_OFF_SOUND_ID, RECORDING_ON_SOUND_ID } from '../recording/constants';
+import { isLiveStreamingRunning, isRecordingRunning } from '../recording/functions';
 
 import { isRecorderTranscriptionsRunning } from './functions';
 
     /* selector */ isRecorderTranscriptionsRunning,
     /* listener */ (isRecorderTranscriptionsRunningValue, { getState, dispatch }) => {
         if (isRecorderTranscriptionsRunningValue) {
-            notifyTranscribingStatusChanged(true);
+            notifyTranscribingStatusChanged(getState, true);
             maybeEmitRecordingNotification(dispatch, getState, true);
         } else {
-            notifyTranscribingStatusChanged(false);
+            notifyTranscribingStatusChanged(getState, false);
             maybeEmitRecordingNotification(dispatch, getState, false);
         }
     }
 /**
  * Notify external application (if API is enabled) that transcribing has started or stopped.
  *
+ * @param {Function} getState - The Redux state.
  * @param {boolean} on - True if transcribing is on, false otherwise.
  * @returns {void}
  */
-function notifyTranscribingStatusChanged(on: boolean) {
+function notifyTranscribingStatusChanged(getState: IStore['getState'], on: boolean) {
     if (typeof APP !== 'undefined') {
+        const state = getState();
+        const isRecording = isRecordingRunning(state);
+        const isStreaming = isLiveStreamingRunning(state);
+        const mode = isRecording ? JitsiRecordingConstants.mode.FILE : JitsiRecordingConstants.mode.STREAM;
+
+        APP.API.notifyRecordingStatusChanged(isRecording || isStreaming, mode, undefined, on);
         APP.API.notifyTranscribingStatusChanged(on);
     }
 }