Widgets & Entry Points

The player and widget components let you embed short-form video outside the full-screen feed. Use the player for a single video (hero sections, product pages, inline previews) and the widget for a horizontal carousel or vertical grid of video cards (home screens, dashboards, discovery surfaces). Both components require content fetched via fetchContent().

Flutter: Single player and widget components are coming soon for the Flutter SDK. For now, use the full-screen feed via ShortKitFeed.

Fetching content

Before displaying videos, fetch ContentItem objects from the ShortKit API:

iOS (Swift)
Android
React Native
Web

// Fetch up to 5 items
let items = try await shortKit.fetchContent(limit: 5)

// Fetch with a filter (FeedFilter also accepts section, author, contentType, metadata)
let filtered = try await shortKit.fetchContent(limit: 5, filter: FeedFilter(tags: ["sports"]))

val items = shortKit.fetchContent(limit = 5) // suspend fun

const { fetchContent } = useShortKit();
const items = await fetchContent(5);

const items = await sk.fetchContent({ limit: 5 });

fetchContent(limit:filter:) returns an array of resolved ContentItem objects with streaming URLs, metadata, and captions. limit defaults to 10. Pass a FeedFilter to restrict results by tags, section, author, content type, or custom metadata. For full model definitions see the Content Types guide.

Single player

PlayerConfig

Property	Type	Default	Description
`cornerRadius`	`CGFloat` / `Float` / `number`	`12`	Corner radius of the player view in points.
`clickAction`	`PlayerClickAction`	`.feed` / `FEED` / `'feed'`	What happens when the user taps the player. See click actions.
`autoplay`	`Bool` / `Boolean` / `boolean`	`true`	Start playback automatically when a content item is set.
`loop`	`Bool` / `Boolean` / `boolean`	`true`	Restart playback from the beginning when the video ends.
`muteOnStart`	`Bool` / `Boolean` / `boolean`	`true`	Begin playback muted.
`videoOverlay`	`VideoOverlayMode` / `OverlayConfig`	`.none` / `'none'`	Overlay rendered on top of the video. On React Native the property is named `overlay`.

Embedding a player

iOS (UIKit)
iOS (SwiftUI)
Android
React Native
Web

ViewController.swift

import ShortKitSDK

class ViewController: UIViewController {
    private var shortKit: ShortKit!
    private var playerVC: ShortKitPlayerViewController!

    override func viewDidLoad() {
        super.viewDidLoad()

        shortKit = ShortKit(
            apiKey: "pk_live_your_publishable_key",
            config: FeedConfig()
        )

        let config = PlayerConfig(
            cornerRadius: 16,
            clickAction: .feed,
            muteOnStart: true
        )

        playerVC = ShortKitPlayerViewController(shortKit: shortKit, config: config)
        addChild(playerVC)
        playerVC.view.frame = CGRect(x: 16, y: 100, width: 200, height: 350)
        view.addSubview(playerVC.view)
        playerVC.didMove(toParent: self)

        Task {
            let items = try await shortKit.fetchContent(limit: 5)
            if let first = items.first {
                playerVC.configure(with: first)
                playerVC.activate()
            }
        }
    }

    override func viewWillDisappear(_ animated: Bool) {
        super.viewWillDisappear(animated)
        playerVC.deactivate()
    }
}

ContentView.swift

import SwiftUI
import ShortKitSDK

struct ContentView: View {
    let shortKit = ShortKit(
        apiKey: "pk_live_your_publishable_key",
        config: FeedConfig()
    )

    @State private var item: ContentItem?

    var body: some View {
        VStack {
            if let item {
                ShortKitPlayerView(
                    shortKit: shortKit,
                    config: PlayerConfig(
                        cornerRadius: 16,
                        clickAction: .feed
                    )
                )
                .frame(width: 200, height: 350)
            }
        }
        .task {
            let items = try? await shortKit.fetchContent(limit: 5)
            item = items?.first
        }
    }
}

Store the ShortKit instance outside the view body. Creating it inside the body property causes re-initialization on every SwiftUI render pass.

MainActivity.kt

import dev.shortkit.ShortKit
import dev.shortkit.PlayerConfig
import dev.shortkit.PlayerClickAction
import dev.shortkit.ShortKitPlayerView

