@playkit-js/playkit-js-providers 2.40.1 → 2.40.2-canary.0-45b4098

package/src/k-provider/ovp/loaders/session-loader.ts

@@ -0,0 +1,62 @@
+import OVPSessionService from '../services/session-service';
+import OVPConfiguration from '../config';
+import RequestBuilder from '../../../util/request-builder';
+import {ILoader} from '../../../types';
+
+export default class OVPSessionLoader implements ILoader {
+  private _widgetId: string;
+  private _requests!: Array<RequestBuilder>;
+  private _response: any = {};
+
+  public static get id(): string {
+    return 'session';
+  }
+
+  public set requests(requests: Array<RequestBuilder>) {
+    this._requests = requests;
+  }
+
+  public get requests(): Array<RequestBuilder> {
+    return this._requests;
+  }
+
+  public set response(response: any) {
+    this._response.ks = response[0].data.ks;
+  }
+
+  public get response(): any {
+    return this._response.ks;
+  }
+
+  /**
+   * @constructor
+   * @param {Object} params loader params
+   */
+  constructor(params: any) {
+    this.requests = this.buildRequests(params);
+    this._widgetId = params.widgetId;
+  }
+
+  /**
+   * Builds loader requests
+   * @function
+   * @param {Object} params Requests parameters
+   * @returns {RequestBuilder} The request builder
+   * @static
+   */
+  public buildRequests(params: any): Array<RequestBuilder> {
+    const config = OVPConfiguration.get();
+    const requests: Array<RequestBuilder> = [];
+    requests.push(OVPSessionService.anonymousSession(config.serviceUrl, params.widgetId));
+    return requests;
+  }
+
+  /**
+   * Loader validation function
+   * @function
+   * @returns {boolean} Is valid
+   */
+  public isValid(): boolean {
+    return !!this._widgetId;
+  }
+}

package/src/k-provider/ovp/loaders/ui-config-loader.ts

@@ -0,0 +1,71 @@
+import OVPUIConfService from '../services/ui-conf-service';
+import {KalturaUIConfResponse} from '../response-types';
+import OVPConfiguration from '../config';
+import RequestBuilder from '../../../util/request-builder';
+import {ILoader} from '../../../types';
+
+export default class OVPUIConfigLoader implements ILoader {
+  private _uiConfId: number;
+  private _requests!: Array<RequestBuilder>;
+  private _response: any = {};
+
+  public static get id(): string {
+    return 'uiConf';
+  }
+
+  public set requests(requests: Array<RequestBuilder>) {
+    this._requests = requests;
+  }
+
+  public get requests(): Array<RequestBuilder> {
+    return this._requests;
+  }
+
+  public set response(response: any) {
+    this._response.uiConf = new KalturaUIConfResponse(response[0].data);
+  }
+
+  public get response(): any {
+    if (this._response && this._response.uiConf && this._response.uiConf.config)
+      try {
+        return JSON.parse(this._response.uiConf.config).plugins;
+      } catch (err) {
+        return null;
+      }
+    else {
+      return null;
+    }
+  }
+
+  /**
+   * @constructor
+   * @param {Object} params loader params
+   */
+  constructor(params: any) {
+    this.requests = this.buildRequests(params);
+    this._uiConfId = params.uiConfId;
+  }
+
+  /**
+   * Builds loader requests
+   * @function
+   * @param {Object} params Requests parameters
+   * @returns {RequestBuilder} The request builder
+   * @static
+   */
+  public buildRequests(params: any): Array<RequestBuilder> {
+    const config = OVPConfiguration.get();
+    const requests: Array<RequestBuilder> = [];
+    requests.push(OVPUIConfService.get(config.serviceUrl, params.ks, params.uiConfId));
+    return requests;
+  }
+
+  /**
+   * Loader validation function
+   * @function
+   * @returns {boolean} Is valid
+   */
+  public isValid(): boolean {
+    return !!this._uiConfId;
+  }
+}

package/src/k-provider/ovp/play-source-url-builder.ts

