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

package/src/k-provider/ott/response-types/kaltura-playback-context.ts

@@ -0,0 +1,73 @@
+import ServiceResult from '../../common/base-service-result';
+import {KalturaAccessControlMessage} from '../../common/response-types/kaltura-access-control-message';
+import KalturaRuleAction from './kaltura-rule-action';
+import KalturaPlaybackSource from './kaltura-playback-source';
+import KalturaBumpersPlaybackPluginData from './kaltura-bumper-playback-plugin-data';
+
+export default class KalturaPlaybackContext extends ServiceResult {
+  public static Type: {[type: string]: string} = {
+    DOWNLOAD: 'DOWNLOAD',
+    TRAILER: 'TRAILER',
+    CATCHUP: 'CATCHUP',
+    START_OVER: 'START_OVER',
+    PLAYBACK: 'PLAYBACK'
+  };
+  /**
+   * @member - The playback sources
+   * @type {Array<KalturaPlaybackSource>}
+   */
+  public sources: Array<KalturaPlaybackSource> = [];
+  /**
+   * @member - Array of actions as received from the rules that invalidated
+   * @type {Array<KalturaRuleAction>}
+   */
+  public actions: KalturaRuleAction[] = [];
+  /**
+   * @member - Array of access control massages
+   * @type {Array<KalturaAccessControlMessage>}
+   */
+  public messages: Array<KalturaAccessControlMessage> = [];
+  /**
+   * @member - Array of bumper plugins
+   * @type {Array<KalturaBumpersPlaybackPluginData>}
+   */
+  public plugins: Array<KalturaBumpersPlaybackPluginData> = [];
+
+  /**
+   * @constructor
+   * @param {Object} response The response
+   */
+  constructor(response: any) {
+    super(response);
+    if (!this.hasError) {
+      const messages = response.messages;
+      if (messages) {
+        messages.map(message => this.messages.push(new KalturaAccessControlMessage(message)));
+      }
+      const actions = response.actions;
+      if (actions) {
+        actions.map(action => this.actions.push(new KalturaRuleAction(action)));
+      }
+      const sources = response.sources;
+      if (sources) {
+        sources.map(source => this.sources.push(new KalturaPlaybackSource(source)));
+      }
+      const plugins = response.plugins;
+      if (plugins) {
+        plugins.map(plugin => this.plugins.push(new KalturaBumpersPlaybackPluginData(plugin)));
+      }
+    }
+  }
+
+  public hasBlockAction(): boolean {
+    return this.getBlockAction() !== undefined;
+  }
+
+  public getBlockAction(): KalturaRuleAction | undefined {
+    return this.actions.find(action => action.type === KalturaRuleAction.Type.BLOCK);
+  }
+
+  public getErrorMessages(): Array<KalturaAccessControlMessage> {
+    return this.messages;
+  }
+}

package/src/k-provider/ott/response-types/kaltura-playback-source.ts

@@ -0,0 +1,62 @@
+import {KalturaDrmPlaybackPluginData} from '../../common/response-types/kaltura-drm-playback-plugin-data';
+
+export type OTTKalturaPlaybackSource = KalturaPlaybackSource;
+
+export default class KalturaPlaybackSource {
+  public format: string;
+  public protocols: string;
+  public drm: Array<KalturaDrmPlaybackPluginData> = [];
+  public adsPolicy: string;
+  public adsParam: string;
+  public duration: number;
+  public url: string;
+  public type: string;
+  public fileId: number;
+
+  /**
+   * @constructor
+   * @param {Object} source The response
+   */
+  constructor(source: any) {
+    this.format = source.format;
+    this.adsPolicy = source.adsPolicy;
+    this.adsParam = source.adsParam;
+    this.duration = source.duration;
+    this.url = source.url;
+    this.type = source.type;
+    this.fileId = source.id;
+    this.protocols = source.protocols;
+    if (source.drm) {
+      source.drm.map(drm => this.drm.push(new KalturaDrmPlaybackPluginData(drm)));
+    }
+  }
+
+  /**
+   * Checks if source has DRM data
+   * @function hasDrmData
+   * @returns {boolean} Is source has DRM
+   */
+  public hasDrmData(): boolean {
+    return this.drm && this.drm.length > 0;
+  }
+
+  /**
+   * Returns source desired protocol if supported
+   * @param {string} protocol - the desired protocol for the source (base play url protocol)
+   * @returns {string} - protocol if protocol is in the protocols list - if not empty string returned
+   */
+  public getProtocol(protocol: string): string {
+    let returnValue: string = '';
+    if (this.protocols && this.protocols.length > 0) {
+      const protocolsArr: Array<string> = this.protocols.split(',');
+      protocolsArr.forEach(p => {
+        if (p === protocol) {
+          returnValue = p;
+        }
+      });
+    } else if (protocol === 'http') {
+      return protocol;
+    }
+    return returnValue;
+  }
+}

