@raydiant/playlist-window-manager 0.0.0-test-27 → 0.0.0-test-29

package/src/BrowserWindowRenderer.ts

@@ -3,12 +3,11 @@ import {
   BrowserWindow,
   BrowserView,
   ipcMain,
-  screen,
   IpcMainEvent,
   Event,
-  Details,
   BrowserWindowConstructorOptions,
   BrowserViewConstructorOptions,
+  RenderProcessGoneDetails,
 } from 'electron';
 import {
   PresentationWindowRenderer,
@@ -16,9 +15,7 @@ import {
   WindowBounds,
   Logger,
 } from './types';
-import lodash from 'lodash';
 import WindowUnresponsiveError from './WindowUnresponsiveError';
-import { areBoundsEqual, isFullscreen } from './boundUtils';
 
 interface ProxySettings {
   proxyRules: string;
@@ -35,7 +32,10 @@ interface BrowserWindowRendererWindow {
     payload?: any
   ) => void;
   unresponsiveCallback: () => void;
-  renderProcessGoneCallback: (event: Event, details: Details) => void;
+  renderProcessGoneCallback: (
+    event: Event,
+    details: RenderProcessGoneDetails
+  ) => void;
 }
 
 interface BrowserWindowRendererOptions {
@@ -55,9 +55,6 @@ export default class BrowserWindowRenderer
   private windows: {
     [windowId: string]: BrowserWindowRendererWindow;
   } = {};
-  private windowsBounds: {
-    [windowId: string]: WindowBounds;
-  } = {};
   private windowCrashHandler: (reason: string) => void = (_: string) => {};
 
   private browserWindowPool = new WindowPool<BrowserWindow>();
@@ -65,14 +62,12 @@ export default class BrowserWindowRenderer
 
   // Create a hidden window to preload BrowserViews.
   private offscreenWindow = new BrowserWindow({
-    ...this.opts.bounds,
     show: false,
     frame: this.opts.frame,
     hasShadow: this.opts.hasShadow,
-    useContentSize: true,
-    fullscreen: isFullscreen(this.opts.bounds),
     webPreferences: {
       preload: path.join(__dirname, 'preload.js'),
+      contextIsolation: false,
     },
   });
 
@@ -81,28 +76,13 @@ export default class BrowserWindowRenderer
   private logger: Logger;
 
   constructor(private opts: BrowserWindowRendererOptions) {
-    this.logger = opts.logger;
-    opts.logger.info(
-      `playlist-window-manager/src/BrowserWindowRenderer.ts constructor1 ${JSON.stringify(
-        opts.bounds
-      )}`
-    );
-    this.setWindowOrViewBounds(this.offscreenWindow, opts.bounds);
-    opts.logger.info(
-      `playlist-window-manager/src/BrowserWindowRenderer.ts constructor2 ${JSON.stringify(
-        {
-          fullscreen: this.offscreenWindow.isFullScreen(),
-          bounds: this.offscreenWindow.getBounds(),
-          normalBounds: this.offscreenWindow.getNormalBounds(),
-          contentBounds: this.offscreenWindow.getContentBounds(),
-        }
-      )}`
-    );
-
+    this.offscreenWindow.setBounds(opts.bounds);
     if (opts.proxySettings) {
       this.proxySettings = opts.proxySettings;
     }
 
+    this.logger = opts.logger;
+
     if (opts.windowCrashHandler) {
       this.windowCrashHandler = opts.windowCrashHandler;
     }
@@ -115,21 +95,7 @@ export default class BrowserWindowRenderer
     backgroundColor,
     receiveMessageCallback,
     errorCallback,
-  }: CreateWindowOptions): Promise<void> {
-    const windowBounds =
-      parentWindowId && !this.opts.renderChildWindowsAsBrowserViews
-        ? {
-            ...bounds,
-            x: bounds.x + this.opts.bounds.x,
-            y: bounds.y + this.opts.bounds.y,
-          }
-        : bounds;
-
-    this.logger.info(
-      `playlist-window-manager/src/BrowserWindowRenderer.ts createWindow1: ${JSON.stringify(
-        windowBounds
-      )}`
-    );
+  }: CreateWindowOptions) {
     const window: BrowserWindowRendererWindow = {
       parentWindowId,
       // If we are creating a child window and renderChildWindowsAsBrowserViews is true,
@@ -144,7 +110,6 @@ export default class BrowserWindowRenderer
           : this.createOrGetPooledBrowserWindow(windowId, {
               show: false,
               frame: this.opts.frame,
-              fullscreen: isFullscreen(this.opts.bounds),
               // NOTE: useWindowPool: true does not work with renderChildWindowsAsBrowserViews: false
               // because the parent can't be changed after creating the BrowserWindow.
               parent: parentWindowId
@@ -154,13 +119,21 @@ export default class BrowserWindowRenderer
               hasShadow: this.opts.hasShadow,
               webPreferences: {
                 preload: path.join(__dirname, 'preload.js'),
+                contextIsolation: false,
               },
             }),
       // If we are creating a child window and renderChildWindowsAsBrowserViews is false that means
       // we are rendering child windows with BrowserWindow. BrowserWindows are positioned absolutely so
       // to place them in the correct spot relative to their parent we need to add the main window's x / y.
       // BrowserViews are relatively positioned so we don't need to do that.
-      bounds: windowBounds,
+      bounds:
+        parentWindowId && !this.opts.renderChildWindowsAsBrowserViews
+          ? {
+              ...bounds,
+              x: bounds.x + this.opts.bounds.x,
+              y: bounds.y + this.opts.bounds.y,
+            }
+          : bounds,
 
       receiveMessageCallback: (
         _: IpcMainEvent,
@@ -180,7 +153,10 @@ export default class BrowserWindowRenderer
         );
       },
 
-      renderProcessGoneCallback: (_: Event, details: Details) => {
+      renderProcessGoneCallback: (
+        _: Event,
+        details: RenderProcessGoneDetails
+      ) => {
         this.logger.error(
           `Window received 'render-process-gone' event. Reason: ${details.reason}`,
           { windowId }
@@ -209,20 +185,9 @@ export default class BrowserWindowRenderer
 
     if (window.view instanceof BrowserView) {
       this.moveWindowOffscreen(window);
-      this.logger.info(
-        `playlist-window-manager/src/BrowserWindowRenderer.ts createWindow2: ${JSON.stringify(
-          {
-            fullscreen: this.offscreenWindow.isFullScreen(),
-            bounds: this.offscreenWindow.getBounds(),
-            normalBounds: this.offscreenWindow.getNormalBounds(),
-            contentBounds: this.offscreenWindow.getContentBounds(),
-          }
-        )}`
-      );
     }
 
     this.windows[windowId] = window;
-    this.windowsBounds[windowId] = lodash.cloneDeep(windowBounds);
     // Listen for messages from window.
     ipcMain.on(windowId, window.receiveMessageCallback);
 
@@ -234,49 +199,7 @@ export default class BrowserWindowRenderer
       );
     }
 
-    if (window.view instanceof BrowserWindow) {
-      this.logger.info(
-        `playlist-window-manager/src/BrowserWindowRenderer.ts createWindow4: ${JSON.stringify(
-          {
-            newBounds: window.bounds,
-            fullscreen: window.view.isFullScreen(),
-            bounds: window.view.getBounds(),
-            contentBounds: window.view.getContentBounds(),
-            normalBounds: window.view.getNormalBounds(),
-          }
-        )}`
-      );
-    } else {
-      this.logger.info(
-        `playlist-window-manager/src/BrowserWindowRenderer.ts createWindow5: ${JSON.stringify(
-          {
-            newBounds: window.bounds,
-            bounds: window.view.getBounds(),
-          }
-        )}`
-      );
-    }
-    this.setWindowOrViewBounds(window.view, window.bounds);
-    if (window.view instanceof BrowserWindow) {
-      this.logger.info(
-        `playlist-window-manager/src/BrowserWindowRenderer.ts createWindow7: ${JSON.stringify(
-          {
-            fullscreen: window.view.isFullScreen(),
-            bounds: window.view.getBounds(),
-            contentBounds: window.view.getContentBounds(),
-            normalBounds: window.view.getNormalBounds(),
-          }
-        )}`
-      );
-    } else {
-      this.logger.info(
-        `playlist-window-manager/src/BrowserWindowRenderer.ts createWindow8: ${JSON.stringify(
-          {
-            bounds: window.view.getBounds(),
-          }
-        )}`
-      );
-    }
+    window.view.setBounds(window.bounds);
 
     if (this.proxySettings) {
       await window.view.webContents.session.setProxy(this.proxySettings);
@@ -304,95 +227,28 @@ export default class BrowserWindowRenderer
         `Failed to update window bounds, missing window id '${windowId}'`
       );
     }
-
-    this.logger.info(
-      `playlist-window-manager/src/BrowserWindowRenderer.ts updateWindowBounds1: ${JSON.stringify(
-        bounds
-      )}`
-    );
     window.bounds = bounds;
 
     if (window.view instanceof BrowserWindow && window.parentWindowId) {
       // Child BrowserWindows are absolutely positioned so we need to add the main windows
       // x/y to when updating the child window's bounds.
-      const newBounds = {
+      window.view.setBounds({
         ...window.bounds,
         x: window.bounds.x + this.opts.bounds.x,
         y: window.bounds.y + this.opts.bounds.y,
-      };
-      this.logger.info(
-        `playlist-window-manager/src/BrowserWindowRenderer.ts updateWindowBounds2: ${JSON.stringify(
-          newBounds
-        )}`
-      );
-      this.setWindowOrViewBounds(window.view, newBounds);
-
-      this.logger.info(
-        `playlist-window-manager/src/BrowserWindowRenderer.ts updateWindowBounds3: ${JSON.stringify(
-          {
-            fullscreen: window.view.isFullScreen(),
-            bounds: window.view.getBounds(),
-            normalBounds: window.view.getNormalBounds(),
-            contentBounds: window.view.getContentBounds(),
-          }
-        )}`
-      );
+      });
     } else {
-      this.logger.info(
-        `playlist-window-manager/src/BrowserWindowRenderer.ts updateWindowBounds4: ${JSON.stringify(
-          window.bounds
-        )}`
-      );
-      this.setWindowOrViewBounds(window.view, window.bounds);
-      this.logger.info(
-        `playlist-window-manager/src/BrowserWindowRenderer.ts updateWindowBounds5: ${JSON.stringify(
-          window.view.getBounds()
-        )}`
-      );
+      window.view.setBounds(window.bounds);
     }
   }
 
   public showWindow(windowId: string, isFocused: boolean) {
-    this.logger.info(
-      `playlist-window-manager/src/BrowserWindowRenderer.ts showWindow1: ${windowId}`
-    );
     const window = this.getWindow(windowId);
-    const windowBounds = this.getWindowBounds(windowId);
-    if (!window || !windowBounds) {
+    if (!window) {
       throw new Error(`Failed to show window, missing window id '${windowId}'`);
     }
 
     if (window.view instanceof BrowserWindow) {
-      this.logger.info(
-        `playlist-window-manager/src/BrowserWindowRenderer.ts showWindow2: ${JSON.stringify(
-          {
-            fullscreen: window.view.isFullScreen(),
-            isMaximized: window.view.isMaximized(),
-            bounds: window.view.getBounds(),
-            windowBounds: windowBounds,
-            normalBounds: window.view.getNormalBounds(),
-            contentBounds: window.view.getContentBounds(),
-          }
-        )}`
-      );
-      if (!areBoundsEqual(window.view.getBounds(), windowBounds)) {
-        this.logger.info(
-          `playlist-window-manager/src/BrowserWindowRenderer.ts showWindow3: setWindowOrViewBounds`
-        );
-        this.setWindowOrViewBounds(window.view, windowBounds);
-      }
-
-      this.logger.info(
-        `playlist-window-manager/src/BrowserWindowRenderer.ts showWindow4: ${JSON.stringify(
-          {
-            fullscreen: window.view.isFullScreen(),
-            isMaximized: window.view.isMaximized(),
-            bounds: window.view.getBounds(),
-            normalBounds: window.view.getNormalBounds(),
-            contentBounds: window.view.getContentBounds(),
-          }
-        )}`
-      );
       if (isFocused) {
         window.view.show();
       } else {
@@ -453,7 +309,6 @@ export default class BrowserWindowRenderer
     }
 
     delete this.windows[windowId];
-    delete this.windowsBounds[windowId];
 
     if (this.opts.useWindowPool) {
       this.logPoolStats();
@@ -502,125 +357,10 @@ export default class BrowserWindowRenderer
     window.view.webContents.setAudioMuted(false);
   }
 
-  /**
-   * This function is designed to solve missing 1px issue.
-   * If we set 1920x1080 bounds on 1920x1080 display
-   * then the actual BrowserWindow resolution would be
-   * 1919x1079.
-   */
-  private setWindowOrViewBounds(
-    window: BrowserWindow | BrowserView,
-    bounds: WindowBounds
-  ) {
-    if (window instanceof BrowserView) {
-      this.logger.info(
-        `playlist-window-manager/src/BrowserWindowRenderer.ts setWindowOrViewBounds1: ${JSON.stringify(
-          {
-            windowBounds: window.getBounds(),
-            bounds,
-          }
-        )}`
-      );
-      window.setBounds(bounds);
-      return;
-    }
-
-    this.logger.info(
-      `playlist-window-manager/src/BrowserWindowRenderer.ts setWindowOrViewBounds2: ${JSON.stringify(
-        {
-          newBounds: bounds,
-          fullscreen: window.isFullScreen(),
-          isMaximized: window.isMaximized(),
-          bounds: window.getBounds(),
-          contentBounds: window.getContentBounds(),
-          normalBounds: window.getNormalBounds(),
-        }
-      )}`
-    );
-
-    // calling setBounds or setFullscreen may introduce -1px resolution error
-    // so we try to avoid unnecessary calls
-    if (areBoundsEqual(window.getBounds(), bounds)) {
-      this.logger.info(
-        `playlist-window-manager/src/BrowserWindowRenderer.ts setWindowOrViewBounds3: bounds are equal`
-      );
-      return;
-    }
-
-    if (isFullscreen(bounds) !== window.isFullScreen()) {
-      this.logger.info(
-        `playlist-window-manager/src/BrowserWindowRenderer.ts setWindowOrViewBounds4: setFullScreen`
-      );
-      window.setFullScreen(isFullscreen(bounds));
-    }
-
-    this.logger.info(
-      `playlist-window-manager/src/BrowserWindowRenderer.ts setWindowOrViewBounds5: ${JSON.stringify(
-        {
-          fullscreen: window.isFullScreen(),
-          isMaximized: window.isMaximized(),
-          bounds: window.getBounds(),
-          contentBounds: window.getContentBounds(),
-          normalBounds: window.getNormalBounds(),
-        }
-      )}`
-    );
-
-    if (!areBoundsEqual(window.getBounds(), bounds)) {
-      this.logger.info(
-        `playlist-window-manager/src/BrowserWindowRenderer.ts setWindowOrViewBounds6: setBounds`
-      );
-      window.setBounds(bounds);
-    }
-
-    this.logger.info(
-      `playlist-window-manager/src/BrowserWindowRenderer.ts setWindowOrViewBounds7: ${JSON.stringify(
-        {
-          fullscreen: window.isFullScreen(),
-          isMaximized: window.isMaximized(),
-          bounds: window.getBounds(),
-          contentBounds: window.getContentBounds(),
-          normalBounds: window.getNormalBounds(),
-        }
-      )}`
-    );
-
-    if (window.isFullScreen() && !isFullscreen(window.getBounds())) {
-      this.logger.info(
-        `playlist-window-manager/src/BrowserWindowRenderer.ts setWindowOrViewBounds8: maximize: ${JSON.stringify(
-          {
-            fullscreen: window.isFullScreen(),
-            isMaximized: window.isMaximized(),
-            bounds: window.getBounds(),
-            contentBounds: window.getContentBounds(),
-            normalBounds: window.getNormalBounds(),
-          }
-        )}`
-      );
-      window.maximize();
-    }
-
-    this.logger.info(
-      `playlist-window-manager/src/BrowserWindowRenderer.ts setWindowOrViewBounds9: ${JSON.stringify(
-        {
-          fullscreen: window.isFullScreen(),
-          isMaximized: window.isMaximized(),
-          bounds: window.getBounds(),
-          contentBounds: window.getContentBounds(),
-          normalBounds: window.getNormalBounds(),
-        }
-      )}`
-    );
-  }
-
   private getWindow(windowId: string): BrowserWindowRendererWindow | null {
     return this.windows[windowId];
   }
 
-  private getWindowBounds(windowId: string): WindowBounds | null {
-    return this.windowsBounds[windowId];
-  }
-
   private moveWindowOffscreen(window: BrowserWindowRendererWindow) {
     if (!(window.view instanceof BrowserView)) {
       throw new Error(
@@ -728,18 +468,6 @@ export default class BrowserWindowRenderer
       }
     }
 
-    this.logger.info(
-      `playlist-window-manager/src/BrowserWindowRenderer.ts createOrGetPooledBrowserWindow1: ${JSON.stringify(
-        {
-          screen: screen.getPrimaryDisplay().bounds,
-          fullscreen: browserWindow.isFullScreen(),
-          bounds: browserWindow.getBounds(),
-          contentBounds: browserWindow.getContentBounds(),
-          normalBounds: browserWindow.getNormalBounds(),
-        }
-      )}`
-    );
-
     return browserWindow;
   }
 
@@ -747,13 +475,6 @@ export default class BrowserWindowRenderer
     windowId: string,
     browserWindow: BrowserWindow
   ) {
-    this.logger.info(
-      `playlist-window-manager/src/BrowserWindowRenderer.ts destroyOrUnloadPooledBrowserWindow1: ${JSON.stringify(
-        {
-          windowId,
-        }
-      )}`
-    );
     if (this.opts.useWindowPool) {
       this.hideWindow(windowId);
       await browserWindow.webContents.loadURL('about:blank');

package/src/PlaylistWindowManager.ts

@@ -9,6 +9,10 @@ import {
   Logger,
   WorkerState,
   AnalyticsEvent,
+  Charge,
+  ChargeRequest,
+  ChargeResponse,
+  Terminal,
 } from './types';
 import PresentationWindow from './PresentationWindow';
 import PlaylistWindowManagerState from './PlaylistWindowManagerState';
@@ -67,6 +71,9 @@ export interface PlaylistWindowManagerOptions {
 
   // Called when the current window wants to disable the interrupt lock
   onDisableInterruptLock?: () => void;
+
+  // Called when a window needs the current terminal object.
+  getTerminal?: () => Terminal | null;
 }
 
 // Wait at least 3 seconds before restarting or moving onto the next window
@@ -84,12 +91,12 @@ export default class PlaylistWindowManager extends EventEmitter {
   private overrideNextPresentation: RE.NextPresentationID | null = null;
   private currentWindow: PresentationWindow | null = null;
   private nextWindow: PresentationWindow | null = null;
-  private hasPendingInterrupt = false;
+  private hasPendingInterrupt: boolean = false;
   private ruleEngine: RE.RuleEngine | null = null;
   private state: PlaylistWindowManagerState | null = null;
   private renderer: PresentationWindowRenderer | null = null;
-  private restartCurrentWindowOnEnd = false;
-  private shouldHardRestart = false;
+  private restartCurrentWindowOnEnd: boolean = false;
+  private shouldHardRestart: boolean = false;
   private currentWindowError: null | Error = null;
   private interruptCheckTimeout: ReturnType<typeof setTimeout> | null = null;
   private currentPresentationCompleteTimeout: ReturnType<
@@ -98,8 +105,8 @@ export default class PlaylistWindowManager extends EventEmitter {
   private lastCompleteAt: Date | null = null;
   private bounds?: WindowBounds;
   private themeOverride?: Theme;
-  private forceMute = false;
-  private isFocused = false;
+  private forceMute: boolean = false;
+  private isFocused: boolean = false;
 
   private workerState: WorkerState = {};
 
@@ -344,7 +351,6 @@ export default class PlaylistWindowManager extends EventEmitter {
   }
 
   public updateBounds(bounds: WindowBounds) {
-    // TODO log bounds
     this.bounds = bounds;
     if (this.currentWindow) {
       this.currentWindow.updateBounds(this.bounds);
@@ -397,7 +403,7 @@ export default class PlaylistWindowManager extends EventEmitter {
     }
   }
 
-  public async show(isFocused = true) {
+  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.
@@ -441,6 +447,43 @@ export default class PlaylistWindowManager extends EventEmitter {
     }
   }
 
+  public sendChargeResponse(response: ChargeResponse) {
+    // Send charge response to the current window. The window will check if
+    // has a matching request id and if so, send the response to the app.
+    if (this.currentWindow) {
+      this.currentWindow.sendChargeResponse(response);
+    }
+
+    // Send charge response to the next window.
+    if (this.nextWindow) {
+      this.nextWindow.sendChargeResponse(response);
+    }
+  }
+
+  public sendCharge(charge: Charge) {
+    // Send charge to the current window.
+    if (this.currentWindow) {
+      this.currentWindow.sendCharge(charge);
+    }
+
+    // Send charge to the next window.
+    if (this.nextWindow) {
+      this.nextWindow.sendCharge(charge);
+    }
+  }
+
+  public sendTerminal(terminal: Terminal | null) {
+    // Send terminal to the current window.
+    if (this.currentWindow) {
+      this.currentWindow.sendTerminal(terminal);
+    }
+
+    // Send terminal to the next window.
+    if (this.nextWindow) {
+      this.nextWindow.sendTerminal(terminal);
+    }
+  }
+
   private createWindow(pr: RE.NextPresentationID): PresentationWindow {
     const {
       readyTimeoutDurationSeconds,
@@ -480,12 +523,6 @@ export default class PlaylistWindowManager extends EventEmitter {
 
     const windowId = uuidv4();
 
-    logger.info(
-      `playlist-window-manager/src/PlaylistWindowManager.ts createWindow1 ${JSON.stringify(
-        this.bounds
-      )}`
-    );
-
     return new PresentationWindow({
       windowManager: this,
       renderer: this.renderer,
@@ -511,6 +548,7 @@ export default class PlaylistWindowManager extends EventEmitter {
       globalRule: this.ruleEngine.globalRule,
       isPreview,
       workerState: this.workerState,
+      getTerminal: this.options.getTerminal,
     });
   }
 
@@ -530,6 +568,7 @@ export default class PlaylistWindowManager extends EventEmitter {
     this.currentWindow.onEnableInterruptLock(this.handleEnableInterruptLock);
     this.currentWindow.onDisableInterruptLock(this.handleDisableInterruptLock);
     this.currentWindow.onAnalyticsEvent(this.handleAnalyticsEvent);
+    this.currentWindow.onChargeRequest(this.handleChargeRequest);
 
     await this.currentWindow.load();
   }
@@ -702,6 +741,7 @@ export default class PlaylistWindowManager extends EventEmitter {
         this.handleDisableInterruptLock
       );
       this.currentWindow.onAnalyticsEvent(this.handleAnalyticsEvent);
+      this.currentWindow.onChargeRequest(this.handleChargeRequest);
     }
 
     // Play new current window.
@@ -771,6 +811,12 @@ export default class PlaylistWindowManager extends EventEmitter {
     this.emitCurrentWindowEvent('window_analytics_event', event);
   };
 
+  private handleChargeRequest = (request: ChargeRequest) => {
+    // Emit the event on the current window. Only the current window should
+    // send charge requests since the next window is not visible.
+    this.emitCurrentWindowEvent('window_charge_request', request);
+  };
+
   private handleCurrentPresentationComplete = async () => {
     const { logger } = this.options;