### Initialize Player for Program Date Time

Source: https://www.radiantmediaplayer.com/docs/latest/hls-streaming.html

Example setup for a player instance to listen for meta events and retrieve program date time metadata.

```html
<script src="https://cdn.radiantmediatechs.com/rmp/10.7.8/js/rmp.min.js"></script>
<div id="rmp"></div>
<script>
  const src = {
    hls: 'https://your-live-hls-stream-with-program-date-time-metadata.m3u8'
  };
  const settings = {
    licenseKey: 'your-license-key',
    src,
    width: 640,
    height: 360
  };
  const elementID = 'rmp';
  const rmp = new RadiantMP(elementID);
  rmp.on('meta', () => {
    // Each time meta event fires, metadata getter can be queried
    console.log(rmp.metadata);
  });
  // Initialization ... and done!
  async function initRmpPlayer() {
    try {
      await rmp.init(settings);
    } catch(error) {
      console.error('Radiant Media Player failed to initialize', error);
    }
  }
  initRmpPlayer();
</script>
```

--------------------------------

### Initialize Player for SEI Metadata

Source: https://www.radiantmediaplayer.com/docs/latest/hls-streaming.html

Example setup for a player instance to listen for meta events and retrieve SEI packet data.

```html
<script src="https://cdn.radiantmediatechs.com/rmp/10.7.8/js/rmp.min.js"></script>
<div id="rmp"></div>
<script>
  const src = {
    hls: 'https://your-hls-stream-with-sei-packets-with-resolution-payloadType-5.m3u8'
  };
  const settings = {
    licenseKey: 'your-license-key',
    src,
    width: 640,
    height: 360
  };
  const elementID = 'rmp';
  const rmp = new RadiantMP(elementID);
  rmp.on('meta', () => {
    // Each time meta event fires, metadata getter can be queried
    console.log(rmp.metadata);
  });
  // Initialization ... and done!
  async function initRmpPlayer() {
    try {
      await rmp.init(settings);
    } catch(error) {
      console.error('Radiant Media Player failed to initialize', error);
    }
  }
  initRmpPlayer();
</script>
```

--------------------------------

### Initialize Radiant Media Player with Playback Rate

Source: https://www.radiantmediaplayer.com/docs/latest/documentation.html

Example setup for the player including HLS source, license key, and enabled playback rate controls.

```html
<script src="https://cdn.radiantmediatechs.com/rmp/10.7.8/js/rmp.min.js"></script>
<div id="rmp"></div>
<script>
// Streaming source - HLS in this example
  const src = {
    hls: 'https://your-hls-url.m3u8' 
  };
  const settings = {
    licenseKey: 'your-license-key',
    width: 640,
    height: 360,
    src,
    // Playback rate settings
    speed: true,
    speedRates: [0.25, 0.5, 1, 1.5, 2, 4],
    contentMetadata: {
      poster: [
        'https://your-poster-url.jpg'
      ]
    }
  };
  const rmp = new RadiantMP('rmp');

  async function initRmpPlayer() {
    try {
      await rmp.init(settings);
    } catch (error) {
      console.error('Radiant Media Player failed to initialize', error);
    }
  }
  initRmpPlayer(); 

</script>
```

--------------------------------

### Start Content Download

Source: https://www.radiantmediaplayer.com/docs/latest/offline-storage-playback.html

Initiates the download process for offline storage.

```javascript
rmp.download().then(() => {
  console.log('download has completed');
}).catch(warning => {
  console.warn(warning);
});
```

--------------------------------

### Implement Mutually Exclusive Playback

Source: https://www.radiantmediaplayer.com/docs/latest/gist/mutually-exclusive-playback/index.html

This example initializes three player instances and uses event listeners to pause the other two players whenever one starts playback. Ensure you replace 'your-license-key' with a valid license key.

```html
<script src="https://cdn.radiantmediatechs.com/rmp/10.7.8/js/rmp.min.js"></script>
<div id="rmp1"></div>
<div id="rmp2"></div>
<div id="rmp3"></div>
<script>
  const src1 = {
    hls: 'https://www.radiantmediaplayer.com/media/v1/avc-mp4/hls/playlist.m3u8'
  };
  const src2 = {
    hls: 'https://www.radiantmediaplayer.com/media/hls/fmp4/apple/master.m3u8'
  };
  const src3 = {
    hls: 'https://storage.googleapis.com/shaka-demo-assets/angel-one-hls/hls.m3u8'
  };
  const settings1 = {
    licenseKey: 'your-license-key',
    src: src1,
    width: 640,
    height: 360
  };
  const settings2 = {
    licenseKey: 'your-license-key',
    src: src2,
    width: 640,
    height: 360
  };
  const settings3 = {
    licenseKey: 'your-license-key',
    src: src3,
    width: 640,
    height: 360
  };
  const elementID1 = 'rmp1';
  const elementID2 = 'rmp2';
  const elementID3 = 'rmp3';
  const rmp1 = new RadiantMP(elementID1);
  const rmp2 = new RadiantMP(elementID2);
  const rmp3 = new RadiantMP(elementID3);

  function wireAPI() {
    rmp1.on('play', () => {
      rmp2.pause();
      rmp3.pause();
    });
    rmp2.on('play', () => {
      rmp1.pause();
      rmp3.pause();
    });
    rmp3.on('play', () => {
      rmp1.pause();
      rmp2.pause();
    });
  }

  async function initRmpPlayer() {
    try {
      rmp1.init(settings1);
      rmp2.init(settings2);
      rmp3.init(settings3);
    } catch (error) {
      console.error('Radiant Media Player failed to initialize', error);
    }
  }

  wireAPI();
  initRmpPlayer();
</script>
```

