@raydiant/playlist-window-manager 0.27.1 → 0.27.3-rc.1

package/build/BrowserWindowRenderer.d.ts

@@ -31,6 +31,7 @@ export default class BrowserWindowRenderer implements PresentationWindowRenderer
     removeWindow(windowId: string): Promise<void>;
     sendMessageString(windowId: string, message: string): void;
     sendMessageObject(windowId: string, type: string, payload?: any): void;
+    sendOnlineStatus(windowId: string, isOnline: boolean): void;
     muteWindow(windowId: string): void;
     unMuteWindow(windowId: string): void;
     private getWindow;

package/build/BrowserWindowRenderer.js

@@ -90,7 +90,7 @@ var BrowserWindowRenderer = /** @class */ (function () {
              * This option fixes window not being able to take fullscreen leaving
              * 1px gap at the right and bottom of the screen.
              */
-            resizable: false,
+            // resizable: false,
             frame: this.opts.frame,
             hasShadow: this.opts.hasShadow,
             webPreferences: {
@@ -133,7 +133,7 @@ var BrowserWindowRenderer = /** @class */ (function () {
                                      * This option fixes window not being able to take fullscreen leaving
                                      * 1px gap at the right and bottom of the screen.
                                      */
-                                    resizable: false,
+                                    // resizable: false,
                                     frame: this.opts.frame,
                                     // NOTE: useWindowPool: true does not work with renderChildWindowsAsBrowserViews: false
                                     // because the parent can't be changed after creating the BrowserWindow.
@@ -320,6 +320,13 @@ var BrowserWindowRenderer = /** @class */ (function () {
         }
         window.view.webContents.send('electron-main', { type: type, payload: payload });
     };
+    BrowserWindowRenderer.prototype.sendOnlineStatus = function (windowId, isOnline) {
+        var window = this.getWindow(windowId);
+        if (!window) {
+            throw new Error("Failed to send isOnline status to window, missing window id '".concat(windowId, "'"));
+        }
+        window.view.webContents.send('online-status', isOnline);
+    };
     BrowserWindowRenderer.prototype.muteWindow = function (windowId) {
         var window = this.getWindow(windowId);
         if (!window) {

package/build/PlaylistWindowManager.d.ts

@@ -20,6 +20,7 @@ export interface PlaylistWindowManagerOptions {
     onEnableInterruptLock?: () => void;
     onDisableInterruptLock?: () => void;
     getTerminal?: () => Terminal | null;
+    getOnlineStatus?: () => boolean;
 }
 export default class PlaylistWindowManager extends EventEmitter {
     private options;
@@ -80,6 +81,7 @@ export default class PlaylistWindowManager extends EventEmitter {
     sendChargeResponse(response: ChargeResponse): void;
     sendCharge(charge: Charge): void;
     sendTerminal(terminal: Terminal | null): void;
+    sendOnlineStatus(isOnline: boolean): void;
     private createWindow;
     private loadCurrentWindow;
     private shouldPreload;

package/build/PlaylistWindowManager.js

@@ -676,6 +676,14 @@ var PlaylistWindowManager = /** @class */ (function (_super) {
             this.nextWindow.sendTerminal(terminal);
         }
     };
+    PlaylistWindowManager.prototype.sendOnlineStatus = function (isOnline) {
+        if (this.currentWindow) {
+            this.currentWindow.sendOnlineStatus(isOnline);
+        }
+        if (this.nextWindow) {
+            this.nextWindow.sendOnlineStatus(isOnline);
+        }
+    };
     PlaylistWindowManager.prototype.createWindow = function (pr) {
         var _a = this.options, readyTimeoutDurationSeconds = _a.readyTimeoutDurationSeconds, appRendererUrl = _a.appRendererUrl, appRendererOfflineSupport = _a.appRendererOfflineSupport, backgroundColor = _a.backgroundColor, device = _a.device, logger = _a.logger, windowName = _a.windowName, parentWindowId = _a.parentWindowId, isPreview = _a.isPreview;
         if (!this.ruleEngine) {
@@ -721,6 +729,7 @@ var PlaylistWindowManager = /** @class */ (function (_super) {
             isPreview: isPreview,
             workerState: this.workerState,
             getTerminal: this.options.getTerminal,
+            getOnlineStatus: this.options.getOnlineStatus,
         });
     };
     PlaylistWindowManager.prototype.loadCurrentWindow = function () {

package/build/PresentationWindow.d.ts

@@ -33,6 +33,7 @@ export interface PresentationWindowOptions {
         [key: string]: string;
     }) => void;
     getTerminal?: () => Terminal | null;
+    getOnlineStatus?: () => boolean;
 }
 export default class PresentationWindow {
     private options;
@@ -102,6 +103,7 @@ export default class PresentationWindow {
     sendChargeResponse(response: ChargeResponse): void;
     sendCharge(charge: Charge): void;
     sendTerminal(terminal: Terminal | null): void;
+    sendOnlineStatus(isOnline: boolean): void;
     private isEmbeddedApp;
     private allChildWindowManagersReady;
     private checkIsReadyCallback;

package/build/PresentationWindow.js

@@ -755,6 +755,17 @@ var PresentationWindow = /** @class */ (function () {
             return wm.sendTerminal(terminal);
         });
     };
+    PresentationWindow.prototype.sendOnlineStatus = function (isOnline) {
+        var _a = this.options, windowId = _a.windowId, renderer = _a.renderer;
+        // Send online-status event. This Separate from sendMessageObject since we
+        // are bypassing Raydiant SDK message receivers.
+        if (renderer.sendOnlineStatus) {
+            renderer.sendOnlineStatus(windowId, isOnline);
+        }
+        Object.values(this.windowManagers).forEach(function (wm) {
+            wm.sendOnlineStatus(isOnline);
+        });
+    };
     PresentationWindow.prototype.isEmbeddedApp = function () {
         var _a = this.options, applicationVersion = _a.applicationVersion, isPreview = _a.isPreview;
         // If the application has a source url, always use it for rendering the preview.
@@ -1068,6 +1079,7 @@ var PresentationWindow = /** @class */ (function () {
                                 }
                             },
                             getTerminal: this.options.getTerminal,
+                            getOnlineStatus: this.options.getOnlineStatus,
                         });
                         // Hook up child window manager events to bubble up to the parent.
                         if (parentWindowManager) {

package/build/embeddedApps.js

@@ -56,6 +56,8 @@ function createEmbeddedApp(presentation, applicationVersion, metadata) {
             value = presentation.applicationVariables[queryParamName];
             if (value === undefined)
                 value = '';
+            if (value === null)
+                value = '';
             if (Array.isArray(value)) {
                 value = JSON.stringify(value);
             }

package/build/embeddedApps.test.js

@@ -149,3 +149,11 @@ test('Replaces $deviceId with empty string when in the query string and metadata
     });
     expect((0, embeddedApps_1.default)(presentation, applicationVersion, createMetadata())).toBe("https://example.com/content?device=");
 });
+test('Replaces null with empty string', function () {
+    expect((0, embeddedApps_1.default)(createPresentation({
+        applicationVariables: { file: null },
+    }), createApplicationVersion({
+        embeddedUrlFormat: "https://example.come?image=:file",
+        presentationProperties: [{ type: 'file', name: 'file' }],
+    }), createMetadata())).toBe("https://example.come?image=");
+});

package/build/preload.js

@@ -4,7 +4,7 @@ var electron_1 = require("electron");
 var internals = {
     sendMessage: function (windowId, type, payload) {
         electron_1.ipcRenderer.send(windowId, type, payload);
-    }
+    },
 };
 // Set __RAYDIANT_INTERNALS on window so it is accessible in to the running application.
 window.__RAYDIANT_INTERNALS = internals;
@@ -18,3 +18,104 @@ electron_1.ipcRenderer.on('electron-main', function (_, message) {
         console.error('Failed to handle message from main process, receiveMessage is not defined');
     }
 });
+// Create a custom event that mimics the behavior of the native online/offline events.
+function makeWindowEvent(type) {
+    var event = new Event(type);
+    Object.defineProperty(event, 'srcElement', {
+        get: function () { return window; },
+    });
+    Object.defineProperty(event, 'target', {
+        get: function () { return window; },
+    });
+    return event;
+}
+// Synchronously get the initial online status. This is handled in photon by the renderer
+// service. Calling sendSync avoids a flash of incorrect status when loading or refreshing
+// the page.
+var isOnline = electron_1.ipcRenderer.sendSync('get-online-status');
+// Listen for online status changes from the main process.
+electron_1.ipcRenderer.on('online-status', function (_, nextIsOnline) {
+    console.log("Online status: ".concat(nextIsOnline));
+    if (nextIsOnline !== isOnline) {
+        console.log('Online status changed, updating navigator.onLine');
+        isOnline = nextIsOnline;
+        var events_1 = makeWindowEvent(isOnline ? 'online' : 'offline');
+        var listeners = isOnline ? onlineListeners : offlineListeners;
+        console.log("Running ".concat(isOnline ? 'online' : 'offline', " listeners, count: ").concat(listeners.size));
+        listeners.forEach(function (listener) {
+            if (typeof listener === 'function') {
+                listener(events_1);
+            }
+            else if (listener.handleEvent) {
+                listener.handleEvent(events_1);
+            }
+        });
+    }
+});
+// Replace navigator.onLine with our implementation that uses a the device’s local connectivity
+// service. This will allow apps to receive an accurate and reliable value for navigator.onLine
+// when running on the device.
+Object.defineProperty(navigator, 'onLine', {
+    get: function () {
+        console.log("navigator.onLine called, returning ".concat(isOnline));
+        return isOnline;
+    },
+});
+var offlineListeners = new Set();
+var onlineListeners = new Set();
+var originalAddEventListener = window.addEventListener.bind(window);
+Object.defineProperty(window, 'addEventListener', {
+    value: function (type, listener) {
+        if (type === 'online') {
+            console.log("Intercepted online addEventListener");
+            onlineListeners.add(listener);
+        }
+        else if (type === 'offline') {
+            console.log("Intercepted offline addEventListener");
+            offlineListeners.add(listener);
+        }
+        else {
+            return originalAddEventListener(type, listener);
+        }
+    },
+});
+var originalRemoveEventListener = window.removeEventListener.bind(window);
+Object.defineProperty(window, 'removeEventListener', {
+    value: function (type, listener) {
+        if (type === 'online') {
+            console.log("Intercepted online removeEventListener");
+            onlineListeners.delete(listener);
+        }
+        else if (type === 'offline') {
+            console.log("Intercepted offline removeEventListener");
+            offlineListeners.delete(listener);
+        }
+        else {
+            return originalRemoveEventListener(type, listener);
+        }
+    },
+});
+// // TODO: Remove this (for local dev only).
+// (window as any).simulateOnline = () => {
+//   isOnline = true;
+//   console.log(`Running online listeners, count: ${onlineListeners.size}`);
+//   onlineListeners.forEach((listener) => {
+//     if (typeof listener === 'function') {
+//       listener(makeWindowEvent('online'));
+//     } else if (listener.handleEvent) {
+//       listener.handleEvent(makeWindowEvent('online'));
+//     }
+//   });
+// };
+// // TODO: Remove this (for local dev only).
+// (window as any).simulateOffline = () => {
+//   isOnline = false;
+//   console.log(`Running offline listeners, count: ${offlineListeners.size}`);
+//   offlineListeners.forEach((listener) => {
+//     if (typeof listener === 'function') {
+//       listener(makeWindowEvent('offline'));
+//     } else if (listener.handleEvent) {
+//       listener.handleEvent(makeWindowEvent('offline'));
+//     }
+//   });
+// };

package/build/types.d.ts

@@ -112,6 +112,7 @@ export interface PresentationWindowRenderer {
     sendMessageObject(windowId: string, type: string, payload?: any): void;
     muteWindow(windowId: string): void;
     unMuteWindow(windowId: string): void;
+    sendOnlineStatus?(windowId: string, isOnline: boolean): void;
 }
 export interface OpenChildWindowOptions {
     windowId: string;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@raydiant/playlist-window-manager",
-  "version": "0.27.1",
+  "version": "0.27.3-rc.1",
   "description": "Window manager for playlist playback.",
   "main": "build/index.js",
   "scripts": {

package/src/BrowserWindowRenderer.ts

@@ -67,7 +67,7 @@ export default class BrowserWindowRenderer
      * This option fixes window not being able to take fullscreen leaving
      * 1px gap at the right and bottom of the screen.
      */
-    resizable: false,
+    // resizable: false,
     frame: this.opts.frame,
     hasShadow: this.opts.hasShadow,
     webPreferences: {
@@ -119,7 +119,7 @@ export default class BrowserWindowRenderer
                * This option fixes window not being able to take fullscreen leaving
                * 1px gap at the right and bottom of the screen.
                */
-              resizable: false,
+              // resizable: false,
               frame: this.opts.frame,
               // NOTE: useWindowPool: true does not work with renderChildWindowsAsBrowserViews: false
               // because the parent can't be changed after creating the BrowserWindow.
@@ -348,6 +348,17 @@ export default class BrowserWindowRenderer
     window.view.webContents.send('electron-main', { type, payload });
   }
 
+  public sendOnlineStatus(windowId: string, isOnline: boolean) {
+    const window = this.getWindow(windowId);
+    if (!window) {
+      throw new Error(
+        `Failed to send isOnline status to window, missing window id '${windowId}'`
+      );
+    }
+
+    window.view.webContents.send('online-status', isOnline);
+  }
+
   public muteWindow(windowId: string) {
     const window = this.getWindow(windowId);
     if (!window) {

package/src/PlaylistWindowManager.ts

@@ -78,6 +78,9 @@ export interface PlaylistWindowManagerOptions {
 
   // Called when a window needs the current terminal object.
   getTerminal?: () => Terminal | null;
+
+  // Called when a window needs to check if the device is online.
+  getOnlineStatus?: () => boolean;
 }
 
 // Wait at least 3 seconds before restarting or moving onto the next window
@@ -488,6 +491,16 @@ export default class PlaylistWindowManager extends EventEmitter {
     }
   }
 
+  public sendOnlineStatus(isOnline: boolean) {
+    if (this.currentWindow) {
+      this.currentWindow.sendOnlineStatus(isOnline);
+    }
+
+    if (this.nextWindow) {
+      this.nextWindow.sendOnlineStatus(isOnline);
+    }
+  }
+
   private createWindow(pr: RE.NextPresentationID): PresentationWindow {
     const {
       readyTimeoutDurationSeconds,
@@ -555,6 +568,7 @@ export default class PlaylistWindowManager extends EventEmitter {
       isPreview,
       workerState: this.workerState,
       getTerminal: this.options.getTerminal,
+      getOnlineStatus: this.options.getOnlineStatus,
     });
   }
 

package/src/PresentationWindow.ts

@@ -59,6 +59,7 @@ export interface PresentationWindowOptions {
     string: { [key: string]: string }
   ) => void;
   getTerminal?: () => Terminal | null;
+  getOnlineStatus?: () => boolean;
 }
 
 // TODO: Automatically inject latest version when building in CI.
@@ -525,6 +526,20 @@ export default class PresentationWindow {
     );
   }
 
+  public sendOnlineStatus(isOnline: boolean) {
+    const { windowId, renderer } = this.options;
+    // Send online-status event. This Separate from sendMessageObject since we
+    // are bypassing Raydiant SDK message receivers.
+
+    if (renderer.sendOnlineStatus) {
+      renderer.sendOnlineStatus(windowId, isOnline);
+    }
+
+    Object.values(this.windowManagers).forEach((wm) => {
+      wm.sendOnlineStatus(isOnline);
+    });
+  }
+
   private isEmbeddedApp() {
     const { applicationVersion, isPreview } = this.options;
 
@@ -876,6 +891,7 @@ export default class PresentationWindow {
           }
         },
         getTerminal: this.options.getTerminal,
+        getOnlineStatus: this.options.getOnlineStatus,
       });
 
       // Hook up child window manager events to bubble up to the parent.

package/src/embeddedApps.test.ts

@@ -277,3 +277,18 @@ test('Replaces $deviceId with empty string when in the query string and metadata
     createEmbeddedApp(presentation, applicationVersion, createMetadata())
   ).toBe(`https://example.com/content?device=`);
 });
+
+test('Replaces null with empty string', () => {
+  expect(
+    createEmbeddedApp(
+      createPresentation({
+        applicationVariables: { file: null },
+      }),
+      createApplicationVersion({
+        embeddedUrlFormat: `https://example.come?image=:file`,
+        presentationProperties: [{ type: 'file', name: 'file' }],
+      }),
+      createMetadata()
+    )
+  ).toBe(`https://example.come?image=`);
+});

package/src/embeddedApps.ts

@@ -66,6 +66,7 @@ export default function createEmbeddedApp(
 
       value = presentation.applicationVariables[queryParamName];
       if (value === undefined) value = '';
+      if (value === null) value = '';
       if (Array.isArray(value)) {
         value = JSON.stringify(value);
       }

package/src/preload.ts

@@ -8,7 +8,7 @@ interface RaydiantInternals {
 const internals: RaydiantInternals = {
   sendMessage: (windowId: string, type: string, payload?: any) => {
     ipcRenderer.send(windowId, type, payload);
-  }
+  },
 };
 
 // Set __RAYDIANT_INTERNALS on window so it is accessible in to the running application.
@@ -25,3 +25,124 @@ ipcRenderer.on('electron-main', (_: IpcRendererEvent, message: string) => {
     );
   }
 });
+
+// Create a custom event that mimics the behavior of the native online/offline events.
+function makeWindowEvent(type: string) {
+  const event = new Event(type);
+
+  Object.defineProperty(event, 'srcElement', {
+    get: () => window,
+  });
+
+  Object.defineProperty(event, 'target', {
+    get: () => window,
+  });
+
+  return event;
+}
+
+// Synchronously get the initial online status. This is handled in photon by the renderer
+// service. Calling sendSync avoids a flash of incorrect status when loading or refreshing
+// the page.
+let isOnline = ipcRenderer.sendSync('get-online-status');
+
+// Listen for online status changes from the main process.
+ipcRenderer.on(
+  'online-status',
+  (_: IpcRendererEvent, nextIsOnline: boolean) => {
+    console.log(`Online status: ${nextIsOnline}`);
+
+    if (nextIsOnline !== isOnline) {
+      console.log('Online status changed, updating navigator.onLine');
+      isOnline = nextIsOnline;
+
+      const events = makeWindowEvent(isOnline ? 'online' : 'offline');
+      const listeners = isOnline ? onlineListeners : offlineListeners;
+
+      console.log(
+        `Running ${isOnline ? 'online' : 'offline'} listeners, count: ${
+          listeners.size
+        }`
+      );
+
+      listeners.forEach((listener) => {
+        if (typeof listener === 'function') {
+          listener(events);
+        } else if (listener.handleEvent) {
+          listener.handleEvent(events);
+        }
+      });
+    }
+  }
+);
+
+// Replace navigator.onLine with our implementation that uses a the device’s local connectivity
+// service. This will allow apps to receive an accurate and reliable value for navigator.onLine
+// when running on the device.
+Object.defineProperty(navigator, 'onLine', {
+  get: () => {
+    console.log(`navigator.onLine called, returning ${isOnline}`);
+    return isOnline;
+  },
+});
+
+const offlineListeners = new Set<EventListenerOrEventListenerObject>();
+const onlineListeners = new Set<EventListenerOrEventListenerObject>();
+
+const originalAddEventListener = window.addEventListener.bind(window);
+Object.defineProperty(window, 'addEventListener', {
+  value: (type: string, listener: EventListenerOrEventListenerObject) => {
+    if (type === 'online') {
+      console.log(`Intercepted online addEventListener`);
+      onlineListeners.add(listener);
+    } else if (type === 'offline') {
+      console.log(`Intercepted offline addEventListener`);
+      offlineListeners.add(listener);
+    } else {
+      return originalAddEventListener(type, listener);
+    }
+  },
+});
+
+const originalRemoveEventListener = window.removeEventListener.bind(window);
+Object.defineProperty(window, 'removeEventListener', {
+  value: (type: string, listener: EventListenerOrEventListenerObject) => {
+    if (type === 'online') {
+      console.log(`Intercepted online removeEventListener`);
+      onlineListeners.delete(listener);
+    } else if (type === 'offline') {
+      console.log(`Intercepted offline removeEventListener`);
+      offlineListeners.delete(listener);
+    } else {
+      return originalRemoveEventListener(type, listener);
+    }
+  },
+});
+
+// // TODO: Remove this (for local dev only).
+// (window as any).simulateOnline = () => {
+//   isOnline = true;
+
+//   console.log(`Running online listeners, count: ${onlineListeners.size}`);
+//   onlineListeners.forEach((listener) => {
+//     if (typeof listener === 'function') {
+//       listener(makeWindowEvent('online'));
+//     } else if (listener.handleEvent) {
+//       listener.handleEvent(makeWindowEvent('online'));
+//     }
+//   });
+// };
+
+// // TODO: Remove this (for local dev only).
+// (window as any).simulateOffline = () => {
+//   isOnline = false;
+
+//   console.log(`Running offline listeners, count: ${offlineListeners.size}`);
+//   offlineListeners.forEach((listener) => {
+//     if (typeof listener === 'function') {
+//       listener(makeWindowEvent('offline'));
+//     } else if (listener.handleEvent) {
+//       listener.handleEvent(makeWindowEvent('offline'));
+//     }
+//   });
+// };

package/src/types.ts

@@ -139,6 +139,11 @@ export interface PresentationWindowRenderer {
 
   // Called when unmuting a window.
   unMuteWindow(windowId: string): void;
+
+  // Called when sending isOnline status to the inner window. This is used to override
+  // the navigator.isOnline property in the inner window. This is only defined for Electron
+  // renderers. Browser renderers do not need to override navigator.isOnline.
+  sendOnlineStatus?(windowId: string, isOnline: boolean): void;
 }
 
 export interface OpenChildWindowOptions {