@mediakind/mkplayer 1.3.0 → 1.4.1

package/alias/index.d.ts

@@ -1,8 +1,8 @@
 export type MKBitrate = string | number;
-export type MKRequestHeaders = {
+export type MKHeaders = {
     [key: string]: string;
 };
-export type MKRequestBodyParams = {
+export type MKRequestBody = {
     [key: string]: any;
 };
 export type MKRequestQueryParams = {

package/classes/common/MKAzukiResponseUtils.d.ts

@@ -1,8 +1,13 @@
+import { MKHeaders, MKRequestQueryParams } from "../../alias";
 import { MKDrmType, MKStreamType } from "../../enums";
-import { MKProgramInfo, MKProgramRestrictions } from "../../interfaces";
+import { MKProgramInfo, MKProgramRestrictions, MKRollInfo } from "../../interfaces";
 export declare abstract class MKAzukiResponseUtils {
+    static getRollInfo(response: any, requestBaseUrl: string, queryParams: MKRequestQueryParams, requestHeaders: MKHeaders): MKRollInfo;
     static getStreamType(response: any): MKStreamType;
     static getDrmType(response: any): MKDrmType;
     static getProgramRestrictions(response: any): MKProgramRestrictions;
     static getProgramInfo(response: any): MKProgramInfo;
+    private static getDrmConfig;
+    private static getSourceUrls;
+    private static pluckPreferredCdn;
 }

package/classes/common/MKPlatform.d.ts

@@ -11,7 +11,7 @@ export declare abstract class MKPlatform {
     private static isPlayStation5;
     private static isPlayStation4;
     private static isSafari;
-    private static isIOSDevice;
+    static isIOSDevice(): boolean;
     private static isIOSWebView;
     private static isChrome;
     private static isFirefox;
@@ -25,5 +25,8 @@ export declare abstract class MKPlatform {
     private static isLinux;
     private static isIOSFamily;
     private static isChromeCast;
-    private static isAndroid;
+    static isAndroid(): boolean;
+    static isTablet(): boolean;
+    static isPhone(): boolean;
+    static isDesktop(): boolean;
 }

package/classes/common/MKUtils.d.ts

@@ -17,4 +17,5 @@ export declare abstract class MKUtils {
     static isNumber(value: any): boolean;
     static isBoolean(value: any): boolean;
     static isMKError(value: any): boolean;
+    static isValidISODateString(date: string): boolean;
 }

package/classes/error/MKAdobeSessionConcurrencyError.d.ts

@@ -0,0 +1,7 @@
+import { MKError } from "../../interfaces";
+export declare class MKAdobeSessionConcurrencyError implements MKError {
+    code: string;
+    name: string;
+    message: string;
+    constructor(error: any);
+}

package/classes/error/index.d.ts

@@ -1,3 +1,4 @@
+export { MKAdobeSessionConcurrencyError } from "./MKAdobeSessionConcurrencyError";
 export { MKAzukiRequestError } from "./MKAzukiRequestError";
 export { MKBitmovinPlayerError } from "./MKBitmovinPlayerError";
 export { MKHttpError } from "./MKHttpError";

package/classes/player/MKBitmovinPlayer.d.ts

@@ -1,6 +1,6 @@
 import { MKEventBase } from "../common";
 import { MKBufferType, MKLogLevel, MKMediaType, MKTimeMode, MKViewMode } from "../../enums";
-import { MKPlayerConfig, MKSourceConfig, MKLowLatencySyncConfig, MKBufferLevel, MKPlayerEngine, MKViewModeOptions, MKTimeRange, MKVideoQuality, MKAudioQuality, MKDownloadedVideoData, MKDownloadedAudioData, MKAudioTrack, MKSubtitleTrack, MKThumbnail } from "../../interfaces";
+import { MKPlayerConfig, MKSourceConfig, MKLowLatencySyncConfig, MKBufferLevel, MKPlayerEngine, MKViewModeOptions, MKTimeRange, MKVideoQuality, MKAudioQuality, MKDownloadedVideoData, MKDownloadedAudioData, MKAudioTrack, MKSubtitleTrack, MKThumbnail, MKSourceOptions } from "../../interfaces";
 export declare class MKBitmovinPlayer extends MKEventBase implements MKPlayerEngine {
     private player;
     private playerUI?;
@@ -68,6 +68,7 @@ export declare class MKBitmovinPlayer extends MKEventBase implements MKPlayerEng
     isStalled(): boolean;
     isViewModeAvailable(viewMode: MKViewMode): boolean;
     load(sourceConfig: MKSourceConfig, disableSeeking?: boolean): Promise<void>;
+    reload(start: string, sourceOptions?: MKSourceOptions): Promise<void>;
     mute(issuer?: string): void;
     pause(issuer?: string): void;
     play(issuer?: string): Promise<void>;
@@ -78,9 +79,6 @@ export declare class MKBitmovinPlayer extends MKEventBase implements MKPlayerEng
     setAspectRatio(aspectratio: string | number): void;
     setAudio(trackID: string): void;
     setAudioQuality(audioQualityID: string): void;
-    setAuthorizationToken(_authorizationToken: string): void;
-    setInhomeStatus(_inhomeStatus: boolean): void;
-    setLocationDetail(_locationDetail: string): void;
     setLogLevel(level: MKLogLevel): void;
     setPlaybackSpeed(speed: number): void;
     setPosterImage(url: string, keepPersistent: boolean): void;

package/classes/player/MKPlayer.d.ts

@@ -1,6 +1,6 @@
 import { MKEventBase } from "../common";
 import { MKBufferType, MKLogLevel, MKMediaType, MKTimeMode, MKViewMode } from "../../enums";
-import { MKAudioQuality, MKAudioTrack, MKBufferLevel, MKDownloadedAudioData, MKDownloadedVideoData, MKLowLatencySyncConfig, MKPlayerAPI, MKPlayerConfig, MKSourceConfig, MKSubtitleTrack, MKThumbnail, MKTimeRange, MKVideoQuality, MKViewModeOptions } from "../../interfaces";
+import { MKAudioQuality, MKAudioTrack, MKBufferLevel, MKDownloadedAudioData, MKDownloadedVideoData, MKLowLatencySyncConfig, MKPlayerAPI, MKPlayerConfig, MKSourceConfig, MKSourceOptions, MKSubtitleTrack, MKThumbnail, MKTimeRange, MKVideoQuality, MKViewModeOptions } from "../../interfaces";
 export declare class MKPlayer extends MKEventBase implements MKPlayerAPI {
     private playerConfig;
     private videoContainer;
@@ -10,8 +10,9 @@ export declare class MKPlayer extends MKEventBase implements MKPlayerAPI {
     private sourceConfig?;
     private thumbnailManager;
     private programManager?;
-    private sessionBeaconTimer?;
     private sourceLoaded;
+    private sessionManager?;
+    private adobeSessionConcurrencyRequest?;
     constructor(videoContainer: HTMLElement, playerConfig: MKPlayerConfig);
     addCastMetadata(metadata: any): boolean;
     addSubtitle(subtitleTrack: MKSubtitleTrack): void;
@@ -60,6 +61,7 @@ export declare class MKPlayer extends MKEventBase implements MKPlayerAPI {
     isStalled(): boolean;
     isViewModeAvailable(viewMode: MKViewMode): boolean;
     load(sourceConfig: MKSourceConfig, disableSeeking?: boolean): Promise<void>;
+    reload(start: string, sourceOptions?: MKSourceOptions): Promise<void>;
     mute(issuer?: string): void;
     pause(issuer?: string): void;
     play(issuer?: string): Promise<void>;
@@ -99,7 +101,5 @@ export declare class MKPlayer extends MKEventBase implements MKPlayerAPI {
     private unloadAndEmitErrorEvent;
     private emitProgramRestrictionsEvent;
     private loadSource;
-    private scheduleSessionBeaconNotifications;
-    private onBeaconNotificationError;
-    private cancelSessionBeaconNotifications;
+    private onSessionConcurrencyNotificationError;
 }

package/classes/request/MKAdobeSessionConcurrencyRequest.d.ts

@@ -0,0 +1,20 @@
+import { MKAdobePrimetimeConfig, MKError, MKSessionConcurrencyAPI } from "../../interfaces";
+import { MKHttpRequest } from "./MKHttpRequest";
+export declare class MKAdobeSessionConcurrencyRequest extends MKHttpRequest implements MKSessionConcurrencyAPI {
+    private static readonly DEFAULT_PRODUCTION_ENDPOINT;
+    private static readonly DEFAULT_STAGING_ENDPOINT;
+    private static readonly DEFAULT_TIMER_FREQUENCY;
+    private session;
+    private config;
+    private heartBeatTimer?;
+    private heartBeatFrequency;
+    private errorCallback?;
+    constructor(config: MKAdobePrimetimeConfig, errorCallback?: (error: MKError) => void);
+    startSession(): Promise<void>;
+    stopSession(): Promise<void>;
+    private notifyHeartBeat;
+    private scheduleHeartBeat;
+    private validateConfig;
+    private getRequestUrl;
+    private getRequestHeaders;
+}

package/classes/request/MKAzukiRequest.d.ts

@@ -1,26 +1,39 @@
 import { MKHttpRequest } from "./MKHttpRequest";
-import { MKProgramInfo, MKSourceConfig, MKRollInfo } from "../../interfaces";
-export declare class MKAzukiRequest extends MKHttpRequest {
+import { MKProgramInfo, MKSourceConfig, MKRollInfo, MKSessionConcurrencyAPI, MKError } from "../../interfaces";
+export declare class MKAzukiRequest extends MKHttpRequest implements MKSessionConcurrencyAPI {
     private mediaId;
     private ownerUid;
     private sessionId;
     private baseUrl;
     private headers;
     private isLive;
+    private beaconInterval;
     private rightsMode;
     private catchupStartTime?;
     private localStorage;
-    private beaconInterval;
+    private isDvrFromRollingBuffer;
+    private errorCallback?;
+    private beaconTimer?;
+    private adobePrimetimeConfig?;
     static locationDetail?: string;
     static inhomeStatus: boolean;
-    constructor(sourceConfig: MKSourceConfig);
+    static responseTime: {
+        registration: number;
+        roll: number;
+        beacons: number;
+        query: number;
+    };
+    constructor(sourceConfig: MKSourceConfig, errorCallback?: (error: MKError) => void);
     setAuthorizationToken(authorizationToken: string): void;
     getBeaconInterval(): number;
     registrationRequest(): Promise<void>;
     rollRequest(): Promise<MKRollInfo>;
-    beaconRequest(isFinalBeacon?: boolean): Promise<void>;
     programInfoRequest(startDate: string, endDate: string): Promise<MKProgramInfo[]>;
-    pendingBeaconRequest(): Promise<void>;
+    startSession(): Promise<void>;
+    stopSession(): Promise<void>;
+    private scheduleBeaconRequest;
+    private beaconRequest;
+    private pendingBeaconRequest;
     private getRequestHeaders;
     private saveBeaconData;
     private clearBeaconData;

package/classes/request/MKHttpRequest.d.ts

@@ -1,11 +1,12 @@
-import { MKHttpRequestOptions } from "../../interfaces";
+import { MKHttpRequestOptions, MKHttpResponse } from "../../interfaces";
 export declare class MKHttpRequest {
-    private abortController;
+    private xhrController;
     constructor();
-    get(url: string, options?: MKHttpRequestOptions): Promise<Response>;
-    put(url: string, options?: MKHttpRequestOptions): Promise<Response>;
-    post(url: string, options?: MKHttpRequestOptions): Promise<Response>;
-    delete(url: string, options?: MKHttpRequestOptions): Promise<Response>;
+    get(url: string, options?: MKHttpRequestOptions): Promise<MKHttpResponse>;
+    put(url: string, options?: MKHttpRequestOptions): Promise<MKHttpResponse>;
+    post(url: string, options?: MKHttpRequestOptions): Promise<MKHttpResponse>;
+    delete(url: string, options?: MKHttpRequestOptions): Promise<MKHttpResponse>;
     cancelRequest(): void;
     private request;
+    private getAllResponseHeaders;
 }

package/classes/request/index.d.ts

@@ -1,2 +1,3 @@
+export { MKAdobeSessionConcurrencyRequest } from "./MKAdobeSessionConcurrencyRequest";
 export { MKAzukiRequest } from "./MKAzukiRequest";
 export { MKHttpRequest } from "./MKHttpRequest";

package/constants/MKConstants.d.ts

@@ -13,5 +13,6 @@ export declare const MKConstants: {
         AzukiError: string;
         PlayerError: string;
         ProgramRestrictionError: string;
+        AdobePrimetimeSessionConcurrencyError: string;
     };
 };

package/enums/MKErrorCode.d.ts

@@ -48,8 +48,6 @@ export declare enum MKErrorCode {
     PLAYER_DRM_PLAYREADY_INVALID_HEADER_KEY_VALUE_PAIR = "4-74-2012",
     PLAYER_DRM_RESTRICTED_OUTPUT = "4-74-2013",
     PLAYER_DRM_INIT_DATA_MISSING = "4-74-2015",
-    PROGRAM_RESTRICTION_WIFI = "4-80-100",
-    PROGRAM_RESTRICTION_CELLULAR = "4-80-101",
     PROGRAM_RESTRICTION_PHONE = "4-80-102",
     PROGRAM_RESTRICTION_TABLET = "4-80-103",
     PROGRAM_RESTRICTION_STB = "4-80-104",

package/enums/MKProgramRestrictionType.d.ts

@@ -6,5 +6,14 @@ export declare enum MKProgramRestrictionType {
     SeekForward = "seekforward",
     SeekBackward = "seekbackward",
     Restart = "restart",
-    Timeshift = "timeshift"
+    Timeshift = "timeshift",
+    SeekSkip = "seekskip",
+    CatchUp = "catchup",
+    AndroidBlocked = "androidblocked",
+    IOSBlocked = "iosblocked",
+    PhoneBlocked = "phoneblocked",
+    TabletBlocked = "tabletblocked",
+    DesktopBlocked = "desktopblocked",
+    OutofhomeBlocked = "outofhomeblocked",
+    AirplayBlocked = "airplayblocked"
 }

package/interfaces/MKAdobePrimetimeConfig.d.ts

@@ -0,0 +1,11 @@
+export interface MKAdobePrimetimeConfig {
+    applicationId: string;
+    requesterId: string;
+    resourceId: string;
+    userId: string;
+    upstreamUserId: string;
+    slmt: string;
+    mvpd: string;
+    endpointUrl?: string;
+    isStaging?: boolean;
+}

package/interfaces/MKAzukiConfig.d.ts

@@ -1,7 +1,7 @@
-import { MKRequestHeaders } from "../alias";
+import { MKHeaders } from "../alias";
 export interface MKAzukiConfig {
     serverUrl: string;
     authToken: string;
     ownerUid?: string;
-    headers?: MKRequestHeaders;
+    headers?: MKHeaders;
 }

package/interfaces/MKFairplayDrmConfig.d.ts

@@ -1,10 +1,10 @@
-import { MKRequestHeaders } from "../alias";
+import { MKHeaders } from "../alias";
 import { MKHttpResponseType } from "../enums";
 export interface MKFairplayDrmConfig {
     LA_URL?: string;
     certificateURL: string;
-    certificateHeaders?: MKRequestHeaders;
-    headers?: MKRequestHeaders;
+    certificateHeaders?: MKHeaders;
+    headers?: MKHeaders;
     licenseResponseType?: MKHttpResponseType;
     maxCertificateRequestRetries?: number;
     maxLicenseRequestRetries?: number;

package/interfaces/MKHttpRequestOptions.d.ts

@@ -1,7 +1,8 @@
-import { MKRequestBodyParams, MKRequestHeaders, MKRequestQueryParams } from "../alias";
+import { MKRequestBody, MKHeaders, MKRequestQueryParams } from "../alias";
 export interface MKHttpRequestOptions {
     timeout?: number;
-    headers?: MKRequestHeaders;
-    body?: MKRequestBodyParams;
+    headers?: MKHeaders;
+    body?: MKRequestBody;
     queryParams?: MKRequestQueryParams;
+    withCredentials?: boolean;
 }

package/interfaces/MKHttpResponse.d.ts

@@ -0,0 +1,12 @@
+import { MKHeaders } from "../alias";
+export interface MKHttpResponse {
+    headers?: MKHeaders;
+    ok: boolean;
+    status: number;
+    statusText: string;
+    redirected?: boolean;
+    responseTime: number;
+    url: string;
+    json: <T>() => T;
+    text: () => Promise<string>;
+}

package/interfaces/MKPlayReadyDrmConfig.d.ts

@@ -1,9 +1,9 @@
-import { MKRequestHeaders } from "../alias";
+import { MKHeaders } from "../alias";
 export interface MKPlayReadyDrmConfig {
     LA_URL?: string;
     customData?: string;
     forceSSL?: boolean;
-    headers?: MKRequestHeaders;
+    headers?: MKHeaders;
     licenseRequestRetryDelay?: number;
     maxLicenseRequestRetries?: number;
     plaintextChallenge?: boolean;

package/interfaces/MKPlayerAPI.d.ts

@@ -12,6 +12,7 @@ import { MKTimeRange } from "./MKTimeRange";
 import { MKVideoQuality } from "./MKVideoQuality";
 import { MKViewModeOptions } from "./MKViewModeOptions";
 import { MKPlayerEvent, MKTimeMode, MKLogLevel, MKViewMode, MKBufferType, MKMediaType } from "../enums";
+import { MKSourceOptions } from "./MKSourceOptions";
 export interface MKPlayerAPI {
     addCastMetadata(metadata: any): boolean;
     addSubtitle(subtitleTrack: MKSubtitleTrack): void;
@@ -60,6 +61,7 @@ export interface MKPlayerAPI {
     isStalled(): boolean;
     isViewModeAvailable(viewMode: MKViewMode): boolean;
     load(sourceConfig: MKSourceConfig, disableSeeking?: boolean): Promise<void>;
+    reload(start: string, sourceOptions?: MKSourceOptions): Promise<void>;
     mute(issuer?: string): void;
     on(eventType: MKPlayerEvent, callback: MKPlayerEventCallback): void;
     off(eventType: MKPlayerEvent, callback: MKPlayerEventCallback): void;

package/interfaces/MKPlayerEngine.d.ts

@@ -1,3 +1,3 @@
 import { MKPlayerAPI } from "./MKPlayerAPI";
-export interface MKPlayerEngine extends MKPlayerAPI {
+export interface MKPlayerEngine extends Omit<MKPlayerAPI, "setInhomeStatus" | "setLocationDetail" | "setAuthorizationToken"> {
 }

package/interfaces/MKRegisteredSource.d.ts

@@ -1,7 +1,10 @@
+import { MKAdobePrimetimeConfig } from "./MKAdobePrimetimeConfig";
 import { MKAzukiConfig } from "./MKAzukiConfig";
 export interface MKRegisteredSource {
     mediaId: string;
+    adobePrimetimeConfig?: MKAdobePrimetimeConfig;
     azukiConfig: MKAzukiConfig;
     applicationToken?: string;
     catchupStartTime?: string;
+    isDvrFromRollingBuffer?: boolean;
 }

package/interfaces/MKSessionConcurrencyAPI.d.ts

@@ -0,0 +1,4 @@
+export interface MKSessionConcurrencyAPI {
+    startSession(): Promise<void>;
+    stopSession(): Promise<void>;
+}

package/interfaces/MKSourceOptions.d.ts

@@ -1,11 +1,11 @@
-import { MKRequestHeaders } from "../alias";
+import { MKHeaders } from "../alias";
 import { MKStartOffsetTimelineReference } from "../enums";
 import { MKPeriodInformation } from "./MKPeriodInformation";
 export interface MKSourceOptions {
     audioCodecPriority?: string[];
     dashManifestWithCredentials?: boolean;
     dashWithCredentials?: boolean;
-    headers?: MKRequestHeaders;
+    headers?: MKHeaders;
     hlsManifestWithCredentials?: boolean;
     hlsWithCredentials?: boolean;
     manifestWithCredentials?: boolean;

package/interfaces/MKWidevineModularDrmConfig.d.ts

@@ -1,8 +1,8 @@
-import { MKRequestHeaders } from "../alias";
+import { MKHeaders } from "../alias";
 export interface MKWidevineModularDrmConfig {
     LA_URL?: string;
     audioRobustness?: string;
-    headers?: MKRequestHeaders;
+    headers?: MKHeaders;
     licenseRequestRetryDelay?: number;
     maxLicenseRequestRetries?: number;
     prepareLicense?: ((licenseObject: any) => any);

package/interfaces/{MKFMTSASiDEvent.d.ts → events/MKFMTSASiDEvent.d.ts}

@@ -1,4 +1,4 @@
-import { MKPlayerEventBase } from "./events";
+import { MKPlayerEventBase } from ".";
 export interface MKFMTSASiDEvent extends MKPlayerEventBase {
     initToken: string;
     assetId: string;

package/interfaces/events/index.d.ts

@@ -28,6 +28,7 @@ export { MKDownloadFinishedEvent } from "./MKDownloadFinishedEvent";
 export { MKDrmLicenseAddedEvent } from "./MKDrmLicenseAddedEvent";
 export { MKDurationChangedEvent } from "./MKDurationChangedEvent";
 export { MKErrorEvent } from "./MKErrorEvent";
+export { MKFMTSASiDEvent } from "./MKFMTSASiDEvent";
 export { MKLatencyModeChangedEvent } from "./MKLatencyModeChangedEvent";
 export { MKMediaPlaybackQualityChangeEvent } from "./MKMediaPlaybackQualityChangeEvent";
 export { MKMediaQualityChangeEvent } from "./MKMediaQualityChangeEvent";

package/interfaces/index.d.ts

@@ -2,7 +2,9 @@ export * from "./events";
 export { MKAdaptationConfig } from "./MKAdaptationConfig";
 export { MKAdaptationData } from "./MKAdaptationData";
 export { MKAdaptationPlatformConfig } from "./MKAdaptationPlatformConfig";
+export { MKAdobePrimetimeConfig } from "./MKAdobePrimetimeConfig";
 export { MKAnalyticsConfig } from "./MKAnalyticsConfig";
+export { MKAdCompanion } from "./MKAdCompanion";
 export { MKAudioAdaptationData } from "./MKAudioAdaptationData";
 export { MKAudioQuality } from "./MKAudioQuality";
 export { MKAudioTrack } from "./MKAudioTrack";
@@ -14,7 +16,6 @@ export { MKBufferMediaTypeConfig } from "./MKBufferMediaTypeConfig";
 export { MKCastConfig } from "./MKCastConfig";
 export { MKCdn } from "./MKCdn";
 export { MKCdnOptions } from "./MKCdnOptions";
-export { MKAdCompanion } from "./MKAdCompanion";
 export { MKDownloadedAudioData } from "./MKDownloadedAudioData";
 export { MKDownloadedData } from "./MKDownloadedData";
 export { MKDownloadedVideoData } from "./MKDownloadedVideoData";
@@ -22,8 +23,8 @@ export { MKDrmConfig } from "./MKDrmConfig";
 export { MKDrmLicense } from "./MKDrmLicense";
 export { MKError } from "./MKError";
 export { MKFairplayDrmConfig } from "./MKFairplayDrmConfig";
-export { MKFMTSASiDEvent } from "./MKFMTSASiDEvent";
 export { MKHttpRequestOptions } from "./MKHttpRequestOptions";
+export { MKHttpResponse } from "./MKHttpResponse";
 export { MKImageMediaPlaylist } from "./MKImageMediaPlaylist";
 export { MKLiveConfig } from "./MKLiveConfig";
 export { MKLogConfig } from "./MKLogConfig";
@@ -51,6 +52,7 @@ export { MKQuality } from "./MKQuality";
 export { MKQualityMetadata } from "./MKQualityMetadata";
 export { MKRegisteredSource } from "./MKRegisteredSource";
 export { MKRollInfo } from "./MKRollInfo";
+export { MKSessionConcurrencyAPI } from "./MKSessionConcurrencyAPI";
 export { MKSourceConfig } from "./MKSourceConfig";
 export { MKSourceLabelingConfig } from "./MKSourceLabelingConfig";
 export { MKSourceLabelingStreamTypeConfig } from "./MKSourceLabelingStreamTypeConfig";