--------------------------------

### Initialize Player with Custom Labels

Source: https://www.radiantmediaplayer.com/docs/latest/international-player-labels.html

Example showing how to pass a custom labels object during player initialization.

```html
<script src="https://cdn.radiantmediatechs.com/rmp/10.7.8/js/rmp.min.js"></script>
<!-- Player container element -->
<div id="rmp"></div>
<script>
  const src = {
    hls: 'https://your-hls-url.m3u8'
  };
  // Define player labels
  const labels = {
    english: {
      hint: {
        play: 'Custom Text',
        pause: 'Custom Text'
      }
    },
    spanish: {
      hint: {
        play: 'Texto personalizado',
        pause: 'Texto personalizado'
      }
    }
  };
  // Player settings
  const settings = {
    src,
    licenseKey: 'your-license-key',
    width: 640,
    height: 360,
    speed: true,
    sharing: true,
    labels,
    contentMetadata: {
      poster: [
        'https://your-poster-url.jpg'
      ]
    }
  };
  const rmp = new RadiantMP('rmp');

  // Player initialisation
  async function initRmpPlayer() {
    try {
      await rmp.init(settings);  
      console.log('player ready');
    } catch (error) {
      console.error('Radiant Media Player failed to initialize', error);
    }
  }
  initRmpPlayer();
</script>
```

--------------------------------

### Initialize Live Audio-Only Player

Source: https://www.radiantmediaplayer.com/docs/latest/audio-only.html

Setup for live HLS audio-only streaming.

```html
<!-- Include Radiant Media Player JavaScript file in your <body> or <head> -->
<script src="https://cdn.radiantmediatechs.com/rmp/10.7.8/js/rmp.min.js"></script>
<!-- Player container element -->
<div id="rmp"></div>
<!-- Set up player configuration options -->
<script>

  // Streaming source - Live HLS audio-only in this example
  const src = {
    hls: 'https://your-live-audio-only-hls-url.m3u8'
  };
  const settings = {
    licenseKey: 'your-license-key',
    src,
    width: 640,
    // Set up audio-only UI and optimisations
    audioOnly: true
  };
  const rmp = new RadiantMP('rmp');

  // Initialization ... and done!
  async function initRmpPlayer() {
    try {
      await rmp.init(settings);
    } catch(error) {
      console.error('Radiant Media Player failed to initialize', error);
    }
  }
  initRmpPlayer();

</script>
```

--------------------------------

### Load Downloaded Item

Source: https://www.radiantmediaplayer.com/docs/latest/offline-storage-playback.html

Starts playback of a previously downloaded item.

```javascript
rmp.loadDownload(storedItem).then(() => {
  console.log('loadDownload has completed');
}).catch(warning => {
  console.warn(warning);
});
```

--------------------------------

### Module build self-hosting initialization

Source: https://www.radiantmediaplayer.com/docs/latest/player-builds.html

Example of importing the player as an ES2015 module when self-hosting files.

```javascript
// import Radiant Media Player as a ES2015 module
import RadiantMP from 'radiantmediaplayer/dist/rmp.min.mjs';
// HLS streaming source
const src = {
  hls: 'https://your-live-hls-url.m3u8'
};
// Your player settings
const settings = {
  licenseKey: 'your-license-key',
  src,
  width: 640,
  height: 360,
  pathToRmpFiles: 'radiantmediaplayer/',
  contentMetadata: {
    poster: [
      'https://your-poster-url.jpg'
    ]
  }
};
const elementID = 'rmp';
const rmp = new RadiantMP(elementID);
// Player initialisation
async function initRmpPlayer() {
  try {
    await rmp.init(settings);
  } catch (error) {
    console.error('Radiant Media Player failed to initialize', error);
  }
}
initRmpPlayer();
```

--------------------------------

### Module build cloud-player initialization

Source: https://www.radiantmediaplayer.com/docs/latest/player-builds.html

JavaScript initialization code for the cloud-player module setup.

```javascript
// main.js
// import Radiant Media Player as a ES2015 module (cloud-player)
import RadiantMP from 'rmp';
// HLS streaming source
const src = {
  hls: 'https://your-live-hls-url.m3u8'
};
// Your player settings
const settings = {
  licenseKey: 'your-license-key',
  src,
  width: 640,
  height: 360,
  contentMetadata: {
    poster: [
      'https://your-poster-url.jpg'
    ]
  }
};
const elementID = 'rmp';
const rmp = new RadiantMP(elementID);
// Player initialisation
async function initRmpPlayer() {
  try {
    await rmp.init(settings);
  } catch (error) {
    console.error('Radiant Media Player failed to initialize', error);
  }
}
initRmpPlayer();
```

--------------------------------

### Compute player load and startup performance

Source: https://www.radiantmediaplayer.com/docs/latest/api-documentation.html

Example demonstrating how to measure library load time, player readiness, and startup time using event listeners.

