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

package/src/entities/media-entry.ts

@@ -0,0 +1,104 @@
+import MediaSources from './media-sources';
+import {ProviderMediaEntryObject} from '../types';
+import {Poster} from '../types/poster';
+
+export default class MediaEntry {
+  public static Type: {[type: string]: string} = {
+    VOD: 'Vod',
+    LIVE: 'Live',
+    IMAGE: 'Image',
+    AUDIO: 'Audio',
+    UNKNOWN: 'Unknown'
+  };
+  public static DvrStatus: {[type: string]: number} = {
+    ON: 1,
+    OFF: 0
+  };
+
+  /**
+   * @member - entry id
+   * @type {string}
+   */
+  public id?: string;
+  /**
+   * @member - entry name
+   * @type {string}
+   */
+  public name?: string;
+  /**
+   * @member - entry sources
+   * @type {MediaSources}
+   */
+  public sources: MediaSources;
+  /**
+   * @member - entry duration
+   * @type {number}
+   */
+  public duration?: number;
+  /**
+   * @member - entry type
+   * @type {string}
+   */
+  public type: string;
+  /**
+   * @member - entry metadata
+   * @type {Object}
+   */
+  public metadata: any;
+  /**
+   * @member - DVR status
+   * @type {number}
+   */
+  public dvrStatus?: number;
+  /**
+   * @member - media status
+   * @type {number}
+   */
+  public status?: number;
+  /**
+   * @member - media poster
+   * @type {string | Array<Object>}
+   */
+  public poster?: string | Poster[];
+
+  /**
+   * @member - assetReferenceType
+   * @type {string }
+   */
+  public assetReferenceType?: string;
+
+  /**
+   * @member - The download URL of the entry.
+   * @type {string}
+   */
+  public downloadUrl?: string;
+
+  /**
+   * @constructor
+   */
+  constructor() {
+    this.metadata = new Map();
+    this.sources = new MediaSources();
+    this.type = MediaEntry.Type.UNKNOWN;
+  }
+
+  /**
+   * Convert class to native js object.
+   * @returns {ProviderMediaEntryObject} - The json class object.
+   */
+  public toJSON(): ProviderMediaEntryObject {
+    return {
+      id: this.id,
+      name: this.name,
+      sources: this.sources.toJSON(),
+      duration: this.duration,
+      dvrStatus: this.dvrStatus,
+      status: this.status,
+      metadata: this.metadata,
+      type: this.type,
+      poster: this.poster,
+      assetReferenceType: this.assetReferenceType,
+      downloadUrl: this.downloadUrl
+    };
+  }
+}

package/src/entities/media-format.ts

@@ -0,0 +1,47 @@
+import {ProviderMediaFormatType} from '../types';
+
+export const MediaFormat: {[name: string]: ProviderMediaFormatType} = {
+  DASH: {
+    name: 'dash',
+    mimeType: 'application/dash+xml',
+    pathExt: 'mpd'
+  },
+  HLS: {
+    name: 'hls',
+    mimeType: 'application/x-mpegURL',
+    pathExt: 'm3u8'
+  },
+  WVM: {
+    name: 'wvm',
+    mimeType: 'video/wvm',
+    pathExt: 'wvm'
+  },
+  MP4: {
+    name: 'mp4',
+    mimeType: 'video/mp4',
+    pathExt: 'mp4'
+  },
+  MP3: {
+    name: 'mp3',
+    mimeType: 'audio/mpeg',
+    pathExt: 'mp3'
+  }
+};
+
+export const SupportedStreamFormat: Map<string, ProviderMediaFormatType> = new Map([
+  ['mpegdash', MediaFormat.DASH],
+  ['applehttp', MediaFormat.HLS],
+  ['url', MediaFormat.MP4]
+]);
+
+/**
+ * returns a boolean whether a source is progressive or not
+ * @param {string} formatName - the format name
+ * @returns {boolean} - if source is progressive or not
+ */
+function isProgressiveSource(formatName: string): boolean {
+  const sourceFormat = SupportedStreamFormat.get(formatName);
+  return !!sourceFormat && sourceFormat.name === MediaFormat.MP4.name;
+}
+
+export {isProgressiveSource};

package/src/entities/media-source.ts

