Settings Lists

1 Motivation
2 How do Settings Lists Work?
3 In-Depth Usage
- 3.1 Manifest Setting List Implementation
- 3.2 Exhibit Manipulation
- 3.3 Backend Data Flow
4 Manual Retrieval

Motivation

Often when an exhibit requires some form of presets, the developer will need a way to represent many instances of identically structured groups of settings. For example, imagine a simple exhibit that controls a lighting system where the goal is to change the state of the lights with different presets. Sounds simple enough; just use a Dropdown setting type where the user can select one of the many preconfigured presets:

export const MANIFEST = {
    manifest: {
        statuses: [ ... ],
        controls: [ ... ],
        settings: [
			{
                id: "lighting-presets",
                type: "Dropdown",
                display: "Lighting Preset",
                items: [
                    {
                      id: "morning",
                      display: "Morning",
                      order: 0
                    },
                    {
                      id: "afternoon",
                      display: "afternoon"
                    },
                    {
                      id: "evening",
                      display: "Evening"
                    }
                ]
            }
        ]
    }
}

But what if an additional preset is added to the lighting system after the exhibit is installed? Then the exhibit developer must manually add this preset to the manifest:

export const MANIFEST = {
  manifest: {
      statuses: [ ... ],
      controls: [ ... ],
      settings: [
    {
              id: "lighting-presets",
              type: "Dropdown",
              display: "Lighting Preset",
              items: [
                  [...]
                  {
                    id: "after-hours",
                    display: "After Hours"
                  }
              ]
          }
      ]
  }
}

So if more presets need to be added post-installation, this setup requires a considerable effort to update the exhibit over its lifecycle.

Settings Lists solve this problem by allowing a developer to define groups of settings that can be dynamically created and modified after exhibit installation.

How do Settings Lists Work?

Setting Lists enable the dynamic creation of settings in the Gumband UI by following a pre-defined schema in the manifest. The schema of the Setting List is essentially the class definition of each item the Setting List contains, which defines the Setting fields and types that should be present in each new Setting List item instance. Once the schema is defined in the manifest, Setting List item instances can be manipulated through the Gumband UI. When these instances are created, modified, or deleted, the Gumband platform sends signals to the exhibit’s NodeJS SDK with the updated changes.

In-Depth Usage

For this example, imagine an exhibit that takes a few pieces of data to configure different presets for a Digital Signage display.

Manifest Setting List Implementation

Settings Lists are defined in the Manifest file in a similar manner to top-level settings. The only difference is that they require an additional property to define the schema; an array of settings.

export const MANIFEST = {
  manifest: {
      statuses: [ ... ],
      controls: [ ... ],
      settings: [
        {
          id: "screens",
          type: "SettingsList",
          display: "Screens",
          order: 0, // optional
          schema: [ // any Gumband setting types can be included
            {
                id: "bkg_img",
                type: "FileSelection",
                display: "Background Image",
                order: 0
            },
            {
                id: "header",
                type: "TextInput",
                display: "Header",
                order: 1
            },
            {
                id: "body",
                type: "TextInput",
                display: "Body",
                order: 2
            }
          ]
        },
      ],
  }
}

Exhibit Manipulation

Once added to the manifest and with the exhibit running, the Settings List will appear as its own setting on the Settings Page. The (0) indicates that there are currently no instances of list items in the Screens SettingsList. Click it to view, create, and modify list items.

Create a new Setting List item by clicking the Create New button, which will open a modal.

Backend Data Flow

Upon list item creation, a new, blank instance of a Screens Setting List item called “Welcome Screen” will appear in the UI. This creation also triggers event triggers a SETTING_LIST_RECEIVED callback to be fired in the Exhibit’s NodeJS SDK application:

The settings within the Welcome Screen list items are just like any other setting. Simply edit the fields and save.

When you click the Save button, your Exhibit’s NodeJS SDK application will receive data as shown above, through the SETTING_RECEIVED callback’s payload variable:

This callback is fired for each individual Setting modified, which means that if fields in more than one Setting List item instance are updated, you’ll receive them all as individual setting callbacks, in potentially any order:

Manual Retrieval

It is also possible to retrieve SettingsList instances manually.

With two Setting List items in the Screens SettingsList, the following code will deliver JSON-formatted data of the SettingsList schema followed by the items themselves with all associated data.

Individual Settings within each setting list item can be retrieved and modified manually as well:

The sdk version 1.0.45 introduced features that allowed the above example to work as shown. However, previous versions of the sdk were unable to find settings contained within settings lists without the exhibit developer implementing a workaround. If you are using sdk version 1.0.44 or lower, you must implement something similar to following workaround to manually read and write settings contained within SettingLists.

The key logic for this method of retrieving and saving a SettingsList item setting is to first get its id value, as listed in the previous gb.getAllSettingLists() example, above. With this id, you can retrieve or save the Setting value through a modified command: gb.exhibit.getSetting(<id>).

The following example assumes the exhibit has a single Setting List.

You can also update the Setting value through a similar mechanism:

With these callbacks and access functions provided by the NodeJS SDK, it becomes a breeze to respond to setting changes in real time or retrieve and update the List elements as a single-point-of-truth. To provide a robust means of storing intricate data, it’s possible to nest a SettingsList inside the schema of another in the Manifest. Currently up to Two levels of SettingsList nesting are supported. For example, the following modification to our original Manifest would allow any number of Images to be added to any particular Screen SettingsList instance.