package/src/k-provider/ott/response-types/kaltura-rule-action.ts

@@ -0,0 +1,25 @@
+export default class KalturaRuleAction {
+  public static Type: {[type: string]: string | number} = {
+    BLOCK: 'BLOCK',
+    START_DATE_OFFSET: 'START_DATE_OFFSET',
+    END_DATE_OFFSET: 'END_DATE_OFFSET',
+    USER_BLOCK: 'USER_BLOCK',
+    ALLOW_PLAYBACK: 'ALLOW_PLAYBACK',
+    BLOCK_PLAYBACK: 'BLOCK_PLAYBACK',
+    APPLY_DISCOUNT_MODULE: 'APPLY_DISCOUNT_MODULE'
+  };
+
+  /**
+   * @member - The type of the action
+   * @type {string|number}
+   */
+  public type: string | number;
+
+  /**
+   * @constructor
+   * @param {Object} data - The response
+   */
+  constructor(data: any) {
+    this.type = data.type;
+  }
+}

package/src/k-provider/ott/services/asset-service.ts

@@ -0,0 +1,50 @@
+import OTTService from './ott-service';
+import RequestBuilder from '../../../util/request-builder';
+import {ProviderPlaybackContextOptions} from '../../../types';
+
+const SERVICE_NAME: string = 'asset';
+
+export default class OTTAssetService extends OTTService {
+  /**
+   * Creates an instance of RequestBuilder for session.startWidgetSession
+   * @function anonymousSession
+   * @param {string} serviceUrl The service base URL
+   * @param {string} ks The partner ID
+   * @param {string} assetId The asset ID
+   * @param {string} type The asset type (media/recording/epg)
+   * @param {ProviderPlaybackContextOptions} playbackContextOptions The playbackContextOptions
+   * @returns {RequestBuilder} The request builder
+   * @static
+   */
+  public static getPlaybackContext(
+    serviceUrl: string,
+    ks: string,
+    assetId: string,
+    type: string,
+    playbackContextOptions: ProviderPlaybackContextOptions
+  ): RequestBuilder {
+    const headers: Map<string, string> = new Map();
+    headers.set('Content-Type', 'application/json');
+    const request = new RequestBuilder(headers);
+    request.service = SERVICE_NAME;
+    request.action = 'getPlaybackContext';
+    request.method = 'POST';
+    request.url = request.getUrl(serviceUrl);
+    const contextDataParams: any = {objectType: 'KalturaPlaybackContextOptions'};
+    Object.assign(contextDataParams, playbackContextOptions);
+    request.params = {assetId: assetId, assetType: type, contextDataParams: contextDataParams, ks: ks};
+    return request;
+  }
+
+  public static get(serviceUrl: string, ks: string, assetId: string, assetReferenceType: string): RequestBuilder {
+    const headers: Map<string, string> = new Map();
+    headers.set('Content-Type', 'application/json');
+    const request = new RequestBuilder(headers);
+    request.service = SERVICE_NAME;
+    request.action = 'get';
+    request.method = 'POST';
+    request.url = request.getUrl(serviceUrl);
+    request.params = {id: assetId, assetReferenceType: assetReferenceType, ks: ks};
+    return request;
+  }
+}