class MainActivity : AppCompatActivity() {
    private lateinit var playerView: ShortKitPlayerView

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)

        val shortKit = ShortKit(
            context = this,
            apiKey = "pk_live_your_publishable_key",
            config = FeedConfig()
        )

        val config = PlayerConfig(
            cornerRadius = 16f,
            clickAction = PlayerClickAction.FEED,
            muteOnStart = true
        )

        playerView = findViewById(R.id.player_view)
        playerView.initialize(shortKit, config)

        lifecycleScope.launch {
            val items = shortKit.fetchContent(limit = 5)
            items.firstOrNull()?.let { item ->
                playerView.setItem(item)
                playerView.activate()
            }
        }
    }
}

Add the player view to your layout:

activity_main.xml

<dev.shortkit.ShortKitPlayerView
    android:id="@+id/player_view"
    android:layout_width="200dp"
    android:layout_height="350dp"
    android:layout_marginStart="16dp"
    android:layout_marginTop="100dp" />

PlayerScreen.tsx

import React, { useEffect, useState } from 'react';
import {
  ShortKitProvider,
  ShortKitPlayer,
  useShortKit,
} from '@shortkitsdk/react-native';
import type { ContentItem } from '@shortkitsdk/react-native';

function Player() {
  const { fetchContent } = useShortKit();
  const [item, setItem] = useState<ContentItem | null>(null);

  useEffect(() => {
    fetchContent(5).then((items) => {
      if (items.length > 0) setItem(items[0]);
    });
  }, []);

  if (!item) return null;

  return (
    <ShortKitPlayer
      contentItem={item}
      config={{
        cornerRadius: 16,
        clickAction: 'feed',
        muteOnStart: true,
      }}
      style={{ width: 200, height: 350 }}
    />
  );
}

export default function PlayerScreen() {
  return (
    <ShortKitProvider
      apiKey="pk_live_your_publishable_key"
      config={{}}
    >
      <Player />
    </ShortKitProvider>
  );
}

app.js

const sk = new ShortKit({
  apiKey: 'pk_live_your_publishable_key',
});

const items = await sk.fetchContent({ limit: 5 });

if (items.length > 0) {
  const player = sk.createPlayer(document.getElementById('player'), {
    config: {
      cornerRadius: 16,
      clickAction: 'feed',
      autoplay: true,
      loop: true,
      muteOnStart: true,
    },
  });
  player.setItem(items[0]);
}

Activate and deactivate

The player does not manage its own visibility lifecycle. Call activate() when the player is on screen and deactivate() when it leaves. This gives you full control over playback in scroll views, tab bars, and navigation stacks.

Method	Effect
`activate()`	Starts or resumes playback (respects `autoplay` and `muteOnStart`).
`deactivate()`	Pauses playback and releases the active player resources.

On React Native, use the active prop instead of method calls. It defaults to the value of config.autoplay (which is true by default). Set it to false to pause and true to resume.

<ShortKitPlayer
  contentItem={item}
  active={isVisible}
  config={{ clickAction: 'mute' }}
  style={{ width: 200, height: 350 }}
/>

The widget displays a horizontal carousel or vertical grid of video cards with muted autoplay. Tapping a card opens the feed by default.

WidgetConfig

Property	Type	Default	Description
`cardCount`	integer	`3`	Number of video cards visible in the carousel. Has no effect when `layout` is `.grid`.
`cardSpacing`	float	`8`	Spacing between cards (carousel) or between grid cells, in points (iOS) or dp (Android/RN).
`cornerRadius`	float	`12`	Corner radius applied to each card.
`autoplay`	boolean	`true`	Whether the visible card plays automatically.
`muteOnStart`	boolean	`true`	Whether playback starts muted.
`loop`	boolean	`true`	Whether each card loops when it reaches the end.
`rotationInterval`	number	`10`	Android and React Native only. Time in milliseconds before the carousel advances to the next card (e.g. `10_000` for 10 seconds). On iOS, advancement is driven by the preview reaching its end — this property is ignored. Flutter support is coming soon. Applies to carousel layout only.
`clickAction`	enum	`.feed`	Action performed when a card is tapped. See click actions.
`cardOverlay` / `overlay`	enum	`.none`	Overlay rendered on top of each card. The React Native prop is named `overlay`; iOS and Android use `cardOverlay`.
`layout`	`WidgetLayout`	`.carousel`	Layout mode — horizontal carousel or vertical grid. See Layout.
`playbackMode`	`WidgetPlaybackMode`	`.singleVisibleRotating`	How the widget activates preview playback across cells. See Playback mode.
`previewDuration`	`TimeInterval`	`5`	Duration in seconds of the looping preview clip shown on each card.
`filter`	`FeedFilter?`	`nil`	Filter applied when the widget fetches content automatically. Same format as the `filter` parameter in `fetchContent()`.

