@gumlet/insights-js-core 1.0.1 → 1.1.0

package/js/core/AnalyticsStateMachineFactory.js

@@ -0,0 +1,36 @@
+import PlayerDetector from '../utils/PlayerDetector';
+import {BitmovinAnalyticsStateMachine} from '../analyticsStateMachines/BitmovinAnalyticsStateMachine';
+import {Bitmovin7AnalyticsStateMachine} from '../analyticsStateMachines/Bitmovin7AnalyticsStateMachine';
+import {VideojsAnalyticsStateMachine} from '../analyticsStateMachines/VideoJsAnalyticsStateMachine';
+import {HTML5AnalyticsStateMachine} from '../analyticsStateMachines/HTML5AnalyticsStateMachine';
+
+/**
+ * Stateless. Auto-maps given player instance to new state-machine instances.
+ * @class
+ */
+class AnalyticsStateMachineFactory {
+  /**
+   * @param {object} player
+   * @param {AnalyticsStateMachineCallbacks} stateMachineCallbacks
+   * @param {AnalyticsStateMachineOptions} opts
+   */
+  static getAnalyticsStateMachine(player, stateMachineCallbacks, opts = {}) {
+    if (PlayerDetector.isBitmovinVersionPre7(player)) {
+      return new BitmovinAnalyticsStateMachine(stateMachineCallbacks, opts);
+    } else if (PlayerDetector.isBitmovinVersion7Plus(player)) {
+      return new Bitmovin7AnalyticsStateMachine(stateMachineCallbacks, opts);
+    } else if (PlayerDetector.isVideoJs(player)) {
+      return new VideojsAnalyticsStateMachine(stateMachineCallbacks, opts);
+    } else if (
+      PlayerDetector.isHlsjs(player) ||
+      PlayerDetector.isDashjs(player) ||
+      PlayerDetector.isShaka(player)) {
+      return new HTML5AnalyticsStateMachine(stateMachineCallbacks, opts);
+    } else {
+      // throw new Error('Could not detect player type');
+      return new HTML5AnalyticsStateMachine(stateMachineCallbacks, opts);
+    }
+  }
+}
+
+export default AnalyticsStateMachineFactory;

package/js/core/GumletInsightsExport.js

@@ -0,0 +1,75 @@
+import Analytics from './Analytics';
+import {Players} from '../enums/Players';
+import CdnProviders from '../enums/CDNProviders';
+import EVENTS from "../enums/Events";
+
+let analytics;
+
+const register = (player, opts = {}) => {
+  return analytics.register(player, opts);
+};
+
+const registerVideoJSPlayer = (player, opts = {}) => {
+  return analytics.registerVideoJSPlayer(player, opts);
+};
+
+const registerDashJSPlayer = (player, opts = {}) => {
+  return analytics.registerDashJSPlayer(player, opts);
+};
+
+const registerHLSJSPlayer = (player, opts = {}) => {
+  return analytics.registerHLSJSPlayer(player, opts);
+};
+
+const registerShakaPlayer = (player, opts = {}) => {
+  return analytics.registerShakaPlayer(player, opts);
+};
+
+const registerHTML5Player = (player, opts = {}) => {
+  return analytics.registerHTML5Player(player, opts);
+};
+
+const registerReactNativeVideoPlayer = (player, opts = {}) => {
+  return analytics.registerReactNativeVideoPlayer(player, opts);
+};
+
+const getCurrentImpressionId = () => {
+  return analytics.getCurrentImpressionId();
+};
+
+const getAnalyticsStateMachine = () => {
+  return analytics.analyticsStateMachine;
+};
+
+const analyticsWrapper = (config) => {
+  analytics = new Analytics(config);
+  return {
+    register                      : register,
+    registerVideoJSPlayer         : registerVideoJSPlayer,
+    registerDashJSPlayer          : registerDashJSPlayer,
+    registerHLSJSPlayer           : registerHLSJSPlayer,
+    registerShakaPlayer           : registerShakaPlayer,
+    registerHTML5Player           : registerHTML5Player,
+    registerReactNativeVideoPlayer: registerReactNativeVideoPlayer,
+    getCurrentImpressionId        : getCurrentImpressionId,
+    stateMachine                  : getAnalyticsStateMachine,
+    setCustomData                 : analytics.setCustomData,
+    setCustomDataOnce             : analytics.setCustomDataOnce,
+  };
+};
+
+analyticsWrapper.Players = Players;
+analyticsWrapper.CdnProviders = CdnProviders;
+
+if (typeof window !== "undefined")
+{
+window.gumlet                 = window.gumlet || {};
+window.gumlet.insights        = analyticsWrapper;
+window.gumletInsightsEvents   = EVENTS;
+window.gumletSupportedPlayers = Players;
+}
+else{
+  
+}
+
+export default analyticsWrapper;