package/src/k-provider/ott/services/bookmark/bookmark-service.ts

@@ -0,0 +1,48 @@
+import OTTService from '../ott-service';
+import RequestBuilder from '../../../../util/request-builder';
+import OTTConfiguration from '../../config';
+
+const SERVICE_NAME: string = 'bookmark';
+
+export default class OTTBookmarkService extends OTTService {
+  /**
+   * Creates an instance of RequestBuilder for session.startWidgetSession
+   * @function add
+   * @param {string} serviceUrl - The service url
+   * @param {string} ks - The ks
+   * @param {Object} bookmark - The udid
+   * @returns {RequestBuilder} - The request builder
+   * @static
+   */
+  public static add(serviceUrl: string, ks: string, bookmark: any): RequestBuilder {
+    const headers: Map<string, string> = new Map();
+    headers.set('Content-Type', 'application/json');
+    const request = new RequestBuilder(headers);
+    request.service = SERVICE_NAME;
+    request.action = 'add';
+    request.method = 'POST';
+    request.url = request.getUrl(serviceUrl);
+    const playerData: any = {
+      objectType: 'KalturaBookmarkPlayerData',
+      action: bookmark.playerData.action,
+      averageBitrate: bookmark.playerData.averageBitrate,
+      totalBitrate: bookmark.playerData.totalBitrate,
+      currentBitrate: bookmark.playerData.currentBitrate,
+      fileId: bookmark.playerData.fileId
+    };
+    const bookmarkServiceParams: any = {
+      objectType: 'KalturaBookmark',
+      type: bookmark.type,
+      context: bookmark.context,
+      id: bookmark.id,
+      position: bookmark.position,
+      playerData: playerData
+    };
+    if (bookmark.programId) bookmarkServiceParams.programId = bookmark.programId;
+    const config = OTTConfiguration.get();
+    const serviceParams = config.serviceParams;
+    Object.assign(serviceParams, {bookmark: bookmarkServiceParams, ks: ks});
+    request.params = JSON.stringify(serviceParams);
+    return request;
+  }
+}

package/src/k-provider/ott/services/bookmark/index.ts

@@ -0,0 +1,11 @@
+import RequestBuilder from '../../../../util/request-builder';
+import OTTConfiguration from '../../config';
+import OTTBookmarkService from './bookmark-service';
+
+declare let __VERSION__: string;
+declare let __NAME__: string;
+
+const NAME = __NAME__ + '-bookmark-service';
+const VERSION = __VERSION__;
+
+export {OTTBookmarkService, OTTConfiguration, RequestBuilder, NAME, VERSION};

package/src/k-provider/ott/services/ott-service.ts

@@ -0,0 +1,33 @@
+import MultiRequestBuilder from '../../common/multi-request-builder';
+import OTTConfiguration from '../config';
+
+const SERVICE_NAME: string = 'multirequest';
+
+export default class OTTService {
+  /**
+   * Gets a new instance of MultiRequestBuilder with ott params
+   * @function getMultiRequest
+   * @param {string} ks The ks
+   * @param {string} partnerId The partner ID
+   * @returns {MultiRequestBuilder} The multi request builder
+   * @static
+   */
+  public static getMultiRequest(ks: string, partnerId?: number): MultiRequestBuilder {
+    const config = OTTConfiguration.get();
+    const ottParams = config.serviceParams;
+    if (ks) {
+      Object.assign(ottParams, {ks: ks});
+    }
+    if (partnerId) {
+      Object.assign(ottParams, {partnerId: partnerId});
+    }
+    const headers: Map<string, string> = new Map();
+    headers.set('Content-Type', 'application/json');
+    const multiReq = new MultiRequestBuilder(headers);
+    multiReq.method = 'POST';
+    multiReq.service = SERVICE_NAME;
+    multiReq.url = multiReq.getUrl(config.serviceUrl);
+    multiReq.params = ottParams;
+    return multiReq;
+  }
+}