@@ -0,0 +1,59 @@
+import OVPConfiguration from './config';
+
+type urlParamsType = {
+  partnerId: number,
+  entryId: string,
+  ks: string,
+  uiConfId?: number,
+  format: string,
+  protocol: string,
+  extension: string,
+  flavorIds?: string
+};
+
+export default class PlaySourceUrlBuilder {
+  /**
+   * Returns source url by given url params
+   * @function build
+   * @param {urlParamsType} urlParams The params
+   * @returns {string} The URL
+   * @static
+   */
+  public static build(urlParams: urlParamsType): string {
+    const config = OVPConfiguration.get();
+    const serviceUrlOrigin: string = config.serviceUrl.substr(0, config.serviceUrl.lastIndexOf('/'));
+    const {partnerId, entryId, ks, uiConfId, format, protocol, extension, flavorIds} = urlParams;
+
+    //verify mandatory params
+    // @ts-expect-error - fff
+    if (!serviceUrlOrigin || isNaN(Number.parseInt(partnerId)) || !entryId || !format || !protocol) {
+      return '';
+    }
+
+    let playUrl = serviceUrlOrigin;
+    if (!serviceUrlOrigin.endsWith('/')) {
+      playUrl += '/';
+    }
+    playUrl += 'p/' + partnerId + '/sp/' + partnerId + '00' + '/playManifest/entryId/' + entryId + '/protocol/' + protocol + '/format/' + format;
+
+    if (flavorIds) {
+      playUrl += '/flavorIds/' + flavorIds;
+    } else if (uiConfId) {
+      playUrl += '/uiConfId/' + uiConfId;
+    }
+
+    if (ks !== '') {
+      playUrl += '/ks/' + ks;
+    }
+
+    if (extension !== '') {
+      playUrl += '/a.' + extension;
+    }
+
+    if (uiConfId && flavorIds !== '') {
+      playUrl += '?uiConfId=' + uiConfId;
+    }
+
+    return playUrl;
+  }
+}

package/src/k-provider/ovp/provider-parser.ts