Layout

WidgetConfig.layout controls whether the widget renders as a horizontal carousel or a vertical grid.

Value	Description
`.carousel`	Default. Cards scroll horizontally in a single row within the widget’s fixed height.
`.grid(columns:cellAspectRatio:scrollable:)`	Vertical grid with configurable columns.

Grid parameters:

Parameter	Type	Description
`columns`	`Int`	Number of columns. Must be at least `1`.
`cellAspectRatio`	`CGFloat`	Cell height ÷ cell width. Use `16.0/9.0` for portrait video, `9.0/16.0` for landscape, or `1.0` for square.
`scrollable`	`Bool`	When `true` (default) the grid manages its own scroll view and fills its assigned frame — use this for a standalone grid surface. When `false`, the grid expands to fit all of its content without internal scrolling and defers scrolling to the enclosing scroll view — use this to embed the grid inside a host-managed scroll view alongside other content.

Two helper methods on WidgetConfig make it easier to size the container when using a non-scrollable embedded grid:

iOS (Swift)
Android
React Native

// Height of each individual cell given the container's current width
let cellHeight = config.gridCellHeight(forContainerWidth: view.bounds.width)

// Total height needed to display all items (non-scrollable grids only)
let totalHeight = config.preferredGridHeight(forContainerWidth: view.bounds.width, itemCount: items.count)

gridCellHeight returns nil for carousel layouts. preferredGridHeight returns nil for carousel layouts and for scrollable grid layouts (where total height is unbounded).

Playback mode

WidgetConfig.playbackMode controls how the widget activates preview playback across its cells.

Value	Works with	Description
`.singleVisibleRotating`	Carousel	Default. One visible card plays at a time. When its preview ends the widget advances to the next visible card. Off-screen cards never play.
`.allVisibleSimultaneous`	Carousel	Up to 3 visible cards play simultaneously. Each card loops its own preview independently. Cards beyond the first 3 visible and all off-screen cards stay paused.
`.gridAlternating(startSide:)`	Grid	One cell per visible row plays at a time, alternating left and right columns on successive rows, up to 4 active previews simultaneously. Each active cell loops its preview. When more rows are equally visible, the topmost rows take priority. When using this mode with a non-scrollable embedded grid, call `parentScrollViewDidScroll(_:)` on every scroll event so the widget can correctly score cell visibility against the parent viewport.

The startSide parameter on gridAlternating controls which column plays in the first row:

iOS (Swift)
Android
React Native

// Row 0 → rightmost column, row 1 → leftmost, row 2 → rightmost, …
let config = WidgetConfig(
    layout: .grid(columns: 3, cellAspectRatio: 16.0 / 9.0),
    playbackMode: .gridAlternating(startSide: .right)
)

GridSide values: .left (default), .right.

WidgetInput

WidgetInput describes a video by its playback ID. Pass an array of these to configure(with:) or appendItems(_:).

iOS (Swift)
Android
React Native

case video(playbackId: String, origin: ContentOrigin = .other, fallbackUrl: String? = nil)

Parameter	Type	Default	Description
`playbackId`	`String`	required	The video’s playback ID, available on `ContentItem.playbackId`.
`origin`	`ContentOrigin`	`.other`	Origin of the video. Use `.iosUpload` for videos uploaded directly from the device; `.other` for all other sources.
`fallbackUrl`	`String?`	`nil`	Optional direct video URL used as a fallback when the primary stream is unavailable.

Because ContentItem.playbackId is optional, use compactMap when converting from fetchContent() results:

let items = try await shortKit.fetchContent(limit: 10)
let inputs = items.compactMap { $0.playbackId.map { WidgetInput.video(playbackId: $0) } }
widgetVC.configure(with: inputs)

iOS (UIKit)
Android
React Native
Web

ViewController.swift

import ShortKitSDK

class ViewController: UIViewController {
    private var shortKit: ShortKit!

