Monitor Samsung Tizen

Samsung Tizen smart TVs expose device-level analytics through the Samsung Developer portal, but those metrics do not cover player-level QoE — buffering ratios, startup time, rendition switches, and error rates stay invisible unless you instrument the player directly. FastPix Video Data uses the @fastpix-core JavaScript SDK to capture these metrics from any HTML5-based player running inside a Tizen app, giving you the same QoE dashboard visibility you get on web and mobile. Install the SDK, pass your Workspace Key and player instance to fastpixMetrix.tracker(), and playback data flows to the FastPix dashboard.

Prerequisites

• A FastPix account with access to a workspace
• Your Workspace Key from the FastPix dashboard → Workspaces section
• A Samsung Tizen smart TV app project set up with HTML5, CSS, and JavaScript
• Tizen Studio installed on your development machine

NOTE

Test on a physical Samsung TV with Developer Mode enabled. The Tizen emulator may not fully support AVPlay or advanced video playback features.

Get your Workspace Key

1. Log in to the FastPix dashboard.
2. Navigate to the Workspaces section.
3. Copy the Workspace Key for the workspace you want to monitor.

Include this key in your JavaScript code on every page where you track video performance.

Use the FastPix Player (built-in analytics)

If your Samsung Tizen app uses the FastPix Player (@fastpix/fp-player), Video Data collection is built in, no separate SDK integration is needed. Add the <fastpix-player> element with your metadata-workspace-key attribute and data tracking starts on first play.

1
<fastpix-player
2
  playback-id="your-playback-id"
3
  metadata-workspace-key="your-workspace-key"
4
></fastpix-player>

For complete setup instructions and available metadata attributes, see Integrate Video Data with the player.

NOTE

If you use FastPix Player, skip the third-party integration sections. The sections that follow cover HLS.js, DASH.js, native HTML5, and AVPlay for apps that do not use FastPix Player.

Choose a third-party player integration

Samsung Tizen apps play video through HTML5-based JavaScript player SDKs or Samsung’s proprietary AVPlay API. For HTML5-based players, the setup code is the same as the standard web guide — follow the linked guide and apply the Tizen-specific considerations in the next section.

HLS.js

Install @fastpix-core via npm, create your HLS.js player instance, and pass both the player instance and the Hls constructor to fastpixMetrix.tracker() along with your workspace_id and metadata.

For complete setup instructions, code examples, and configuration options, see Monitor HLS.js.

DASH.js

Install @fastpix-core via npm, initialize your DASH.js MediaPlayer instance, and pass both the player instance and the dashjs module to fastpixMetrix.tracker() along with your workspace_id and metadata.

For complete setup instructions, code examples, and configuration options, see Monitor DASH.js.

Native HTML5 video element

Samsung Tizen TVs support HLS playback natively through the HTML5 <video> element without an external player SDK. Set the video source on the <video> element and pass it to fastpixMetrix.tracker() with your workspace_id and metadata. No hlsjs or dashjs option is needed — pass only the data object.

For the complete integration pattern and configuration options, see Monitor HTML5 video element.

Samsung AVPlay API

Samsung’s proprietary AVPlay API handles video decoding outside the HTML5 <video> element. Because @fastpix-core instruments standard DOM-based players, it cannot attach directly to AVPlay’s native pipeline. If your app uses AVPlay exclusively, the FastPix Video Data SDK does not support direct AVPlay monitoring at this time.

Workaround for hybrid apps: If your Tizen app renders the AVPlay video surface but manages playback state in JavaScript, you can create a hidden HTML5 <video> element, mirror AVPlay state changes (play, pause, seek, error) to it via JavaScript event dispatching, and pass that element to fastpixMetrix.tracker(). This provides approximate telemetry but does not capture rendition-level or buffer metrics from AVPlay’s internal pipeline.

Apply Tizen-specific considerations

The SDK code for HTML5-based players is identical to the standard web guides. Samsung Tizen apps have platform constraints that affect deployment, permissions, and testing.

Declare Tizen privileges

Your app’s config.xml must include the required privileges for network access and media playback:

1
<!-- config.xml -->
2
<tizen:privilege name="http://tizen.org/privilege/internet"/>
3
<tizen:privilege name="http://developer.samsung.com/privilege/avplay"/>
4
<tizen:privilege name="http://developer.samsung.com/privilege/drmplay"/>

