@gumlet/insights-js-core 1.0.3 → 1.1.0

package/js/core/Analytics.js

@@ -0,0 +1,1357 @@
+/* global __VERSION__ */
+import LicenseCall from '../utils/LicenseCall';
+import EventsCall from '../utils/EventsCall';
+import SessionCreationCall from '../utils/SessionCreationCall';
+import PlayerInitCall from '../utils/PlayerInitCall';
+import Utils from '../utils/Utils';
+import logger from '../utils/Logger';
+import AdapterFactory from './AdapterFactory';
+import AnalyticsStateMachineFactory from './AnalyticsStateMachineFactory';
+import CastClient from '../cast/CastClient';
+import CastReceiver from '../cast/CastReceiver';
+import GumletEventEnum from '../enums/GumletEnum';
+
+import {HTML5AnalyticsStateMachine} from '../analyticsStateMachines/HTML5AnalyticsStateMachine';
+import {VideojsAnalyticsStateMachine} from '../analyticsStateMachines/VideoJsAnalyticsStateMachine';
+
+import VideoJsAdapter from "../adapters/VideoJsAdapter";
+import {HlsjsAdapter} from "../adapters/HlsjsAdapter";
+import {DashjsAdapter} from "../adapters/DashjsAdapter";
+import {HTML5Adapter} from "../adapters/HTML5Adapter";
+import {ShakaAdapter} from "../adapters/ShakaAdapter";
+
+class Analytics {
+  static PAGE_LOAD_TYPE               = {
+    FOREGROUND: 1, BACKGROUND: 2
+  };
+  static LICENSE_CALL_PENDING_TIMEOUT = 200;
+  static PAGE_LOAD_TYPE_TIMEOUT       = 200;
+  static CAST_RECEIVER_CONFIG_MESSAGE = 'CAST_RECEIVER_CONFIG_MESSAGE';
+
+  constructor(config) {
+    this.config = config;
+
+    // this.licenseCall                  = new LicenseCall();
+    this.analyticsCall                = new EventsCall();
+    this.sessionCreationCall          = new SessionCreationCall();
+    this.playerInitCall               = new PlayerInitCall();
+    this.castClient                   = new CastClient();
+    this.castReceiver                 = new CastReceiver();
+
+    this.droppedSampleFrames = 0;
+    this.licensing           = 'granted';
+    this.startupTime         = 0;
+    this.pageLoadType        = Analytics.PAGE_LOAD_TYPE.FOREGROUND;
+
+    this.autoplay = undefined;
+
+    this.isCastClient = false;
+    this.isCastReceiver = false;
+    this.isAllowedToSendSamples = false;
+    this.samplesQueue = [];
+
+    this.previousState = undefined;
+    this.previousStateTimeStamp = new Date();
+
+    this.firstPlayTimestamp = 0;
+
+    this.isMuted = false;
+    this.isFullScreen = undefined;
+    this.videoWidthPixels = undefined;
+    this.videoHeightPixels = undefined;
+    this.upscalePercentage = undefined;
+    this.downscalePercentage = undefined;
+    this.videoBitrate = undefined;
+    this.audioCodec = undefined;
+    this.videoCodec = undefined;
+    this.currentTime = 0;
+
+    try {
+      this.orientation = screen.orientation.type.match(/\w+/)[0];
+      screen.orientation.onchange = function (){
+          // logs 'portrait' or 'landscape'
+          this.orientation = screen.orientation.type.match(/\w+/)[0];
+      };
+
+    } catch (e) {
+        this.orientation = "undetected";
+    }
+
+    // this.setPageLoadType();
+
+    this.setConfigParameters();
+    this.init();
+    this.setupSample();
+    // this.sendAnalyticsSetupCall();
+    this.setupStateMachineCallbacks();
+
+    // Casting related settings ignored for now
+
+    // if (this.config.cast && this.config.cast.receiver) {
+    //   this.isCastReceiver = true;
+    //   this.castReceiver.setUp();
+    //   this.castReceiver.setCallback((event) => {
+    //     switch (event.type) {
+    //       case Analytics.CAST_RECEIVER_CONFIG_MESSAGE:
+    //         this.castClientConfig = event.data;
+    //         this.updateSampleToCastClientConfig(this.sample, this.castClientConfig);
+    //         this.updateSamplesToCastClientConfig(this.samplesQueue, event.data);
+    //         this.isAllowedToSendSamples = true;
+    //         break;
+    //     }
+    //   });
+    // }
+  }
+
+  // updateSamplesToCastClientConfig(samples, castClientConfig) {
+  //   for (let i = 0; i < samples.length; i++) {
+  //     this.updateSampleToCastClientConfig(samples[i], castClientConfig);
+  //   }
+  // }
+  //
+  // updateSampleToCastClientConfig(sample, castClientConfig) {
+  //   const {config, userId, impressionId, domain, path, language, userAgent} = castClientConfig;
+  //   sample.impressionId = impressionId;
+  //   sample.userId = userId;
+  //   sample.userAgent = userAgent;
+  //   sample.domain = domain;
+  //   sample.path = path;
+  //   sample.language = language;
+  //
+  //   this.setConfigParameters(sample, config);
+  // }
+
+  // setPageLoadType() {
+  //   window.setTimeout(() => {
+  //     if (document[Utils.getHiddenProp()] === true) {
+  //       this.pageLoadType = Analytics.PAGE_LOAD_TYPE.BACKGROUND;
+  //     }
+  //   }, Analytics.PAGE_LOAD_TYPE_TIMEOUT);
+  //   this.pageURL = window.location.href;
+  //   console.log(window.location.href)
+  // }
+
+  init() {
+    if (!this.isCastReceiver && (this.config.property_id == '' || !Utils.validString(this.config.property_id))) {
+      console.error('Invalid analytics property_id provided');
+      return;
+    }
+
+    logger.setLogging(this.config.debug || false);
+
+    // if (!this.isCastReceiver) {
+      //this.checkLicensing(this.config.property_id);
+    // } else {
+    //   this.licensing = 'granted';
+    // }
+
+    this.propertyId = this.config.property_id;
+   
+    // if (typeof window === "window" && window)//(typeof window.parent.location !== "undefined")
+    if (typeof window !== "undefined" && typeof window.parent !== "undefined")
+    {
+      this.pageURL = (window.location != window.parent.location)
+            ? document.referrer
+            : document.location.href ;
+
+    }else if(this.config.page_url){
+      this.pageURL = this.config.page_url;
+    }else{
+      this.pageURL = null;
+    }
+
+    // this.setConfigParameters();
+    let test = false;
+    if (this.config.test) {
+      test = true;
+    }
+
+    let overrideSessionID = null;
+    if (this.config.sessionID) {
+      overrideSessionID = this.config.sessionID;
+    }
+
+    let sendSessionRequest = true;
+    if (this.config.hasOwnProperty('sendSessionRequest')) {
+      sendSessionRequest = this.config.sendSessionRequest;
+    }
+
+    let overrideUserID = null;
+    if (this.config.userID) {
+      overrideUserID = this.config.userID;
+    }
+
+    this.setUserId(test, overrideUserID);
+    this.setSessionId(test, overrideSessionID, sendSessionRequest);
+    this.setPlayerInstanceId();
+    this.setPlaybackId();
+  }
+
+  setConfigParameters(sample = this.sample, config = this.config) {
+    // Random custom strings
+    this.customData1                    = Utils.getCustomDataString(config.customData1);
+    this.customData2                    = Utils.getCustomDataString(config.customData2);
+    this.customData3                    = Utils.getCustomDataString(config.customData3);
+    this.customData4                    = Utils.getCustomDataString(config.customData4);
+    this.customData5                    = Utils.getCustomDataString(config.customData5);
+    this.customData6                    = Utils.getCustomDataString(config.customData6);
+    this.customData7                    = Utils.getCustomDataString(config.customData7);
+    this.customData8                    = Utils.getCustomDataString(config.customData8);
+    this.customData9                    = Utils.getCustomDataString(config.customData9);
+    this.customData10                   = Utils.getCustomDataString(config.customData10);
+
+    // Player specific custom data
+    this.customPlayerIntegrationVersion = Utils.getCustomDataString(config.customPlayerIntegrationVersion);
+    this.customPlayerName               = Utils.getCustomDataString(config.customPlayerName);
+    this.customPageType                 = Utils.getCustomDataString(config.customPageType);
+
+    // User specific custom data
+    this.customUserId                   = Utils.getCustomDataString(config.userId);
+    this.userName                       = Utils.getCustomDataString(config.userName);
+    this.userEMail                      = Utils.getCustomDataString(config.userEMail);
+    this.userPhone                      = Utils.getCustomDataString(config.userPhone);
+    this.userProfileImage               = Utils.getCustomDataString(config.userProfileImage);
+    this.userAddressLine1               = Utils.getCustomDataString(config.userAddressLine1);
+    this.userAddressLine2               = Utils.getCustomDataString(config.userAddressLine2);
+    this.userCity                       = Utils.getCustomDataString(config.userCity);
+    this.userState                      = Utils.getCustomDataString(config.userState);
+    this.userCountry                    = Utils.getCustomDataString(config.userCountry);
+    this.userZipcode                    = Utils.getCustomDataString(config.userZipcode);
+
+    // Video specific custom data
+    this.customContentType              = Utils.getCustomDataString(config.customContentType);
+    this.customVideoDurationMillis      = Utils.getCustomDataString(config.customVideoDurationMillis);
+    this.customEncodingVariant          = Utils.getCustomDataString(config.customEncodingVariant);
+    this.customVideoLanguage            = Utils.getCustomDataString(config.customVideoLanguage);
+    this.customVideoId                  = Utils.getCustomDataString(config.customVideoId);
+    this.customVideoSeries              = Utils.getCustomDataString(config.customVideoSeries);
+    this.customVideoProducer            = Utils.getCustomDataString(config.customVideoProducer);
+    this.customVideoTitle               = Utils.getCustomDataString(config.customVideoTitle);
+    this.customVideoVariantName         = Utils.getCustomDataString(config.customVideoVariantName);
+    this.customVideoVariant             = Utils.getCustomDataString(config.customVideoVariant);
+
+
+    this.SDKVersion = "1.0.0";
+    this.experimentName = config.experimentName;
+  }
+
+  updateCustomUserData(config){
+    // User specific custom data
+    this.customUserId                   = Utils.getCustomDataString(config.userId);
+    this.userName                       = Utils.getCustomDataString(config.userName);
+    this.userEMail                      = Utils.getCustomDataString(config.userEMail);
+    this.userPhone                      = Utils.getCustomDataString(config.userPhone);
+    this.userProfileImage               = Utils.getCustomDataString(config.userProfileImage);
+    this.userAddressLine1               = Utils.getCustomDataString(config.userAddressLine1);
+    this.userAddressLine2               = Utils.getCustomDataString(config.userAddressLine2);
+    this.userCity                       = Utils.getCustomDataString(config.userCity);
+    this.userState                      = Utils.getCustomDataString(config.userState);
+    this.userCountry                    = Utils.getCustomDataString(config.userCountry);
+    this.userZipcode                    = Utils.getCustomDataString(config.userZipcode);
+  }
+
+  updateCustomVideoData(config){
+    // Video specific custom data
+    this.customContentType              = Utils.getCustomDataString(config.customContentType);
+    this.customVideoDurationMillis      = Utils.getCustomDataString(config.customVideoDurationMillis);
+    this.customEncodingVariant          = Utils.getCustomDataString(config.customEncodingVariant);
+    this.customVideoLanguage            = Utils.getCustomDataString(config.customVideoLanguage);
+    this.customVideoId                  = Utils.getCustomDataString(config.customVideoId);
+    this.customVideoSeries              = Utils.getCustomDataString(config.customVideoSeries);
+    this.customVideoProducer            = Utils.getCustomDataString(config.customVideoProducer);
+    this.customVideoTitle               = Utils.getCustomDataString(config.customVideoTitle);
+    this.customVideoVariantName         = Utils.getCustomDataString(config.customVideoVariantName);
+    this.customVideoVariant             = Utils.getCustomDataString(config.customVideoVariant);
+  }
+
+  updateCustomData(config){
+    this.customData1                  = Utils.getCustomDataString(config.customData1);
+    this.customData2                  = Utils.getCustomDataString(config.customData2);
+    this.customData3                  = Utils.getCustomDataString(config.customData3);
+    this.customData4                  = Utils.getCustomDataString(config.customData4);
+    this.customData5                  = Utils.getCustomDataString(config.customData5);
+    this.customData6                  = Utils.getCustomDataString(config.customData6);
+    this.customData7                  = Utils.getCustomDataString(config.customData7);
+    this.customData8                  = Utils.getCustomDataString(config.customData8);
+    this.customData9                  = Utils.getCustomDataString(config.customData9);
+    this.customData10                 = Utils.getCustomDataString(config.customData10);
+  }
+
+  updateCustomPlayerData(config){
+    this.customPlayerIntegrationVersion    = Utils.getCustomDataString(config.customPlayerIntegrationVersion);
+    this.customPlayerName                  = Utils.getCustomDataString(config.customPlayerName);
+    this.customPageType                    = Utils.getCustomDataString(config.customPageType);
+  }
+
+  setSessionData() {
+    this.sessionData = {
+      session_id: this.sessionId,
+      property_id: this.propertyId,
+      user_id: this.userId,
+      custom_user_id: this.customUserId,
+      custom_data_1: this.customData1,
+      custom_data_2: this.customData2,
+      custom_data_3: this.customData3,
+      custom_data_4: this.customData4,
+      custom_data_5: this.customData5,
+      custom_data_6: this.customData6,
+      custom_data_7: this.customData7,
+      custom_data_8: this.customData8,
+      custom_data_9: this.customData9,
+      custom_data_10: this.customData10,
+      user_name: this.userName,
+      user_email: this.userEMail,
+      user_phone: this.userPhone,
+      user_profile_image: this.userProfileImage,
+      user_address_line1: this.userAddressLine1,
+      user_address_line2: this.userAddressLine2,
+      user_city: this.userCity,
+      user_state: this.userState,
+      user_country: this.userCountry,
+      user_zipcode: this.userZipcode,
+      viewer_client_version: this.SDKVersion,
+      meta_browser: this.meta_browser,
+      meta_device_manufacturer: this.meta_device_manufacturer,
+      meta_operating_system_version: this.meta_operating_system_version,
+      meta_operating_system: this.meta_operating_system,
+      meta_device_name: this.meta_device_name,
+      meta_browser_version: this.meta_browser_version,
+      meta_device_category: this.meta_device_category,
+      meta_device_architecture: this.meta_device_architecture,
+      meta_device_display_width: this.meta_device_display_width,
+      meta_device_display_height: this.meta_device_display_height,
+      meta_device_is_touchscreen: this.meta_device_is_touchscreen,
+      meta_device_display_dpr: this.meta_device_display_dpr
+    }
+
+    if (this.config.deviceData) {
+      this.sessionData.meta_device_name = this.config.deviceData.meta_device_name;
+      this.sessionData.meta_device_manufacturer = this.config.deviceData.meta_device_manufacturer;
+      this.sessionData.meta_operating_system_version = this.config.deviceData.meta_operating_system_version;
+      this.sessionData.meta_operating_system = this.config.deviceData.meta_operating_system;
+      this.sessionData.meta_browser = this.config.deviceData.meta_browser;
+      this.sessionData.meta_device_display_dpr = this.config.deviceData.meta_device_display_dpr;
+      this.sessionData.meta_browser_version = this.config.deviceData.meta_browser_version;
+      this.sessionData.meta_device_category = this.config.deviceData.meta_device_category;
+      this.sessionData.meta_device_architecture = this.config.deviceData.meta_device_architecture;
+      this.sessionData.meta_device_display_width = this.config.deviceData.meta_device_display_width;
+      this.sessionData.meta_device_display_height = this.config.deviceData.meta_device_display_height;
+      this.sessionData.meta_device_is_touchscreen = this.config.deviceData.meta_device_is_touchscreen;
+    }else{
+      this.sessionData.meta_device_display_width = window.screen.width;
+      this.sessionData.meta_device_display_height = window.screen.height;
+      this.sessionData.meta_device_display_dpr = parseInt(window.devicePixelRatio);
+      if ("ontouchstart" in document.documentElement){
+        this.sessionData.meta_device_is_touchscreen = "true";
+      }
+    }
+  }
+
+  setPlayerData(data=null) {
+    this.playerData = {
+      player_instance_id          : this.playerInstanceId,
+      property_id                 : this.propertyId,
+      session_id                  : this.sessionId,
+      user_id                     : this.userId,
+      custom_user_id              : this.customUserId,
+      custom_data_1               : this.customData1,
+      custom_data_2               : this.customData2,
+      custom_data_3               : this.customData3,
+      custom_data_4               : this.customData4,
+      custom_data_5               : this.customData5,
+      custom_data_6               : this.customData6,
+      custom_data_7               : this.customData7,
+      custom_data_8               : this.customData8,
+      custom_data_9               : this.customData9,
+      custom_data_10              : this.customData10,
+      player_integration_version  : this.customPlayerIntegrationVersion,
+      meta_page_type              : this.customPageType,
+      meta_page_url               : this.pageURL,
+    }
+
+    if (this.config.deviceData) {
+      this.playerData.player_preload = this.config.playerData.player_preload;
+      this.playerData.player_autoplay = this.config.playerData.player_autoplay;
+      this.playerData.player_software_version = this.config.playerData.player_software_version;
+      this.playerData.player_integration_version = this.config.playerData.player_integration_version;
+      this.playerData.player_name = this.config.playerData.player_name;
+      this.playerData.player_language_code = this.config.playerData.player_language_code;
+      this.playerData.player_software = this.config.playerData.player_software;
+      this.playerData.meta_page_url = this.config.playerData.meta_page_url;
+      this.playerData.meta_page_type = this.config.playerData.meta_page_type;
+      this.playerData.player_height_pixels = this.config.playerData.player_height_pixels;
+      this.playerData.player_width_pixels = this.config.playerData.player_width_pixels;
+    }
+    // Player Height
+    if (data && Utils.validNumber(data.videoWindowHeight)) {
+      this.playerData.player_height_pixels = data.videoWindowHeight;
+    }
+    // Player width
+    if (data && Utils.validNumber(data.videoWindowWidth)) {
+      this.playerData.player_width_pixels = data.videoWindowWidth;
+    }
+    // Player is configured to autoplay
+    if (data && Utils.validBoolean(data.autoplay)) {
+      this.playerData.player_autoplay = data.autoplay;
+    }
+    // Player is configured to preload when page loads
+    if (data && Utils.validBoolean(data.preload)) {
+      this.playerData.player_preload = data.preload;
+    }
+    // Player software version
+    if (data && Utils.validString(data.version)) {
+      this.playerData.player_software_version = data.version;
+    }
+    // Player language
+    if (data && Utils.validString(data.audioLanguage)) {
+      this.playerData.player_language_code = data.audioLanguage;
+    }
+    // Player Software name
+    if (data && Utils.validString(data.playerSoftware)) {
+      this.playerData.player_software = data.playerSoftware;
+    }
+  }
+
+  setUserId(test=false, override=null) {
+    if(override){
+      this.userId = override;
+      return;
+    }
+    if (test) {
+      this.userId = Utils.uuidv4();
+      return;
+    }
+    const userId = Utils.getCookie('gumlet_user_id');
+    if (!userId || userId === '') {
+      // let date = new Date();
+      // date.setTime(date.getTime() + (30*24*60*60*1000));
+      // document.cookie = 'gumlet_user_id=' + Utils.uuidv4()+'; expires='+date.toUTCString()+'; path=/';
+      // this.userId   = Utils.getCookie('gumlet_user_id');
+      this.userId  = Utils.setCookie('gumlet_user_id', 30*24*60);
+    } else {
+      this.userId = userId;
+    }
+  }
+
+  setPlayerInstanceId() {
+    if(this.config.getUUID){
+      this.playerInstanceId = this.config.getUUID();
+    }else{
+      this.playerInstanceId = Utils.uuidv4();  
+    }
+    this.setPlayerData();
+  }
+
+  setPlaybackId() {
+    if(this.config.getUUID){
+      this.playbackId = this.config.getUUID();
+    }else{
+      this.playbackId = Utils.uuidv4();
+    }
+  }
+
+  setSessionId(test=false, override=null, sendSessionRequest=true) {
+    if (override) {
+      this.sessionId = override;
+      this.setSessionData();
+      if(sendSessionRequest){
+        this.sessionCreationCall.sendRequest(this.sessionData, Utils.noOp);
+      }
+      return;
+    }
+    if (test) {
+      this.sessionId = Utils.uuidv4();
+      return;
+    }
+    const sessionId = Utils.getCookie('gumlet_session_id');
+    if (!sessionId || sessionId === '') {
+    //   let date = new Date();
+    //   date.setTime(date.getTime() + (30*60*1000));
+    //   document.cookie = 'gumlet_session_id=' + Utils.uuidv4()+'; expires='+date.toUTCString()+'; path=/';
+      this.sessionId  = Utils.setCookie('gumlet_session_id', 30);
+      this.setSessionData();
+      // Call Analytics API to create session.
+      this.sessionCreationCall.sendRequest(this.sessionData, Utils.noOp);
+    } else {
+      this.sessionId = sessionId;
+      this.setSessionData();
+    }
+  }
+
+  sendAnalyticsSetupCall() {
+    this.sendAnalyticsRequestAndClearValues(GumletEventEnum.SETUP, {millis_from_previous_event: 0});
+    this.setState(GumletEventEnum.SETUP);
+  }
+
+  getMillisFromPreviousState(){
+    let currentTime = new Date();
+    return currentTime.getTime() - this.previousStateTimeStamp.getTime();
+  }
+
+  setVideoData(data){
+    if (data && Utils.validNumber(data.duration)) {
+      this.videoDuration = Utils.calculateTime(data.duration);
+    }
+
+    // for web i.e. from statemachines
+    if (data && Utils.validString(data.streamType)) {
+      this.videoSourceType = data.streamType;
+      if (data.streamType === "dash" && Utils.validString(data.mpdUrl)) {
+        this.videoSourceUrl = data.mpdUrl;
+        this.videoSourceHostname = (new URL(this.videoSourceUrl)).hostname;
+      }else if (data.streamType === "hls" && Utils.validString(data.m3u8Url)) {
+        this.videoSourceUrl = data.m3u8Url;
+        this.videoSourceHostname = (new URL(this.videoSourceUrl)).hostname;
+      }
+      else if (data.streamType === "hls" && Utils.validString(data.streamUrl)) {
+        this.videoSourceUrl = data.streamUrl;
+        this.videoSourceHostname = (new URL(this.videoSourceUrl)).hostname;
+      }
+      else if (data.streamType === "progressive" && Utils.validString(data.progUrl)) {
+        this.videoSourceUrl = data.progUrl;
+        this.videoSourceHostname = (new URL(this.videoSourceUrl)).hostname;
+      }else if(data && data.streamUrl){
+        this.videoSourceUrl = data.streamUrl;
+        this.videoSourceHostname = (new URL(this.videoSourceUrl)).hostname;
+      }
+    }
+
+    // override from react native SDK
+    if (data && data.streamUrl) {
+      this.videoSourceUrl = data.streamUrl;
+    }
+    if (data && data.sourceHostName) {
+      this.videoSourceHostname = data.sourceHostName;
+    }
+
+    if (data && data.hasOwnProperty('muted')) {
+      this.isMuted = data.muted;
+    }
+
+    if (data && data.currentVideoData && Utils.validNumber(data.currentVideoData.height) && data.currentVideoData.height > 0) {
+      this.videoHeightPixels = data.currentVideoData.height;
+    }
+    if (data && data.currentVideoData && Utils.validNumber(data.currentVideoData.width) && data.currentVideoData.width > 0) {
+      this.videoWidthPixels = data.currentVideoData.width;
+    }
+    if (data && data.currentVideoData && Utils.validNumber(data.currentVideoData.bitrate) && data.currentVideoData.bitrate > -1) {
+      // player gives the bbitrate in bits per second covert to normalised unit across all SDK to megabit per second
+      this.videoBitrate = data.currentVideoData.bitrate/1000000;
+    }
+    
+    if (data && data.currentVideoData && Utils.validString(data.currentVideoData.audioCodec) && data.currentVideoData.audioCodec.length > 0) {
+      this.audioCodec = data.currentVideoData.audioCodec;
+    }
+
+    if (data && data.currentVideoData && Utils.validString(data.currentVideoData.videoCodec) && data.currentVideoData.videoCodec.length > 0) {
+      this.videoCodec = data.currentVideoData.videoCodec;
+    }
+    // calculate scaling if both videowidth and player width are there
+    let scaling = 0;
+    if (this.videoWidthPixels && this.playerData.player_width_pixels) {
+      scaling = (this.playerData.player_width_pixels - this.videoWidthPixels)/this.videoWidthPixels
+    }else {
+      this.upscalePercentage = undefined;
+      this.downscalePercentage = undefined;
+      return;
+    }
+
+    if (scaling > 0) {
+      this.upscalePercentage = scaling*100;
+      this.downscalePercentage = 0;
+    }else if (scaling < 0) {
+      this.upscalePercentage = 0;
+      this.downscalePercentage = scaling*100*(-1);
+    }else {
+      this.upscalePercentage = 0;
+      this.downscalePercentage = 0;
+    }
+
+    const parsedURL = new URL(this.videoSourceUrl);
+    if(parsedURL.hostname === "video.gumlet.io" && !this.customVideoId){
+      this.customVideoId = parsedURL.pathname.split("/")[2];
+    }
+  }
+
+  setupStateMachineCallbacks() {
+    this.stateMachineCallbacks = {
+      // All of these are called in the onLeaveState Method.
+      // So it's the last sample
+      setup: (time, state, event) => {
+        // if (!this.isCastReceiver) {
+        // this.sample.impressionId = Utils.uuidv4();
+        // }
+        logger.log('Setup Gumlet analytics ' + this.analyticsVersion);
+        this.setDuration(time);
+        // this.sample.playerStartupTime = time;
+        // this.sample.pageLoadType      = this.pageLoadType;
+
+        // if (window.performance && window.performance.timing) {
+        //   const loadTime           = Utils.getCurrentTimestamp() - window.performance.timing.navigationStart;
+        //   this.sample.pageLoadTime = loadTime;
+        //   logger.log('Page loaded in ' + loadTime + 'ms');
+        // }
+        this.setVideoData(event);
+
+        // this.setPlaybackSettingsFromLoadedEvent(event);
+        this.sendAnalyticsRequestAndClearValues(GumletEventEnum.SETUP, {millis_from_previous_event: 0});
+        this.setState(GumletEventEnum.SETUP);
+        // this.sample.pageLoadType = this.pageLoadType;
+        // this.sample.pageLoadTime = 0;
+      },
+
+      // ready: Utils.noOp,
+      ready: (time, state, event) => {
+          this.setDuration(time);
+          this.setVideoData(event);
+          this.setPlaybackSettingsFromLoadedEvent(event);
+          this.sendAnalyticsRequestAndClearValues(GumletEventEnum.PLAYER_READY);
+          this.setState(GumletEventEnum.PLAYER_READY);
+          // Make player instance call as data is recieved here for player
+          this.setPlayerData(event);
+          this.playerInitCall.sendRequest(this.playerData, Utils.noOp);
+      },
+
+      loaded: (time, state, event, latency=null) => {
+        this.setDuration(time);
+        this.setVideoData(event);
+        this.setPlaybackSettingsFromLoadedEvent(event);
+        let overridePayload = {};
+        if (latency !== null) {
+          overridePayload = {millis_from_previous_event: latency, previous_event: GumletEventEnum.PLAYER_READY};
+        }
+        // Override millis from previous event and previous event to preserve event flow in case of
+        // HTML5 player where they are not preloaded/autoplayed and the video gets laoded after play button is clicked
+        this.sendAnalyticsRequestAndClearValues(GumletEventEnum.PLAYBACK_READY, overridePayload);
+        if (latency === null) {
+          // don't set playback ready event in state as it causes state flow mismatch if
+          // HTML5 player are not loaded on pageload as video source gets loaded after play button is clicked
+          this.setState(GumletEventEnum.PLAYBACK_READY);
+        }
+      },
+
+      startup: (time, state) => {
+        this.setDuration(time);
+        // this.sample.videoStartupTime = time;
+        // this.setState(state);
+
+        // this.startupTime += time;
+        // this.sample.startupTime = this.startupTime;
+        // this.sample.autoplay = this.autoplay;
+
+        // this.sendAnalyticsRequestAndClearValues();
+        // this.sample.autoplay = undefined;
+      },
+      'first_play': (time, state, event) => {
+          this.setDuration(time);
+          this.setVideoData(event);
+          this.setPlaybackSettingsFromLoadedEvent(event);
+          this.sendAnalyticsRequestAndClearValues(GumletEventEnum.PLAY);
+          this.setState(GumletEventEnum.PLAY);
+          this.firstPlayTimestamp = new Date();
+          // Make a call for event_playbackStarted as well
+      },
+      play: (time, state, event) => {
+          this.setDuration(time);
+          this.setVideoData(event);
+          this.setPlaybackSettingsFromLoadedEvent(event);
+          this.sendAnalyticsRequestAndClearValues(GumletEventEnum.PLAY);
+          this.setState(GumletEventEnum.PLAY);
+      },
+
+      updateSample: (playbackSettings) => {
+        this.setPlaybackSettingsFromLoadedEvent(playbackSettings);
+      },
+
+      playing: (time, state, event) => {
+        this.setDuration(time);
+        this.setVideoData(event);
+        this.setPlaybackSettingsFromLoadedEvent(event);
+        this.sendAnalyticsRequestAndClearValues(GumletEventEnum.PLAYING);
+        this.setState(GumletEventEnum.PLAYING);
+
+        // this.setDuration(time);
+        // this.setState(state);
+        // this.sample.played = time;
+        //
+        // this.setDroppedFrames(event);
+        //
+        // this.sendAnalyticsRequestAndClearValues();
+      },
+
+      playback_started: (time, state, event) => {
+        this.setDuration(time);
+        this.setVideoData(event);
+        this.setPlaybackSettingsFromLoadedEvent(event);
+        let currentTime = new Date();
+        let latency = currentTime.getTime() - this.firstPlayTimestamp.getTime();
+        this.sendAnalyticsRequestAndClearValues(GumletEventEnum.PLAYBACK_STARTED, {millis_from_previous_event: latency});
+        this.setState(GumletEventEnum.PLAYBACK_STARTED);
+
+        // this.setDuration(time);
+        // this.setState(state);
+        // this.sample.played = time;
+        //
+        // this.setDroppedFrames(event);
+        //
+        // this.sendAnalyticsRequestAndClearValues();
+      },
+
+      playingAndBye: (time, state, event) => {
+        this.setDuration(time);
+        // this.setState(state);
+        // this.sample.played = time;
+
+        this.setDroppedFrames(event);
+
+        this.sendUnloadRequest();
+      },
+
+      heartbeat: (time, state, event) => {
+        // this.setDroppedFrames(event);
+        // this.setState(state);
+        this.setDuration(time);
+        this.setVideoData(event);
+        this.setPlaybackSettingsFromLoadedEvent(event);
+        // this.sample.played = this.sample.duration;
+        // this.sendAnalyticsRequestAndClearValues();
+        this.sendAnalyticsRequestAndClearValues(GumletEventEnum.PLAYBACK_UPDATE);
+        this.setState(GumletEventEnum.PLAYBACK_UPDATE);
+      },
+
+      qualitychange: (time, state) => {
+        this.setDuration(time);
+        // this.setState(state);
+
+        // this.sendAnalyticsRequestAndClearValues();
+      },
+
+      'qualitychange_pause': (time, state) => {
+        this.setDuration(time);
+        // this.setState(state);
+
+        // this.sendAnalyticsRequestAndClearValues();
+      },
+
+      'qualitychange_rebuffering': (time, state) => {
+        this.setDuration(time);
+        // this.setState(state);
+
+        // this.sendAnalyticsRequestAndClearValues();
+      },
+
+      videoChange: (event) => {
+        this.stateMachineCallbacks.setVideoTimeEndFromEvent(event);
+        this.stateMachineCallbacks.setVideoTimeStartFromEvent(event);
+        this.setPlaybackSettingsFromLoadedEvent(event);
+        // this.setPlaybackVideoPropertiesFromEvent(event);
+      },
+
+      audioChange: (event) => {
+        this.stateMachineCallbacks.setVideoTimeEndFromEvent(event);
+        this.stateMachineCallbacks.setVideoTimeStartFromEvent(event);
+        // this.sample.audioBitrate = event.bitrate;
+      },
+
+      pause: (time, state, event) => {
+        this.setDuration(time);
+        this.setVideoData(event);
+        this.setPlaybackSettingsFromLoadedEvent(event);
+        this.sendAnalyticsRequestAndClearValues(GumletEventEnum.PAUSE);
+        this.setState(GumletEventEnum.PAUSE);
+
+        // this.setDuration(time);
+        // this.setState(state);
+        //
+        // this.sample.paused = time;
+        //
+        // this.sendAnalyticsRequestAndClearValues();
+      },
+      'start_rebuffer': (time, state, event, test=false) => {
+        this.setDuration(time);
+        this.setVideoData(event);
+        this.setPlaybackSettingsFromLoadedEvent(event);
+        if (!test) {
+          this.sendAnalyticsRequestAndClearValues(GumletEventEnum.START_REBUFFER);
+        }
+        this.setState(GumletEventEnum.START_REBUFFER);
+
+        // this.setDuration(time);
+        // this.setState(state);
+        //
+        // this.sample.paused = time;
+        //
+        // this.sendAnalyticsRequestAndClearValues();
+      },
+      'end_rebuffer': (time, state, event, test=false) => {
+        this.setDuration(time);
+        this.setVideoData(event);
+        this.setPlaybackSettingsFromLoadedEvent(event);
+        if (!test) {
+          this.sendAnalyticsRequestAndClearValues(GumletEventEnum.END_REBUFFER);
+        }else {
+          return this.getSample(GumletEventEnum.END_REBUFFER);
+        }
+        this.setState(GumletEventEnum.END_REBUFFER);
+
+        // this.setDuration(time);
+        // this.setState(state);
+        //
+        // this.sample.paused = time;
+        //
+        // this.sendAnalyticsRequestAndClearValues();
+      },
+      'playback_seeked': (seekedFrom, seekedTo, seekLatency, toEvent) => {
+        // call seeked event
+        // this.setVideoData(event);
+        // this.setPlaybackSettingsFromLoadedEvent(event);
+
+        this.sendAnalyticsRequestAndClearValues(GumletEventEnum.SEEKED, {from:seekedFrom, to:seekedTo});
+        this.setState(GumletEventEnum.SEEKED);
+        // Setup the sample again as additional data was passed to the sample which needs to be removed
+        this.setupSample();
+        // Call event after seek with latency
+        if (toEvent === 'PAUSE') {
+          this.sendAnalyticsRequestAndClearValues(GumletEventEnum.PAUSE, {millis_from_previous_event: seekLatency});
+          this.setState(GumletEventEnum.PAUSE);
+        }else if (toEvent === 'PLAYING') {
+          this.sendAnalyticsRequestAndClearValues(GumletEventEnum.PLAYING, {millis_from_previous_event: seekLatency});
+          this.setState(GumletEventEnum.PLAYING);
+        }
+      },
+
+      'paused_seeking': (time, state, event) => {
+        this.setDuration(time);
+        // this.setState(state);
+
+        // this.sample.seeked = time;
+
+        // this.sendAnalyticsRequestAndClearValues();
+      },
+
+      'play_seeking': Utils.noOp,
+
+      'end_play_seeking': (time, state, event) => {
+        // this.setState(state);
+        this.setDuration(time);
+
+        // this.sample.seeked = time;
+
+        // this.sendAnalyticsRequestAndClearValues();
+      },
+
+      rebuffering: (time, state, event) => {
+        this.setDuration(time);
+        // this.setState(state);
+
+        // this.sample.buffered = time;
+
+        // this.sendAnalyticsRequestAndClearValues();
+      },
+
+      error: (event) => {
+        this.stateMachineCallbacks.setVideoTimeEndFromEvent(event);
+        this.stateMachineCallbacks.setVideoTimeStartFromEvent(event);
+
+        this.sendAnalyticsRequestAndClearValues(GumletEventEnum.ERROR, {error_code:event.code, error:event.message});
+        this.setState(GumletEventEnum.ERROR);
+        // Setup the sample again as additional data was passed to the sample which needs to be removed
+        this.setupSample();
+      },
+
+      end: (time, state, event) => {
+        // this.sample.impressionId = Utils.uuidv4();
+        this.setPlaybackId();
+        this.setDuration(time);
+        this.sendAnalyticsRequestAndClearValues(GumletEventEnum.END);
+        this.setState(GumletEventEnum.END);
+      },
+
+      ad: (time, state, event) => {
+        this.setDuration(time);
+        // this.setState(state);
+        // this.sample.ad = time;
+
+        this.setDroppedFrames(event);
+
+        // this.sendAnalyticsRequestAndClearValues();
+      },
+
+      mute: (time, event) => {
+        this.isMuted = true;
+        this.setPlaybackSettingsFromLoadedEvent(event);
+        this.sendAnalyticsRequestAndClearValues(GumletEventEnum.MUTE);
+      },
+
+      unMute: (time, event) => {
+        this.isMuted = false;
+        this.setPlaybackSettingsFromLoadedEvent(event);
+        this.sendAnalyticsRequestAndClearValues(GumletEventEnum.UNMUTE);
+      },
+
+      muting_ready: Utils.noOp,
+      muting_play: Utils.noOp,
+      muting_pause: Utils.noOp,
+
+      setVideoTimeEndFromEvent: (event) => {
+        // if (Utils.validNumber(event.currentTime)) {
+          // this.sample.videoTimeEnd = Utils.calculateTime(event.currentTime);
+        // }
+      },
+
+      setVideoTimeStartFromEvent: (event) => {
+        // if (Utils.validNumber(event.currentTime)) {
+          // this.sample.videoTimeStart = Utils.calculateTime(event.currentTime);
+        // }
+      },
+
+      startCasting: (timestamp, event) => {
+        if (event && event.resuming) {
+          this.isAllowedToSendSamples = false;
+          logger.warning('Player started casting but a session is already casting!');
+          return;
+        }
+
+        this.isCastClient = true;
+        this.isAllowedToSendSamples = false;
+
+        const {domain, path, language, userAgent, userId, impressionId} = this.sample;
+        const castStartMessage = {
+          type: Analytics.CAST_RECEIVER_CONFIG_MESSAGE,
+          data: {
+            config: this.config,
+            userId,
+            domain,
+            path,
+            language,
+            userAgent,
+            impressionId
+          }
+        };
+
+        this.castClient.setUp();
+        this.castClient.sendMessage(castStartMessage);
+      },
+
+      casting: () => {
+        this.isCastClient = false;
+        this.samplesQueue = [];
+        this.isAllowedToSendSamples = true;
+      },
+
+      source_changing: () => {
+        // this.sample.impressionId = Utils.uuidv4();
+      },
+
+      resetSessionExpiry: () => {
+        if (this.config.test) {
+          return;
+        }
+
+        if (this.config.sessionID) {
+          return;
+        }
+
+        Utils.setCookie('gumlet_session_id', 30, this.sessionId);
+        Utils.setCookie('gumlet_user_id', 30*24*60, this.userId);
+        // const sessionId = Utils.getCookie('gumlet_session_id');
+        // if (!sessionId || sessionId === '') {
+        //   this.setSessionId(test);
+        // }else {
+        //   let date = new Date();
+        //   date.setTime(date.getTime() + (30*60*1000));
+        //   if(typeof window === "window" && window)
+        //   {
+        //     document.cookie = 'gumlet_session_id=' + sessionId+'; expires='+date.toUTCString()+'; path=/';
+        //   }
+        //   else{
+        //     let gumlet_session_id = 'gumlet_session_id=' + sessionId+'; expires='+date.toUTCString()+'; path=/';
+        //   }
+          
+        // }
+      }
+    };
+  }
+
+  register = (player, opts = {}) => {
+    if (!player) {
+      this.analyticsStateMachine = new HTML5AnalyticsStateMachine(this.stateMachineCallbacks, opts);
+      return this.analyticsStateMachine;
+    }
+    
+    if (!opts.starttime) {
+      opts.starttime = Utils.getCurrentTimestamp();
+    }
+    this.analyticsStateMachine = AnalyticsStateMachineFactory.getAnalyticsStateMachine(player, this.stateMachineCallbacks, opts);
+    this.adapter = AdapterFactory.getAdapter(player, this.record, this.analyticsStateMachine, opts.mediaElement);
+    if (!this.adapter) {
+      logger.error('Could not detect player.');
+      return;
+    }
+  };
+
+  registerVideoJSPlayer = (player, opts = {}) => {
+    if (!opts.starttime) {
+      opts.starttime = Utils.getCurrentTimestamp();
+    }
+    this.analyticsStateMachine = new VideojsAnalyticsStateMachine(this.stateMachineCallbacks, opts);
+    this.adapter = new VideoJsAdapter(player, this.record, this.analyticsStateMachine);
+  };
+
+  registerHLSJSPlayer = (player, opts = {}) => {
+    if (!opts.starttime) {
+      opts.starttime = Utils.getCurrentTimestamp();
+    }
+    this.analyticsStateMachine = new HTML5AnalyticsStateMachine(this.stateMachineCallbacks, opts);
+    this.adapter = new HlsjsAdapter(player, this.record, this.analyticsStateMachine);
+  };
+
+  registerShakaPlayer = (player, opts = {}) => {
+    if (!opts.starttime) {
+      opts.starttime = Utils.getCurrentTimestamp();
+    }
+    this.analyticsStateMachine = new HTML5AnalyticsStateMachine(this.stateMachineCallbacks, opts);
+    this.adapter = new ShakaAdapter(player, this.record, this.analyticsStateMachine, opts.mediaElement);
+  };
+
+  registerHTML5Player = (player, opts = {}) => {
+    if (!opts.starttime) {
+      opts.starttime = Utils.getCurrentTimestamp();
+    }
+    this.analyticsStateMachine = new HTML5AnalyticsStateMachine(this.stateMachineCallbacks, opts);
+    this.adapter = new HTML5Adapter(player, this.record, this.analyticsStateMachine);
+  };
+
+  registerDashJSPlayer = (player, opts = {}) => {
+    if (!opts.starttime) {
+      opts.starttime = Utils.getCurrentTimestamp();
+    }
+    this.analyticsStateMachine = new HTML5AnalyticsStateMachine(this.stateMachineCallbacks, opts);
+    this.adapter = new DashjsAdapter(player, this.record, this.analyticsStateMachine);
+  };
+
+  registerReactNativeVideoPlayer = (opts) => {
+    if (!opts.starttime) {
+      opts.starttime = Utils.getCurrentTimestamp();
+    }
+    this.analyticsStateMachine = new HTML5AnalyticsStateMachine(this.stateMachineCallbacks, opts);
+    return this.analyticsStateMachine;
+  };
+
+  getCurrentImpressionId = () => {
+    return this.sample.impressionId;
+  };
+
+  record = (eventType, eventObject) => {
+    eventObject = eventObject || {};
+
+    this.analyticsStateMachine.callEvent(eventType, eventObject, Utils.getCurrentTimestamp());
+  };
+
+  setDuration(duration) {
+    // this.sample.duration = duration;
+  }
+
+  setState(state=undefined) {
+    if (state) {
+      this.previousState = state;
+      this.previousStateTimeStamp = new Date();
+    }
+  }
+
+  // setPlaybackVideoPropertiesFromEvent(event) {
+    // if (Utils.validNumber(event.width)) {
+    //   this.sample.videoPlaybackWidth = event.width;
+    // }
+    // if (Utils.validNumber(event.height)) {
+    //   this.sample.videoPlaybackHeight = event.height;
+    // }
+    // if (Utils.validNumber(event.bitrate)) {
+    //   this.videoBitrate = event.bitrate;
+    // }
+  // }
+
+  setDroppedFrames = (event) => {
+    // if (Utils.validNumber(event.droppedFrames)) {
+    //   this.sample.droppedFrames = 0;
+    // }
+  };
+
+  setPlaybackSettingsFromLoadedEvent(loadedEvent) {
+    if (loadedEvent && Utils.validNumber(loadedEvent.currentTime)) {
+      this.currentTime = Utils.calculateTime(loadedEvent.currentTime);
+    }
+    if (loadedEvent && Utils.validBoolean(loadedEvent.isFullScreen)) {
+      this.isFullScreen = loadedEvent.isFullScreen;
+    }
+    if (loadedEvent && Utils.validBoolean(loadedEvent.isCasting)) {
+      this.isCasting = loadedEvent.isCasting;
+    }
+
+
+    // if (Utils.validBoolean(loadedEvent.isLive)) {
+    //   this.sample.isLive = loadedEvent.isLive;
+    // }
+    // if (Utils.validString(loadedEvent.version)) {
+    //   this.sample.version = this.sample.player + '-' + loadedEvent.version;
+    // }
+    // if (Utils.validString(loadedEvent.type)) {
+    //   this.sample.playerTech = loadedEvent.type;
+    // }
+    // if (Utils.validString(loadedEvent.streamType)) {
+    //   this.sample.streamFormat = loadedEvent.streamType;
+    // }
+    // if (Utils.validString(loadedEvent.mpdUrl)) {
+    //   this.sample.mpdUrl = loadedEvent.mpdUrl;
+    // }
+    // if (Utils.validString(loadedEvent.m3u8Url)) {
+    //   this.sample.m3u8Url = loadedEvent.m3u8Url;
+    // }
+    // if (Utils.validString(loadedEvent.progUrl)) {
+    //   this.sample.progUrl = loadedEvent.progUrl;
+    // }
+    // if (Utils.validNumber(loadedEvent.videoWindowHeight)) {
+    //   this.sample.videoWindowHeight = loadedEvent.videoWindowHeight;
+    // }
+    // if (Utils.validBoolean(loadedEvent.isMuted)) {
+    //   this.isMuted = loadedEvent.isMuted;
+    // }
+    // if (Utils.validBoolean(loadedEvent.autoplay)) {
+    //   this.autoplay = loadedEvent.autoplay;
+    // }
+    //
+    // if (this.sample.streamFormat === 'progressive') {
+    //   this.videoBitrate = loadedEvent.progBitrate;
+    // }
+  }
+
+  setupSample() {
+    // Base data that is sent to all events API call
+    this.sample = {
+      property_id                   : this.propertyId,
+      session_id                    : this.sessionId,
+      user_id                       : this.userId,
+      player_instance_id            : this.playerInstanceId,
+      playback_id                   : this.playbackId,
+      from                          : undefined,                                      // int
+      to                            : undefined,                                      // int
+      playback_time_instant_millis  : undefined,                                      // float
+      bitrate_mbps                  : this.videoBitrate,                              // float
+      // Event based i.e. when error is called
+      error_code                    : undefined,                                      // string
+      error                         : undefined,                                      // string
+      error_text                    : undefined,                                      // string
+
+      video_cover                   : undefined,                                      // string
+      video_cover_reference         : undefined,                                      // string
+      player_remote_played          : undefined,                                      // boolean
+      video_total_duration_millis   : this.videoDuration,                                      // int
+      video_width_pixels            : undefined,                                      // int
+      video_height_pixels           : undefined,                                      // int
+      video_source_url              : undefined,                                      // string
+      video_source_hostname         : undefined,                                      // string
+      video_source_type             : undefined,                                      // string
+      custom_content_type           : this.customContentType,                         // string
+      custom_video_duration_millis  : this.customVideoDurationMillis,                 // int
+      custom_encoding_variant       : this.customEncodingVariant,                     // string
+      custom_video_language         : this.customVideoLanguage,                       // strirg
+      custom_video_id               : this.customVideoId,                             // string
+      custom_video_series           : this.customVideoSeries,                         // string
+      custom_video_producer         : this.customVideoProducer,                       // string
+      custom_video_title            : this.customVideoTitle,                          // string
+      custom_video_variant_name     : this.customVideoVariantName,                    // string
+      custom_video_variant          : this.customVideoVariant,                        // string
+      muted                         : this.isMuted,                                   // boolean
+      // Setting Based
+      casting                       : undefined,                                      // boolean
+      fullscreen                    : this.isFullScreen,                                      // boolean
+      video_downscale_percentage    : undefined,                                      // int
+      video_upscale_percentage      : undefined,                                      // int
+
+      // Event Based
+      orientation                   : undefined,                                      // string
+      orientation_from              : undefined,                                      // string
+      quality                       : undefined,                                      // string
+      quality_from                  : undefined,                                      // string
+      previous_event                : undefined,                                      // string
+      millis_from_previous_event    : undefined,                                      // integer
+      
+      video_codec                   : undefined,                                      // string
+      audio_codec                   : undefined,                                      // string
+
+      custom_data_1                 : this.customData1,
+      custom_data_2                 : this.customData2,
+      custom_data_3                 : this.customData3,
+      custom_data_4                 : this.customData4,
+      custom_data_5                 : this.customData5,
+      custom_data_6                 : this.customData6,
+      custom_data_7                 : this.customData7,
+      custom_data_8                 : this.customData8,
+      custom_data_9                 : this.customData9,
+      custom_data_10                : this.customData10
+    };
+  }
+
+  getSample(event=null, overrideData={}) {
+    let sampleData                          = this.sample;
+
+    sampleData.event                        = event;
+    if(this.config.getUUID){
+      sampleData.event_id                   = this.config.getUUID();
+    }else{
+      sampleData.event_id                   = Utils.uuidv4();
+    }
+    
+    sampleData.custom_data_1                = this.customData1;
+    sampleData.custom_data_2                = this.customData2;
+    sampleData.custom_data_3                = this.customData3;
+    sampleData.custom_data_4                = this.customData4;
+    sampleData.custom_data_5                = this.customData5;
+    sampleData.custom_data_6                = this.customData6;
+    sampleData.custom_data_7                = this.customData7;
+    sampleData.custom_data_8                = this.customData8;
+    sampleData.custom_data_9                = this.customData9;
+    sampleData.custom_data_10               = this.customData1;
+
+    sampleData.custom_content_type          = this.customContentType;
+    sampleData.custom_video_duration_millis = this.customVideoDurationMillis;
+    sampleData.custom_encoding_variant      = this.customEncodingVariant;
+    sampleData.custom_video_language        = this.customVideoLanguage;
+    sampleData.custom_video_id              = this.customVideoId;
+    sampleData.custom_video_series          = this.customVideoSeries;
+    sampleData.custom_video_producer        = this.customVideoProducer;
+    sampleData.custom_video_title           = this.customVideoTitle;
+    sampleData.custom_video_variant_name    = this.customVideoVariantName;
+    sampleData.custom_video_variant         = this.customVideoVariant;
+
+    sampleData.millis_from_previous_event   = this.getMillisFromPreviousState();
+    sampleData.previous_event               = this.previousState;
+    sampleData.fullscreen                   = this.isFullScreen;
+    sampleData.muted                        = this.isMuted;
+    sampleData.video_width_pixels           = this.videoWidthPixels;
+    sampleData.video_height_pixels          = this.videoHeightPixels;
+    sampleData.video_total_duration_millis  = this.videoDuration;
+    sampleData.bitrate                      = this.videoBitrate;
+    sampleData.audio_codec                  = this.audioCodec;
+    sampleData.video_codec                  = this.videoCodec;
+    sampleData.orientation                  = this.orientation;
+    sampleData.playback_time_instant_millis = this.currentTime;
+    sampleData.video_source_type            = this.videoSourceType;
+    sampleData.video_source_url             = this.videoSourceUrl;
+    sampleData.video_upscale_percentage     = this.upscalePercentage;
+    sampleData.video_downscale_percentage   = this.downscalePercentage;
+    sampleData.video_source_hostname        = this.videoSourceHostname;
+    Object.keys(overrideData).forEach(function(key) {
+      sampleData[key] = overrideData[key]
+    })
+    return sampleData;
+  }
+
+  // checkLicensing(key) {
+  //   this.licenseCall.sendRequest(key,
+  //     this.sample.domain,
+  //     this.sample.analyticsVersion,
+  //     this.handleLicensingResponse.bind(this));
+  // }
+
+  // handleLicensingResponse(licensingResponse) {
+  //   if (licensingResponse.status === 'granted') {
+  //     this.licensing = 'granted';
+  //   } else if (licensingResponse.status === 'skip') {
+  //     this.licensing = 'denied';
+  //     logger.log('Impression should not be sampled');
+  //   } else {
+  //     this.licensing = 'denied';
+  //     logger.log('Analytics license denied, reason: ' + licensingResponse.message);
+  //   }
+  // }
+
+  sendAnalyticsRequest(event, overrideData) {
+    // TODO: remove this not needed as added z param to all calls in Http.js
+    // this.sample.time = Utils.getCurrentTimestamp();
+
+    let sample = this.getSample(event, overrideData);
+    this.analyticsCall.sendRequest(sample, Utils.noOp);
+    return;
+
+    // if (!this.isCastClient && !this.isCastReceiver) {
+    //   this.analyticsCall.sendRequest(sample, Utils.noOp);
+    //   return;
+    // }
+
+    // if (!this.isAllowedToSendSamples) {
+    //   const copySample = {...this.sample};
+    //   this.samplesQueue.push(copySample);
+    // } else {
+    //   for (let i = 0; i < this.samplesQueue.length; i++) {
+    //     this.analyticsCall.sendRequest(this.samplesQueue[i], Utils.noOp);
+    //   }
+    //   this.samplesQueue = [];
+    //
+    //   this.analyticsCall.sendRequest(this.sample, Utils.noOp);
+    // }
+  }
+
+  sendAnalyticsRequestAndClearValues(event=null, overrideData={}) {
+    if (!event) {
+      logger.log('event null passed not hitting the injestion API');
+      return False;
+    }
+    this.sendAnalyticsRequest(event, overrideData);
+    // this.clearValues();
+  }
+
+  sendUnloadRequest() {
+    if (this.licensing === 'denied') {
+      return;
+    }
+
+    if (typeof navigator.sendBeacon === 'undefined') {
+      this.sendAnalyticsRequestSynchronous();
+    }
+    else {
+      const success = navigator.sendBeacon(this.analyticsCall.getAnalyticsServerUrl(),
+        JSON.stringify(this.sample));
+      if (!success) {
+        this.sendAnalyticsRequestSynchronous();
+      }
+    }
+  }
+
+  sendAnalyticsRequestSynchronous() {
+    if (this.licensing === 'denied') {
+      return;
+    }
+
+    this.analyticsCall.sendRequestSynchronous(this.sample, Utils.noOp);
+  }
+
+  clearValues() {
+    this.sample.ad       = 0;
+    this.sample.paused   = 0;
+    this.sample.played   = 0;
+    this.sample.seeked   = 0;
+    this.sample.buffered = 0;
+
+    this.sample.playerStartupTime = 0;
+    this.sample.videoStartupTime  = 0;
+    this.sample.startupTime       = 0;
+
+    this.sample.duration      = 0;
+    this.sample.droppedFrames = 0;
+    this.sample.pageLoadType  = 0;
+  }
+
+  getDroppedFrames(frames) {
+    if (frames != undefined && frames != 0) {
+      const droppedFrames = frames - this.droppedSampleFrames;
+      this.droppedSampleFrames = frames;
+      return droppedFrames;
+    }
+    else {
+      return 0;
+    }
+  }
+}
+
+export default Analytics;