package/src/k-provider/ott/services/user-service.ts

@@ -0,0 +1,31 @@
+import OTTService from './ott-service';
+import RequestBuilder from '../../../util/request-builder';
+
+const SERVICE_NAME: string = 'ottuser';
+
+export default class OTTUserService extends OTTService {
+  /**
+   * Creates an instance of RequestBuilder for session.startWidgetSession
+   * @function anonymousSession
+   * @param {string} serviceUrl The service base URL
+   * @param {string} partnerId The partner ID
+   * @param {string} udid The udid
+   * @returns {RequestBuilder} The request builder
+   * @static
+   */
+  public static anonymousLogin(serviceUrl: string, partnerId: number, udid?: string): RequestBuilder {
+    const headers: Map<string, string> = new Map();
+    headers.set('Content-Type', 'application/json');
+    const request = new RequestBuilder(headers);
+    request.service = SERVICE_NAME;
+    request.action = 'anonymousLogin';
+    request.method = 'POST';
+    request.url = request.getUrl(serviceUrl);
+    const params: any = {partnerId: partnerId};
+    if (udid) {
+      Object.assign(params, {udid: udid});
+    }
+    request.params = params;
+    return request;
+  }
+}

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

@@ -0,0 +1,28 @@
+import {clone} from '../../util/clone';
+import {ProviderEnvConfigObject} from '../../types';
+
+const defaultConfig: any = {
+  serviceUrl: 'https://cdnapisec.kaltura.com/api_v3',
+  cdnUrl: 'https://cdnapisec.kaltura.com',
+  serviceParams: {
+    apiVersion: '3.3.0',
+    format: 1
+  },
+  useApiCaptions: true,
+  loadThumbnailWithKs: false,
+  replaceHostOnlyManifestUrls: false
+};
+
+export default class OVPConfiguration {
+  public static set(clientConfig?: ProviderEnvConfigObject): void {
+    if (clientConfig) {
+      Object.assign(defaultConfig, clientConfig);
+    }
+  }
+
+  public static get(): any {
+    return clone(defaultConfig);
+  }
+}
+
+export {OVPConfiguration};

package/src/k-provider/ovp/external-captions-builder.ts

@@ -0,0 +1,37 @@
+import {addKsToUrl} from './provider-parser';
+import {CaptionType, PKExternalCaptionObject} from '../../types';
+
+const KalturaCaptionType: CaptionType = {
+  SRT: '1',
+  DFXP: '2',
+  WEBVTT: '3',
+  CAP: '4'
+};
+
+const CaptionsFormatsMap: {[format: string]: string} = {
+  '3': 'vtt',
+  '1': 'srt'
+};
+
+class ExternalCaptionsBuilder {
+  public static createConfig(captions: Array<any>, ks: string): Array<PKExternalCaptionObject> {
+    return captions.map(caption => {
+      let url = caption.url;
+      let type = CaptionsFormatsMap[caption.format];
+      if ([KalturaCaptionType.DFXP, KalturaCaptionType.CAP].includes(caption.format)) {
+        url = caption.webVttUrl;
+        type = CaptionsFormatsMap[KalturaCaptionType.WEBVTT];
+      }
+      url = addKsToUrl(url, ks);
+      return {
+        default: !!caption.isDefault,
+        type: type,
+        language: caption.languageCode,
+        label: caption.label,
+        url: url
+      };
+    });
+  }
+}
+
+export {ExternalCaptionsBuilder};

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

@@ -0,0 +1,13 @@
+import OVPProvider from './provider';
+import OVPProviderParser from './provider-parser';
+import RequestBuilder from '../../util/request-builder';
+import * as ResponseTypes from './response-types';
+
+declare let __VERSION__: string;
+declare let __NAME__: string;
+
+const NAME = __NAME__ + '-ovp';
+const VERSION = __VERSION__;
+
+export {OVPProvider as Provider, OVPProviderParser as ProviderParser, NAME, VERSION, RequestBuilder, ResponseTypes};
+