NOTE

The avplay and drmplay privileges are required only if your app uses the Samsung AVPlay API. HTML5-based player integrations need only the internet privilege.

Manage memory

Samsung Tizen TVs have constrained resources:

• Destroy the player on exit: Call hls.destroy() (HLS.js), dashPlayer.reset() (DASH.js), or avplay.close() (AVPlay) when the viewer finishes a video session.
• Run one player instance at a time: Avoid creating multiple simultaneous instances.
• The FastPix SDK batches analytics events to minimize network overhead.

Handle remote control input

Tizen TV apps are controlled via remote control. Ensure you handle key events for playback controls (play, pause, stop, seek). The FastPix SDK automatically tracks playback state changes. For AVPlay-based apps, you will need to register media keys using tizen.tvinputdevice.registerKey() and handle the corresponding key codes in a keydown event listener.

1
// Register media keys
2
tizen.tvinputdevice.registerKey("MediaPlay");
3
tizen.tvinputdevice.registerKey("MediaPause");
4
tizen.tvinputdevice.registerKey("MediaStop");
5
6
// Handle key events
7
document.addEventListener("keydown", (e) => {
8
  switch (e.keyCode) {
9
    case 415: /* MediaPlay */  break;
10
    case 19:  /* MediaPause */ break;
11
    case 413: /* MediaStop */  break;
12
  }
13
});

The FastPix SDK automatically tracks playback state changes triggered by these controls.

Deploy and test with Developer Mode

1. Enable Developer Mode on your Samsung TV (Settings → Apps → Developer Mode).
2. Use Tizen Studio or the CLI to package and install:

$
# Package the app
$
tizen package -t wgt -s your-certificate -- .
$
$
# Install on the TV
$
sdb install MyApp.wgt

3. Set debug: true in the FastPix configuration to verify events in the Tizen Studio Web Inspector console.

Confirm network access

The TV must reach the FastPix data collection endpoints. On restricted networks, allowlist the FastPix data ingestion domain.

Tag views with metadata

All player integrations accept the same metadata fields inside the data object. Set custom_1 to "Samsung Tizen" and custom_2 to the player SDK name (for example, "HLS.js", "DASH.js", "AVPlay", "native-html5") so you can filter smart TV performance in the FastPix dashboard.

1
data: {
2
  workspace_id: "your-workspace-key",
3
  player_name: "Samsung Tizen HLS.js Player",
4
  custom_1: "Samsung Tizen",
5
  custom_2: "HLS.js"
6
}

Verify the integration

After deploying your app to a Samsung Tizen TV:

1. Set debug: true in the tracker configuration.
2. Open the Web Inspector in Tizen Studio to check for FastPix debug logs in the console.
3. Play a video and confirm events appear in the FastPix dashboard under the Data section.
4. Filter by the player_name you set to isolate Samsung smart TV views.

Frequently asked questions

Can FastPix monitor Samsung’s proprietary AVPlay API directly?

Not at this time. The @fastpix-core SDK instruments DOM-based players (HLS.js, DASH.js, native HTML5 <video>). AVPlay processes video outside the DOM, so the SDK cannot attach to its internal pipeline. If your app manages AVPlay state in JavaScript, you can mirror events to a hidden <video> element as an approximation.

Which Tizen privileges does the FastPix SDK need?

The SDK itself requires only the http://tizen.org/privilege/internet privilege for sending analytics events. The avplay and drmplay privileges are needed only if your app uses the Samsung AVPlay API for video playback — they are not required by the FastPix SDK.

Does the Tizen emulator work for testing FastPix Video Data?

The emulator handles basic HTML5 video playback, so you can verify SDK initialization and event structure. However, AVPlay and some advanced HLS features are not available in the emulator. Test on a physical Samsung TV for accurate QoE metrics.

How do I register remote control keys for playback tracking?

Call tizen.tvinputdevice.registerKey() for each media key (MediaPlay, MediaPause, MediaStop) and handle the corresponding key codes in a keydown listener. The FastPix SDK detects playback state changes automatically — you do not need to send events to the SDK when a key is pressed.

What’s next?

• Monitor HLS.js
• Monitor DASH.js
• Monitor HTML5 video element
• Integrate Video Data with the player
• Pass custom metadata to metrics