package/js/enums/CDNProviders.js

@@ -0,0 +1,11 @@
+const CdnProviders = {
+  CLOUDFLARE: 'cloudflare',
+  AKAMAI: 'akamai',
+  FASTLY: 'fastly',
+  MAXCDN: 'maxcdn',
+  CLOUDFRONT: 'cloudfront',
+  CHINACACHE: 'chinacache',
+  BITGRAVITY: 'bitgravity'
+};
+
+export default CdnProviders;

package/js/enums/Events.js

@@ -0,0 +1,32 @@
+const Events = {
+  READY            : 'ready',
+  STARTUP          : 'startup',
+  SOURCE_LOADED    : 'sourceLoaded',
+  PLAY             : 'play',
+  PAUSE            : 'pause',
+  TIMECHANGED      : 'timechanged',
+  SEEK             : 'seek',
+  SEEKED           : 'seeked',
+  START_CAST       : 'startCasting',
+  END_CAST         : 'endCasting',
+  START_BUFFERING  : 'startBuffering',
+  END_BUFFERING    : 'endBuffering',
+  AUDIO_CHANGE     : 'audioChange',
+  VIDEO_CHANGE     : 'videoChange',
+  START_FULLSCREEN : 'startFullscreen',
+  END_FULLSCREEN   : 'endFullscreen',
+  START_AD         : 'adStart',
+  END_AD           : 'adEnd',
+  MUTE             : 'mute',
+  UN_MUTE          : 'unMute',
+  ERROR            : 'playerError',
+  PLAYBACK_FINISHED: 'end',
+  SCREEN_RESIZE    : 'resize',
+  UNLOAD           : 'unload',
+  END              : 'end',
+  METADATA_LOADED  : 'metadataLoaded',
+  SOURCE_UNLOADED  : 'sourceUnloaded',
+  PLAYBACK_PLAYING : 'playback_playing',
+};
+
+export default Events;

package/js/enums/GumletEnum.js

@@ -0,0 +1,19 @@
+const GumletEventEnum = {
+  SETUP            : 'event_setup',
+  PLAYER_READY     : 'event_player_ready',
+  PLAYBACK_READY   : 'event_playback_ready',
+  PLAYBACK_STARTED : 'event_playback_started',
+  PAUSE            : 'event_pause',
+  PLAY             : 'event_play',
+  PLAYING          : 'event_playing',
+  PLAYBACK_UPDATE  : 'event_playback_update',
+  END              : 'event_ended',
+  MUTE             : 'event_muted',
+  UNMUTE           : 'event_unmute',
+  SEEKED           : 'event_seeked',
+  START_REBUFFER   : 'event_rebuffer_start',
+  END_REBUFFER     : 'event_rebuffer_end',
+  ERROR            : 'event_error',
+};
+
+export default GumletEventEnum;

package/js/enums/MIMETypes.js

@@ -0,0 +1,30 @@
+const MP4 = 'video/mp4';
+const WEBM = 'video/webm';
+const HLS = 'application/x-mpegURL';
+const DASH = 'application/dash+xml';
+
+export const MIMETypes = {
+  MP4,
+  WEBM,
+  HLS,
+  DASH
+};
+
+export function getMIMETypeFromFileExtension(path) {
+
+  path = path.toLowerCase();
+
+  if (path.endsWith('.m3u8')) {
+    return HLS;
+  }
+  if (path.endsWith('.mp4') || path.endsWith('.m4v') || path.endsWith('.m4a')) {
+    return MP4;
+  }
+  if (path.endsWith('.webm')) {
+    return WEBM;
+  }
+  if (path.endsWith('.mpd')) {
+    return DASH;
+  }
+  return null;
+}

package/js/enums/Players.js

@@ -0,0 +1,11 @@
+export const Players = {
+  BITMOVIN            : 'bitmovin',
+  JW                  : 'jw',
+  RADIANT             : 'radiant',
+  VIDEOJS             : 'videojs',
+  HLSJS               : 'hlsjs',
+  SHAKA               : 'shaka',
+  DASHJS              : 'dashjs',
+  HTML                : 'html5',
+  REACTNATIVEVIDEO    : 'react-native-video'
+};

