Data Sharing Between Apps

Overview

The Channels are globally accessed named contexts that allow users to dynamically group apps, instructing them to work over the same shared data object. The Channels API enables you to:

  • discover Channels - get the names and contexts of all Channels;
  • navigate through Channels - get the current Channel, join and leave Channels, subscribe for the event which fires when the current Channel has changed;
  • publish and subscribe - publish data to other apps on the same Channel and subscribe for Channel updates to react to data published by other apps;

Channels are based on Shared Contexts. A context object may contain different types of data, e.g. ids, displayName, etc.:

{
    "contact": {
        "ids": [
            {
                "systemName": "iosfId",
                "nativeId": "0031r00002IukOxAAJ"
            },
            {
                "systemName": "rest.id",
                "nativeId": "0e23375b-dd4f-456a-b034-98ee879f0eff"
            }
        ],
        "displayName": "Nola Rios",
        "name": {
            "lastName": "Rios",
            "firstName": "Nola",
            "otherNames": null,
            "honorific": "Ms.",
            "postNominalLetters": null
        }
    }
}

Different apps on the same Channel may use different parts of the data. A "Client List" app, for example, may update the context object with data for the selected user (ids, displayName, etc.). A "Portfolio" app may use the ids to load the portfolio of the client that the user has selected in the "Client List" app.

The Channels API is accessible through the io.channels object.

The Live Examples section demonstrates using the Channels API. To see the code and experiment with it, open the embedded examples directly in CodeSandbox.

Defining Channels

The Channels are enabled by default for all apps in an io.Connect Browser project. If you decide to migrate your app to io.Connect Desktop, no code change will be necessary as the Channels will be automatically enabled for your app there as well.

Use the channels property of the configuration object when initializing the @interopio/browser-platform library in the Main app to define the Channels that will be available for your project:

import IOBrowserPlatform from "@interopio/browser-platform";

const config = {
    licenseKey: "my-license-key",
    channels: {
        // Channel definitions.
        definitions: [
            {
                name: "Red",
                meta: {
                    color: "red"
                },
                data: { io: 42 }
            },
            {
                name: "Green",
                meta: {
                    color: "#008000"
                }
            }
        ]
    }
};

const { io } = await IOBrowserPlatform(config);

The only required properties in a Channel definition object are name and color. The color property expects an HTML color name or a hex value. You can add any number of additional custom properties to the meta object. The data property holds context data specific to the Channel.

Current Channel

To get the name of the Channel to which your app is currently joined, use the my() method:

const myChannel = io.channels.my();

All Channels

To get a list of all Channel names, use the all() method:

const channelNames = await io.channels.all();

Join & Leave Channels

To make your app join a Channel programmatically, use the join() method and specify the name of the Channel to join:

await io.channels.join("Red");

To leave the Channel your app is currently on, use the leave() method:

await io.channels.leave();

Retrieving Channel Context

To get the context of a Channel, use the get() method which accepts a Channel name as a required parameter:

const data = await io.channels.get("Green");

To get a list of the contexts of all Channels, use the list() method:

const channelContexts = await io.channels.list();

Subscribing for Channel Updates

To track the data in the current Channel, use the subscribe() method:

const handler = (data, channelInfo) => {
    // The callback will be invoked each time the data is updated.
    console.log(data);
};

// Subscribe for updates from the Channel your app is currently on.
io.channels.subscribe(handler);

The callback receives the data from the Channel and information about the current Channel.

The callback will be invoked in three cases:

  • the data property of the Channel you are currently on is updated;
  • the user has switched the Channel and you are receiving a snapshot of the new Channel data;
  • your app isn't joined to a Channel anymore (e.g., the user has deselected the current Channel). In this case, both data and channelInfo will be undefined;

To subscribe for updates from a specific Channel, use the subscribeFor() method:

const channelName = "Green";
const handler = (data, channelInfo) => {
    // The callback will be invoked each time the data is updated.
    console.log(data);
};

await io.channels.subscribeFor(channelName, handler);

The subscribeFor() method accepts a Channel name as a first parameter and a callback to handle Channel data updates.

Use the unsubscribe function returned by subscribe() and subscribeFor() to stop tracking updates of the Channel data:

const unsubscribe = await io.channels.subscribeFor(channelName, handler);

unsubscribe();

The handlers passed to the subscribe() and subscribeFor() methods also accept the Channel context and the updating Interop Instance peer ID as second and third arguments. The ChannelContext object contains the name of the Channel and the Channel meta data, and the updating Interop instance peer ID can be used to identify the app updating the Channel:

const handler = (data, channelContext, updaterID) => {
    // Check the current Interop instance peer ID against the updating instance ID.
    const isUpdatedByMe = io.interop.instance.peerId === updaterID;

    if(!isUpdatedByMe) {
        // Another app has published in the Channel.
        console.log(`App "${updaterID}" has published "${JSON.stringify(data)}" in Channel "${channelContext.name}".`);
    };
};

io.channels.subscribe(handler);

Publishing Data

To update the context of the Channel, use publish(). The publish() method accepts two parameters - data to publish (required) and an optional Channel ID specifying which Channel context to update. If you don't specify a Channel ID, the current Channel will be updated.

Updating the current Channel:

const data = { RIC: "VOD.L" };

await io.channels.publish(data);

Updating a specific Channel:

const data = { RIC: "VOD.L" };
const channelName = "Green";

await io.channels.publish(data, channelName);

Note that a Channel may contain multiple data structures, e.g. RIC and clientId. When executing the code above, only the RIC field will be updated, leaving the other fields of the context unchanged.

The publish() method will throw an exception if your app isn't on a Channel and tries to publish data.

Channel Events

If you want to monitor how your app moves between Channels, subscribe for updates with the onChanged() method:

const handler = (newChannel) => {
    if (newChannel) {
        // Handle the case where you have switched to another Channel.
        console.log(newChannel);
    } else {
        // Handle the case where your app isn't joined to any Channel
        // (e.g., the user has deselected the current Channel).
        console.log("No Channel selected.")
    };
};

io.channels.onChanged(handler);

Live Examples

Discover and Navigate

The app below demonstrates how to navigate through the available Channels using the join() and leave() methods of the Channels API. An app can be part of only one Channel at a time. The example app also demonstrates how to get the context (name, meta, data) of any Channel using the get() method. Discovering the available Channels is achieved using the all() method.

The background color of the example app reflects the color of the current Channel. Click on the "Get" button to log the context data of the selected Channel.

Open in CodeSandbox

Publish and Subscribe

Once multiple apps are on the same Channel, they can communicate by publishing and subscribing data to the Channel. This is achieved through the shared context data object that the apps monitor using the subscribe() method of the Channels API and/or update using the publish() method. The callback provided to subscribe() is invoked when the context of the Channel that the app is currently on has been updated.

When the two apps below are on the same Channel, App B can publish data that is received and logged by App A if it has subscribed for updates of the current Channel. Note that if the apps aren't on the same Channel, or if App A hasn't subscribed for updates, the apps won't exchange any data.

Open in CodeSandbox

Channel Selector UI

To allow the users of your io.Connect Browser app to use the available Channels, you will need to provide them with some sort of UI. Below are examples of Channel Selector widgets developed using the Channels API and some of the most popular libraries and frameworks.

Note that these widgets are only examples. Feel free to use them as they are or as a reference to create your own Channel Selector. io.Connect Desktop ships with a fully functioning Channel Selector that all apps with enabled Channels can use.

JavaScript

The example below uses a custom jQuery Selectmenu widget:

Open in CodeSandbox

Reference

For a complete list of the available Channels API methods and properties, see the Channels API Reference Documentation.