Radiant Media Player

Player modules

Search

How do player modules work?

Radiant Media Player UI includes interactive modules with various functionalities. Those modules are:

• Quality (e.g. bitrate) selection module: represented by a cog icon and has a .rmp-quality CSS class
• Closed captions selection module: represented by a CC icon and has a .rmp-captions CSS class
• Audio language selection module: represented by a headset icon and has a .rmp-audio CSS class
• Sharing module: represented by a tripod icon and has a .rmp-sharing CSS class
• Playback rate selection module: represented by a clock icon and has a .rmp-speed CSS class
• Casting module: represented by a Google Cast icon and has a .rmp-cast CSS class
• AirPlay module: represented by an AirPlay cast icon and has a .rmp-airplay CSS class
• Related module: represented by a grid menu icon and has a .rmp-related CSS class
• Chapter markers (WebVTT): represented by a bookmark icon and has a .rmp-chapters CSS class
• Picture-in-picture module: represented by a picture-in-picture icon and has a .rmp-pip CSS class
• Virtual reality module: represented by a HMD icon and has a .rmp-vr CSS class
• Information module: A module that allows for custom text to be displayed in an overaly on top of the player when the module is interacted with
• Loop module: When interacted with this module enables or disables loop behavior in the player
• Theater mode module: When interacted with this module will enlarge the player size to give a more immersive viewing experience

Those modules can be enabled through player settings or will automatically be shown when needed. Modules are located at the top of the player. When multiple modules are available they are tiled horizontally.

When interacted with, the quality, captions, audio, sharing, speed, related and chapters modules will open a mobile-first semi-transparent overlay allowing the viewer to easily select a rendition, audio track, playback rate, related item ...

All those modules have a specific .rmp-module CSS class. When the mouse is over a module a hint shall display - clearly identifying the role of the module. This hint will have a .rmp-hint CSS class. Labels for modules can be customised through our labelling system.

Modules settings

hideModule: Object

hideModule: {
  quality: false,
  captions: false,
  audio: false,
  volume: false
};

This setting can be used to hide player modules. The quality, captions, audio, volume modules can be hidden. The above example shows the default values.

Information module

infoModule: String

Custom text to be displayed in an overaly on top of the player when the module is interacted with. Note: you can use HTML markup (example <a> or <em>) in the text to customize it. Default: ''.

Loop module

loopModule: Boolean

Enables or disables loop behavior in the player. Default: false.

Theater mode module

theaterModeModule: Boolean

Enables or disables theater mode module in the player. Default: false.

Modules API

getModuleOverlayVisible(moduleType)

rmp.getModuleOverlayVisible('quality');

This method takes as input a String (moduleType) and returns a Boolean stating if the input module is currently open or not (e.g. input module overlay is visible or not). Input parameter can be: 'quality', 'sharing', 'audio', 'captions', 'speed', 'related' or 'chapters'.

setModuleOverlayVisible(moduleType, visible)

rmp.setModuleOverlayVisible('quality', true);

This method takes as input a String (moduleType) and a Boolean (visible) and shows or hides the targeted module. Input parameter (moduleType) can be: 'quality', 'sharing', 'audio', 'captions', 'speed', 'related' or 'chapters'.

Adding custom player modules

In the event you want to add a custom module to the player we have prepared an easy way to do so. All that is required to add a custom module is a name for this module, a SVG icon and a JavaScript callback function to create interactivity for your custom module. Custom modules are passed to the player with the customModule setting. This setting expects to see an Array of Object, each Object defining a custom module. The customModule Array can hold multiple custom modules. Let us run through an example:

<script src="https://cdn.radiantmediatechs.com/rmp/7.8.0/js/rmp.min.js"></script>
<div id="rmp"></div>
<script>
// Here we start by creating a player instance
const rmp = new RadiantMP('rmp');
// Your streaming source - HLS in this example
const src = {
  hls: 'https://your-hls-url.m3u8'
};
// Then we define a custom module - in this case a 10s rewind module
const rewindCustomModule = {
  hint: 'Rewind', // Then name of the module - will show as hint within player UI
  svg: 'https://cdn.radiantmediatechs.com/img/replay-10-icon.svg', // Then SVG icon for the module
  svgHover: 'https://cdn.radiantmediatechs.com/img/replay-10-icon-hover.svg', // An optional second icon that can be displayed when the module is hovered
  callback: () => { // Our callback function
    rmp.seekTo(rmp.getCurrentTime() - 10000);
  }
};
// customModule must be passed as an Array
const customModule = [rewindCustomModule];
// Your player settings
const settings = {
  licenseKey: 'your-license-key',
  src: src,
  width: 640,
  height: 360,
  // Passing custom module data
  customModule: customModule,
  contentMetadata: {
    poster: [
      'https://your-poster-url.jpg'
    ]
  }
};
// Init player
rmp.init(settings);
</script>