```html
<!-- Here we start our timer to compute time to load rmp.min.js -->
<script>
  let timeAfterLoad;
  const timeBeforeLoad = Date.now();
</script>
<script src="https://cdn.radiantmediatechs.com/rmp/10.7.8/js/rmp.min.js"></script>
<div id="rmp"></div>
<script>
  const src = {
    hls: 'https://your-hls-url.m3u8'
  };
  const settings = {
    licenseKey: 'your-license-key',
    src,
    width: 640,
    height: 360,
    contentMetadata: {
      poster: [
        'https://your-poster-url.jpg'
      ]
    }
  };  
  const elementID = 'rmp';
  const rmp = new RadiantMP(elementID);
  // We wire our events before calling init
  rmp.on('ready', () => {
    // ready event fires this is when the timer for timeReady getter stops
    const timeToLoad = timeAfterLoad - timeBeforeLoad;
    const timeToReady = rmp.timeReady;
    const totalReadyTime = timeToLoad + timeToReady;
    // print our data to console
    console.log('timeToLoad is ' + timeToLoad + ' ms');
    console.log('timeToReady is ' + timeToReady + ' ms');
    console.log('totalReadyTime is ' + totalReadyTime + ' ms');
  });
  // Here we also print the player start-up time
  rmp.on('firstframe', () => {
    const startupTime = rmp.startUpTime;
    console.log('startupTime is ' + startupTime + ' ms');
  });
  // Here we stop our timer to compute time to load rmp.min.js
  // In this case we also add the time it took to create Radiant Media Player instance and to wire our app logic
  timeAfterLoad =  Date.now();
  // init is called this is when the timer for timeReady getter starts
  // Initialization ... and done!
  async function initRmpPlayer() {
    try {
      await rmp.init(settings);
    } catch(error) {
      console.error('Radiant Media Player failed to initialize', error);
    }
  }
  initRmpPlayer();
</script>
```

--------------------------------

### Get preload configuration

Source: https://www.radiantmediaplayer.com/docs/latest/api-documentation.html

Returns the preload mode used for player start up.

```javascript
const preload = rmp.preloadConfiguration;
```

--------------------------------

### Get current DVR time

Source: https://www.radiantmediaplayer.com/docs/latest/dvr-streaming.html

Retrieves the relative time from the start of the current DVR window in milliseconds.

```javascript
const currentTime = rmp.currentTime;
```

--------------------------------

### Initialize Player with Interactive Transcripts

Source: https://www.radiantmediaplayer.com/docs/latest/interactive-transcripts.html

Full implementation example including the required HTML container structure and JavaScript initialization with transcript settings.

```html
<!-- Include Radiant Media Player JavaScript file in your <body> or <head> -->
<script src="https://cdn.radiantmediatechs.com/rmp/10.7.8/js/rmp-hlsjs.min.js"></script>
<!-- Transcripts and player container element -->
<div class="rmp-transcripts-container">
  <div class="rmp-transcripts-player-wrapper">
    <div id="rmp"></div>
  </div>
</div>
<script>
  const src = {
    hls: 'https://your-hls-url.m3u8'
  };
  // Your player settings
  const settings = {
    licenseKey: 'your-license-key',
    src,
    autoHeightMode: true,
    // Passing transcripts files to the player
    transcripts: [
      {
        lng: 'en',
        name: 'English',
        uri: 'https://www.radiantmediaplayer.com/media/vtt/transcripts/transcript.vtt'
      },
      {
        lng: 'fr',
        name: 'Français',
        uri: 'https://www.radiantmediaplayer.com/media/vtt/transcripts/transcript-fr.vtt'
      }
    ],
    contentMetadata: {
      poster: [
        'https://your-poster-url.jpg'
      ]
    }
  };
  const rmp = new RadiantMP('rmp');

  // Player initialisation
  async function initRmpPlayer() {
    try {
      await rmp.init(settings);  
    } catch (error) {
      console.error('Radiant Media Player failed to initialize', error);
    }
  }
  initRmpPlayer();

</script>
```

--------------------------------

### Initialize Radiant Media Player with a custom module

Source: https://www.radiantmediaplayer.com/docs/latest/player-modules.html

Demonstrates the full setup including player initialization and passing a single custom module via the settings object.

```html
<script src="https://cdn.radiantmediatechs.com/rmp/10.7.8/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.currentTime - 10000).then(() => {
        console.log('seekTo was successful');
      }).catch(warning => {
        console.warn(warning);
      });
    }
  };

  // customModule must be passed as an Array
  const customModule = [rewindCustomModule];

  // Your player settings
  const settings = {
    licenseKey: 'your-license-key',
    src,
    width: 640,
    height: 360,
    // Passing custom module data
    customModule: customModule,
    contentMetadata: {
      poster: [
        'https://your-poster-url.jpg'
      ]
    }
  };

  // Player initialisation
  async function initRmpPlayer() {
    try {
      await rmp.init(settings);
    } catch (error) {
      console.error('Radiant Media Player failed to initialize', error);
    }
  }
  initRmpPlayer();

</script>
```

--------------------------------

### Module build cloud-player HTML setup

Source: https://www.radiantmediaplayer.com/docs/latest/player-builds.html

HTML structure using an importmap to map the player module for cloud-based hosting.

```html
<!DOCTYPE html>
<html lang="en">
  <head>
    <meta charset="utf-8">
    <title>My video app</title>
    <!-- we map rmp to our cloud player file -->
    <script type="importmap">
      {
        "imports": {
          "rmp": "https://cdn.radiantmediatechs.com/rmp/10.7.8/js/rmp.min.mjs"
        }
      }
    </script>
  </head>
  <body>
    <!-- Player container element -->
    <div id="rmp"></div>
    <script type="module" src="/main.js"></script>
  </body>
</html>
```

