snapshot of https://github.com/jitsi/jitsi-meet.git @ fd1749dd28f4138aa80234fc7f311b19aaffa0e7 (2026-09-15)

react/features/virtual-background/actions.ts

@@ -0,0 +1,166 @@
+import { IStore } from '../app/types';
+import { showWarningNotification } from '../notifications/actions';
+import { NOTIFICATION_TIMEOUT_TYPE } from '../notifications/constants';
+import { createVirtualBackgroundEffect } from '../stream-effects/virtual-background';
+
+import { BACKGROUND_ENABLED, SET_VIRTUAL_BACKGROUND } from './actionTypes';
+import { VIRTUAL_BACKGROUND_TYPE } from './constants';
+import logger from './logger';
+import { IVirtualBackground } from './reducer';
+
+/** Minimal shape of a JitsiLocalTrack needed for effect management. */
+interface IJitsiTrack {
+    setEffect: (effect?: Object) => Promise<void>;
+}
+
+/** Track parameter type — accepts the JitsiLocalTrack, Object (from legacy callers), or null. */
+type TrackParam = IJitsiTrack | Object | null | undefined;
+
+/**
+ * Reverts the virtual background Redux state, clears the effect on the track, and shows an
+ * error notification. Shared by the init-failure and runtime-failure paths.
+ *
+ * @param {Function} dispatch - Redux dispatch.
+ * @param {IVirtualBackground} prevBackground - State snapshot taken before the failed toggle.
+ * @param {IJitsiTrack} jitsiTrack - The video track to clear the effect from.
+ * @param {string} reason - Human-readable reason for the failure (logged, not shown in UI).
+ * @returns {Promise<void>}
+ */
+async function handleEffectFailure(
+        dispatch: IStore['dispatch'],
+        prevBackground: IVirtualBackground,
+        jitsiTrack: TrackParam,
+        reason: string): Promise<void> {
+    logger.error(`[VirtualBackground] Effect failure: ${reason}`);
+
+    dispatch(backgroundEnabled(prevBackground.backgroundEffectEnabled));
+    dispatch(setVirtualBackground(prevBackground));
+
+    if (jitsiTrack) {
+        try {
+            await (jitsiTrack as IJitsiTrack).setEffect(undefined);
+        } catch (cleanupErr) {
+            logger.warn('[VirtualBackground] Failed to clear effect after failure:', cleanupErr);
+        }
+    }
+
+    dispatch(showWarningNotification(
+        { titleKey: 'virtualBackground.backgroundEffectError' },
+        NOTIFICATION_TIMEOUT_TYPE.LONG
+    ));
+}
+
+/**
+ * Signals the local participant activate the virtual background video or not.
+ *
+ * @param {Object} options - Represents the virtual background set options.
+ * @param {Object} jitsiTrack - Represents the jitsi track that will have backgraund effect applied.
+ * @returns {Promise}
+ */
+export function toggleBackgroundEffect(options: IVirtualBackground, jitsiTrack: TrackParam) {
+    return async function(dispatch: IStore['dispatch'], getState: IStore['getState']) {
+        const prevBackground = getState()['features/virtual-background'];
+
+        dispatch(backgroundEnabled(options.backgroundEffectEnabled));
+        dispatch(setVirtualBackground(options));
+        const state = getState();
+        const virtualBackground = state['features/virtual-background'];
+
+        if (jitsiTrack) {
+            const track = jitsiTrack as IJitsiTrack;
+
+            try {
+                if (options.backgroundEffectEnabled) {
+                    const effect = await createVirtualBackgroundEffect(virtualBackground);
+
+                    if (effect) {
+                        effect.onInferenceFailure = () => {
+                            handleEffectFailure(dispatch, prevBackground, jitsiTrack,
+                                'persistent inference failure');
+                        };
+                    }
+
+                    await track.setEffect(effect);
+                    if (effect) {
+                        await effect.initPromise;
+                    }
+                } else {
+                    await track.setEffect(undefined);
+                    dispatch(backgroundEnabled(false));
+                }
+            } catch (error) {
+                await handleEffectFailure(dispatch, prevBackground, jitsiTrack,
+                    String(error));
+            }
+        }
+    };
+}
+
+/**
+ * Sets the selected virtual background image object.
+ *
+ * @param {Object} options - Represents the virtual background set options.
+ * @returns {{
+ *     type: SET_VIRTUAL_BACKGROUND,
+ *     virtualSource: string,
+ *     blurValue: number,
+ *     type: string,
+ * }}
+ */
+export function setVirtualBackground(options?: IVirtualBackground) {
+    return {
+        type: SET_VIRTUAL_BACKGROUND,
+        virtualSource: options?.virtualSource,
+        blurValue: options?.blurValue,
+        backgroundType: options?.backgroundType,
+        selectedThumbnail: options?.selectedThumbnail
+    };
+}
+
+/**
+ * Signals the local participant that the background effect has been enabled.
+ *
+ * @param {boolean} backgroundEffectEnabled - Indicate if virtual background effect is activated.
+ * @returns {{
+ *      type: BACKGROUND_ENABLED,
+ *      backgroundEffectEnabled: boolean
+ * }}
+ */
+export function backgroundEnabled(backgroundEffectEnabled?: boolean) {
+    return {
+        type: BACKGROUND_ENABLED,
+        backgroundEffectEnabled
+    };
+}
+
+/**
+ * Simulates blurred background selection/removal on video background. Used by API only.
+ *
+ * @param {JitsiLocalTrack} videoTrack - The targeted video track.
+ * @param {string} [blurType] - Blur type to apply. Accepted values are 'slight-blur', 'blur' or 'none'.
+ * @param {boolean} muted - Muted state of the video track.
+ * @returns {Promise}
+ */
+export function toggleBlurredBackgroundEffect(videoTrack: TrackParam, blurType: 'slight-blur' | 'blur' | 'none',
+        muted: boolean) {
+    return async function(dispatch: IStore['dispatch'], _getState: IStore['getState']) {
+        if (muted || !videoTrack || !blurType) {
+            return;
+        }
+
+        if (blurType === 'none') {
+            dispatch(toggleBackgroundEffect({
+                backgroundEffectEnabled: false,
+                selectedThumbnail: blurType
+            }, videoTrack));
+        } else {
+            dispatch(toggleBackgroundEffect({
+                backgroundEffectEnabled: true,
+                backgroundType: VIRTUAL_BACKGROUND_TYPE.BLUR,
+                blurValue: blurType === 'blur' ? 25 : 8,
+                selectedThumbnail: blurType
+            }, videoTrack));
+        }
+    };
+}
+