@mediakind/mkplayer 1.0.22 → 1.0.24

package/src/BufferLevel.ts

@@ -1,7 +0,0 @@
-/**
- * Interface used to describe the MKPlayer's current buffer level
- */
-export interface BufferLevel {
-  audio: number;
-  video: number;
-}

package/src/LabelConfig.ts

@@ -1,14 +0,0 @@
-/**
- * Config to change the labels in the player dropdown
- */
-export interface LabelConfig {
-  /**
-   * list of labels to use in the audio dropdown
-   */
-  audio?: Record<string, string>;
-
-  /**
-   * list of labels to use in the captions dropdown
-   */
-  captions?: Record<string, string>;
-}

package/src/Logger.ts

@@ -1,51 +0,0 @@
-export class Logger {
-  private static enabled: boolean = false;
-
-  public static enable() {
-    this.enabled = true;
-  }
-
-  public static disable() {
-    this.enabled = false;
-  }
-
-  public static log(message?: any, ...optionalParams: any[]): void {
-    if (typeof console === 'undefined') {
-      return;
-    }
-
-    if (this.enabled) {
-      console.log(message, ...optionalParams);
-    }
-  }
-
-  public static error(message?: any, ...optionalParams: any[]): void {
-    if (typeof console === 'undefined') {
-      return;
-    }
-
-    if (this.enabled) {
-      console.error(message, ...optionalParams);
-    }
-  }
-
-  public static warn(message?: any, ...optionalParams: any[]): void {
-    if (typeof console === 'undefined') {
-      return;
-    }
-
-    if (this.enabled) {
-      console.warn(message, ...optionalParams);
-    }
-  }
-
-  public static debug(message?: any, ...optionalParams: any[]): void {
-    if (typeof console === 'undefined') {
-      return;
-    }
-
-    if (this.enabled) {
-      console.debug(message, ...optionalParams);
-    }
-  }
-}

package/src/MKPlayer.ts