--------------------------------

### Get or set active audio track

Source: https://www.radiantmediaplayer.com/docs/latest/api-documentation.html

Use these methods to get or set the ID of the active audio track.

```javascript
const audioTrack = rmp.audioTrack;
```

```javascript
rmp.audioTrack = 1;
```

--------------------------------

### Radiant Media Player Initialization with Custom Icons

Source: https://www.radiantmediaplayer.com/docs/latest/player-skins.html

Example showing how to include the player script and configure the customIconsLoc setting within the player initialization.

```html
<!-- Include Radiant Media Player JavaScript file in your <body> or <head> -->
<script src="https://cdn.radiantmediatechs.com/rmp/10.7.8/js/rmp.min.js"></script>
<!-- Player container element -->
<div id="rmp"></div>
<!-- Set up player configuration options -->
<script>
  // Your streaming source - HLS in this example
  const src = {
    hls: 'https://your-hls-url.m3u8'
  };
  // Your player settings
  const settings = {
    licenseKey: 'your-license-key',
    src,
    width: 640,
    height: 360,
    skin: 's1',
    contentMetadata: {
      poster: [
        'https://your-poster-url.jpg'
      ]
    },
    // Custom icon URI
    customIconsLoc: 'https://cdn.radiantmediatechs.com/rmp/svg/icons.json'
  };
  const rmp = new RadiantMP('rmp');
  // Initialization ... and done!
  async function initRmpPlayer() {
    try {
      await rmp.init(settings);
    } catch(error) {
      console.error('Radiant Media Player failed to initialize', error);
    }
  }
  initRmpPlayer();
</script>
```

--------------------------------

### init(settings)

Source: https://www.radiantmediaplayer.com/docs/latest/api-documentation.html

Initializes the player with the provided settings object.

```APIDOC
## init(settings)

### Description
Starts player initialisation. Returns a Promise that resolves if initialization was successful or rejects to an ErrorData Object.

### Parameters
- **settings** (RadiantMediaPlayerSettings) - Required - The player configuration object.
```

--------------------------------

### Google IMA Ad Tag Example

Source: https://www.radiantmediaplayer.com/docs/latest/video-ads-documentation.html

Example of an ad tag URL configured for use with the Google IMA SDK.

```text
https://pubads.g.doubleclick.net/gampad/ads?sz=640x480&iu=/124319096/external/single_ad_samples&ciu_szs=300x250&impl=s&gdfp_req=1&env=vp&output=vast&unviewed_position_start=1&cust_params=deployment%3Ddevsite%26sample_ct%3Dlinear&url=%5Breferrer_url%5D&correlator=%5Btimestamp%5D&description_url=__page-url__
```

--------------------------------

### loadDownload(storedItem)

Source: https://www.radiantmediaplayer.com/docs/latest/offline-storage-playback.html

Starts playback of a previously downloaded item.

```APIDOC
## loadDownload(storedItem)

### Description
Starts playback for a stored item. When playback starts, the player fires a 'playing' event.

### Parameters
- **storedItem** (Object) - The downloaded item object retrieved from listDownloadedContent.
```

--------------------------------

### Initialize Radiant Media Player with rmp-vast

Source: https://www.radiantmediaplayer.com/docs/latest/video-ads-api-rmp-vast.html

This example demonstrates how to include the player script, configure settings for VAST ads, and register event listeners for ad lifecycle tracking.

```html
<!-- Include Radiant Media Player JavaScript file in your <body> or <head> -->
<script src="https://cdn.radiantmediatechs.com/rmp/10.7.8/js/rmp.min.js"></script>
<!-- Player container element -->
<div id="rmp"></div>
<!-- Set up player configuration options -->
<script>
  // Streaming source - HLS in this example
  const src = {
    hls: 'https://your-hls-url.m3u8'
  };
  // Player settings
  const settings = {
    licenseKey: 'your-license-key',
    src,
    width: 640,
    height: 360,
    ads: true,
    // This is a demo VAST tag - use your own
    adParser: 'rmp-vast',
    adTagUrl: 'https://www.radiantmediaplayer.com/vast/tags/inline-linear.xml',
    contentMetadata: {
      poster: [
        'https://your-poster-url.jpg'
      ]
    }
  };
  const elementID = 'rmp';
  const rmp = new RadiantMP(elementID);
  // We attach our events and call our methods
  rmp.on('adloaded', () => {
    console.log('adloaded');
  });
  rmp.on('adstarted', () => {
    console.log('adstarted');
    console.log(rmp.duration);
    console.log(rmp.adTitle);
  });
  rmp.on('adclick', () => {
    console.log('adclick');
  });
  rmp.on('aderror', () => {
    console.log('aderror');
  });
  // Initialization - only after API events are registered
  // Initialization ... and done!
  async function initRmpPlayer() {
    try {
      await rmp.init(settings);
    } catch(error) {
      console.error('Radiant Media Player failed to initialize', error);
    }
  }
  initRmpPlayer();
</script>
```

--------------------------------

### Implement Companion Ads with rmp-vast

Source: https://www.radiantmediaplayer.com/docs/latest/companion-ads.html

Example showing how to initialize the player and use the adstarted event to retrieve and append a companion ad to the DOM.