@@ -0,0 +1,70 @@
+import Drm from './drm';
+import {ProviderMediaSourceObject} from '../types';
+
+export default class MediaSource {
+  /**
+   * @member - media source id
+   * @type {string}
+   */
+  public id!: string;
+  /**
+   * @member - media source url
+   * @type {string}
+   */
+  public url!: string;
+  /**
+   * @member - media source mimetype
+   * @type {string}
+   */
+  public mimetype!: string;
+  /**
+   * @member - media source drm data
+   * @type {Array<Drm>}
+   */
+  public drmData?: Array<Drm>;
+  /**
+   * @member - media source bandwidth
+   * @type {number}
+   */
+  public bandwidth?: number;
+  /**
+   * @member - media source width
+   * @type {number}
+   */
+  public width?: number;
+  /**
+   * @member - media source height
+   * @type {number}
+   */
+  public height?: number;
+  /**
+   * @member - media source label
+   * @type {string}
+   */
+  public label?: string;
+
+  /**
+   * Convert class to native js object.
+   * @returns {ProviderMediaSourceObject} - The json class object.
+   */
+  public toJSON(): ProviderMediaSourceObject {
+    const response: ProviderMediaSourceObject = {
+      id: this.id,
+      url: this.url,
+      mimetype: this.mimetype
+    };
+    if (this.bandwidth) response.bandwidth = this.bandwidth;
+    if (this.width) response.width = this.width;
+    if (this.height) response.height = this.height;
+    if (this.label) response.label = this.label;
+    if (this.drmData && this.drmData.length > 0) {
+      response.drmData = [];
+      this.drmData.forEach(d => {
+        if (Array.isArray(response.drmData)) {
+          response.drmData.push(d.toJSON());
+        }
+      });
+    }
+    return response;
+  }
+}

package/src/entities/media-sources.ts

@@ -0,0 +1,79 @@
+import MediaSource from './media-source';
+import {MediaFormat} from './media-format';
+import {ImageSource} from './image-source';
+import {PKExternalCaptionObject, ProviderMediaFormatType, ProviderMediaSourcesObject} from '../types';
+
+export default class MediaSources {
+  /**
+   * Progressive download media sources container.
+   * @type {Array<MediaSource>}
+   * @public
+   */
+  public progressive: Array<MediaSource>;
+  /**
+   * Dash media sources container.
+   * @type {Array<MediaSource>}
+   * @public
+   */
+  public dash: Array<MediaSource>;
+  /**
+   * Hls media sources container.
+   * @type {Array<MediaSource>}
+   * @public
+   */
+  public hls: Array<MediaSource>;
+  public image: Array<ImageSource>;
+  public captions?: Array<PKExternalCaptionObject>;
+
+  /**
+   * @constructor
+   */
+  constructor() {
+    this.progressive = [];
+    this.dash = [];
+    this.hls = [];
+    this.image = [];
+  }
+
+  /**
+   * Maps the source to one of the containers according to his media format.
+   * @param {MediaSource} source - The source to add to one of the containers.
+   * @param {MediaFormat} mediaFormat - The media format of the source.
+   * @returns {void}
+   */
+  public map(source: MediaSource, mediaFormat?: ProviderMediaFormatType): void {
+    if (mediaFormat) {
+      switch (mediaFormat.name) {
+      case MediaFormat.MP4.name:
+        this.progressive.push(source);
+        break;
+      case MediaFormat.DASH.name:
+        this.dash.push(source);
+        break;
+      case MediaFormat.HLS.name:
+        this.hls.push(source);
+        break;
+      default:
+        break;
+      }
+    }
+  }
+
+  /**
+   * Convert class to native js object.
+   * @returns {ProviderMediaSourcesObject} - The json class object.
+   */
+  public toJSON(): ProviderMediaSourcesObject {
+    const response: ProviderMediaSourcesObject = {
+      progressive: [],
+      dash: [],
+      hls: [],
+      image: []
+    };
+    this.progressive.forEach(p => response.progressive.push(p.toJSON()));
+    this.hls.forEach(h => response.hls.push(h.toJSON()));
+    this.dash.forEach(d => response.dash.push(d.toJSON()));
+    response.image = this.image;
+    return response;
+  }
+}

package/src/entities/playlist.ts

@@ -0,0 +1,41 @@
+import MediaEntry from '../entities/media-entry';
+
+export default class Playlist {
+  /**
+   * @member - playlist id
+   * @type {string}
+   */
+  public id?: string;
+  /**
+   * @member - playlist name
+   * @type {string}
+   */
+  public name?: string;
+  /**
+   * @member - playlist description
+   * @type {string}
+   */
+  public description?: string;
+
+  /**
+   * @member - playlist poster
+   * @type {string}
+   */
+  public poster?: string;
+
+  /**
+   * @member - playlist items
+   * @type {Array<MediaEntry>}
+   */
+  public items: Array<MediaEntry>;
+
+  /**
+   * @member - playlist last played entry
+   * @type {string}
+   */
+  public playlistLastEntryId?: string;
+
+  constructor() {
+    this.items = [];
+  }
+}

package/src/k-provider/common/base-provider.ts