package/src/k-provider/ovp/loaders/data-loader-manager.ts

@@ -0,0 +1,17 @@
+import DataLoaderManager from '../../common/data-loader-manager';
+import OVPService from '../services/ovp-service';
+import {ProviderNetworkRetryParameters} from '../../../types';
+
+/**
+ * OTTDataLoaderManager is a class that handles the OVP data loading
+ * @param {string} playerVersion - player version
+ * @param {string} partnerId - partner id
+ * @param {string} ks - ks
+ * @param {ProviderNetworkRetryParameters} [networkRetryConfig] - network retry configuration
+ */
+export default class OVPDataLoaderManager extends DataLoaderManager {
+  constructor(playerVersion: string, partnerId: number, ks: string = '', networkRetryConfig: ProviderNetworkRetryParameters) {
+    super(networkRetryConfig);
+    this._multiRequest = OVPService.getMultiRequest(playerVersion, ks, partnerId);
+  }
+}

package/src/k-provider/ovp/loaders/entry-list-loader.ts

@@ -0,0 +1,69 @@
+import RequestBuilder from '../../../util/request-builder';
+import OVPConfiguration from '../config';
+import OVPBaseEntryService from '../services/base-entry-service';
+import {KalturaBaseEntryListResponse} from '../response-types/kaltura-base-entry-list-response';
+import {ILoader} from '../../../types';
+
+export default class OVPEntryListLoader implements ILoader {
+  private _entries: Array<string>;
+  private _requests!: Array<RequestBuilder>;
+  private _response: any = {playlistItems: {entries: []}};
+
+  public static get id(): string {
+    return 'entry_list';
+  }
+
+  /**
+   * @constructor
+   * @param {Object} params loader params
+   */
+  constructor(params: any) {
+    this.requests = this.buildRequests(params);
+    this._entries = params.entries;
+  }
+
+  public set requests(requests: Array<RequestBuilder>) {
+    this._requests = requests;
+  }
+
+  public get requests(): Array<RequestBuilder> {
+    return this._requests;
+  }
+
+  public set response(response: any) {
+    let mediaEntryResponse: KalturaBaseEntryListResponse;
+    response.forEach(item => {
+      mediaEntryResponse = new KalturaBaseEntryListResponse(item.data);
+      this._response.playlistItems.entries.push(mediaEntryResponse.entries[0]);
+    });
+  }
+
+  public get response(): any {
+    return this._response;
+  }
+
+  /**
+   * 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> = [];
+    params.entries.forEach(entry => {
+      requests.push(OVPBaseEntryService.list(config.serviceUrl, params.ks, entry.entryId || entry, params.redirectFromEntryId, entry.referenceId));
+    });
+    return requests;
+  }
+
+  /**
+   * Loader validation function
+   * @function
+   * @returns {boolean} Is valid
+   */
+  public isValid(): boolean {
+    return !!(this._entries && this._entries.length);
+  }
+}

package/src/k-provider/ovp/loaders/media-entry-loader.ts