```html
<script src="https://cdn.radiantmediatechs.com/rmp/10.7.8/js/rmp.min.js"></script>
<div id="rmp"></div>
<br><br>
<!-- here is where the companion ad will be displayed -->
<div id="companionId" style="width: 300px; height: 250px;"></div>
<script>
  const src = {
    hls: 'https://your-hls-url.m3u8'
  };
  const settings = {
    licenseKey: 'your-license-key',
    src,
    width: 640,
    height: 360,
    contentMetadata: {
      poster: [
        'https://your-poster-url.jpg'
      ]
    },
    ads: true,
    adParser: 'rmp-vast',
    adTagUrl: 'https://your-ad-tag-url'
  };
  const rmp = new RadiantMP('rmp');
  // we wait for the adstarted event
  rmp.on('adstarted', () => {
    // we need to call getCompanionAds BEFORE calling getCompanionAd so that 
    // rmp-vast can first create a collection of available companion ads based on getCompanionAds 
    // input parameters
    const list = rmp.getCompanionAds(900, 750);
    if (list.length === 3) {
      const img = rmp.getCompanionAd(2);
      if (img instanceof HTMLElement) {
        // we get our companion ad image and we can append it to DOM now
        // VAST trackers will be called automatically when needed
        const companionId = document.getElementById('companionId');
        companionId.appendChild(img);
      }
    }
  });
  // Initialization ... and done!
  async function initRmpPlayer() {
    try {
      await rmp.init(settings);
    } catch(error) {
      console.error('Radiant Media Player failed to initialize', error);
    }
  }
  initRmpPlayer();
</script>
```

--------------------------------

### hlsStartLoad()

Source: https://www.radiantmediaplayer.com/docs/latest/api-documentation.html

Method to start or restart the playlist/fragment loading process.

```APIDOC
## hlsStartLoad()

### Description
Allows to start/restart the playlist/fragment loading process. Should be called after the manifestparsed event has fired.

### Usage
```javascript
rmp.hlsStartLoad();
```
```

--------------------------------

### Manage Mute State

Source: https://www.radiantmediaplayer.com/docs/latest/api-documentation.html

Get or set the muted state of the player.

```javascript
const mute = rmp.mute;
```

```javascript
rmp.mute = true;
```

--------------------------------

### Player Configuration for WebVTT Chapters

Source: https://www.radiantmediaplayer.com/docs/latest/chapters.html

Example showing how to initialize the player with the chaptersLoc setting. The WebVTT file must be served with appropriate CORS headers.

```html
<script src="https://cdn.radiantmediatechs.com/rmp/10.7.8/js/rmp.min.js"></script>
<div id="rmp"></div>
<script>
  const src = {
    hls: 'https://your-hls-url.m3u8'
  };
  const settings = {
    licenseKey: 'your-license-key',
    src,
    width: 640,
    height: 272,
    // here we tell the player where to look for a WebVTT chapters file
    chaptersLoc: 'https://www.radiantmediaplayer.com/media/vtt/chapters/chapters.vtt',
    contentMetadata: {
      poster: [
        'https://your-poster-url.jpg'
      ]
    }
  };
  const rmp = new RadiantMP('rmp');

  // Player initialisation
  async function initRmpPlayer() {
    try {
      await rmp.init(settings);  
      console.log('player ready');
    } catch (error) {
      console.error('Radiant Media Player failed to initialize', error);
    }
  }
  initRmpPlayer();

</script>
```

--------------------------------

### Get app name

Source: https://www.radiantmediaplayer.com/docs/latest/api-documentation.html

Returns the current appName set for the player.

```javascript
const appName = rmp.appNameConfiguration;
```

--------------------------------

### Initialize Player with Closed Captions

Source: https://www.radiantmediaplayer.com/docs/latest/closed-captions-documentation.html

Full implementation example including script inclusion, player container, configuration settings, and asynchronous initialization.

```html
<!-- Include Radiant Media Player JavaScript file in your <body> or <head> -->
<script src="https://cdn.radiantmediatechs.com/rmp/10.7.8/js/rmp-vttjs.min.js"></script>
<!-- Player container element -->
<div id="rmp"></div>
<script>
  const src = {
    hls: 'https://your-hls-url.m3u8'
  };
  // Your WebVTT closed captions
  const ccFiles = [
    {
      lng: 'en',
      name: 'English',
      uri: 'https://www.radiantmediaplayer.com/media/vtt/captions/cc.vtt',
      default: false
    },
    {
      lng: 'fr',
      name: 'Français',
      uri: 'https://www.radiantmediaplayer.com/media/vtt/captions/cc-fr.vtt',
      default: false
    }
  ];
  // Your player settings
  const settings = {
    licenseKey: 'your-license-key',
    src,
    width: 640,
    height: 360,
    ccFiles,
    crossorigin: 'anonymous', // On iOS this is required for loading cross-origin VTT files
    contentMetadata: {
      poster: [
        'https://your-poster-url.jpg'
      ]
    }
  };
  const rmp = new RadiantMP('rmp');

  // Player initialisation
  async function initRmpPlayer() {
    try {
      await rmp.init(settings);  
      console.log('player ready');
    } catch (error) {
      console.error('Radiant Media Player failed to initialize', error);
    }
  }
  initRmpPlayer(); 

</script>
```

--------------------------------

### Manage content metadata

Source: https://www.radiantmediaplayer.com/docs/latest/api-documentation.html

Get or set the content metadata object.

```javascript
const contentMetadata = rmp.contentMetadataConfiguration;
```