@@ -0,0 +1,112 @@
+import {getLogLevel, setLogLevel, setLogger, LogLevelType, LogLevel} from '../../util/logger';
+import DataLoaderManager from './data-loader-manager';
+import Error from '../../util/error/error';
+import {ProviderEntryListObject, ProviderMediaConfigObject, ProviderPlaylistInfoObject, ProviderMediaConfigSourcesObject, ProviderNetworkRetryParameters, ProviderOptionsObject, ProviderPlaylistObject} from '../../types';
+
+export default class BaseProvider<MI> {
+  private _partnerId: number;
+  private _widgetId?: string;
+  private _ks: string;
+  private _uiConfId?: number;
+  public _dataLoader!: DataLoaderManager;
+  private _playerVersion: string;
+  public _logger: any;
+  protected _isAnonymous: boolean;
+  public _networkRetryConfig: ProviderNetworkRetryParameters = {
+    async: true,
+    timeout: 0,
+    maxAttempts: 4
+  };
+
+  public get partnerId(): number {
+    return this._partnerId;
+  }
+
+  public get widgetId(): string {
+    return this._widgetId || this.defaultWidgetId;
+  }
+
+  public get defaultWidgetId(): string {
+    return '_' + this._partnerId;
+  }
+
+  public get uiConfId(): number | undefined {
+    return this._uiConfId;
+  }
+
+  public get ks(): string {
+    return this._ks;
+  }
+
+  public set ks(value: string) {
+    this._ks = value;
+  }
+
+  public get playerVersion(): string {
+    return this._playerVersion;
+  }
+
+  public get isAnonymous(): boolean {
+    return this._isAnonymous;
+  }
+
+  constructor(options: ProviderOptionsObject, playerVersion: string) {
+    setLogger(options.logger);
+    this._partnerId = options.partnerId;
+    this._widgetId = options.widgetId;
+    this._uiConfId = options.uiConfId;
+    this._isAnonymous = !options.ks;
+    this._ks = options.ks || '';
+    this._playerVersion = playerVersion;
+  }
+
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  public getMediaConfig(mediaInfo: MI): Promise<ProviderMediaConfigObject> {
+    return Promise.reject(
+      new Error(Error.Severity.CRITICAL, Error.Category.PROVIDER, Error.Code.METHOD_NOT_IMPLEMENTED, {
+        message: 'getMediaConfig method must be implement by the derived class'
+      })
+    );
+  }
+
+  // eslint-disable-next-line  @typescript-eslint/no-unused-vars
+  public getPlaylistConfig(playlistInfo: ProviderPlaylistInfoObject): Promise<ProviderPlaylistObject> {
+    return Promise.reject(
+      new Error(Error.Severity.CRITICAL, Error.Category.PROVIDER, Error.Code.METHOD_NOT_IMPLEMENTED, {
+        message: 'The provider does not support loading playlist by id'
+      })
+    );
+  }
+
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  public getEntryListConfig(entryListInfo: ProviderEntryListObject): Promise<ProviderPlaylistObject> {
+    return Promise.reject(
+      new Error(Error.Severity.CRITICAL, Error.Category.PROVIDER, Error.Code.METHOD_NOT_IMPLEMENTED, {
+        message: 'The provider does not support loading entry list'
+      })
+    );
+  }
+
+  protected _verifyHasSources(sources: ProviderMediaConfigSourcesObject): void {
+    if (sources.hls.concat(sources.dash, sources.progressive, sources.image).length === 0) {
+      throw new Error(Error.Severity.CRITICAL, Error.Category.SERVICE, Error.Code.MISSING_PLAY_SOURCE, {
+        action: '',
+        messages: `No play source for entry id: ${sources.id}`
+      });
+    }
+  }
+
+  public get LogLevel(): LogLevelType {
+    return LogLevel;
+  }
+
+  public getLogLevel(name?: string): any {
+    return getLogLevel(name);
+  }
+
+  public setLogLevel(level: any, name?: string): void {
+    setLogLevel(level, name);
+  }
+}
+
+export {BaseProvider}

package/src/k-provider/common/base-service-result.ts

@@ -0,0 +1,56 @@
+export default class ServiceResult {
+  /**
+   * @member - Is service returned an error
+   * @type {boolean}
+   */
+  public hasError: boolean = false;
+  /**
+   * @member - The service error
+   * @type {ServiceError}
+   */
+  public error!: ServiceError;
+  /**
+   * @member - The service result data
+   * @type {Object}
+   */
+  public data: any;
+
+  /**
+   * @constructor
+   * @param {Object} response - Service response
+   */
+  constructor(response: any) {
+    if (response.objectType === 'KalturaAPIException') {
+      this.hasError = true;
+      this.error = new ServiceError(response.code, response.message);
+    } else if (response.error && response.error.objectType === 'KalturaAPIException') {
+      this.hasError = true;
+      this.error = new ServiceError(response.error.code, response.error.message);
+    } else {
+      this.data = response;
+    }
+  }
+}
+
+class ServiceError {
+  /**
+   * @member - The error code
+   * @type {string}
+   */
+  public code: string;
+  /**
+   * @member - The error message
+   * @type {string}
+   */
+  public message: string;
+
+  /**
+   * @constructor
+   * @param {string} code - The result code
+   * @param {string} message - The result message
+   */
+  constructor(code: string, message: string) {
+    this.code = code;
+    this.message = message;
+  }
+}

