How to communicate between Electron and Swift application using Notifications

There are several ways to communicate between desktop apps which include REST API’s, websockets, system notifications and so on… This post I will focus particularly on a simple way to send data back and forth between a electron app and swift app — who would’ve thought this was an actual scenario I encountered at work.

Electron exposes in their API post and subscription notification methods that make listening/receiving global events simple. Likewise, Swift has CFNotificationCenter which allows global OS events to be posted/received. Do not confuse with NotificationCenter as that is limited to the events within the context of the Swift app.

In a nutshell, all we need to do is setup post and subscribe methods in both Electron and Swift apps to establish two-way communication.

Setup Post & Subscribe Methods in Electron

In the main process file in Electron (usually main.js) we want to import the systemPreferences API from Electron.

I would typically place my post and subscribe methods in the app.whenReady() code block. Below is a sample code block of the post and subscribe function setup.

1import {systemPreferences} from "electron"
2
3app.whenReady().then(async () => {
4   
5  systemPreferences.subscribeNotification(
6        "subscribeEvent",
7        (event, userInfo) => {
8          console.log(userInfo);
9        },
10    );
11  
12   // you would probably embed this in a ipcMain event call to hook up to UI
13  systemPreferences.postNotification(
14      "postEvent",
15      {
16       // some data
17        foo: "bar"
18      },
19      true,
20  );
21})
Copy

According to the Electron docs, systemPreferences.postNotification takes 3 arguments, event name (string), data to be sent (object) and boolean flag to deliver immediately or not.

systemPreferences.subscribeNotification takes 3 arguments, event name (string), and a callback which exposes the event and the data being received.

Setup Post & Subscribe Methods in Swift

Similar to the Electron setup, we would create a notification listener and specific functions to post notifications to Electron — you can also post notifications upon receiving them.

You can place the listener or post notification function anywhere, however, for simplicity you can test it by placing it in the AppDelegate. Find below some sample code to subscribe/post global notifications in Swift.

1// AppDelegate.swift
2
3// subscription listener subscribing to "some-event-name" posted by Electron or other app
4func observer() {
5    CFNotificationCenterAddObserver(CFNotificationCenterGetDistributedCenter(), Unmanaged.passRetained(self).toOpaque(), observerCallback, "some-event-name" as CFString , nil, .deliverImmediately)
6}
7
8// the listener callback - do something when you receive "some-event-name" event.
9let observerCallback: CFNotificationCallback = { center , observer, name, object, info in
10    // perform check on incoming data to see if it exists as a dictionary (object sent from javascript)
11    if let data = info as? Dictionary<String, Any> {
12     // Check if value present before using it
13      guard let method = data["foo"] as? String else { return }
14      print(method)
15      // we can also post a event back
16      postNotification()
17    } else {
18      print("Could not parse incoming data")
19    }
20  }
21
22func postNotification() {
23  // create notification event name that other apps will listen to
24  let notificationName: CFNotificationName = .init(rawValue: "some-event-name" as CFString)
25  // emit notification with data dictionary with key-value as String types
26  let data: [String:String] = ["foo":"bar"]
27  CFNotificationCenterPostNotification(CFNotificationCenterGetDistributedCenter(), NotificationName, nil, data as CFDictionary, true)
28}
Copy

Conclusion

I have demonstrated how to implement both post and subscribe methods for notifications in Electron and Swift. Obviously the logic is barebones so it is up to you to extend it for your use case.