```javascript
rmp.contentMetadataConfiguration = {
  title,
  description,
  poster
};
```

--------------------------------

### Manage waiting UI

Source: https://www.radiantmediaplayer.com/docs/latest/api-documentation.html

Get or set the player waiting mode.

```javascript
const waitingUI = rmp.waitingUI;
```

```javascript
rmp.waitingUI = true;
```

--------------------------------

### Manage loop configuration

Source: https://www.radiantmediaplayer.com/docs/latest/api-documentation.html

Get or set the player loop mode.

```javascript
const loopConfiguration = rmp.loopConfiguration;
```

```javascript
rmp.loopConfiguration = true;
```

--------------------------------

### Get stream type

Source: https://www.radiantmediaplayer.com/docs/latest/api-documentation.html

Returns the currently loaded streaming protocol.

```javascript
const streamType = rmp.streamType;
```

--------------------------------

### rmp.init(settings)

Source: https://www.radiantmediaplayer.com/docs/latest/api-documentation.html

Initializes the player with the provided configuration settings.

```APIDOC
## rmp.init(settings)

### Description
Asynchronously initializes the player instance with the specified configuration object.

### Parameters
- **settings** (object) - Required - Configuration object containing licenseKey, src, width, height, and other player settings.

### Returns
- **Promise** - Resolves when the player is ready for API calls.
```

--------------------------------

### Manage playback state

Source: https://www.radiantmediaplayer.com/docs/latest/api-documentation.html

Get or set the player paused state.

```javascript
const paused = rmp.paused;
```

```javascript
rmp.paused = true;
```

--------------------------------

### init(settings)

Source: https://www.radiantmediaplayer.com/docs/latest/api-documentation.html

Initializes the Radiant Media Player instance with the provided settings.

```APIDOC
## init(settings)

### Description
Initializes the player. This method returns a Promise that resolves when the player is ready or rejects with an ErrorData object if initialization fails.

### Method
Method call on `rmp` instance.

### Parameters
- **settings** (Object) - Required - Configuration object for the player.

### Request Example
```javascript
try {
  await rmp.init(settings);
} catch (error) {
  console.log(error.code);
  console.log(error.message);
}
```
```

--------------------------------

### Get player version

Source: https://www.radiantmediaplayer.com/docs/latest/api-documentation.html

Retrieve the current player version string.

```javascript
const playerVersion = rmp.playerVersion;
```

--------------------------------

### download()

Source: https://www.radiantmediaplayer.com/docs/latest/offline-storage-playback.html

Requests the player to start downloading content for offline storage.

```APIDOC
## download()

### Description
Returns a Promise that resolves when the download request has completed or rejects with a WarningData object. The 'downloadcompleted' event fires when finished, while 'downloadstarted' and 'downloadprogress' provide status updates.
```

--------------------------------

### Initialize Radiant Media Player for Frame-Accurate Seeking

Source: https://www.radiantmediaplayer.com/docs/latest/frame-accurate-seeking.html

This example demonstrates how to configure the player with necessary settings like forceMseHlsOnAppleDevices and use the seekToFrame method once the player is playing.

```html
<!-- Include Radiant Media Player - here we use the optimised build for HLS streaming -->
<script src="https://cdn.radiantmediatechs.com/rmp/10.7.8/js/rmp-hlsjs.min.js"></script>
<!-- Player container element -->
<div id="rmp"></div>
<!-- Set up player configuration options -->
<script>

  // HLS streaming source
  const src = {
    hls: 'https://your-live-hls-url.m3u8'
  };
  // Your player settings
  const settings = {
    licenseKey: 'your-license-key',
    src,
    width: 640,
    height: 360,
    // If you use MP4/WebM progressive download you need to explicitly set frameRate setting
    // This is auto-guess for MPEG-DASH and HLS (FRAME-RATE attribute required in manifest for HLS)
    // frameRate: 24,
    // If you want to start using frame navigation before play set preload: 'auto'
    preload: 'auto',
    // For frame navigation to work on Apple devices
    forceMseHlsOnAppleDevices: true,
    contentMetadata: {
      poster: [
        'https://your-poster-url.jpg'
      ]
    }
  };

  const elementID = 'rmp';
  const rmp = new RadiantMP(elementID);

  rmp.one('playing', async () => {
    try {
      await rmp.seekToFrame('1000');
      //await rmp.seekToFrame('next'); // Also possible
    } catch (warning) {
      console.warn(warning);
    }
    rmp.pause();
    console.log(rmp.totalFramesNumber);
  });

  // Player initialisation
  async function initRmpPlayer() {
    try {
      await rmp.init(settings);  
      console.log('player ready');
    } catch (error) {
      console.error('Radiant Media Player failed to initialize', error);
    }
  }
  initRmpPlayer();

</script>
```

--------------------------------

### Initialize Radiant Media Player

Source: https://www.radiantmediaplayer.com/docs/latest/api-documentation.html

Basic setup including script inclusion, container definition, and player initialization with configuration settings.