package/js/enums/StreamTypes.js

@@ -0,0 +1,15 @@
+import {MIMETypes} from './MIMETypes';
+
+const { MP4, WEBM, HLS, DASH } = MIMETypes;
+
+const mapping = {
+  [MP4]: 'mp4',
+  [WEBM]: 'webm',
+  [HLS]: 'hls',
+  [DASH]: 'dash' 
+};
+
+export function getStreamTypeFromMIMEType(mimeType) {
+  return mapping[mimeType];
+}
+

package/js/utils/EventsCall.js

@@ -0,0 +1,22 @@
+import HttpCall from './HttpCall';
+import {ANALYTICS_BACKEND_BASE_URL} from './Settings';
+
+class EventsCall extends HttpCall{
+  static analyticsServerUrl = ANALYTICS_BACKEND_BASE_URL;
+
+  sendRequest = function(sample, callback) {
+    sample.event_family = 'session_event';
+    this.get(EventsCall.analyticsServerUrl, sample, callback);
+  };
+
+  sendRequestSynchronous = function(sample, callback) {
+    sample.event_family = 'session_event';
+    this.get(EventsCall.analyticsServerUrl, sample, callback, false);
+  };
+
+  getAnalyticsServerUrl = function() {
+    return EventsCall.analyticsServerUrl;
+  }
+}
+
+export default EventsCall;

package/js/utils/HttpCall.js

@@ -0,0 +1,57 @@
+import Utils from '../utils/Utils';
+
+class HttpCall {
+  get(url, body, callback, async = true) {
+    let xhttp;
+    let legacyMode = false;
+
+    if (window.XDomainRequest) {
+      legacyMode = true;
+    }
+
+    if (legacyMode) {
+      xhttp = new window.XDomainRequest();
+    } else {
+      xhttp = new XMLHttpRequest();
+    }
+
+    const responseCallback = function() {
+      if (xhttp.readyState == XMLHttpRequest.DONE) {
+        if (xhttp.responseText <= 0) {
+          return;
+        }
+        
+        const sampleResponse = JSON.parse(xhttp.responseText);
+
+        callback(sampleResponse);
+      }
+    };
+
+    if (legacyMode) {
+      xhttp.onload = responseCallback;
+    } else {
+      xhttp.onreadystatechange = responseCallback;
+    }
+
+    // TODO: resolve to milliseconds
+    body['z'] = (new Date()).getTime()/1000;
+
+    const removeUnwantedValues = [undefined, null, false]
+
+    // Body cleanup
+    Object.keys(body).forEach(key => removeUnwantedValues.indexOf(body[key]) !== -1 && delete body[key])
+    // Remove NaN from payload
+    // Since NaN is the only JavaScript value that is treated as unequal to itself
+    Object.keys(body).forEach(key => body[key] !== body[key] && delete body[key])
+
+    // Create the queryString for URL
+    let queryString = Utils.jsonToQueryString(body);
+    url += queryString;
+
+    xhttp.open('GET', url, async);
+
+    xhttp.send(null);
+  }
+}
+
+export default HttpCall;

package/js/utils/LicenseCall.js

@@ -0,0 +1,18 @@
+import HttpCall from './HttpCall';
+import {ANALYTICS_BACKEND_BASE_URL} from './Settings';
+
+class LicenseCall extends HttpCall {
+  static licenseServerUrl = ANALYTICS_BACKEND_BASE_URL + '/licensing';
+
+  sendRequest = function(key, domain, version, callback) {
+    const licensingRequest = {
+      key: key,
+      domain: domain,
+      analyticsVersion: version
+    };
+
+    this.get(LicenseCall.licenseServerUrl, licensingRequest, callback);
+  };
+}
+
+export default LicenseCall;

package/js/utils/Logger.js

@@ -0,0 +1,40 @@
+class Logger {
+  constructor(showLogs = false) {
+    this.showLogs = showLogs;
+  }
+
+  setLogging(logging) {
+    this.showLogs = logging;
+  }
+
+  isLogging() {
+    return this.showLogs;
+  }
+
+  log = function(msg) {
+    if (!this.showLogs) {
+      return;
+    }
+
+    console.log(msg);
+  };
+
+  error = function(msg) {
+    if (!this.showLogs) {
+      return;
+    }
+
+    console.error(msg);
+  };
+
+  warning = function(msg) {
+    if (!this.showLogs) {
+      return;
+    }
+
+    console.warn(msg);
+  }
+}
+
+const logger = new Logger();
+export default logger;