package/src/k-provider/common/data-loader-manager.ts

@@ -0,0 +1,115 @@
+import MultiRequestBuilder, {MultiRequestResult} from './multi-request-builder';
+import Error from '../../util/error/error';
+import {ILoader, ProviderNetworkRetryParameters} from '../../types';
+
+export default class DataLoaderManager {
+  /**
+   * @member - Loaders response map index
+   * @type {Map<string,Array<number>>}
+   * @private
+   */
+  private _loadersResponseMap: Map<string, Array<number>> = new Map();
+  /**
+   * @member - Loaders multi request
+   * @type {MultiRequestBuilder}
+   * @protected
+   */
+  protected _multiRequest!: MultiRequestBuilder;
+  /**
+   * @member - Loaders multi response
+   * @type {MultiRequestResult}
+   * @private
+   */
+  private _multiResponse!: MultiRequestResult;
+  /**
+   * @member - Loaders to execute
+   * @type {Map<string,Function>}
+   * @private
+   */
+  private _loaders: Map<string, ILoader> = new Map();
+
+  private _networkRetryConfig: ProviderNetworkRetryParameters;
+
+  constructor(networkRetryConfig: ProviderNetworkRetryParameters) {
+    this._networkRetryConfig = networkRetryConfig;
+  }
+
+  /**
+   * Add loader to execution loaders map
+   * @function
+   * @param {Function} loader Loader to add
+   * @param {Object} params Loader params
+   * @param {string} ks ks
+   * @returns {void}
+   */
+  public add(loader: {new(...params): ILoader, id: string}, params: any, ks?: string): void {
+    const execution_loader = new loader(params);
+    if (execution_loader.isValid()) {
+      this._loaders.set(loader.id, execution_loader);
+      // Get the start index from the multiReqeust before adding current execution_loader requests
+      const startIndex = this._multiRequest.requests.length;
+      // Get the requests
+      const requests = execution_loader.requests;
+      this._multiRequest.retryConfig = this._networkRetryConfig;
+      // Add requests to multiRequest queue
+      requests.forEach(request => {
+        request.params = request.params || {};
+        request.params.ks = request.params.ks || ks;
+        this._multiRequest.add(request);
+      });
+      // Create range array of current execution_loader requests
+      const executionLoaderResponseMap = Array.from(new Array(requests.length), (val, index) => index + startIndex);
+      // Add to map
+      this._loadersResponseMap.set(loader.id, executionLoaderResponseMap);
+    }
+  }
+
+  /**
+   * Get data from all loaders using multi request
+   * @param {boolean} requestsMustSucceed whether all of the requests must succeed or not
+   * @function
+   * @returns {Promise} Promise
+   */
+  public fetchData(requestsMustSucceed?: boolean): Promise<any> {
+    return new Promise((resolve, reject) => {
+      this._multiRequest.execute(requestsMustSucceed).then(
+        data => {
+          this._multiResponse = data.response;
+          const preparedData: any = this.prepareData(data.response);
+          if (preparedData.success) {
+            resolve(this._loaders);
+          } else {
+            reject(
+              new Error(Error.Severity.CRITICAL, Error.Category.NETWORK, Error.Code.API_RESPONSE_MISMATCH, {
+                headers: data.headers
+              })
+            );
+          }
+        },
+        err => {
+          reject(err);
+        }
+      );
+    });
+  }
+
+  /**
+   * Prepare fetched data
+   * @function
+   * @param {MultiRequestResult} response - The multi request result
+   * @returns {Object} - The prepared data
+   */
+  public prepareData(response: MultiRequestResult): any {
+    this._loaders.forEach((loader, name) => {
+      const loaderDataIndexes = this._loadersResponseMap.get(name);
+      try {
+        if (loaderDataIndexes && loaderDataIndexes.length > 0) {
+          loader.response = response.results.slice(loaderDataIndexes[0], loaderDataIndexes[loaderDataIndexes.length - 1] + 1);
+        }
+      } catch (err) {
+        return {success: false, error: err};
+      }
+    });
+    return {success: true, data: this._loaders};
+  }
+}