```html
<!-- Include Radiant Media Player JavaScript file in your <body> or <head> -->
<script src="https://cdn.radiantmediatechs.com/rmp/10.7.8/js/rmp.min.js"></script>
<!-- Player container element -->
<div id="rmp"></div>
<!-- Set up player configuration options -->
<script>

  // Your streaming source - in this example HLS
  const src = {
    hls: 'https://your-hls-url.m3u8'
  };
  // Your player settings
  const settings = {
    licenseKey: 'your-license-key',
    src,
    width: 640,
    height: 360,
    contentMetadata: {
      poster: [
        'https://your-poster-url.jpg'
      ]
    }
  };

  const elementID = 'rmp';
  const rmp = new RadiantMP(elementID);

  rmp.on('playing', () => {
    console.log('player has received playing event');
    // Set a custom quality
    rmp.quality = 0;
  });

  // Player initialisation
  async function initRmpPlayer() {
    try {
      await rmp.init(settings);  
      console.log('player ready');
      // Player is ready - we can start making API calls
      console.log(rmp.streamType);
    } catch (error) {
      console.error('Radiant Media Player failed to initialize', error);
    }
  }
  initRmpPlayer();

</script>
```

--------------------------------

### RadiantMP.init(settings)

Source: https://www.radiantmediaplayer.com/docs/latest/documentation.html

Initializes the Radiant Media Player instance with a configuration object.

```APIDOC
## RadiantMP.init(settings)

### Description
Initializes the player with provided settings, including source, license key, and playback configurations.

### Parameters
- **settings** (Object) - Required - Configuration object containing player settings such as `licenseKey`, `src`, `speed`, `speedRates`, and `contentMetadata`.
```

--------------------------------

### livePresentationStartTimeAsDate

Source: https://www.radiantmediaplayer.com/docs/latest/live-dvr-streaming.html

Getter to retrieve the presentation start time of the live stream.

```APIDOC
### livePresentationStartTimeAsDate

#### Description
Returns the presentation start time date for the live stream as an ISO/IEC 8601:2004 string. Returns an empty string if not available.

#### Return Type
String
```

--------------------------------

### Initialize Radiant Media Player with FairPlay Streaming

Source: https://www.radiantmediaplayer.com/docs/latest/fairplay-drm-documentation.html

Basic implementation using the Apple reference sample pattern. Requires providing the HLS URL, server certificate URL, and processSPC URL within the fpsDrm configuration object.

```html
<!-- Include Radiant Media Player JavaScript file in your <body> or <head> -->
<script src="https://cdn.radiantmediatechs.com/rmp/10.7.8/js/rmp.min.js"></script>
<!-- Player container element -->
<div id="rmp"></div>
<!-- Set up player configuration options -->
<script>
  const src = { 
    fps: 'https://your-url-to-fps-hls.m3u8' 
  };
  const settings = {
    licenseKey: 'your-license-key',
    src,
    width: 640,
    height: 360,
    contentMetadata: {
      poster: [
        'https://your-poster-url.jpg'
      ]
    },
    // passing FPS DRM settings
    fpsDrm: {
      certificatePath: 'https://your-url-to-server-certificate.cer',
      processSpcPath: 'https://your-url-to-server-processSPC'
    }
  };
  const rmp = new RadiantMP('rmp');
  // Initialization ... and done!
  async function initRmpPlayer() {
    try {
      await rmp.init(settings);
    } catch(error) {
      console.error('Radiant Media Player failed to initialize', error);
    }
  }
  initRmpPlayer();
</script>
```

--------------------------------

### Get Ad Duration

Source: https://www.radiantmediaplayer.com/docs/latest/video-ads-api.html

Returns the total duration of the linear advertisement in milliseconds.

```javascript
rmp.adDuration;
```

--------------------------------

### Manage controls visibility

Source: https://www.radiantmediaplayer.com/docs/latest/api-documentation.html

Get or set whether player controls are visible.

```javascript
const controlsVisible = rmp.controlsVisible;
```

```javascript
rmp.controlsVisible = false;
```

--------------------------------

### Initialize Player and Overlay Logic

Source: https://www.radiantmediaplayer.com/docs/latest/player-modules.html

Include the player script and initialize the player instance, then append the custom overlay element to the player container with dynamic data updates.

```javascript
<script src="https://cdn.radiantmediatechs.com/rmp/10.7.8/js/rmp.min.js"></script>
<div id="rmp"></div>
<script>
  const src = {
    hls: 'https://your-hls-url.m3u8'
  };
  // player settings
  const settings = {
    licenseKey: 'your-license-key',
    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);

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

  // Player initialisation
  async function initRmpPlayer() {
    try {
      await rmp.init(settings);
      console.log('ready');

      // Add bandwidth data
      const textFieldBW = document.createElement('div');
      textFieldBW.textContent = 'Client bandwidth: ' + Math.round(rmp.bandwidthEstimate / 1000) + ' kbps';
      setInterval(() => {
        textFieldBW.textContent = 'Client bandwidth: ' + Math.round(rmp.bandwidthEstimate / 1000) + ' kbps';
      }, 1000);
      rmpCustomOverlay.appendChild(textFieldBW);

      // Add position data
      const options = {
        enableHighAccuracy: true,
        timeout: 5000,
        maximumAge: 3600000
      };
      navigator.geolocation.getCurrentPosition((pos) => {
        const crd = pos.coords;
        console.log(crd);
        const textFieldLat = document.createElement('div');
        textFieldLat.textContent = 'Latitude: ' + crd.latitude;
        const textFieldLong = document.createElement('div');
        textFieldLong.textContent = 'Longitude: ' + crd.longitude;
        rmpCustomOverlay.appendChild(textFieldLat);
        rmpCustomOverlay.appendChild(textFieldLong);
      }, (error) => {
        console.warn(`ERROR(${error.code}): ${error.message}`);
      }, options);
      rmpContainer.appendChild(rmpCustomOverlay);
    } catch (error) {
      console.error('Radiant Media Player failed to initialize', error);
    }
  }
  initRmpPlayer();
</script>
```