At all player sizes the player accepts a maximum of 7 modules. If more modules are available the overflow modules will be hidden. You can change this through player CSS if needed.

If we wanted to pass two custom modules we would have something like - see this example here

// We define our first custom module - in this case a 10s rewind module
const rewindCustomModule = {
  hint: 'Rewind',
  svg: 'https://cdn.radiantmediatechs.com/img/replay-10-icon.svg',
  svgHover: 'https://cdn.radiantmediatechs.com/img/replay-10-icon-hover.svg',
  callback: () => {
    rmp.seekTo(rmp.getCurrentTime() - 10000);
  }
};
// Then our second custom module - in this case a download video module
const downloadCustomModule = {
  hint: 'Download',
  svg: 'https://cdn.radiantmediatechs.com/img/download-icon.svg',
  svgHover: 'https://cdn.radiantmediatechs.com/img/download-icon-hover.svg',
  callback: () => {
    rmp.pause();
    window.open(
      'https://url-to-download-media-file.mp4',
      '_blank'
    );
  }
};
// customModule must be passed as an Array
const customModule = [rewindCustomModule, downloadCustomModule];

Adding custom overlay

Below is an example of how to implement a custom overlay on top of the player displaying custom information (public IP and client bandwidth of viewer). This example can be viewed live here.

CSS (to be added to your page <head>

<style>
  .rmp-custom-overlay {
    background: rgba(255, 255, 255, 0.7);
    color: #000000;
    border: 2px solid #000000;
    position: absolute;
    left: 8px;
    top: 8px;
    font-size: 14px;
    padding: 8px;
    text-align: left;
    border-radius: 4px;
  }

  .rmp-custom-overlay > div:first {
    margin-bottom: 10px;
  }
</style>

HTML + JavaScript (to be added to your page <body>

<script src="https://cdn.radiantmediatechs.com/rmp/7.8.0/js/rmp.min.js"></script>
<div id="rmp"></div>
<script>
  const src = {
    hls: 'https://5b44cf20b0388.streamlock.net:8443/vod/smil:bbb.smil/playlist.m3u8'
  };
  // player settings
  const settings = {
    licenseKey: 'your-license-key',
    src: src,
    width: 640,
    height: 360,
    skin: 's1',
    contentMetadata: {
      poster: [
        'https://www.radiantmediaplayer.com/images/poster-rmp-demo.jpg'
      ]
    }
  };
  const elementID = 'rmp';
  const rmp = new RadiantMP(elementID);
  rmp.init(settings);

  // we define our custom overlay div element
  const rmpContainer = document.getElementById(elementID);
  const rmpCustomOverlay = document.createElement('div');
  rmpCustomOverlay.className = 'rmp-custom-overlay';

  // callback that is being run when IP data is fetched from ipify servers
  function getIP(json) {
    // add public IP
    const textFieldIP = document.createElement('div');
    textFieldIP.textContent = 'Public IP: ' + json.ip;
    rmpCustomOverlay.appendChild(textFieldIP);
    // add client bandwidth
    const textFieldBW = document.createElement('div');
    textFieldBW.textContent = 'Client bandwidth: ' + Math.round(rmp.getBandwidthEstimate() / 1000) + ' kbps';
    setInterval(() => {
      textFieldBW.textContent = 'Client bandwidth: ' + Math.round(rmp.getBandwidthEstimate() / 1000) + ' kbps';
    }, 1000);
    rmpCustomOverlay.appendChild(textFieldBW);
  }
  // when ready event fires we append our custom overlay div element
  // so that this element is appended on top of other player elements
  rmpContainer.addEventListener('ready', () => {
    rmpContainer.appendChild(rmpCustomOverlay);
  });
</script>
<!-- script to get public IP address from ipify servers - https://www.ipify.org -->
<script type="application/javascript" src="https://api.ipify.org?format=jsonp&callback=getIP"></script>

If you want the custom overlay to auto-hide with player controls add the following CSS to your page:

.rmp-custom-overlay {
  -webkit-transition-property: opacity,visibility;
  -moz-transition-property: opacity,visibility;
  transition-property: opacity,visibility;
  -webkit-transition-duration: .4s;
  -moz-transition-duration: .4s;
  transition-duration: .4s;
  -webkit-transition-timing-function: ease-in;
  -moz-transition-timing-function: ease-in;
  transition-timing-function: ease-in;
}

.rmp-chrome .rmp-custom-overlay {
  opacity: 1;
  visibility: visible;
}

.rmp-no-chrome .rmp-custom-overlay {
  opacity: 0;
  visibility: hidden;
}