package/js/utils/PlayerDetector.js

@@ -0,0 +1,75 @@
+/* global shaka */
+/* global videojs */
+/* global dashjs */
+/* global Hls */
+
+/**
+ * Stateless. Functions that detect players somehow.
+ * @class
+ */
+
+class PlayerDetector {
+
+  static isBitmovinVersionPre7 = function(player) {
+    if (PlayerDetector.isDashjs(player)) {
+      return false;
+    }
+
+    if (typeof player.getVersion === 'function') {
+      return player.getVersion() < '7';
+    }
+
+    return false;
+  };
+
+  static isBitmovinVersion7Plus = function(player) {
+    if (typeof player.version === 'string') {
+      return player.version >= '7';
+    }
+
+    return false;
+  };
+
+  static isVideoJs = function(player) {
+    if (typeof videojs === 'function') {
+      try {
+        if (videojs(player.id_) === player) {
+          return true;
+        }
+      } catch (err) {}
+    }
+    return false;
+  }
+
+  static isShaka(player) {
+
+    if (!window.shaka) {
+      // Shaka is not defined installed (must be loaded before analytics module)
+      return false;
+    }
+
+    return (
+      typeof shaka.Player === 'function' && player.constructor === shaka.Player
+    );
+
+  }
+
+  static isDashjs(player) {
+    return typeof player.addABRCustomRule === 'function';
+  }
+
+  static isHlsjs(player) {
+
+    if (!window.Hls) {
+      // Hls.js is not defined installed (must be loaded before analytics module)
+      return false;
+    }
+
+    return (
+      typeof window.Hls === 'function' && player.constructor === window.Hls
+    );
+    return false;
+  }
+}
+
+export default PlayerDetector;

package/js/utils/PlayerInitCall.js

@@ -0,0 +1,22 @@
+import HttpCall from './HttpCall';
+import {ANALYTICS_BACKEND_BASE_URL} from './Settings';
+
+class PlayerInitCall extends HttpCall{
+  static analyticsServerUrl = ANALYTICS_BACKEND_BASE_URL;
+
+  sendRequest = function(sample, callback) {
+    sample.event_family = 'player_init';
+    this.get(PlayerInitCall.analyticsServerUrl, sample, callback);
+  };
+
+  sendRequestSynchronous = function(sample, callback) {
+    sample.event_family = 'player_init';
+    this.get(PlayerInitCall.analyticsServerUrl, sample, callback, false);
+  };
+
+  getAnalyticsServerUrl = function() {
+    return PlayerInitCall.analyticsServerUrl;
+  }
+}
+
+export default PlayerInitCall;

package/js/utils/SessionCreationCall.js

@@ -0,0 +1,22 @@
+import HttpCall from './HttpCall';
+import {ANALYTICS_BACKEND_BASE_URL} from './Settings';
+
+class SessionCreationCall extends HttpCall{
+  static analyticsServerUrl = ANALYTICS_BACKEND_BASE_URL;
+
+  sendRequest = function(sample, callback) {
+    sample.event_family = 'session';
+    this.get(SessionCreationCall.analyticsServerUrl, sample, callback);
+  };
+
+  sendRequestSynchronous = function(sample, callback) {
+    sample.event_family = 'session';
+    this.get(SessionCreationCall.analyticsServerUrl, sample, callback, false);
+  };
+
+  getAnalyticsServerUrl = function() {
+    return SessionCreationCall.analyticsServerUrl;
+  }
+}
+
+export default SessionCreationCall;

package/js/utils/Settings.js

@@ -0,0 +1,3 @@
+export const MESSAGE_NAMESPACE = 'urn:x-cast:com.gumlet.ingest.cast';
+export const ANALYTICS_BACKEND_BASE_URL = 'https://ingest.gumlytics.com';
+export const HEARTBEAT_THRESHOLD = 10000;

package/js/utils/Utils.js