--------------------------------

### Implement Ad Error Event Handling

Source: https://www.radiantmediaplayer.com/docs/latest/video-ads-api-rmp-vast.html

Full example demonstrating player initialization and listening for the aderror event to query error details.

```html
<!-- Include Radiant Media Player JavaScript file in your <body> or <head> -->
<script src="https://cdn.radiantmediatechs.com/rmp/10.7.8/js/rmp.min.js"></script>
<div id="rmp"></div>
<!-- Set up player configuration options -->
<script>
  // Streaming source - HLS in this example
  const src = {
    hls: 'https://your-hls-url.m3u8'
  };
  // Player settings
  const settings = {
    licenseKey: 'your-license-key',
    src,
    width: 640,
    height: 360, 
    ads: true,
    // This is a demo VAST tag - use your own
    adParser: 'rmp-vast',
    adTagUrl: 'https://www.radiantmediaplayer.com/vast/tags/empty.xml',
    contentMetadata: {
      poster: [
        'https://your-poster-url.jpg'
      ]
    }
  };
  const elementID = 'rmp';
  const rmp = new RadiantMP(elementID);
  // We listen for the aderror event
  rmp.on('aderror', () => {
    // The Ad error API methods must be queried in an aderror callback
    console.log(rmp.adErrorType);
    console.log(rmp.adErrorMessage);
    console.log(rmp.adVastErrorCode);
  });
  // Initialization ... and done!
  async function initRmpPlayer() {
    try {
      await rmp.init(settings);
    } catch(error) {
      console.error('Radiant Media Player failed to initialize', error);
    }
  }
  initRmpPlayer();
</script>
```

--------------------------------

### Manage controls availability

Source: https://www.radiantmediaplayer.com/docs/latest/api-documentation.html

Get or set whether player controls are available.

```javascript
const controls = rmp.controls;
```

```javascript
rmp.controls = false;
```

--------------------------------

### AudioTrack object structure

Source: https://www.radiantmediaplayer.com/docs/latest/api-documentation.html

Example of the properties contained within an AudioTrack object.

```json
{
  active: true, // Boolean: if the current audio track active or not
  id: 0, // Number: the audio track id
  language: "en" // String: language code for the audio track
}
```

--------------------------------

### Configure Bitmovin Analytics and Handle Source Changes

Source: https://www.radiantmediaplayer.com/docs/latest/bitmovin-analytics.html

Demonstrates initializing the player with Bitmovin Analytics settings and updating the analytics configuration dynamically during a source change event.

```javascript
const src = {
  hls: 'https://your-hls-url.m3u8'
};
const analyticsConfig = {
  key: 'your-bitmovin-key',
  videoId: 'your-video-id',
  title: 'your-video-title'
};
const settings = {
  licenseKey: 'your-radiant-media-player-key',
  src,
  width: 640,
  height: 360,
  autoplay: true,
  // Pass Bitmovin Analytics settings
  bitmovinAnalyticsConfig: analyticsConfig
};
const rmp = new RadiantMP('rmp');     
// Example for changing source with a delay
setTimeout(() => {
  rmp.setSrc({
    hls: 'https://your-new-hls-url.m3u8'
  }).then(() => {
    console.log('setSrc has completed');
  }).catch(warningOrError => {
    // something went wrong with setSrc - it could be fatal error or warning
    if (warningOrError.code < 1000) {
      // this is a fatal error
      console.error(warningOrError);
    } else {
      // this is just a warning
      console.warn(warningOrError);
    }
  });
}, 10000);
      
const container = document.getElementById('rmp');
rmp.on('srcchanging', () => {
  // Example for checking the current bitmovinAnalyticsConfig setting
  let analytics = rmp.bitmovinAnalyticsConfiguration;
  console.log(analytics);
  // Set new bitmovinAnalyticsConfig just before the source change moves forward - e.g. srcchanging API event
  rmp.bitmovinAnalyticsConfiguration = {
    key: 'your-bitmovin-key', // Note you need to pass your Bitmovin key each time you call bitmovinAnalyticsConfiguration setter
    videoId: 'your-new-video-id',
    title: 'your-new-video-title'
  };
  // If needs be we can check the new bitmovinAnalyticsConfig object
  analytics = rmp.bitmovinAnalyticsConfiguration;
  console.log(analytics);
});

// Initialization ... and done!
async function initRmpPlayer() {
  try {
    await rmp.init(settings);
  } catch(error) {
    console.error('Radiant Media Player failed to initialize', error);
  }
}
initRmpPlayer();
```

--------------------------------

### Quality object structure

Source: https://www.radiantmediaplayer.com/docs/latest/api-documentation.html

Example of the properties contained within a Quality object.

```json
{
  active: true, // Boolean: if the current audio track active or not
  audioCodec: "mp4a.40.2", // String: the audio codec name when available
  bitrate: 727221, // Number: the bandwidth in bps required to the play the current rendition
  height: 360, // Number: the height in px of the rendition (not available for audio-only feed)
  id: 0, // Number: the bitrate id
  videoCodec: "avc1.4d401e", // String: the video codec name when available (not available for audio-only feed)
  width: 640 // Number: the width in px of the rendition (not available for audio-only feed)
}
```