@@ -0,0 +1,84 @@
+import RequestBuilder from '../../../util/request-builder';
+import OVPBaseEntryService from '../services/base-entry-service';
+import OVPMetadataService from '../services/meta-data-service';
+import OVPConfiguration from '../config';
+import {KalturaPlaybackContext} from '../response-types';
+import {KalturaMetadataListResponse} from '../response-types';
+import {KalturaBaseEntryListResponse} from '../response-types';
+import {KalturaMediaEntry} from '../response-types';
+import {ILoader} from '../../../types';
+
+type OVPMediaEntryLoaderResponse = {
+  entry: KalturaMediaEntry,
+  playBackContextResult: KalturaPlaybackContext,
+  metadataListResult: KalturaMetadataListResponse
+};
+export type {OVPMediaEntryLoaderResponse};
+
+export default class OVPMediaEntryLoader implements ILoader {
+  private _entryId: string;
+  private _referenceId: string;
+  private _requests!: Array<RequestBuilder>;
+  private _response: any = {};
+
+  public static get id(): string {
+    return 'media';
+  }
+
+  /**
+   * @constructor
+   * @param {Object} params loader params
+   * @boolean {boolean} useExternalCaptions - if we should add captions request to the multirequests.
+   */
+  constructor(params: any) {
+    this.requests = this.buildRequests(params);
+    this._entryId = params.entryId;
+    this._referenceId = params.referenceId;
+  }
+
+  public set requests(requests: Array<RequestBuilder>) {
+    this._requests = requests;
+  }
+
+  public get requests(): Array<RequestBuilder> {
+    return this._requests;
+  }
+
+  public set response(response: any) {
+    const mediaEntryResponse: KalturaBaseEntryListResponse = new KalturaBaseEntryListResponse(response[0].data);
+    this._response.entry = mediaEntryResponse.entries[0];
+    this._response.playBackContextResult = new KalturaPlaybackContext(response[1].data);
+    this._response.metadataListResult = new KalturaMetadataListResponse(response[2].data);
+  }
+
+  public get response(): OVPMediaEntryLoaderResponse {
+    return this._response;
+  }
+
+  /**
+   * 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(OVPBaseEntryService.list(config.serviceUrl, params.ks, params.entryId, params.redirectFromEntryId, params.referenceId));
+    // Use the entry id from the request result to support loading by referenceId
+    const serviceEntryId = params.ks === '{1:result:ks}' ? '{2:result:objects:0:id}' : '{1:result:objects:0:id}';
+    requests.push(OVPBaseEntryService.getPlaybackContext(config.serviceUrl, params.ks, serviceEntryId));
+    requests.push(OVPMetadataService.list(config.serviceUrl, params.ks, serviceEntryId));
+    return requests;
+  }
+
+  /**
+   * Loader validation function
+   * @function
+   * @returns {boolean} Is valid
+   */
+  public isValid(): boolean {
+    return !!(this._entryId || this._referenceId);
+  }
+}

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

@@ -0,0 +1,69 @@
+import RequestBuilder from '../../../util/request-builder';
+import OVPPlaylistService from '../services/playlist-service';
+import OVPConfiguration from '../config';
+import {KalturaPlaylist} from '../response-types';
+import {KalturaMediaEntries} from '../response-types';
+import {ILoader} from '../../../types';
+import { KalturaUserEntryListResponse } from '../response-types';
+
+export default class OVPPlaylistLoader implements ILoader {
+  private _playlistId: string;
+  private _requests!: Array<RequestBuilder>;
+  private _response: any = {};
+
+  public static get id(): string {
+    return 'playlist';
+  }
+
+  /**
+   * @constructor
+   * @param {Object} params loader params
+   */
+  constructor(params: any) {
+    this.requests = this.buildRequests(params);
+    this._playlistId = params.playlistId;
+  }
+
+  public set requests(requests: Array<RequestBuilder>) {
+    this._requests = requests;
+  }
+
+  public get requests(): Array<RequestBuilder> {
+    return this._requests;
+  }
+
+  public set response(response: any) {
+    this._response.playlistData = new KalturaPlaylist(response[0].data);
+    this._response.playlistItems = new KalturaMediaEntries(response[1].data);
+    this._response.playlistUserEntries = new KalturaUserEntryListResponse(response[2].data);
+  }
+
+  public get response(): any {
+    return this._response;
+  }
+
+  /**
+   * 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(OVPPlaylistService.get(config.serviceUrl, params.ks, params.playlistId));
+    requests.push(OVPPlaylistService.execute(config.serviceUrl, params.ks, params.playlistId));
+    requests.push(OVPPlaylistService.getLastEntryId(config.serviceUrl, params.ks, params.playlistId));
+    return requests;
+  }
+
+  /**
+   * Loader validation function
+   * @function
+   * @returns {boolean} Is valid
+   */
+  public isValid(): boolean {
+    return !!this._playlistId;
+  }
+}