Content Discovery

Content Discovery refers to all of the ways that users can discover your app's content on the Platform.

The Platform is constantly improving the ways that content can be discovered, this includes:

• Search: Aggregated Experience Voice

• Search: In-app Voice

• Search: Traditional

• Menu: Editorially cultivated

• Menu: Continue Watching

• Menu: Watch Next

• And more...

Integrating your app with the Content Discovery module is an easy way to give your users an experience they’ll want to engage in over and over.

Full Content Discovery integration consists of the following:

Metadata integration

Asset metadata is required to utilize many content discovery features. Asset metadata describes all the relevant, useful, and important information about a media asset. The metadata you provide is used to directly populate the presentation and discovery of your content on the Platform.

See Metadata Integration for more info.

Navigation intents

In order to enable faster app launches, Firebolt may keep your app loaded even while it's not in use. In order to support "deep links," (ie: opening your app to a specific piece of content that the user selected) your app will need to integrate with the Firebolt Navigation Intents feature.

This integrates your app with basic content discovery features for both deep links as well as in-app search.

See Deep Linking and Navigation Intents for more info.

Continue watching

The Continue Watching feature helps to drive traffic back into your app from an aggregated experience. By pushing viewing progress to the continue watching API, your app enables aggregated experiences to create prominent calls-to-action to resume that content, or watch the next piece of content in a grouping (e.g., the next episode of a TV season).

Enabling this feature is as simple as calling the Discovery.watched() method whenever a user is watching content in your app:

import { Discovery } from '@firebolt-js/sdk'

Discovery.watched(entityId, progress)

You can also specify if the content should be considered fully watched, which prevents users from being relaunched into the credits of a movie, for example:

Discovery.watched(entityId, progress, true)

Lastly, you can specify the date/time at which the content was watched, in order to update the Firebolt "Continue Watching" feature with viewings that have occurred on other platforms:

Discovery.watched(entityId, progress, true, '1995-12-17T03:24:00')

Through Discovery.watched(), users are able to see:

• A log of previously watched content.

• The next episode of a previously watched series.

• quickly jump back and forth to their recently watched content

See the Discovery.watched() API documentation for a complete description of the parameters and how to use them.

Metrics vs Discovery calls

• Metrics calls such as Metrics.mediaProgress() monitor the overall health and performance of your app.

• Discovery calls such as Discovery.watched() enhance personalization and user experience by logging watch history and enabling features like Continue Watching, Resume Points, and Automated Rails.

Consumption data sharing requirements

Providing consumption (viewing) data via the Discovery.watched() API enables multiple product features focused on customer navigation and content resumption, detailed below.  

The first resume point needs to be sent 10 seconds into a given item being watched by a customer. This threshold is based on an aggregate of customer viewing behavior across the UI. Discovery.watched() calls should then be sent every 60 seconds during playback, to allow the most up to date resume point data for customers.

Entitlements push

Entitlements Push allows aggregated experiences to promote your app's content to drive users back into your app.

While your app may simply grant a single entitlement of your entire catalog to all of your users, aggregated experiences generally won't assume so.

By providing a list of entitlements that the current user has, aggregated experiences can be sure to only promote content that won't be gated by a purchase once your app is launched.

To push the current user's entitlements, call Discovery.contentAccess():

import { Discovery } from '@firebolt-js/sdk'
let result = await Discovery.contentAccess({
 entitlements: [
   {
     "entitlementId": "partner.com/entitlement/123",
     "startTime": "2021-04-23T18:25:43.511Z",
     "endTime": "2021-04-23T18:25:43.511Z"
   }
 ],
})
console.log(result)

Note for X1 and other legacy devices

X1 and legacy devices use Discovery.entitlements() to push user entitlements, but this functionality may be deprecated in the future. It is better to use Discovery.contentAccess() where possible.

Sign-in/out push

Sign-in/out Push allows aggregated experiences to know when a user is signed in or out. This might seem like a minor detail, but in order to respect privacy concerns, it's very important that aggregated experiences no longer promote content to a user that is no longer logged in!

Whenever your user signs in or out of the app, just call the corresponding Firebolt API so that aggregated experiences can respect user privacy:

Discovery.signIn()

or

Discovery.signOut()

The Discovery.signIn() method also supports an array of entitlements, just like Discovery.contentAccess(), as a convenience, so your app can update entitlements whenever your user signs in:

Discovery.signIn([
                    {
                    "entitlementId": "partner.com/entitlement/123",
                    "startTime": "2021-04-23T18:25:43.511Z",
                    "endTime": "2021-04-23T18:25:43.511Z"
                    },
                    {
                    "entitlementId": "partner.com/entitlement/456",
                    "startTime": "2021-04-23T18:25:43.511Z",
                    "endTime": "2021-04-23T18:25:43.511Z"
                    }
                ])
    .then(success => {
        console.log(success)
    })