    override func viewDidLoad() {
        super.viewDidLoad()

        shortKit = ShortKit(
            apiKey: "pk_live_your_publishable_key",
            config: FeedConfig()
        )

        let widgetVC = ShortKitWidgetViewController(
            shortKit: shortKit,
            config: WidgetConfig(
                cardCount: 3
            )
        )

        addChild(widgetVC)
        widgetVC.view.frame = CGRect(x: 0, y: 100, width: view.bounds.width, height: 280)
        widgetVC.view.autoresizingMask = [.flexibleWidth]
        view.addSubview(widgetVC.view)
        widgetVC.didMove(toParent: self)

        Task {
            let items = try await shortKit.fetchContent(limit: 5)
            let inputs = items.compactMap { $0.playbackId.map { WidgetInput.video(playbackId: $0) } }
            widgetVC.configure(with: inputs)
        }
    }
}

Add the view to your layout:

activity_main.xml

<dev.shortkit.ShortKitWidgetView
    android:id="@+id/widget"
    android:layout_width="match_parent"
    android:layout_height="280dp" />

Then initialize it in your activity:

MainActivity.kt

import dev.shortkit.ShortKit
import dev.shortkit.FeedConfig
import dev.shortkit.ShortKitWidgetView
import dev.shortkit.WidgetConfig

class MainActivity : AppCompatActivity() {
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)

        val shortKit = ShortKit(
            context = this,
            apiKey = "pk_live_your_publishable_key",
            config = FeedConfig()
        )

        val widget = findViewById<ShortKitWidgetView>(R.id.widget)
        widget.initialize(
            shortKit = shortKit,
            config = WidgetConfig(
                cardCount = 3,
                rotationInterval = 10_000L // milliseconds
            )
        )

        lifecycleScope.launch {
            val items = shortKit.fetchContent(limit = 5)
            widget.configure(items)
        }
    }
}

WidgetScreen.tsx

import React, { useEffect, useState } from 'react';
import {
  ShortKitProvider,
  ShortKitWidget,
  useShortKit,
} from '@shortkitsdk/react-native';
import type { ContentItem } from '@shortkitsdk/react-native';

function Widget() {
  const { fetchContent } = useShortKit();
  const [items, setItems] = useState<ContentItem[]>([]);

  useEffect(() => {
    fetchContent(5).then(setItems);
  }, []);

  return (
    <ShortKitWidget
      config={{
        cardCount: 3,
        rotationInterval: 10000, // milliseconds
      }}
      items={items}
      style={{ height: 280 }}
    />
  );
}

export default function WidgetScreen() {
  return (
    <ShortKitProvider
      apiKey="pk_live_your_publishable_key"
      config={{}}
    >
      <Widget />
    </ShortKitProvider>
  );
}

app.js

const sk = new ShortKit({
  apiKey: 'pk_live_your_publishable_key',
});

const items = await sk.fetchContent({ limit: 5 });

const widget = sk.createWidget(document.getElementById('widget'), {
  config: {
    cardCount: 3,
    cardSpacing: 8,
    cornerRadius: 12,
    rotationInterval: 10000, // milliseconds
    clickAction: 'feed',
  },
});
widget.setItems(items);

These properties are set on the widget component after initialization.

iOS (Swift)
Android
React Native

Set these directly on your ShortKitWidgetViewController instance:

Property	Type	Default	Description
`active`	`Bool`	`true`	When `false`, the widget deactivates all playing cards and releases playback resources. Setting back to `true` resumes playback in place. Use this for tab-focus gating — pause widgets on inactive tabs so the focused surface has uncontested access to playback.
`feedMask`	`FeedMaskMode`	`.none`	Mask applied to the full-screen feed presented when a card is tapped.
`onCardTap`	`((String, Int) -> Void)?`	`nil`	When set, tapping a card invokes this callback with the video’s `playbackId` and its index, and the built-in feed presentation is skipped entirely. When `nil`, `clickAction` governs tap behavior.
`onModalFeedPresented`	`((ShortKitFeedViewController) -> Void)?`	`nil`	Fires immediately before the SDK presents the full-screen feed. Not fired when `onCardTap` is set.
`onModalFeedDismissed`	`(() -> Void)?`	`nil`	Fires when the SDK’s full-screen feed dismisses.
`onContentHeightChange`	`((CGFloat) -> Void)?`	`nil`	Fires whenever the grid’s total content height changes. Non-scrollable grid only — use this to update a height constraint as items are appended. Has no effect on scrollable grids or carousel layouts.

