Jitsi Meet Electron

The application uses the window.jitsiNodeAPI.ipc interface to communicate with the Electron main process.

To handle incoming protocol URLs (e.g., when a user clicks a Jitsi link), the App component listens for the protocol-data-msg event. When a message is received, it follows this workflow:

1. Cleans the input URL.
2. Creates a conference object using createConferenceObjectFromURL.
3. Dispatches an action to add the conference to the recent list.
4. Sends the open-meeting-window command to the main process with the conference details.

Available IPC methods used by App:

• window.jitsiNodeAPI.ipc.addListener('protocol-data-msg', callback): Registers a listener for protocol data.
• window.jitsiNodeAPI.ipc.send('renderer-ready'): Notifies the main process that the renderer is initialized.
• window.jitsiNodeAPI.ipc.send('open-meeting-window', conference): Commands the main process to open the meeting window.

The default configuration object provides metadata for the application (names, URLs) and default connection settings for Jitsi Meet deployments.

Key configuration properties include:

• appName: The display name of the application.
• appProtocolPrefix: The prefix used for the application's custom protocol (e.g., jitsi-meet://). Note that this must also be updated in package.json to ensure consistency.
• defaultServerURL: The fallback Jitsi Meet deployment URL used if no other server is specified.
• defaultServerTimeout: The timeout duration in seconds for server connections.
• aboutURL, sourceURL, feedbackURL, privacyPolicyURL, and termsAndConditionsURL: URLs for informational and support pages.

export default {
    aboutURL: 'https://jitsi.org/what-is-jitsi/',
    sourceURL: 'https://github.com/jitsi/jitsi-meet-electron',
    appName: 'Jitsi Meet',
    appProtocolPrefix: 'jitsi-meet',
    defaultServerURL: 'https://meet.jit.si',
    defaultServerTimeout: 30,
    feedbackURL: 'https://github.com/jitsi/jitsi-meet-electron/issues',
    privacyPolicyURL: 'https://jitsi.org/meet/privacy',
    termsAndConditionsURL: 'https://jitsi.org/meet/terms'
};

When managing a meeting window (the window hosting the Jitsi Meet iframe), you must initialize several SDK handlers from @jitsi/electron-sdk to enable core features. These handlers should be called on the meetingWindow instance.

Key handlers include:

• initPopupsConfigurationMain(window, windowOpenHandler): Configures how popups are handled. The windowOpenHandler determines if a URL should be opened in the Electron app or an external browser.
• setupPictureInPictureMain(window): Enables Picture-in-Picture functionality.
• setupPowerMonitorMain(window): Monitors power states.
• setupScreenSharingMain(window, appName, appId): Sets up screen sharing capabilities. Requires the application name and the build's appId.
• setupRemoteControlMain(window): Enables remote control (requires ENABLE_REMOTE_CONTROL to be true in the source configuration).

// Example setup for a meeting window
initPopupsConfigurationMain(meetingWindow, windowOpenHandler);
setupPictureInPictureMain(meetingWindow);
setupPowerMonitorMain(meetingWindow);
setupScreenSharingMain(meetingWindow, config.appName, pkgJson.build.appId);
if (ENABLE_REMOTE_CONTROL) {
    setupRemoteControlMain(meetingWindow);
}

When using initPopupsConfigurationMain, you must provide a windowOpenHandler to decide how new windows/popups are treated. This prevents unauthorized external navigation and ensures Jitsi-specific popups stay within the Electron environment.

Logic pattern:

1. Use getPopupTarget(url, frameName) from @jitsi/electron-sdk to identify the target.
2. If the target is 'electron', return { action: 'allow' }.
3. If the target is 'browser' or undefined, return { action: 'deny' } and manually open the link using openExternalLink(url) to handle it in the user's default browser.

const windowOpenHandler = ({ url, frameName }: { frameName: string; url: string; }) => {
    const target = getPopupTarget(url, frameName);

    if (!target || target === 'browser') {
        openExternalLink(url);
        return { action: 'deny' };
    }

    if (target === 'electron') {
        return { action: 'allow' };
    }

    return { action: 'deny' };
};

The main process listens for specific IPC messages from the renderer process to manage the lifecycle of the meeting window:

• open-meeting-window: Creates a new meetingWindow (if one doesn't exist) or focuses the existing one and sends a navigate-to-conference message with the provided conference string.
• close-meeting-window: Closes the meetingWindow. Note that closing the meeting window does not quit the entire application; the launcher (mainWindow) remains open.
• restore-meeting-window: Restores and focuses the meetingWindow (useful when returning from Picture-in-Picture).
• jitsi-open-url: Triggers the opening of an external URL via openExternalLink.

// Example of the IPC listeners in main.ts
ipcMain.on('open-meeting-window', (event, conference) => {
    // ... logic to create or focus meetingWindow
});

ipcMain.on('close-meeting-window', () => {
    if (meetingWindow) {
        meetingWindow.close();
    }
});