@@ -1,390 +0,0 @@
-import {
-  BufferType, LogLevel, MediaType, Player, PlayerAPI, PlayerConfig, PlayerEvent, SourceConfig, SubtitleTrack,
-} from 'bitmovin-player';
-import { UIFactory } from 'bitmovin-player-ui';
-import { MKPlayerConfiguration } from './MKPlayerConfiguration';
-import { MKStream } from './MKStream';
-import { MKEvent } from './events/MKEvent';
-import { BufferLevel } from './BufferLevel';
-import { MKPlayerEventCallback } from './events/MKPlayerEventCallback';
-import { Logger } from './Logger';
-import { HttpRequest, HttpRequestType } from 'bitmovin-player/types/core/NetworkAPI';
-import { UrlType } from './events/UrlType';
-import { URLHelper } from './URLHelper';
-
-/**
- * MKPlayer is an HTML5 video player used for playback of HLS and DASH adaptive bitrate streams
- */
-export class MKPlayer {
-  private player: PlayerAPI;
-  private stream: MKStream;
-  /**
-   * constructor used to create a new MKPlayer instance
-   *
-   * @param containerElement - container that the video player will be rendered in
-   * @param mkPlayerConfiguration - configuration for this MKPlayer instance
-   */
-  constructor(containerElement: HTMLElement, mkPlayerConfiguration: MKPlayerConfiguration) {
-    let playerConfig: PlayerConfig = {
-      key: mkPlayerConfiguration.key,
-      playback: {
-        autoplay: mkPlayerConfiguration.autoplay,
-        muted: mkPlayerConfiguration.muted,
-      },
-      analytics: {
-        key: '1c45ae9c-345e-4462-95e2-3e8faccd64f1',
-      },
-      ui: {
-        disableAutoHideWhenHovered: true,
-      },
-      logs: {
-        level: LogLevel.OFF,
-        bitmovin: false,
-      },
-      network: {
-        preprocessHttpRequest: (type: HttpRequestType, request: HttpRequest) => {
-          if (type === 'manifest/hls/master' || type === 'manifest/hls/variant') {
-            if (typeof mkPlayerConfiguration.refreshToken === 'function') {
-              let urlType = this.stream.didFailOver ? UrlType.Secondary : UrlType.Primary;
-              let token = mkPlayerConfiguration.refreshToken(urlType);
-              console.log('[MKPlayer] Appending ' + urlType + ' token: ' + token.name + '=' + token.value);
-              request.url = URLHelper.appendToken(request.url, token.name, token.value);
-            }
-          }
-          return Promise.resolve(request);
-        },
-        preprocessHttpResponse: (type, response) => {
-          if (type === 'manifest/hls/master') {
-            let body = this.manipulateMasterPlaylist((response.body as string));
-            // @ts-ignore
-            response.body = body;
-          }
-          return Promise.resolve(response);
-        },
-      },
-    };
-
-    if (mkPlayerConfiguration.targetLatency > 0) {
-      playerConfig.live = {
-        lowLatency: {
-          targetLatency: mkPlayerConfiguration.targetLatency,
-          catchup: {
-            playbackRateThreshold: 0.075,
-            seekThreshold: 12,
-            playbackRate: 1.2,
-          },
-          fallback: {
-            playbackRateThreshold: 0.075,
-            seekThreshold: 12,
-            playbackRate: 0.8,
-          },
-        },
-      };
-    }
-
-    let player = new Player(containerElement, playerConfig);
-    if (mkPlayerConfiguration.ui !== false) {
-      if (mkPlayerConfiguration.smallScreen) {
-        UIFactory.buildDefaultSmallScreenUI(player);
-      } else {
-        UIFactory.buildDefaultUI(player, playerConfig.ui);
-      }
-    }
-
-    if (mkPlayerConfiguration.debug) {
-      Logger.enable();
-    }
-
-    this.player = player;
-    console.log('%c MKPlayer ' + this.version() + ' www.mediakind.com', 'color: blue');
-  }
-
-  /**
-   * start playback or resumes playback after the player has been paused
-   */
-  play(): Promise<void> {
-    return this.player.play();
-  }
-
-  /**
-   * pauses playback on the player
-   */
-  pause(): void {
-    this.player.pause();
-  }
-
-  /**
-   * destroys the video player. You must create a new MKPlayer if this method is called
-   */
-  destroy(): Promise<void> {
-    return this.player.destroy();
-  }
-
-  /**
-   * Loads a new stream for playback
-   *
-   * @param stream - the stream the player will load
-   */
-  load(stream: MKStream): Promise<void> {
-    let playerSource: SourceConfig;
-    this.stream = stream;
-    let url: string = this.selectUrl();
-
-    if (url.includes('.m3u8')) {
-      playerSource = {
-        hls: url,
-      };
-    } else if (url.includes('.mp4')) {
-      playerSource = {
-        progressive: url,
-      };
-    } else {
-      playerSource = {
-        dash: url,
-      };
-    }
-
-    if (stream.poster) {
-      playerSource.poster = stream.poster;
-    }
-
-      playerSource.labeling = {
-        hls: {
-          tracks: (track) => {
-            if (this.stream.labelConfig && this.stream.labelConfig.audio && this.stream.labelConfig.audio[track.lang]) {
-              return this.stream.labelConfig.audio[track.lang];
-            } else {
-              return track.lang;
-            }
-          },
-          subtitles: (track) => {
-            console.log(track);
-            if (this.stream.labelConfig && this.stream.labelConfig.captions && this.stream.labelConfig.captions[track.lang]) {
-              return this.stream.labelConfig.captions[track.lang];
-            } else {
-              return track.lang;
-            }
-          },
-        },
-      };
-
-    if (stream.assetIdentifier) {
-      playerSource.analytics = {
-        videoId: stream.assetIdentifier,
-        userId: stream.userId,
-        customData1: stream.customData1,
-        customData2: stream.customData2,
-        customData3: stream.customData3,
-        customData4: stream.customData4,
-        customData5: stream.customData5,
-        customData6: this.version(),
-      };
-    }
-
-    if (stream.subtitleTracks && stream.subtitleTracks[0] && stream.subtitleTracks[0].url && !stream.subtitleTracks[0].url.includes('.m3u8')) {
-      playerSource.subtitleTracks = stream.subtitleTracks.map((track) => <SubtitleTrack>{
-        lang: track.language,
-        url: track.url,
-        id: MKPlayer.makeId(4),
-      });
-    }
-
-    Logger.log('[MKPlayer] loading source - ' + JSON.stringify(playerSource));
-
-    return this.player.load(playerSource);
-  }
-
-  /**
-   * Removes a handler for a MKEvent
-   *
-   * @param eventType
-   * @param callback
-   */
-  off(eventType: MKEvent, callback: MKPlayerEventCallback): void {
-    let playerEventType = MKPlayer.mapEvent(eventType);
-    return this.player.off(playerEventType, callback);
-  }
-
-  /**
-   * Subscribes and event handler to a MKEvent
-   *
-   * @param eventType
-   * @param callback
-   */
-  on(eventType: MKEvent, callback: MKPlayerEventCallback): void {
-    let playerEventType = MKPlayer.mapEvent(eventType);
-    return this.player.on(playerEventType, callback);
-  }
-
-  /**
-   * unloads the current playing stream
-   */
-  unload(): Promise<void> {
-    return this.player.unload();
-  }
-
-  /**
-   * gets the player's current time
-   */
-  getCurrentTime(): number {
-    return this.player.getCurrentTime();
-  }
-
-  /**
-   * gets the current audio and video buffer levels
-   *
-   * @returns
-   */
-  getBufferLevels(): BufferLevel {
-    return {
-      audio: this.player.buffer.getLevel(BufferType.ForwardDuration, MediaType.Audio).level,
-      video: this.player.buffer.getLevel(BufferType.ForwardDuration, MediaType.Video).level,
-    };
-  }
-
-  /**
-   * sets the target latency during live playback
-   * @param latency
-   */
-  setTargetLatency(latency: number) {
-    this.player.lowlatency.setTargetLatency(latency);
-  }
-
-  /**
-   * sets the target latency during live playback
-   * @param latency
-   */
-  getLatency(): number {
-    return this.player.lowlatency.getLatency();
-  }
-
-  /**
-   * mutes the player
-   */
-  mute(): void {
-    this.player.mute();
-  }
-
-  /**
-   * gets the current playback speed
-   */
-  playbackSpeed(): number {
-    return this.player.getPlaybackSpeed();
-  }
-
-  /**
-   * unmute the player
-   */
-  unmute(): void {
-    this.player.unmute();
-  }
-
-  /**
-   * sets the player's volume in the range of 0 (silent) to 100 (max volume)
-   *
-   * @param volume The volume to set between 0 and 100
-   */
-  setVolume(volume: number): void {
-    this.player.setVolume(volume);
-  }
-
-  /**
-   * returns the current player version
-   */
-  version(): string {
-    return '1.0.21';
-  }
-
-  private selectUrl(): string {
-    let rand = MKPlayer.getRandomInt(99);
-    if (this.stream.cdnFailoverPercent && this.stream.secondaryUrl && rand < this.stream.cdnFailoverPercent) {
-      Logger.log('[MKPlayer] selecting secondary source url - ' + this.stream.secondaryUrl);
-      this.stream.didFailOver = true;
-      return this.stream.secondaryUrl;
-    } else {
-      Logger.log('[MKPlayer] selecting primary source url - ' + this.stream.primaryUrl);
-      this.stream.didFailOver = false;
-      return this.stream.primaryUrl;
-    }
-  }
-
-  private static getRandomInt(max: number) {
-    return Math.floor(Math.random() * Math.floor(max));
-  }
-
-  private static makeId(length) {
-    let result = '';
-    let characters = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789';
-    let charactersLength = characters.length;
-    for (let i = 0; i < length; i++) {
-      result += characters.charAt(Math.floor(Math.random() * charactersLength));
-    }
-    return result;
-  }
-
-  private static mapEvent(event: MKEvent): PlayerEvent {
-    let playerEventType: PlayerEvent;
-    switch (event) {
-      case MKEvent.BufferingStarted:
-        playerEventType = PlayerEvent.StallStarted;
-        break;
-      case MKEvent.BufferingEnded:
-        playerEventType = PlayerEvent.StallEnded;
-        break;
-      case MKEvent.Playing:
-        playerEventType = PlayerEvent.Playing;
-        break;
-      case MKEvent.Paused:
-        playerEventType = PlayerEvent.Paused;
-        break;
-      case MKEvent.TimeChanged:
-        playerEventType = PlayerEvent.TimeChanged;
-        break;
-      case MKEvent.Ready:
-        playerEventType = PlayerEvent.Ready;
-        break;
-      case MKEvent.Error:
-        playerEventType = PlayerEvent.Error;
-        break;
-      case MKEvent.StreamFinished:
-        playerEventType = PlayerEvent.PlaybackFinished;
-        break;
-      case MKEvent.Warning:
-        playerEventType = PlayerEvent.Warning;
-        break;
-      case MKEvent.QualityChanged:
-        playerEventType = PlayerEvent.VideoPlaybackQualityChanged;
-        break;
-      case MKEvent.SegmentPlayback:
-        playerEventType = PlayerEvent.SegmentPlayback;
-        break;
-      case MKEvent.Unloaded:
-        playerEventType = PlayerEvent.SourceUnloaded;
-        break;
-      case MKEvent.Metadata:
-        playerEventType = PlayerEvent.Metadata;
-        break;
-      case MKEvent.MetadataParsed:
-        playerEventType = PlayerEvent.MetadataParsed;
-        break;
-    }
-    return playerEventType;
-  }
-
-  private manipulateMasterPlaylist(response: string): string {
-    let body = (response as string);
-    if (this.stream.subtitleTracks && this.stream.subtitleTracks[0] && this.stream.subtitleTracks[0].url && this.stream.subtitleTracks[0].url.includes('.m3u8')) {
-      this.stream.subtitleTracks.forEach((track) => {
-        body = body.concat('\n#EXT-X-MEDIA:TYPE=SUBTITLES,'
-          + 'NAME="' + track.language + '",'
-          + 'DEFAULT=YES,'
-          + 'AUTOSELECT=YES,'
-          + 'FORCED=NO,'
-          + 'LANGUAGE="' + track.language + '",GROUP-ID="Subtitles",'
-          + 'URI="' + track.url + '"');
-      });
-    }
-
-    return body;
-  }
-}