setFeedItems(_ inputs: [FeedInput]) supplies an optional seed list of items for the full-screen feed that opens when a card is tapped. The widget’s own cards are always prepended so the tapped clip is the opening item; the seed items follow. FeedInput accepts the same inputs as the full-screen feed — see Embedding a Feed for details.

Embedding a grid

Use WidgetLayout.grid to replace the carousel with a vertical grid. The example below embeds a scrollable standalone grid that fills its assigned frame:

iOS (UIKit)
Android
React Native

ViewController.swift

import ShortKitSDK

class ViewController: UIViewController {
    private var shortKit: ShortKit!
    private var widgetVC: ShortKitWidgetViewController!

    override func viewDidLoad() {
        super.viewDidLoad()

        shortKit = ShortKit(
            apiKey: "pk_live_your_publishable_key",
            config: FeedConfig()
        )

        let config = WidgetConfig(
            cornerRadius: 8,
            layout: .grid(columns: 3, cellAspectRatio: 16.0 / 9.0, scrollable: true),
            playbackMode: .gridAlternating()
        )

        widgetVC = ShortKitWidgetViewController(shortKit: shortKit, config: config)
        addChild(widgetVC)
        widgetVC.view.frame = view.bounds
        widgetVC.view.autoresizingMask = [.flexibleWidth, .flexibleHeight]
        view.addSubview(widgetVC.view)
        widgetVC.didMove(toParent: self)

        Task {
            let items = try await shortKit.fetchContent(limit: 12)
            let inputs = items.compactMap { $0.playbackId.map { WidgetInput.video(playbackId: $0) } }
            widgetVC.configure(with: inputs)
        }
    }
}

Embedded (non-scrollable) grid

When the grid sits inside a host-managed scroll view alongside other content — for example, a home screen with a carousel above and a grid below — set scrollable: false. The grid expands to fit all of its content and lets the parent scroll view handle scrolling. Three additional steps are required:

Resize the container as items load. Subscribe to onContentHeightChange and update your height constraint whenever the grid’s content height changes.
Forward scroll events. Call parentScrollViewDidScroll(_:) from the parent scroll view delegate so the widget can correctly score which grid cells are visible.
Append items for pagination. Call appendItems(_:) to load additional items without a full reload.

iOS (UIKit)
Android
React Native

ViewController.swift

import ShortKitSDK