@@ -0,0 +1,461 @@
+import { KalturaPlaybackContext, KalturaUserEntry } from './response-types';
+import {KalturaMetadataListResponse} from './response-types';
+import {KalturaMediaEntry} from './response-types';
+import {KalturaPlaybackSource} from './response-types';
+import {KalturaBumper} from './response-types';
+import {KalturaDrmPlaybackPluginData} from '../common/response-types/kaltura-drm-playback-plugin-data';
+import PlaySourceUrlBuilder from './play-source-url-builder';
+import XmlParser from '../../util/xml-parser';
+import getLogger from '../../util/logger';
+import OVPConfiguration from './config';
+import MediaEntry from '../../entities/media-entry';
+import Drm from '../../entities/drm';
+import MediaSource from '../../entities/media-source';
+import MediaSources from '../../entities/media-sources';
+import {SupportedStreamFormat, isProgressiveSource} from '../../entities/media-format';
+import Playlist from '../../entities/playlist';
+import EntryList from '../../entities/entry-list';
+import Bumper from '../../entities/bumper';
+import {KalturaRuleAction} from './response-types';
+import {KalturaAccessControlMessage} from '../common/response-types/kaltura-access-control-message';
+import type {OVPMediaEntryLoaderResponse} from './loaders/media-entry-loader';
+import {ExternalCaptionsBuilder} from './external-captions-builder';
+import {ImageSource} from '../../entities/image-source';
+
+class OVPProviderParser {
+  private static _logger = getLogger('OVPProviderParser');
+
+  /**
+   * Returns parsed media entry by given OVP response objects
+   * @function getMediaEntry
+   * @param {string} ks - The ks
+   * @param {number} partnerId - The partner ID
+   * @param {number} uiConfId - The uiConf ID
+   * @param {any} mediaEntryResponse - The media entry response
+   * @returns {MediaEntry} - The media entry
+   * @static
+   * @public
+   */
+  public static getMediaEntry(ks: string, partnerId: number, uiConfId: number | undefined, mediaEntryResponse: any): MediaEntry {
+    const mediaEntry = new MediaEntry();
+    const entry = mediaEntryResponse.entry;
+    const playbackContext = mediaEntryResponse.playBackContextResult;
+    const metadataList = mediaEntryResponse.metadataListResult;
+    const kalturaSources = playbackContext.sources;
+
+    mediaEntry.sources = OVPProviderParser._getParsedSources(kalturaSources, ks, partnerId, uiConfId, entry, playbackContext);
+    OVPProviderParser._fillBaseData(mediaEntry, entry, metadataList);
+    if (mediaEntry.type !== MediaEntry.Type.LIVE && OVPConfiguration.get().useApiCaptions && playbackContext.data.playbackCaptions) {
+      mediaEntry.sources.captions = ExternalCaptionsBuilder.createConfig(playbackContext.data.playbackCaptions, ks);
+    }
+    return mediaEntry;
+  }
+
+  /**
+   * Returns the url with KS
+   * @function addKsToUrl
+   * @param {String} url - The url to add the KS
+   * @param {string} ks - The ks
+   * @returns {string} - The url with KS
+   * @static
+   * @public
+   */
+  public static addKsToUrl(url: string, ks: string): string {
+    const hasUrlExtension = (path): boolean => {
+      const pathWithoutQuery = path.split('?')[0];
+      const pathAfterLastSlash = pathWithoutQuery.replace(/^.*[\\/]/, '');
+      return pathAfterLastSlash.indexOf('.') !== -1;
+    };
+    let ksParam;
+    if (ks) {
+      if (hasUrlExtension(url)) {
+        ksParam = url.indexOf('?') === -1 ? '?ks=' : '&ks=';
+      } else {
+        ksParam = '/ks/';
+      }
+      return url + ksParam + ks;
+    }
+    return url;
+  }
+
+  /**
+   * Returns parsed playlist by given OVP response objects
+   * @function getPlaylist
+   * @param {any} playlistResponse - The playlist response
+   * @returns {Playlist} - The playlist
+   * @static
+   * @public
+   */
+  public static getPlaylist(playlistResponse: any): Playlist {
+    const playlist = new Playlist();
+    const playlistData = playlistResponse.playlistData;
+    const playlistItems = playlistResponse.playlistItems.entries;
+    const playlistUserEntries = playlistResponse.playlistUserEntries.entries;
+    playlist.id = playlistData.id;
+    playlist.name = playlistData.name;
+    playlist.description = playlistData.description;
+    playlist.poster = playlistData.poster;
+    playlist.playlistLastEntryId = playlistUserEntries.map((entry: KalturaUserEntry) => {
+      return entry.playlistLastEntryId;
+    })[0];
+    playlistItems.forEach((entry: KalturaMediaEntry) => {
+      const mediaEntry = new MediaEntry();
+      OVPProviderParser._fillBaseData(mediaEntry, entry);
+      playlist.items.push(mediaEntry);
+    });
+    return playlist;
+  }
+
+  /**
+   * Returns parsed entry list by given OVP response objects
+   * @function getEntryList
+   * @param {any} playlistResponse - response
+   * @returns {Playlist} - The entry list
+   * @static
+   * @public
+   */
+  public static getEntryList(playlistResponse: any): EntryList {
+    const entryList = new EntryList();
+    const playlistItems = playlistResponse.playlistItems.entries;
+    playlistItems.forEach(entry => {
+      const mediaEntry = new MediaEntry();
+      OVPProviderParser._fillBaseData(mediaEntry, entry);
+      entryList.items.push(mediaEntry);
+    });
+    return entryList;
+  }
+
+  /**
+   * Returns parsed bumper by given OTT response objects.
+   * @function getBumper
+   * @param {any} assetResponse - The asset response.
+   * @param {string} ks - The ks
+   * @param {number} partnerId - The partner ID
+   * @returns {?Bumper} - The bumper
+   * @static
+   * @public
+   */
+  public static getBumper(assetResponse: any, ks: string, partnerId: number): Bumper | undefined {
+    const playbackContext = assetResponse.playBackContextResult;
+    const bumperData: KalturaBumper = playbackContext.bumperData[0];
+    if (bumperData) {
+      const bumperSources = bumperData && bumperData.sources;
+      const progressiveBumper = bumperSources.find(bumper => isProgressiveSource(bumper.format));
+      if (progressiveBumper) {
+        const parsedSources = OVPProviderParser._parseProgressiveSources(progressiveBumper, playbackContext, ks, partnerId, 0, bumperData.entryId);
+        if (parsedSources[0]) {
+          return new Bumper({url: parsedSources[0].url, clickThroughUrl: bumperData.clickThroughUrl});
+        }
+      }
+    }
+  }
+
+  private static _fillBaseData(mediaEntry: MediaEntry, entry: KalturaMediaEntry, metadataList?: KalturaMetadataListResponse): MediaEntry {
+    mediaEntry.poster = entry.poster;
+    mediaEntry.id = entry.id;
+    mediaEntry.duration = entry.duration;
+    mediaEntry.downloadUrl = entry.downloadUrl || '';
+    mediaEntry.metadata = OVPProviderParser._parseMetadata(metadataList);
+    mediaEntry.metadata.description = entry.description || '';
+    mediaEntry.metadata.entryId = entry.id || '';
+    mediaEntry.metadata.name = entry.name || '';
+    if (entry.createdAt) mediaEntry.metadata.createdAt = entry.createdAt;
+    if (entry.updatedAt) mediaEntry.metadata.updatedAt = entry.updatedAt;
+    if (entry.creatorId) mediaEntry.metadata.creatorId = entry.creatorId;
+    if (entry.endDate) mediaEntry.metadata.endDate = entry.endDate;
+    if (entry.views) mediaEntry.metadata.views = entry.views;
+    if (entry.plays) mediaEntry.metadata.plays = entry.plays;
+    mediaEntry.metadata.tags = entry.tags || '';
+    mediaEntry.status = entry.status;
+
+    mediaEntry.type = OVPProviderParser._getEntryType(entry.entryType, entry.type);
+    if (mediaEntry.type === MediaEntry.Type.LIVE) {
+      mediaEntry.dvrStatus = entry.dvrStatus;
+    }
+
+    return mediaEntry;
+  }
+
+  private static _getEntryType(entryTypeEnum: number, typeEnum: number | string): string {
+    let type = MediaEntry.Type.UNKNOWN;
+    switch (entryTypeEnum) {
+    case KalturaMediaEntry.MediaType.IMAGE.value:
+      type = MediaEntry.Type.IMAGE;
+      break;
+    case KalturaMediaEntry.MediaType.AUDIO.value:
+      type = MediaEntry.Type.AUDIO;
+      break;
+    default:
+      switch (typeEnum) {
+      case KalturaMediaEntry.EntryType.MEDIA_CLIP.value:
+        type = MediaEntry.Type.VOD;
+        break;
+      case KalturaMediaEntry.EntryType.LIVE_STREAM.value:
+      case KalturaMediaEntry.EntryType.LIVE_CHANNEL.value:
+        type = MediaEntry.Type.LIVE;
+        break;
+      default:
+        type = MediaEntry.Type.UNKNOWN;
+      }
+    }
+    return type;
+  }
+
+  /**
+   * Returns the parsed sources
+   * @function _getParsedSources
+   * @param {Array<KalturaPlaybackSource>} kalturaSources - The kaltura sources
+   * @param {string} ks - The ks
+   * @param {number} partnerId - The partner ID
+   * @param {number} uiConfId - The uiConf ID
+   * @param {Object} entry - The entry
+   * @param {KalturaPlaybackContext} playbackContext - The playback context
+   * @return {MediaSources} - A media sources
+   * @static
+   * @private
+   */
+  private static _getParsedSources(
+    kalturaSources: Array<KalturaPlaybackSource>,
+    ks: string,
+    partnerId: number,
+    uiConfId: number | undefined,
+    entry: any,
+    playbackContext: KalturaPlaybackContext
+  ): MediaSources {
+    const sources = new MediaSources();
+    const addAdaptiveSource = (source: KalturaPlaybackSource): void => {
+      const parsedSource = OVPProviderParser._parseAdaptiveSource(source, playbackContext, ks, partnerId, uiConfId, entry.id);
+      if (parsedSource) {
+        const sourceFormat = SupportedStreamFormat.get(source.format);
+        sources.map(parsedSource, sourceFormat);
+      }
+    };
+    const parseAdaptiveSources = (): void => {
+      kalturaSources.filter(source => !isProgressiveSource(source.format)).forEach(addAdaptiveSource);
+    };
+    // eslint-disable-next-line  @typescript-eslint/explicit-function-return-type
+    const parseProgressiveSources = () => {
+      const progressiveSource = kalturaSources.find(source => {
+        //match progressive source with supported protocol(http/s)
+        return isProgressiveSource(source.format) && source.getProtocol(OVPProviderParser._getBaseProtocol()) !== '';
+      });
+      sources.progressive = OVPProviderParser._parseProgressiveSources(progressiveSource, playbackContext, ks, partnerId, uiConfId, entry.id);
+    };
+
+    const parseImageSources = (): void => {
+      sources.image.push(new ImageSource(entry));
+    };
+
+    const parseExternalMedia = (): void => {
+      const mediaSource = new MediaSource();
+      mediaSource.mimetype = 'video/youtube';
+      mediaSource.url = entry.referenceId;
+      mediaSource.id = entry.id + '_youtube';
+      sources.progressive.push(mediaSource);
+    };
+
+    if (entry.type === KalturaMediaEntry.EntryType.EXTERNAL_MEDIA.value) {
+      parseExternalMedia();
+    } else if (entry.entryType === KalturaMediaEntry.MediaType.IMAGE.value) {
+      parseImageSources();
+    } else if (kalturaSources && kalturaSources.length > 0) {
+      parseAdaptiveSources();
+      parseProgressiveSources();
+    }
+    return sources;
+  }
+
+  /**
+   * Returns a parsed adaptive source
+   * @function _parseAdaptiveSource
+   * @param {KalturaPlaybackSource} kalturaSource - A kaltura source
+   * @param {KalturaPlaybackContext} playbackContext - The playback context
+   * @param {string} ks - The ks
+   * @param {number} partnerId - The partner ID
+   * @param {number} uiConfId - The uiConf ID
+   * @param {string} entryId - The entry id
+   * @returns {?MediaSource} - The parsed adaptive kalturaSource
+   * @static
+   * @private
+   */
+  private static _parseAdaptiveSource(
+    kalturaSource: KalturaPlaybackSource,
+    playbackContext: KalturaPlaybackContext,
+    ks: string,
+    partnerId: number,
+    uiConfId: number | undefined,
+    entryId: string
+  ): MediaSource | null {
+    const mediaSource: MediaSource = new MediaSource();
+    if (kalturaSource) {
+      let playUrl: string = '';
+      const mediaFormat = SupportedStreamFormat.get(kalturaSource.format);
+      const protocol = kalturaSource.getProtocol(OVPProviderParser._getBaseProtocol());
+      const deliveryProfileId = kalturaSource.deliveryProfileId;
+      const format = kalturaSource.format;
+      let extension: string = '';
+      if (mediaFormat) {
+        extension = mediaFormat.pathExt;
+        mediaSource.mimetype = mediaFormat.mimeType;
+      }
+      // in case playbackSource doesn't have flavors we don't need to build the url and we'll use the provided one.
+      if (kalturaSource.hasFlavorIds()) {
+        if (!extension && playbackContext.flavorAssets && playbackContext.flavorAssets.length > 0) {
+          extension = playbackContext.flavorAssets[0].fileExt;
+        }
+        playUrl = PlaySourceUrlBuilder.build({
+          entryId,
+          flavorIds: kalturaSource.flavorIds,
+          format,
+          ks,
+          partnerId,
+          uiConfId,
+          extension,
+          protocol
+        });
+      } else {
+        playUrl = OVPProviderParser.addKsToUrl(kalturaSource.url, ks);
+      }
+      if (!playUrl) {
+        const message = `failed to create play url from source, discarding source: (${entryId}_${deliveryProfileId}), ${format}`;
+        OVPProviderParser._logger.warn(message);
+        return null;
+      }
+      mediaSource.url = playUrl;
+      mediaSource.id = entryId + '_' + deliveryProfileId + ',' + format;
+      if (kalturaSource.hasDrmData()) {
+        const drmParams: Array<Drm> = [];
+        kalturaSource.drm.forEach(drm => {
+          drmParams.push(new Drm(drm.licenseURL, KalturaDrmPlaybackPluginData.Scheme[drm.scheme], drm.certificate));
+        });
+        mediaSource.drmData = drmParams;
+      }
+    }
+    return mediaSource;
+  }
+
+  /**
+   * Returns parsed progressive sources
+   * @function _parseProgressiveSources
+   * @param {KalturaPlaybackSource} kalturaSource - A kaltura source
+   * @param {KalturaPlaybackContext} playbackContext - The playback context
+   * @param {string} ks - The ks
+   * @param {number} partnerId - The partner ID
+   * @param {number} uiConfId - The uiConf ID
+   * @param {string} entryId - The entry id
+   * @returns {Array<MediaSource>} - The parsed progressive kalturaSources
+   * @static
+   * @private
+   */
+  private static _parseProgressiveSources(
+    kalturaSource: KalturaPlaybackSource | undefined,
+    playbackContext: KalturaPlaybackContext,
+    ks: string,
+    partnerId: number,
+    uiConfId: number | undefined,
+    entryId: string
+  ): Array<MediaSource> {
+    const videoSources: Array<MediaSource> = [];
+    const audioSources: Array<MediaSource> = [];
+    if (kalturaSource) {
+      const protocol = kalturaSource.getProtocol(OVPProviderParser._getBaseProtocol());
+      const format = kalturaSource.format;
+      const deliveryProfileId = kalturaSource.deliveryProfileId;
+      const sourceId = deliveryProfileId + ',' + format;
+      playbackContext.flavorAssets.map(flavor => {
+        const mediaSource: MediaSource = new MediaSource();
+        mediaSource.id = flavor.id + sourceId;
+        mediaSource.mimetype = flavor.fileExt === 'mp3' ? 'audio/mp3' : 'video/mp4';
+        mediaSource.height = flavor.height;
+        mediaSource.width = flavor.width;
+        mediaSource.bandwidth = flavor.bitrate * 1024;
+        mediaSource.label = flavor.label || flavor.language;
+        const playUrl = PlaySourceUrlBuilder.build({
+          entryId,
+          flavorIds: flavor.id,
+          format,
+          ks,
+          partnerId: partnerId,
+          uiConfId: uiConfId,
+          extension: flavor.fileExt,
+          protocol
+        });
+        if (playUrl === '') {
+          OVPProviderParser._logger.warn(`failed to create play url from source, discarding source: (${entryId}_${deliveryProfileId}), ${format}.`);
+          return null;
+        } else {
+          mediaSource.url = playUrl;
+          if (flavor.height && flavor.width) {
+            videoSources.push(mediaSource);
+          } else {
+            audioSources.push(mediaSource);
+          }
+        }
+      });
+    }
+    //If we have only audio flavors return them, otherwise return video flavors
+    return audioSources.length && !videoSources.length ? audioSources : videoSources;
+  }
+
+  /**
+   * Ovp metadata parser
+   * @function _parseMetaData
+   * @param {KalturaMetadataListResponse} metadataList The metadata list
+   * @returns {Object} Parsed metadata
+   * @static
+   * @private
+   */
+  private static _parseMetadata(metadataList: KalturaMetadataListResponse | undefined): any {
+    const metadata: any = {};
+    if (metadataList && metadataList.metas && metadataList.metas.length > 0) {
+      metadataList.metas.forEach(meta => {
+        if (meta.xml) {
+          const domParser: DOMParser = new DOMParser();
+          meta.xml = meta.xml.replace(/\r?\n|\r/g, '');
+          meta.xml = meta.xml.replace(/>\s*/g, '>');
+          meta.xml = meta.xml.replace(/>\s*/g, '>');
+          const metaXml: any = domParser.parseFromString(meta.xml, 'text/xml');
+          const metasObj: any = XmlParser.xmlToJson(metaXml);
+          const metaKeys = Object.keys(metasObj.metadata);
+          metaKeys.forEach(key => {
+            metadata[key] = metasObj.metadata[key]['#text'];
+          });
+        }
+      });
+    }
+    return metadata;
+  }
+
+  /**
+   * Returns the base protocol
+   * @function _getBaseProtocol
+   * @returns {string} - The base protocol
+   * @static
+   * @private
+   */
+  private static _getBaseProtocol(): string {
+    const config = OVPConfiguration.get();
+    const protocolRegex = /^https?:/;
+    const result = protocolRegex.exec(config.cdnUrl);
+    const protocol = result ? result[0] : document.location.protocol;
+    if (typeof protocol === 'string') {
+      return protocol.slice(0, -1); // remove ':' from the end
+    }
+    return 'https';
+  }
+
+  public static hasBlockAction(response: OVPMediaEntryLoaderResponse): boolean {
+    return response.playBackContextResult.hasBlockAction();
+  }
+
+  public static getBlockAction(response: OVPMediaEntryLoaderResponse): KalturaRuleAction | undefined {
+    return response.playBackContextResult.getBlockAction();
+  }
+
+  public static getErrorMessages(response: OVPMediaEntryLoaderResponse): Array<KalturaAccessControlMessage> {
+    return response.playBackContextResult.getErrorMessages();
+  }
+}
+
+export const addKsToUrl = OVPProviderParser.addKsToUrl;
+export default OVPProviderParser;