What’s new in Unblu Spark 8

UI improvements

The UIs in Unblu 8 have been improved in a number of areas. The changes focus on making it easier to conduct online meetings in Unblu and improving usability when using multiple channels at once, for example, video call and chat messenger.

Some of the improvements for multimodal uses are:

How the screen is shared between different types of content has been improved. This makes it easier for users to access relevant information in different user interface elements, such as video calls and the chat messenger, at the same time.
The call UI and collaboration space now share a unified UI.
In the call UI, the menu to launch a collaboration layer now appears with the other call controls at the bottom of the screen.
The UI now supports Picture-in-picture (PiP) mode when collaborating during a call. (This feature is only available when using Google Chrome or Microsoft Edge.)

The Agent Desk has been improved in several additional ways:

The unified control bar at the top of a conversation tab makes it easier to find controls in conversations.
The new context bar on right collates information relating to the ongoing conversation. Clicking an icon in the context bar opens the information in a panel, keeping the ongoing call or conversation in view.
The new participant context panel gives agents quick access to information about conversation participants. It also lets agents invoke actions on participants.
In video calls, the view of the agent is larger and can be moved around.

New file upload mechanism

With Unblu 7, files uploaded to Unblu chats were sent to the Collaboration Server with the content type multiform/data. This made it impossible to display any visual feedback to conversation participants, such as an upload progress bar or a status message if the file had to be scanned before being made available in the chat.

In Unblu Spark 8, files are uploaded with the content type application/octetstream. Now, Unblu can display a progress bar during the upload. If you process files in some way before making them available to conversation participants, for example by sending them to an antivirus scanner, Unblu Spark can now accept and forward information about the process’s progress to participants. These improvements make for a better user experience.

The new file upload mechanism is used for uploads from all origins: the Unblu UIs, the Unblu web API, or uploads to the headless browser used for co-browsing. This makes it easier to process file uploads consistently.

If you used a web application firewall (WAF) rule to divert uploaded files to an antivirus scanner, you must make changes to your configuration. For more information, refer to Changes to file uploads.

Native document co-browsing

In previous versions of Unblu, when users wanted to collaborate on, say, a PDF file, Unblu spun up an instance of the Rendering Service. Conversation participants collaborated by interacting with the headless browser running on the Rendering Service.

Unblu Spark 8 comes with a completely new native document co-browsing feature based on the Apryse WebViewer, a JavaScript library that runs on the client of each participant. The Collaboration Server manages the state of the document the same way it does so during embedded co-browsing sessions and is responsible for synchronizing that state among the participants in the collaboration.

Native document co-browsing not only reduces the resources that your organization must provision to run document co-browsing sessions. The WebViewer library also comes with a greater variety of collaboration tools that make native document co-browsing a more interactive experience.

If you want to continue to use server-based document co-browsing, set com.unblu.documentcobrowsing.technology to RENDERING_SERVICE.

Outbound conversations

Until now, when agents initiated a conversation, they couldn’t add specific visitors to the conversation while creating the conversation.

Agents could invite specific agents or teams to join the conversation after it was created. For visitors, however, an agent’s only options were sending visitors a PIN or a link through some communication channel other than Unblu.

Unblu Spark 8 lets agents initiate conversations with specific participants. Depending on how Unblu Spark is configured, they can do so from the Plus menu in the Agent Desk or from a participant’s information panel in an existing conversation. Which visitors an agent can create outbound conversations with is defined by the visibility rules that specify which visitors they can see.

With the necessary permissions, agents can even create new visitor persons to initiate conversations with.

Outbound conversations can use Unblu Spark or an external messenger such as WhatsApp.

Person labels, visibility rules, and conversation visibility

Person labels allow you to assign agents and visitors to categories. For example, you might use person labels to specify which client segment or segments an agent may deal with, or how high you rate a client’s upsell potential.

You can set and read person labels in the Unblu UIs and through the web API and JS APIs. You can also specify which participant types may set and access person labels.

Visibility rules

Visibility rules leverage person labels to give you fine-grained control over which agents and visitors can interact with one another. They restrict which visitors agents can start outbound conversations with.

The queue isn’t affected by visibility rules.

Conversation visibility

In Unblu 7, conversations were private and only visible to participants. With the introduction of visibility rules in Unblu Spark 8, you can use visibility rules to specify that conversations based on a conversation template should be visible to any agent who can see the context person.

New configuration entities

Because of the extent to which Unblu Spark is customizable, each entity has a large number of configuration and text properties. This could be an issue for database migrations with lots of conversations, for example, since each conversation receives a copy of the configuration and properties of the conversation template it was created from.

In Unblu Spark 8, configuration and text properties are stored in separate configuration entities. These configuration entities are then referenced by the entities that use the configuration. If two entities have the same configuration, they can reference the same configuration entity.

Conversation configuration inheritance

In previous versions of Unblu, conversation templates served as static blueprints for the configuration of new conversations: when someone created a new conversation from a template, all the template’s configuration and text properties were copied to the conversation.

With the introduction of configuration entities, conversations can now refer directly to the configuration entity of the conversation template they were created from. Any changes you make to the template’s configuration are then automatically inherited by conversations created from that template. This makes it easier to propagate configuration changes—to long-running conversations, for example—and improves database migration efficiency.

If you want conversations to have their own configuration entities, you can disable configuration inheritance on the conversation templates the conversations are created from.

When you create a conversation using the Unblu web API, you can specify whether the conversation should inherit changes to properties of the template it’s based on independently of the template’s setting in this regard. For example, you can specify that the conversation should inherit changes to the template’s properties, even though the conversation template it was created from states that conversations don’t inherit changes to its properties.

Supported browser versions

Starting with Unblu Spark 8, which browser versions are supported is defined in a more dynamic way, based on the versions supported by the respective browser vendors. For more information, refer to the tables in the Supported browsers section of Browser requirements.