@raydiant/playlist-window-manager 0.0.0-test-1

package/src/PlaylistWindowManager.ts

@@ -0,0 +1,1042 @@
+import * as RE from '@raydiant/playlist-rule-engine';
+import { v4 as uuidv4 } from 'uuid';
+import EventEmitter from 'eventemitter3';
+import {
+  PresentationWindowRenderer,
+  Device,
+  WindowBounds,
+  Theme,
+  Logger,
+  WorkerState,
+  AnalyticsEvent
+} from './types';
+import PresentationWindow from './PresentationWindow';
+import PlaylistWindowManagerState from './PlaylistWindowManagerState';
+import WindowUnresponsiveError from './WindowUnresponsiveError';
+import WindowTimeoutError from './WindowTimeoutError';
+import WindowLoadError from './WindowLoadError';
+
+export interface PlaylistWindowManagerOptions {
+  // The rule engine
+  ruleEngine: RE.RuleEngine;
+
+  // Render data
+  state: PlaylistWindowManagerState;
+
+  // The logger to use
+  logger: Logger;
+
+  // The device object to forward along to each window
+  device?: Device;
+
+  // Set the duration (in seconds) before a presentation will time out
+  // waiting for presentation_ready
+  readyTimeoutDurationSeconds?: number;
+
+  // Override the default app renderer url
+  appRendererUrl?: string;
+
+  // The bounds of the window manager, used for child windows
+  bounds?: WindowBounds;
+
+  // The background color of the windows
+  backgroundColor?: string;
+
+  // Override the selected theme of the presentations
+  themeOverride?: Theme;
+
+  // Set to true to force mute all presentations
+  forceMute?: boolean;
+
+  // The parent window id of the playlist window, set when rendering a playlist from a presentation (MZ, Kiosk).
+  // parentWindowId is unique across all windows being rendererd and is used by window renderers to lookup the
+  // parent window when creating a child window. For example, the BrowserWindowRenderer needs to use a BrowserView
+  // to render child windows instead of a BrowserWindow.
+  parentWindowId?: string;
+
+  // The window name of the playlist window, set when rendering a playlist from a presentation (MZ, Kiosk).
+  // windowName is unique within the parent window. For example, MZ will spawn two child windows with names
+  // 'zone1' and 'zone2'.
+  windowName?: string;
+
+  // Set to true to render the presentation window as a preview.
+  isPreview?: boolean;
+
+  // Called when the current window wants to enable the interrupt lock
+  onEnableInterruptLock?: () => void;
+
+  // Called when the current window wants to disable the interrupt lock
+  onDisableInterruptLock?: () => void;
+}
+
+// Wait at least 3 seconds before restarting or moving onto the next window
+// to prevent log spam causing devices to become unresponsive.
+const minTimeBetweenCompletes = 3000;
+
+interface EvalRuleEngineResult {
+  next: RE.NextPresentationID;
+  preview: RE.NextPresentationID;
+}
+
+export default class PlaylistWindowManager extends EventEmitter {
+  private currentPresentation: RE.NextPresentationID | null = null;
+  private nextPresentation: RE.NextPresentationID | null = null;
+  private overrideNextPresentation: RE.NextPresentationID | null = null;
+  private currentWindow: PresentationWindow | null = null;
+  private nextWindow: PresentationWindow | null = null;
+  private hasPendingInterrupt: boolean = false;
+  private ruleEngine: RE.RuleEngine | null = null;
+  private state: PlaylistWindowManagerState | null = null;
+  private renderer: PresentationWindowRenderer | null = null;
+  private restartCurrentWindowOnEnd: boolean = false;
+  private shouldHardRestart: boolean = false;
+  private currentWindowError: null | Error = null;
+  private interruptCheckTimeout: ReturnType<typeof setTimeout> | null = null;
+  private currentPresentationCompleteTimeout: ReturnType<
+    typeof setTimeout
+  > | null = null;
+  private lastCompleteAt: Date | null = null;
+  private bounds?: WindowBounds;
+  private themeOverride?: Theme;
+  private forceMute: boolean = false;
+  private isFocused: boolean = false;
+
+  private workerState: WorkerState = {};
+
+  constructor(private options: PlaylistWindowManagerOptions) {
+    super();
+
+    this.ruleEngine = options.ruleEngine;
+    this.state = options.state;
+    this.bounds = options.bounds;
+    this.themeOverride = options.themeOverride;
+    this.forceMute = options.forceMute || false;
+  }
+
+  private currentPresentationId(): string | null {
+    return this.currentPresentation
+      ? this.currentPresentation.presentationId
+      : null;
+  }
+
+  private nextPresentationId(): string | null {
+    return this.nextPresentation ? this.nextPresentation.presentationId : null;
+  }
+
+  public async load(): Promise<void> {
+    if (!this.renderer) {
+      throw new Error(
+        'Attempted to load playlist window manager with missing renderer'
+      );
+    }
+
+    const { next, preview } = this.evalRuleEngine();
+
+    const nextPresentationId = next.presentationId;
+    const nextPreviewPresentationId = preview.presentationId;
+
+    // Resolve immediately if there if there is no presentation to play next.
+    if (!nextPresentationId) {
+      return;
+    }
+
+    // We need to set this.currentPresentation before calling shouldPreload in order
+    // to avoid preloading the next presentation id if it's the same as the current.
+    this.currentPresentation = next;
+
+    // Preload next presentation if there is one.
+    if (this.shouldPreload(nextPreviewPresentationId)) {
+      this.nextPresentation = preview;
+      this.preloadNextWindow();
+    } else {
+      await this.removeNextWindow();
+    }
+
+    // Load and wait for current window before playing.
+    await this.loadCurrentWindow();
+  }
+
+  public isEmpty() {
+    if (!this.ruleEngine) return true;
+    const preview = this.ruleEngine.previewNext();
+    return !preview.presentationId;
+  }
+
+  public play() {
+    this.restartCurrentWindowOnEnd = false;
+    this.playCurrentWindow();
+    this.startPreviewCheck();
+  }
+
+  public isPlaying() {
+    if (!this.currentWindow) {
+      return false;
+    }
+    return this.currentWindow.isPlaying();
+  }
+
+  public pause() {
+    // Pausing a playlist means restarting the current window when it completes
+    // instead of moving on to the next one.
+    this.restartCurrentWindowOnEnd = true;
+    this.pauseCurrentWindow();
+    this.stopInterruptCheck();
+  }
+
+  public resume() {
+    // Resuming a playlist will switch to the next window when the current window
+    // completes. We don't want to fire 'play' because that could restart the window's
+    // on complete timer.
+    this.restartCurrentWindowOnEnd = false;
+    this.resumeCurrentWindow();
+    this.startPreviewCheck();
+  }
+
+  public blur() {
+    // Use this method to stop creating windows that are focused. There is no renderer API for
+    // blurring a window because Electron doesn't have a blur() method on BrowserWindows. If focus
+    // should be switched to another PlaylistWindowManager call blur() and then show(true) on the other.
+    this.isFocused = false;
+  }
+
+  public isPaused() {
+    return this.restartCurrentWindowOnEnd;
+  }
+
+  public getRenderer() {
+    return this.renderer;
+  }
+
+  public setRenderer(renderer: PresentationWindowRenderer | null) {
+    this.renderer = renderer;
+  }
+
+  public getRuleEngine() {
+    return this.ruleEngine;
+  }
+
+  public async setRuleEngine(ruleEngine: RE.RuleEngine): Promise<void> {
+    this.ruleEngine = ruleEngine;
+
+    // Eval the rule engine with the latest state. Passing true to suppress preload
+    // mismatch warning, which is expected because the preloaded presentation of the
+    // old playlist won't match the next presentation to preload of the new playlist.
+    const { next, preview } = this.evalRuleEngine(false);
+
+    const nextPresentationId = next.presentationId;
+
+    // If the window manager doesn't have a renderer, update the current and next
+    // presentations but don't load any windows. This handles the case where the
+    // window manager is created with an empty playlist and then has a non-empty
+    // playlist is published to it.
+    if (!this.renderer) {
+      this.currentPresentation = next;
+      this.nextPresentation = preview;
+      return;
+    }
+
+    // If there is no next presentation id then we are have updated to an empty playlist.
+    // Reset the current and next presentations back to null to ensure isEmpty returns true.
+    if (!nextPresentationId) {
+      this.currentPresentation = null;
+      await this.removeCurrentWindow();
+      this.nextPresentation = null;
+      await this.removeNextWindow();
+      return;
+    }
+
+    // We've already evalulated the rule engine to get the new current presentation and the
+    // new next presentation. The current next presentation is replaced with the new current
+    // presentation. Since we've already evaluated the new next presentation above, we need to
+    // prevent evaling the rule engine again when new current presentation completes by setting
+    // this.overrideNextPresentationId. This fixes an issue where the second presentation in the
+    // playlists is skipped after reinitializing.
+    this.overrideNextPresentation = preview;
+
+    // Assume the next window is no longer correct when swapping the rule engine.
+    await this.removeNextWindow();
+
+    // Load the new current presentation with the new rule engine.
+    this.nextPresentation = next;
+    await this.preloadNextWindow();
+  }
+
+  public getState() {
+    return this.state;
+  }
+
+  public setState(state: PlaylistWindowManagerState) {
+    this.state = state;
+  }
+
+  // For setting dynamic tags data from workers and reevaluate rules for playlists
+  // input: newRulesDataStoreObj: {'workers': {'ai': {'percentMales': 30}}}
+  public reinitializeRuleEngineState(newRulesDataStoreObj: RE.RulesDataStore) {
+    const { logger } = this.options;
+
+    logger.debug('Dynamic Rule engine state change event received!');
+    if (this.ruleEngine) {
+      logger.debug(
+        `OLD Rule Data Store: ${JSON.stringify(
+          this.ruleEngine.state
+        )} \n NEW Rule Data Store: ${JSON.stringify(newRulesDataStoreObj)}`
+      );
+      this.ruleEngine.state.rulesDataStore = newRulesDataStoreObj;
+    } else {
+      logger.warn(`No Rule engine found for reinitiazling the state!`);
+      return;
+    }
+
+    // re-evaluate the next presentations depending upon the new rule engine state
+    const checkOverridePresentation = async () => {
+      if (this.ruleEngine) {
+        this.checkPreviewAction();
+
+        // calling reinitialize Rule engine state for inner playlist windows (for MZ)
+        if (this.currentWindow) {
+          this.currentWindow.reinitializePresentationWindowRuleEngineState(
+            newRulesDataStoreObj
+          );
+        }
+
+        if (this.nextWindow) {
+          this.nextWindow.reinitializePresentationWindowRuleEngineState(
+            newRulesDataStoreObj
+          );
+        }
+      }
+    };
+    checkOverridePresentation();
+  }
+
+  // Replace state and rule engine, and reinitialize the window manager.
+  public async reinitialize(
+    state: PlaylistWindowManagerState,
+    ruleEngine: RE.RuleEngine,
+    shouldInterruptPlayback: boolean
+  ) {
+    this.setState(state);
+
+    await this.setRuleEngine(ruleEngine);
+    if (shouldInterruptPlayback) {
+      this.registerInterrupt();
+    }
+  }
+
+  private registerInterrupt() {
+    if (!this.isLocked()) {
+      this.endCurrentPresentation();
+    } else {
+      this.hasPendingInterrupt = true;
+    }
+  }
+
+  public endCurrentPresentation() {
+    this.handleCurrentPresentationComplete();
+  }
+
+  public async destroy() {
+    this.stopInterruptCheck();
+    if (this.currentPresentationCompleteTimeout) {
+      clearTimeout(this.currentPresentationCompleteTimeout);
+    }
+    await Promise.all([this.removeCurrentWindow(), this.removeNextWindow()]);
+  }
+
+  public updateBounds(bounds: WindowBounds) {
+    // TODO log bounds
+    this.bounds = bounds;
+    if (this.currentWindow) {
+      this.currentWindow.updateBounds(this.bounds);
+    }
+    if (this.nextWindow) {
+      this.nextWindow.updateBounds(this.bounds);
+    }
+  }
+
+  public getBounds() {
+    return this.bounds;
+  }
+
+  public setThemeOverride(theme?: Theme) {
+    this.themeOverride = theme;
+    const currentPresentationId = this.currentPresentationId();
+    const nextPresentationId = this.nextPresentationId();
+    if (this.currentWindow && currentPresentationId) {
+      this.currentWindow.setTheme(this.getTheme(currentPresentationId));
+    }
+    if (this.nextWindow && nextPresentationId) {
+      this.nextWindow.setTheme(this.getTheme(nextPresentationId));
+    }
+  }
+
+  public getThemeOverride() {
+    return this.themeOverride;
+  }
+
+  public setForceMute(forceMute: boolean) {
+    this.forceMute = forceMute;
+    if (this.currentWindow) {
+      this.currentWindow.setForceMute(forceMute);
+    }
+    if (this.nextWindow) {
+      this.nextWindow.setForceMute(forceMute);
+    }
+  }
+
+  public getForceMute() {
+    return this.forceMute;
+  }
+
+  public reload() {
+    if (this.currentWindow) {
+      this.currentWindow.reload();
+    }
+    if (this.nextWindow) {
+      this.nextWindow.reload();
+    }
+  }
+
+  public async show(isFocused: boolean = true) {
+    if (this.currentWindow) {
+      // Save the focused state so we know if preloaded windows should be
+      // focused when swapped for the current.
+      this.isFocused = isFocused;
+      this.currentWindow.show(isFocused);
+    }
+  }
+
+  public async hide() {
+    if (this.currentWindow) {
+      this.currentWindow.hide();
+    }
+  }
+
+  public isReady() {
+    if (!this.currentWindow) {
+      return true;
+    }
+    return this.currentWindow.isReady();
+  }
+
+  public isLocked() {
+    if (!this.currentWindow) {
+      return false;
+    }
+    return this.currentWindow.isLocked();
+  }
+
+  public runWorkerSubscriptions(state: WorkerState) {
+    // Persist worker state so new windows can be initialized with it.
+    this.workerState = state;
+
+    // Run worker subcriptions on the current window.
+    if (this.currentWindow) {
+      this.currentWindow.runWorkerSubscriptions(state);
+    }
+
+    // Run worker subscriptions on the next window.
+    if (this.nextWindow) {
+      this.nextWindow.runWorkerSubscriptions(state);
+    }
+  }
+
+  private createWindow(pr: RE.NextPresentationID): PresentationWindow {
+    const {
+      readyTimeoutDurationSeconds,
+      appRendererUrl,
+      backgroundColor,
+      device,
+      logger,
+      windowName,
+      parentWindowId,
+      isPreview
+    } = this.options;
+
+    if (!this.ruleEngine) {
+      throw new Error(
+        'Attempted to create window but ruleEngine was not provided'
+      );
+    }
+
+    if (!this.state) {
+      throw new Error('Attempted to create window but state was not provided');
+    }
+
+    if (!this.renderer) {
+      throw new Error(
+        'Attempted to create window but renderer was not provided'
+      );
+    }
+
+    const presentationId = pr.presentationId;
+    if (!presentationId) {
+      throw new Error('Attempted to create window but presentationId is null');
+    }
+    const presentation = this.state.getPresentation(presentationId);
+    const applicationVersion = this.state.getApplicationVersion(
+      presentation.applicationDeploymentId
+    );
+
+    const windowId = uuidv4();
+
+    return new PresentationWindow({
+      windowManager: this,
+      renderer: this.renderer,
+      logger,
+      windowId,
+      windowName,
+      parentWindowId,
+      presentation,
+      applicationVersion,
+      device,
+      playlistId: pr.playlistId,
+      playlistName: this.ruleEngine.state.playlist(pr.playlistId).name,
+      rule: pr.rule,
+      publishedAt: this.state.getPublishedAt(),
+      theme: this.getTheme(presentationId),
+      forceMute: this.forceMute,
+      readyTimeoutDurationSeconds,
+      appRendererUrl,
+      bounds: this.bounds,
+      backgroundColor,
+      playlistWindowManagerState: this.state,
+      ruleEngineState: this.ruleEngine.state,
+      globalRule: this.ruleEngine.globalRule,
+      isPreview,
+      workerState: this.workerState
+    });
+  }
+
+  private async loadCurrentWindow() {
+    const { logger } = this.options;
+
+    if (!this.currentPresentation) {
+      logger.warn(
+        `Attempted to load current window but currentPresentation not set`
+      );
+      return;
+    }
+
+    this.currentWindow = this.createWindow(this.currentPresentation);
+    this.currentWindow.onComplete(this.handleCurrentPresentationComplete);
+    this.currentWindow.onError(this.handleCurrentPresentationError);
+    this.currentWindow.onEnableInterruptLock(this.handleEnableInterruptLock);
+    this.currentWindow.onDisableInterruptLock(this.handleDisableInterruptLock);
+    this.currentWindow.onAnalyticsEvent(this.handleAnalyticsEvent);
+
+    await this.currentWindow.load();
+  }
+
+  private shouldPreload(
+    presentationId: string | null
+  ): presentationId is string {
+    // Don't preload if there is no presentation.
+    if (presentationId === null) {
+      return false;
+    }
+    // Don't preload the next presentation if it's already preloaded. When the window manager
+    // is first created it will eval the rule engine and set this.nextPresentationId but not
+    // this.nextWindow.
+    if (presentationId === this.nextPresentationId()) {
+      return false;
+    }
+    // An optimization to avoid preloading the same presentation we are currenly playing.
+    // When the current presentation completes we will play it again and then check for
+    // a new presentation to preload.
+    if (presentationId === this.currentPresentationId()) {
+      return false;
+    }
+    return true;
+  }
+
+  private async preloadNextWindow() {
+    const { logger } = this.options;
+
+    if (!this.nextPresentation) {
+      logger.warn(
+        `Attempted to preload next window but nextPresentation not set`
+      );
+      return;
+    }
+
+    this.nextWindow = this.createWindow(this.nextPresentation);
+    this.nextWindow.onError(this.handleNextPresentationError);
+    await this.nextWindow.load();
+
+    // If there is no current window and the next window successfully loaded, show the preloaded window.
+    // NOTE: Apps that use raydiant-kit's onError handler will end up showing an error on screen anyways
+    // because the onError method fires presentation_ready before sending the error. We should fix this
+    // but would require updating raydiant-kit and then all apps.
+    if (!this.currentWindow && !this.nextWindow.didError()) {
+      this.handleCurrentPresentationComplete();
+    }
+  }
+
+  private playCurrentWindow() {
+    const { logger } = this.options;
+
+    if (this.currentWindow) {
+      this.currentWindow.play();
+      this.emitCurrentWindowEvent('window_play');
+    } else {
+      logger.warn(`Attempted to play current window but it doesn't exist`);
+    }
+  }
+
+  private pauseCurrentWindow() {
+    const { logger } = this.options;
+
+    if (this.currentWindow) {
+      this.currentWindow.pause();
+    } else {
+      logger.warn(`Attempted to pause current window but it doesn't exist`);
+    }
+  }
+
+  private resumeCurrentWindow() {
+    const { logger } = this.options;
+
+    if (this.currentWindow) {
+      this.currentWindow.resume();
+    } else {
+      logger.warn(`Attempted to resume current window but it doesn't exist`);
+    }
+  }
+
+  private async restartCurrentWindow() {
+    const { logger } = this.options;
+
+    if (this.currentWindow) {
+      if (this.shouldHardRestart) {
+        logger.info(`Restart current window with hard restart`);
+        await this.removeCurrentWindow();
+        await this.loadCurrentWindow();
+        this.currentWindow.show(this.isFocused);
+      } else {
+        logger.info(`Restart current window`);
+        this.currentWindow.reset();
+      }
+      this.playCurrentWindow();
+    } else {
+      logger.warn(`Attempted to restart current window but it doesn't exist`);
+    }
+  }
+
+  private async removeCurrentWindow() {
+    if (this.currentWindow) {
+      await this.currentWindow.remove();
+    }
+    this.currentWindow = null;
+    this.currentPresentation = null;
+  }
+
+  private async removeNextWindow() {
+    if (this.nextWindow) {
+      await this.nextWindow.remove();
+    }
+    this.nextWindow = null;
+    this.nextPresentation = null;
+  }
+
+  private async swapWindows() {
+    // Get the new next presentation to preload after swapping.
+    let nextPreviewPresentationId: string | null = null;
+    let preview: RE.NextPresentationID | null = null;
+    if (this.overrideNextPresentation) {
+      preview = this.overrideNextPresentation;
+      nextPreviewPresentationId = this.overrideNextPresentation.presentationId;
+      this.overrideNextPresentation = null;
+    } else {
+      const result = this.evalRuleEngine();
+      preview = result.preview;
+      nextPreviewPresentationId = preview.presentationId;
+    }
+
+    // Set this.currentPresentationId before removing the current window to avoid timing issues with previewCheck
+    // triggering during removeCurrentWindow. Current presentation id needs to be set to the next
+    // presentation before calling shouldPreload().
+    this.currentPresentation = this.nextPresentation;
+    // We need to call shouldPreload() before setting this.nextPresentationId. Store the result
+    // here so we can preload the new next presentation after removing the current. Calling
+    // shouldPreload() again after setting this.nextPresentationId will cause the next window
+    // to not preload.
+    const shouldPreload = this.shouldPreload(nextPreviewPresentationId);
+    if (shouldPreload) {
+      // Set this.nextPresentationId before removing the current window. This prevents
+      // race conditions with previewCheck when using the window pool, where removeWindow
+      // is async because we unload the window instead of destroying it.
+      this.nextPresentation = preview;
+    }
+
+    // Clear the pending interrupt whenever we swap the current window for the next one.
+    this.hasPendingInterrupt = false;
+
+    // Next window is ready, show the next one, hide the current window, and
+    // then remove the current window. Show the next window before hiding the
+    // current to avoid flashes when rendering with BrowserWindows on device.
+    if (this.nextWindow) {
+      this.nextWindow.show(this.isFocused);
+    }
+
+    // If current window isn't defined we don't need to hide it but we still
+    // want to make the next window the new current window.
+    if (this.currentWindow) {
+      this.currentWindow.hide();
+      await this.removeCurrentWindow();
+    }
+
+    // Swap windows.
+    this.currentWindow = this.nextWindow;
+    if (this.currentWindow) {
+      this.currentWindow.onComplete(this.handleCurrentPresentationComplete);
+      this.currentWindow.onError(this.handleCurrentPresentationError);
+      this.currentWindow.onEnableInterruptLock(this.handleEnableInterruptLock);
+      this.currentWindow.onDisableInterruptLock(
+        this.handleDisableInterruptLock
+      );
+      this.currentWindow.onAnalyticsEvent(this.handleAnalyticsEvent);
+    }
+
+    // Play new current window.
+    this.playCurrentWindow();
+
+    // Preload the next presentation if there is one.
+    if (shouldPreload) {
+      this.preloadNextWindow();
+    } else {
+      // Set next window to null to reset preload state. We don't want to
+      // remove the next window because it's the new current window.
+      this.nextWindow = null;
+      this.nextPresentation = null;
+    }
+  }
+
+  private evalRuleEngine(warnIfPreloadMismatch = true): EvalRuleEngineResult {
+    const { logger } = this.options;
+
+    if (!this.ruleEngine) {
+      throw new Error(
+        'Attempted to eval rule engine but ruleEngine not provided'
+      );
+    }
+
+    const next = this.ruleEngine.next();
+    const preview = this.ruleEngine.previewNext();
+
+    const nextPresentationId = next.presentationId;
+
+    if (
+      this.nextPresentationId() !== null &&
+      nextPresentationId !== this.nextPresentationId() &&
+      warnIfPreloadMismatch
+    ) {
+      // TODO: Handle the case when the next presentation isn't the preloaded window.
+      // This can happen when we support dynamic rule engine state.
+      logger.warn(
+        `The next presentation id '${nextPresentationId}' doesnt match preloaded presentation id '${this.nextPresentationId()}'`
+      );
+    }
+
+    return { next, preview };
+  }
+
+  private handleEnableInterruptLock = () => {
+    const { onEnableInterruptLock } = this.options;
+    if (onEnableInterruptLock) {
+      onEnableInterruptLock();
+    }
+  };
+
+  private handleDisableInterruptLock = () => {
+    const { onDisableInterruptLock } = this.options;
+    if (onDisableInterruptLock) {
+      onDisableInterruptLock();
+    }
+
+    if (this.hasPendingInterrupt) {
+      this.endCurrentPresentation();
+    }
+  };
+
+  private handleAnalyticsEvent = (event: AnalyticsEvent) => {
+    // Emit the event on the current window. Only the current window should
+    // send analytics events since the next window is not visible.
+    this.emitCurrentWindowEvent('window_analytics_event', event);
+  };
+
+  private handleCurrentPresentationComplete = async () => {
+    const { logger } = this.options;
+
+    // First check if we need to throttle the presentation complete handler.
+    let isThrottled = false;
+    if (this.lastCompleteAt !== null) {
+      const now = new Date();
+      const timeSinceLastComplete = +now - +this.lastCompleteAt;
+
+      if (timeSinceLastComplete < minTimeBetweenCompletes) {
+        isThrottled = true;
+
+        // Throttle presentation complete handler if we have not throttled already.
+        if (this.currentPresentationCompleteTimeout === null) {
+          const delay = minTimeBetweenCompletes - timeSinceLastComplete + 1;
+
+          logger.warn(
+            `Throttling presentation complete handler for ${delay}ms because it was called again in less than ${minTimeBetweenCompletes}ms`
+          );
+
+          this.currentPresentationCompleteTimeout = setTimeout(() => {
+            this.currentPresentationCompleteTimeout = null;
+            this.handleCurrentPresentationComplete();
+          }, delay);
+        } else {
+          logger.warn(
+            `Skipping presentation complete because it is currently throttled`
+          );
+        }
+      }
+    }
+
+    // Don't run presentation complete handler when throttled.
+    if (isThrottled) {
+      return;
+    }
+
+    // Not throttled, update lastCompleteAt and run presentation complete handler.
+    this.lastCompleteAt = new Date();
+
+    // Emit presentation end events.
+    if (this.currentWindowError) {
+      this.emitCurrentWindowErrorEvent(
+        'window_end_error',
+        this.currentWindowError
+      );
+    } else {
+      this.emitCurrentWindowEvent('window_end_success');
+    }
+    // Clear current window error flag.
+    this.currentWindowError = null;
+
+    // If not locked or paused, check if we can move to the next presentation.
+    if (
+      !this.isLocked() &&
+      !this.restartCurrentWindowOnEnd &&
+      this.currentWindow &&
+      this.nextWindow
+    ) {
+      // If the next window is ready, swap windows and preload the next one.
+      if (this.nextWindow.isReady()) {
+        await this.swapWindows();
+      } else {
+        // The next window isn't ready yet, restart the current presentation.
+        // restartCurrentWindow depends on this.shouldHardRestart
+        await this.restartCurrentWindow();
+        // TODO: Do we want to clear shouldHardRestart and currentWindowError on restart?
+      }
+    } else if (this.currentWindow) {
+      // If we aren't supposed to swap to the next window, check if the current window should
+      // be restarted or removed.
+
+      // Eval the rule engine to see if we should still be playing the current window or if
+      // there's a new next window we need to preload.
+      const { next, preview } = this.evalRuleEngine();
+      const nextPreviewPresentationId = preview.presentationId;
+
+      if (!next.presentationId) {
+        // If next.presentationId is null after evaluating the rule engine that means
+        // nothing should be playing, remove the current window.
+        this.removeCurrentWindow();
+      } else {
+        // Restart the current presentation when:
+        // - There's only one presentation in the playlist (no preload)
+        // - The playlist is locked or paused
+        // - There is a still a presentation that should be
+        // NOTE: restartCurrentWindow depends on this.shouldHardRestart
+        await this.restartCurrentWindow();
+
+        // Check to see if there is a presentation to preload. This can happen if
+        // if state has changed since initial load (ie. publish).
+        if (this.shouldPreload(nextPreviewPresentationId)) {
+          this.nextPresentation = preview;
+          this.preloadNextWindow();
+        }
+      }
+    } else if (this.nextWindow) {
+      // There is no current window but there is a next window. Swap to the next window.
+      // This can happen if updating the rule engine from an empty playlist to a non-empty playlist.
+      await this.swapWindows();
+    } else {
+      logger.warn(
+        `Presentation complete received but there's no current window.`
+      );
+    }
+
+    // Clear hard restart after running complete handler. This could be true when the current window errors
+    // but if there's another presentation to move on to we won't restart it but we still need to clear it
+    // so we don't hard restart the new current window when we shouldn't.
+    this.shouldHardRestart = false;
+  };
+
+  private handleCurrentPresentationError = async (error: any) => {
+    const { logger } = this.options;
+
+    logger.warn(
+      `Current presentation had an error, move to next presentation or hard restart current window`
+    );
+
+    const isWindowError =
+      error instanceof WindowUnresponsiveError ||
+      error instanceof WindowTimeoutError ||
+      error instanceof WindowLoadError;
+
+    if (isWindowError) {
+      // Error is window error, hard restart the window if it's the only presentation in the playlist.
+      this.shouldHardRestart = true;
+    }
+
+    // Flag the current presentation as having errored.
+    this.currentWindowError = error;
+
+    this.handleCurrentPresentationComplete();
+  };
+
+  private handleNextPresentationError = async (error: any) => {
+    const { logger } = this.options;
+
+    // Emit event that preload has failed.
+    this.emitNextWindowErrorEvent('window_preload_error', error);
+
+    logger.warn(
+      `Next presentation had an error, preload the next presentation`
+    );
+    const { preview } = this.evalRuleEngine();
+    const nextPreviewPresentationId = preview.presentationId;
+
+    if (this.shouldPreload(nextPreviewPresentationId)) {
+      // Remove the window before preloading a new one.
+      await this.removeNextWindow();
+      // Calling removeNextWindow will set this.nextPresentation to null so we need to
+      // set after but before preloadNextWindow.
+      this.nextPresentation = preview;
+      this.preloadNextWindow();
+    } else {
+      await this.removeNextWindow();
+    }
+  };
+
+  private checkPreviewAction = async () => {
+    const { logger } = this.options;
+    if (!this.ruleEngine) {
+      return;
+    }
+    const preview = this.ruleEngine.previewNext();
+
+    if (this.shouldPreload(preview.presentationId)) {
+      logger.info(
+        `Preview check replacing preloaded presentation '${this.nextPresentationId()}' with new presentation '${
+          preview.presentationId
+        }'`
+      );
+      await this.removeNextWindow();
+      this.nextPresentation = preview;
+      await this.preloadNextWindow();
+    }
+
+    if (preview.shouldInterrupt) {
+      logger.info(
+        `Interrupting current presentation with '${preview.presentationId}'`
+      );
+      this.registerInterrupt();
+    }
+  };
+
+  private startPreviewCheck() {
+    const checkPreview = async () => {
+      if (this.ruleEngine) {
+        this.checkPreviewAction();
+      }
+
+      // Check the preview again on the next minute.
+      const now = new Date();
+      const nextMinute = new Date();
+      nextMinute.setMilliseconds(0);
+      nextMinute.setSeconds(1);
+      nextMinute.setMinutes(now.getMinutes() + 1);
+      const timeUntilNextMinute = +nextMinute - +now;
+
+      this.interruptCheckTimeout = setTimeout(
+        checkPreview,
+        timeUntilNextMinute
+      );
+    };
+
+    checkPreview();
+  }
+
+  private stopInterruptCheck() {
+    if (this.interruptCheckTimeout) {
+      clearTimeout(this.interruptCheckTimeout);
+    }
+  }
+
+  private getTheme(presentationId: string) {
+    if (!this.state) return;
+
+    let theme: Theme | undefined;
+
+    const presentation = this.state.getPresentation(presentationId);
+
+    if (this.themeOverride) {
+      theme = this.themeOverride;
+    } else if (presentation.themeId && this.state) {
+      theme = this.state.getTheme(presentation.themeId);
+    }
+
+    return theme;
+  }
+
+  private emitWindowEvent(
+    label: string,
+    event: string,
+    window: PresentationWindow | null,
+    data?: any
+  ) {
+    const { logger } = this.options;
+
+    if (window) {
+      this.emit(event, {
+        ...window.metadata(),
+        data
+      });
+    } else {
+      logger.warn(`Attempted to emit ${label} window event but window not set`);
+    }
+  }
+
+  private emitCurrentWindowEvent(event: string, data?: any) {
+    return this.emitWindowEvent('current', event, this.currentWindow, data);
+  }
+
+  private emitNextWindowEvent(event: string, data?: any) {
+    return this.emitWindowEvent('next', event, this.nextWindow, data);
+  }
+
+  private emitCurrentWindowErrorEvent(event: string, error: any) {
+    return this.emitCurrentWindowEvent(event, {
+      errorMessage: this.getErrorMessage(error)
+    });
+  }
+
+  private emitNextWindowErrorEvent(event: string, error: any) {
+    return this.emitNextWindowEvent(event, {
+      errorMessage: this.getErrorMessage(error)
+    });
+  }
+
+  private getErrorMessage(error: any) {
+    if (typeof error === 'string') return error;
+    if (error && typeof error === 'object' && error.message)
+      return error.message;
+    return '';
+  }
+}