@@ -0,0 +1,195 @@
+const validString = function(string) {
+  return (string != undefined && typeof string == 'string');
+};
+
+const validBoolean = function(boolean) {
+  return (boolean != undefined && typeof boolean == 'boolean');
+};
+
+const validNumber = function(number) {
+  return (number != undefined && typeof number == 'number');
+};
+
+const sanitizePath = function(path) {
+  return path.replace(/\/$/g, '');
+};
+
+const calculateTime = function(time) {
+  time = time * 1000;
+  return Math.round(time);
+};
+
+const getCurrentTimestamp = function() {
+  return new Date().getTime();
+};
+
+const getDurationFromTimestampToNow = function(timestamp) {
+  return getCurrentTimestamp() - timestamp;
+};
+
+const uuidv4 = function() {
+  return ([1e7]+-1e3+-4e3+-8e3+-1e11).replace(/[018]/g, c =>
+    (c ^ crypto.getRandomValues(new Uint8Array(1))[0] & 15 >> c / 4).toString(16).toUpperCase()
+  );
+}
+
+const getCookie = function(cname) {
+  const name = cname + '=';
+  const ca   = document.cookie.split(';');
+  let item = "";
+  for (let i = 0; i < ca.length; i++) {
+    let c = ca[i];
+    while (c.charAt(0) == ' ') {
+      c = c.substring(1);
+    }
+    if (c.indexOf(name) == 0) {
+      item = c.substring(name.length, c.length);
+    }
+  }
+  
+  if (!item) {
+    try {
+      item = localStorage.getItem(cname);
+    } catch (error) {
+      return "";
+    }
+    // check if localstorage has the item
+    let data = null;
+    if (item){
+      // try parsing the values as a JSON
+      try{
+        data = JSON.parse(item);
+      } catch (e) {
+        return "";
+      }
+    }else{
+      return "";
+    }
+
+    // check if loaded data has expires if not return none
+    let expiresAt = null;
+    if (data.expires) {
+      expiresAt = new Date(data.expires);
+    }else{
+      return "";
+    }
+
+    // Check if expiresAt is a valid dateTime object
+    if (Object.prototype.toString.call(expiresAt) === "[object Date]") {
+      // it is a date
+      if (isNaN(expiresAt)) {
+        // date object is not valid
+        return "";
+      } else {
+        // date object is valid
+      }
+    } else {
+      return "";
+    }
+
+    // Check if expires at is greater than the current time
+    if (expiresAt.getTime() > (new Date()).getTime()) {
+      // if data has value then return it else return ""
+      item = data.value ? data.value : "";
+    }else{
+      return "";
+    }
+  }
+
+  // return read data
+  return item;
+};
+
+const setCookie = function(cname, expiry_mins=30, value=null) {
+    let date = new Date();
+    date.setTime(date.getTime() + (expiry_mins*60*1000));
+    let id = !value ? uuidv4() : value;
+    try {
+      document.cookie = cname+'=' + id +'; expires='+date.toUTCString()+'; path=/';
+      localStorage.setItem(cname, JSON.stringify({
+        expires: date.getTime(),
+        value: id
+      }));
+    } catch (error) {
+    }
+    return id;
+};
+
+const noOp = function() {
+
+};
+
+const times = function (fn, times) {
+  let count = 0;
+  let retVal;
+  return function () {
+    if (count >= times) {
+      return retVal;
+    }
+    retVal = fn.apply(null, arguments);
+    count++;
+    return retVal;
+  };
+};
+
+const once = function (fn) {
+  return times(fn, 1);
+};
+
+const getHiddenProp = function() {
+  const prefixes = ['webkit','moz','ms','o'];
+  if ('hidden' in document) { return 'hidden'; }
+  for (let i = 0; i < prefixes.length; i++){
+    if ((prefixes[i] + 'Hidden') in document) {
+      return prefixes[i] + 'Hidden';
+    }
+  }
+  return null;
+};
+
+const getCustomDataString = function(customData) {
+  if (typeof customData === 'object') {
+    return JSON.stringify(customData);
+  } else if (typeof customData === 'function') {
+    return getCustomDataString(customData());
+  } else if (typeof customData === 'undefined') {
+    return customData;
+  } else if (typeof customData !== 'string') {
+    return String(customData);
+  }
+
+  return customData;
+};
+
+const jsonToQueryString = function(json) {
+  return '?' +
+        Object.keys(json).map(function(key) {
+            return encodeURIComponent(key) + '=' +
+                encodeURIComponent(json[key]);
+        }).join('&');
+}
+
+const currentDateTimeFormatString = function() {
+  const currentDateTime = new Date();
+  return currentDateTime.toISOString();
+}
+
+export default {
+  validString,
+  validBoolean,
+  validNumber,
+  sanitizePath,
+  calculateTime,
+  getCurrentTimestamp,
+  getDurationFromTimestampToNow,
+  uuidv4,
+  getCookie,
+  setCookie,
+  noOp,
+  times,
+  once,
+  getHiddenProp,
+  getCustomDataString,
+  jsonToQueryString,
+  currentDateTimeFormatString
+};