class HomeViewController: UIViewController, UIScrollViewDelegate {
private var shortKit: ShortKit!
private var widgetVC: ShortKitWidgetViewController!
private var gridHeightConstraint: NSLayoutConstraint!

private let scrollView: UIScrollView = {
    let sv = UIScrollView()
    sv.translatesAutoresizingMaskIntoConstraints = false
    return sv
}()

override func viewDidLoad() {
    super.viewDidLoad()

    // Set up the host scroll view
    view.addSubview(scrollView)
    scrollView.delegate = self
    NSLayoutConstraint.activate([
        scrollView.topAnchor.constraint(equalTo: view.topAnchor),
        scrollView.leadingAnchor.constraint(equalTo: view.leadingAnchor),
        scrollView.trailingAnchor.constraint(equalTo: view.trailingAnchor),
        scrollView.bottomAnchor.constraint(equalTo: view.bottomAnchor),
    ])

    shortKit = ShortKit(
        apiKey: "pk_live_your_publishable_key",
        config: FeedConfig()
    )

    let config = WidgetConfig(
        cornerRadius: 8,
        layout: .grid(columns: 3, cellAspectRatio: 16.0 / 9.0, scrollable: false),
        playbackMode: .gridAlternating()
    )

    widgetVC = ShortKitWidgetViewController(shortKit: shortKit, config: config)

    // Resize the container whenever content is added
    widgetVC.onContentHeightChange = { [weak self] height in
        self?.gridHeightConstraint.constant = height
    }

    addChild(widgetVC)
    widgetVC.view.translatesAutoresizingMaskIntoConstraints = false
    scrollView.addSubview(widgetVC.view)
    gridHeightConstraint = widgetVC.view.heightAnchor.constraint(equalToConstant: 0)
    NSLayoutConstraint.activate([
        widgetVC.view.topAnchor.constraint(equalTo: scrollView.contentLayoutGuide.topAnchor),
        widgetVC.view.leadingAnchor.constraint(equalTo: scrollView.contentLayoutGuide.leadingAnchor),
        widgetVC.view.trailingAnchor.constraint(equalTo: scrollView.contentLayoutGuide.trailingAnchor),
        widgetVC.view.bottomAnchor.constraint(equalTo: scrollView.contentLayoutGuide.bottomAnchor),
        widgetVC.view.widthAnchor.constraint(equalTo: scrollView.frameLayoutGuide.widthAnchor),
        gridHeightConstraint,
    ])
    widgetVC.didMove(toParent: self)

    Task {
        let items = try await shortKit.fetchContent(limit: 10)
        let inputs = items.compactMap { $0.playbackId.map { WidgetInput.video(playbackId: $0) } }
        widgetVC.configure(with: inputs)
    }
}

// Forward scroll events so the grid can score cell visibility
func scrollViewDidScroll(_ scrollView: UIScrollView) {
    widgetVC.parentScrollViewDidScroll(scrollView)
}

To size the grid container before items load, use preferredGridHeight(forContainerWidth:itemCount:):

let initialHeight = config.preferredGridHeight(
    forContainerWidth: view.bounds.width,
    itemCount: items.count
) ?? 0
gridHeightConstraint.constant = initialHeight

Appending items

Call appendItems(_:) to add more items to the grid without a full reload — for example, when the user scrolls near the bottom:

Task {
    let nextPage = try await shortKit.fetchContent(limit: 10, filter: FeedFilter(tags: ["sports"]))
    let inputs = nextPage.compactMap { $0.playbackId.map { WidgetInput.video(playbackId: $0) } }
    widgetVC.appendItems(inputs)
}

appendItems is a no-op on an empty input array. It works on both scrollable and non-scrollable grid layouts, inserting items incrementally without a full reload. On carousel layouts it triggers a full reload instead.

Auto-rotation

Auto-rotation applies to carousel layout only (WidgetLayout.carousel). Grid layouts use the playbackMode setting to control preview activation instead.

When autoplay is true (the default), the carousel widget automatically advances through cards. How advancement is triggered differs by platform:

iOS — advancement is driven by the preview reaching its end (singleVisibleRotating mode). Each card plays until its preview clip finishes, then the carousel moves to the next card. rotationInterval has no effect on iOS.
Android and React Native — advancement is timer-based: the carousel advances to the next card after rotationInterval elapses, regardless of playback position.

On all platforms, when the carousel reaches the last card it wraps back to the first. Rotation pauses while the user is actively swiping and resumes once the gesture ends.

The rotationInterval unit differs across platforms. Android and React Native expect milliseconds (e.g. 10_000 / 10000). The property is ignored on iOS.

Click actions

Both PlayerConfig.clickAction and WidgetConfig.clickAction accept the same values:

Value	Behavior
`.feed` / `PlayerClickAction.FEED` / `'feed'`	Opens the full-screen feed starting at the tapped item. This is the default.
`.mute` / `PlayerClickAction.MUTE` / `'mute'`	Toggles audio mute.
`.none` / `PlayerClickAction.NONE` / `'none'`	No action. Useful when you handle taps yourself.

Get Started

Content

Display

Build Your Experience

Users & Data

Widgets & Entry Points

Fetching content

Single player

PlayerConfig

Embedding a player

Activate and deactivate

Widget

WidgetConfig

Layout

Playback mode

WidgetInput

Embedding a widget

Widget properties and callbacks

Embedding a grid

Embedded (non-scrollable) grid

Appending items

Auto-rotation

Click actions

​Fetching content

​Single player

​PlayerConfig

​Embedding a player

​Activate and deactivate

​Widget

​WidgetConfig

​Layout

​Playback mode

​WidgetInput

​Embedding a widget

​Widget properties and callbacks

​Embedding a grid

​Embedded (non-scrollable) grid

​Appending items

​Auto-rotation

​Click actions

Fetching content

Single player

PlayerConfig

Embedding a player

Activate and deactivate

Widget

WidgetConfig

Layout

Playback mode

WidgetInput

Embedding a widget

Widget properties and callbacks

Embedding a grid

Embedded (non-scrollable) grid

Appending items

Auto-rotation

Click actions