package/src/MKPlayerConfiguration.ts

@@ -1,51 +0,0 @@
-/**
- * MKPlayer's configuration interface
- */
-import { UrlType } from './events/UrlType';
-
-export interface MKPlayerConfiguration {
-  /**
-   * Toggles debug output logging
-   */
-  debug: boolean;
-
-  /**
-   * Option to enable the player to start playback after successfully loading a source
-   */
-  autoplay: boolean;
-
-  /**
-   * Option to enable the player to start in a muted state. The user is able to unmute via the UI or an API call through
-   */
-  muted: boolean;
-
-  /**
-   * Boolean indicating if the player should load the small screen ui
-   */
-  smallScreen: boolean;
-
-  /**
-   * Boolean to enable / disable ui
-   */
-  ui: boolean;
-
-  /**
-   * number of seconds the player attempts to stay behind the live point
-   */
-  targetLatency: number;
-
-  /**
-   * license key for the video player
-   */
-  key: string;
-
-  /**
-   * Refresh the CDN Token
-   */
-  refreshToken?: (type: UrlType) => TokenParam;
-}
-
-export interface TokenParam {
-  name: string;
-  value: string;
-}

package/src/MKStream.ts

@@ -1,154 +0,0 @@
-/**
- * Configuration object used when loading a new stream
- */
-import { SubtitleTrack } from './SubtitleTrack';
-import { LabelConfig } from './LabelConfig';
-
-export class MKStream {
-  private readonly _assetIdentifier: string;
-  private readonly _primaryUrl?: string;
-  private readonly _secondaryUrl?: string;
-  private readonly _subtitleTracks: SubtitleTrack[];
-  private readonly _cdnFailoverPercent: number = 0;
-  private readonly _poster: string;
-  private readonly _userId: string;
-  private readonly _customData1: string;
-  private readonly _customData2: string;
-  private readonly _customData3: string;
-  private readonly _customData4: string;
-  private readonly _customData5: string;
-  private readonly _labelConfig: LabelConfig;
-  private _didFailOver: boolean = false;
-
-  /**
-   *
-   * @param primaryUrl - primary stream url
-   * @param secondaryUrl - secondary backup stream url
-   * @param subtitleTracks - a list of external subtitle tracks that should be loaded with the player
-   * @param poster - url to a poster image to render on the player
-   * @param cdnFailoverPercent - percent value from 0-100 describing what percentage of users should initially playback
-   *   the secondary url
-   * @param assetIdentifier - identifier for the current stream
-   * @param labelConfig - config to change the labels in the player dropdown
-   */
-  constructor(primaryUrl: string, assetIdentifier: string, subtitleTracks?: SubtitleTrack[], poster?: string, secondaryUrl?: string, cdnFailoverPercent?: number, userId?: string, customData1?: string, customData2?: string, customData3?: string, customData4?: string, customData5?: string, labelConfig?: LabelConfig) {
-    this._cdnFailoverPercent = cdnFailoverPercent;
-    this._secondaryUrl = secondaryUrl;
-    this._primaryUrl = primaryUrl;
-    this._assetIdentifier = assetIdentifier;
-    this._subtitleTracks = subtitleTracks;
-    this._poster = poster;
-    this._userId = userId;
-    this._customData1 = customData1;
-    this._customData2 = customData2;
-    this._customData3 = customData3;
-    this._customData4 = customData4;
-    this._customData5 = customData5;
-    this._labelConfig = labelConfig;
-  }
-
-  /**
-   * percent value from 0-100 describing what percentage of users should playback the secondary url
-   */
-  public get cdnFailoverPercent(): number {
-    return this._cdnFailoverPercent;
-  }
-
-  /**
-   * primary stream url used during playback
-   */
-  public get primaryUrl(): string {
-    return this._primaryUrl;
-  }
-
-  /**
-   * secondary stream url used during playback
-   */
-  public get secondaryUrl(): string {
-    return this._secondaryUrl;
-  }
-
-  /**
-   * percent value from 0-100 describing what percentage of users should playback the secondary url
-   */
-  public get subtitleTracks(): SubtitleTrack[] {
-    return this._subtitleTracks;
-  }
-
-  /**
-   * identifier for the current stream
-  */
-  public get assetIdentifier(): string {
-    return this._assetIdentifier;
-  }
-
-  /**
-   * poster art for the current stream
-   */
-  public get poster(): string {
-    return this._poster;
-  }
-
-  /**
-   * customData1 field for the current stream
-   */
-  public get customData1(): string {
-    return this._customData1;
-  }
-
-  /**
-   * customData2 field for the current stream
-   */
-  public get customData2(): string {
-    return this._customData2;
-  }
-
-  /**
-   * customData3 field for the current stream
-   */
-  public get customData3(): string {
-    return this._customData3;
-  }
-
-  /**
-   * customData5 field for the current stream
-   */
-  public get customData4(): string {
-    return this._customData4;
-  }
-
-  /**
-   * customData5 field for the current stream
-   */
-  public get customData5(): string {
-    return this._customData5;
-  }
-
-  /**
-   * userId field for the current stream
-   */
-  public get userId(): string {
-    return this._userId;
-  }
-
-  /**
-   * config to change the labels in the player dropdown
-   */
-  public get labelConfig(): LabelConfig {
-    return this._labelConfig;
-  }
-
-  /**
-   * boolean value describing if failover happened
-   */
-  public get didFailOver(): boolean {
-    return this._didFailOver;
-  }
-
-  /**
-   * setter for the didFailOver boolean value
-   */
-  public set didFailOver(value: boolean) {
-    this._didFailOver = value;
-  }
-}

package/src/SubtitleTrack.ts

@@ -1,14 +0,0 @@
-/**
- * Used to describe an external subtitle track (WebVtt or srt) outside of the MKStream manifest url
- */
-export interface SubtitleTrack {
-  /**
-   * url to the external subtitle track
-   */
-  url: string;
-
-  /**
-   * language of the subtitle track. This string will be displayed in the UI
-   */
-  language: string;
-}