@raydiant/playlist-window-manager 0.24.1 → 0.25.1-canary.0

package/src/PresentationWindow.test.ts

@@ -330,4 +330,99 @@ describe('payments', () => {
   });
 });
 
+describe('interrupt locks', () => {
+  test('acquire, renew, release lock', async () => {
+    const testRenderer = createRenderer();
+
+    const onEnableInterruptLock = jest.fn();
+    const onDisableInterruptLock = jest.fn();
+
+    const window = createPresentationWindow({
+      windowId: 'test-interrupt-lock-window-id',
+      presentation: createPresentation(),
+      applicationVersion: createApplicationVersion({
+        embeddedUrlFormat: 'http://test.local/:input',
+      }),
+      renderer: testRenderer,
+    });
+
+    window.onEnableInterruptLock(onEnableInterruptLock);
+    window.onDisableInterruptLock(onDisableInterruptLock);
+
+    await window.load();
+
+    // Acquire lock.
+    testRenderer.runReceiveMessageCallback(
+      'runtime-acquire-interrupt-lock-request',
+      { requestId: 'acquire-request' }
+    );
+
+    // Ensure lock response is sent.
+    const sendMessageObjectCall = testRenderer.sendMessageObject.mock.calls[0];
+    expect(sendMessageObjectCall[0]).toBe('test-interrupt-lock-window-id');
+    expect(sendMessageObjectCall[1]).toBe(
+      'runtime-acquire-interrupt-lock-response'
+    );
+    expect(sendMessageObjectCall[2].requestId).toBe('acquire-request');
+    const lock = sendMessageObjectCall[2].lock;
+    expect(typeof lock.id).toBe('string');
+    expect(lock.id).toBeTruthy();
+    expect(typeof lock.expiresAt).toBe('number');
+    expect(lock.expiresAt).toBeTruthy();
+
+    expect(onEnableInterruptLock).toHaveBeenCalled();
+
+    // Wait 1ms to make sure we have a different expiresAt value.
+    await delay(1);
+
+    // Renew lock.
+    testRenderer.runReceiveMessageCallback(
+      'runtime-renew-interrupt-lock-request',
+      { requestId: 'renew-request', lockId: lock.id }
+    );
+
+    // Ensure renew lock response is sent.
+    const renewLockSendMessageObjectCall =
+      testRenderer.sendMessageObject.mock.calls[1];
+    expect(renewLockSendMessageObjectCall[0]).toBe(
+      'test-interrupt-lock-window-id'
+    );
+    expect(renewLockSendMessageObjectCall[1]).toBe(
+      'runtime-renew-interrupt-lock-response'
+    );
+    expect(renewLockSendMessageObjectCall[2].requestId).toBe('renew-request');
+    const renewedLock = renewLockSendMessageObjectCall[2].lock;
+    expect(renewedLock.id).toBe(lock.id);
+    expect(renewedLock.expiresAt).toBeGreaterThan(lock.expiresAt);
+
+    // Ensure onEnableInterruptLock is not called again.
+    expect(onEnableInterruptLock).toHaveBeenCalledTimes(1);
+
+    // Release lock.
+    testRenderer.runReceiveMessageCallback(
+      'runtime-release-interrupt-lock-request',
+      { requestId: 'release-request', lockId: lock.id }
+    );
+
+    // Ensure release lock response is sent.
+    const releaseLockSendMessageObjectCall =
+      testRenderer.sendMessageObject.mock.calls[2];
+    expect(releaseLockSendMessageObjectCall[0]).toBe(
+      'test-interrupt-lock-window-id'
+    );
+    expect(releaseLockSendMessageObjectCall[1]).toBe(
+      'runtime-release-interrupt-lock-response'
+    );
+    expect(releaseLockSendMessageObjectCall[2].requestId).toBe(
+      'release-request'
+    );
+    const releasedLock = releaseLockSendMessageObjectCall[2].lock;
+    expect(releasedLock.id).toBe(lock.id);
+    expect(releasedLock.expiresAt).toBe(renewedLock.expiresAt);
+
+    // Ensure onDisableInterruptLock is called.
+    expect(onDisableInterruptLock).toHaveBeenCalled();
+  });
+});
+
 // TODO: Backfill tests for all legacy and embedded apps.

package/src/PresentationWindow.ts

@@ -24,6 +24,7 @@ import {
   ChargeRequest,
   ChargeResponse,
   Terminal,
+  InterruptLock,
 } from './types';
 
 export interface PresentationWindowOptions {
@@ -81,6 +82,29 @@ const isValidChargeRequest = (value: any): value is ChargeRequest =>
   typeof value.requestId === 'string' &&
   typeof value.amount === 'number';
 
+const isValidAcquireLockRequest = (
+  value: any
+): value is { requestId: string } =>
+  value && typeof value === 'object' && typeof value.requestId === 'string';
+
+const isValidRenewLockRequest = (
+  value: any
+): value is { requestId: string; lockId: string } =>
+  value &&
+  typeof value === 'object' &&
+  typeof value.requestId === 'string' &&
+  typeof value.lockId === 'string';
+
+const isValidReleaseLockRequest = (
+  value: any
+): value is { requestId: string; lockId: string } =>
+  value &&
+  typeof value === 'object' &&
+  typeof value.requestId === 'string' &&
+  typeof value.lockId === 'string';
+
+const lockDuration = 1000 * 60; // 1 minute
+
 export default class PresentationWindow {
   private didReceiveReady: boolean = false;
   private readyCallback: (() => void) | null = null;
@@ -124,6 +148,9 @@ export default class PresentationWindow {
     ReturnType<typeof setTimeout>
   > = {};
 
+  private interruptLocks: Record<string, InterruptLock> = {};
+  private previouslyLocked = false;
+
   constructor(private options: PresentationWindowOptions) {
     this.builderState = options.builderState;
     this.presentation = options.presentation;
@@ -335,10 +362,39 @@ export default class PresentationWindow {
   }
 
   public isLocked() {
-    return (
-      this.isWindowLocked ||
-      Object.values(this.isChildWindowLocked).some(Boolean)
-    );
+    // Legacy check for a lock on the current window or child windows. These are set by enableInterruptLock
+    // and disableInterruptLock, which are only used by RaydiantKit apps (ie. Virtual Rooms).
+    if (this.isWindowLocked) {
+      this.logDebug(
+        `Window '${this.options.windowId}' is locked due to enableInterruptLock`
+      );
+      return true;
+    }
+    if (Object.values(this.isChildWindowLocked).some(Boolean)) {
+      this.logDebug(
+        `Window '${this.options.windowId}' is locked due to enableInterruptLock on child windows`
+      );
+      return true;
+    }
+
+    // Check interrupt locks on current window or child windows, used by embedded apps (apps created through
+    // the Developer Portal).
+    const now = +new Date();
+    const isExpired = (lock: InterruptLock) => lock.expiresAt < now;
+    if (!Object.values(this.interruptLocks).every(isExpired)) {
+      this.logDebug(
+        `Window '${this.options.windowId}' is locked due to interrupt lock`
+      );
+      return true;
+    }
+    if (Object.values(this.windowManagers).some((wm) => wm.isLocked())) {
+      this.logDebug(
+        `Window '${this.options.windowId}' is locked due to interrupt lock on child windows`
+      );
+      return true;
+    }
+
+    return false;
   }
 
   public setPresentation(
@@ -783,8 +839,22 @@ export default class PresentationWindow {
         themeOverride,
         forceMute,
         isPreview,
-        onEnableInterruptLock: () => this.enableInteruptLock(windowName),
-        onDisableInterruptLock: () => this.disableInteruptLock(windowName),
+        onEnableInterruptLock: () => {
+          // enableInterruptLock is only used by legacy RaydiantKit apps (ie. Virtual Rooms), while
+          // runInterruptCallback is used by Developer Portal apps.
+          if (this.isEmbeddedApp()) {
+            this.runInterruptCallback();
+          } else {
+            this.enableInteruptLock(windowName);
+          }
+        },
+        onDisableInterruptLock: () => {
+          if (this.isEmbeddedApp()) {
+            this.runInterruptCallback();
+          } else {
+            this.disableInteruptLock(windowName);
+          }
+        },
         getTerminal: this.options.getTerminal,
       });
 
@@ -847,6 +917,8 @@ export default class PresentationWindow {
     }
   }
 
+  // Legacy enable interrupt lock for RaydiantKit apps (ie. Virtual Rooms). This has been
+  // replaced by createInterruptLock for embedded apps.
   private enableInteruptLock(windowName?: string) {
     if (windowName) {
       this.isChildWindowLocked[windowName] = true;
@@ -854,12 +926,13 @@ export default class PresentationWindow {
       this.isWindowLocked = true;
     }
 
-    // If the presentation is ready and locked, trigger the enable interrupt callback.
     if (this.isReady() && this.isLocked() && this.enableInterruptLockCallback) {
       this.enableInterruptLockCallback();
     }
   }
 
+  // Legacy disable interrupt lock for RaydiantKit apps (ie. Virtual Rooms). This has been
+  // replaced by releaseInterruptLock for embedded apps.
   private disableInteruptLock(windowName?: string) {
     if (windowName) {
       this.isChildWindowLocked[windowName] = false;
@@ -867,7 +940,6 @@ export default class PresentationWindow {
       this.isWindowLocked = false;
     }
 
-    // If the presentation is ready and unlocked, trigger the disable interrupt callback.
     if (
       this.isReady() &&
       !this.isLocked() &&
@@ -1105,6 +1177,61 @@ export default class PresentationWindow {
         break;
       }
 
+      case 'runtime-acquire-interrupt-lock-request': {
+        if (isValidAcquireLockRequest(payload)) {
+          this.logInfo(`Received 'runtime-acquire-interrupt-lock-request'`);
+
+          const lock = this.createInterruptLock();
+
+          this.sendMessageObject('runtime-acquire-interrupt-lock-response', {
+            requestId: payload.requestId,
+            lock: { id: lock.id, expiresAt: lock.expiresAt },
+          });
+        } else {
+          this.logWarning(
+            `Invalid payload for runtime-acquire-interrupt-lock-request message: ${payload}`
+          );
+        }
+
+        break;
+      }
+
+      case 'runtime-renew-interrupt-lock-request': {
+        if (isValidRenewLockRequest(payload)) {
+          this.logInfo(`Received 'runtime-renew-interrupt-lock-request'`);
+
+          const lock = this.renewInterruptLock(payload.lockId);
+
+          this.sendMessageObject('runtime-renew-interrupt-lock-response', {
+            requestId: payload.requestId,
+            lock: { id: lock.id, expiresAt: lock.expiresAt },
+          });
+        } else {
+          this.logWarning(
+            `Invalid payload for runtime-renew-interrupt-lock-request message: ${payload}`
+          );
+        }
+        break;
+      }
+
+      case 'runtime-release-interrupt-lock-request': {
+        if (isValidReleaseLockRequest(payload)) {
+          this.logInfo(`Received 'runtime-release-interrupt-lock-request'`);
+
+          const lock = this.releaseInterruptLock(payload.lockId);
+
+          this.sendMessageObject('runtime-release-interrupt-lock-response', {
+            requestId: payload.requestId,
+            lock: { id: lock.id, expiresAt: lock.expiresAt },
+          });
+        } else {
+          this.logWarning(
+            `Invalid payload for runtime-release-interrupt-lock-request message: ${payload}`
+          );
+        }
+        break;
+      }
+
       default: {
         this.logWarning(`Received unknown embedded message type: ${type}`);
       }
@@ -1407,6 +1534,95 @@ export default class PresentationWindow {
       return '';
     });
   }
+
+  private createInterruptLock() {
+    const lockId = uuidv4();
+    const lock = {
+      id: lockId,
+      expiresAt: +new Date() + lockDuration,
+      timeout: this.createLockTimeout(lockId),
+    };
+
+    this.interruptLocks[lock.id] = lock;
+
+    this.runInterruptCallback();
+
+    return lock;
+  }
+
+  private renewInterruptLock(id: string) {
+    let lock = this.interruptLocks[id];
+    if (lock) {
+      // Reset expiration time.
+      lock.expiresAt = +new Date() + lockDuration;
+
+      // Reset timeout.
+      if (lock.timeout) {
+        clearTimeout(lock.timeout);
+      }
+      lock.timeout = this.createLockTimeout(id);
+    } else {
+      // If the lock doesn't exist it was already released, create a new lock with the same id.
+      lock = {
+        id,
+        expiresAt: +new Date() + lockDuration,
+        timeout: this.createLockTimeout(id),
+      };
+
+      this.interruptLocks[lock.id] = lock;
+    }
+
+    this.runInterruptCallback();
+
+    return lock;
+  }
+
+  private releaseInterruptLock(id: string) {
+    let lock = this.interruptLocks[id];
+    if (lock) {
+      if (lock.timeout) {
+        clearTimeout(lock.timeout);
+      }
+      delete this.interruptLocks[id];
+    } else {
+      // If the lock doesn't exist it was already released, return a fake lock object to
+      // send a response back to the running app.
+      lock = { id, expiresAt: 0, timeout: null };
+    }
+
+    this.runInterruptCallback();
+
+    return lock;
+  }
+
+  private createLockTimeout(id: string) {
+    return setTimeout(() => {
+      this.logInfo(`Interrupt lock expired, releasing: ${id}`);
+      this.releaseInterruptLock(id);
+    }, lockDuration);
+  }
+
+  private runInterruptCallback() {
+    const currentlyLocked = this.isLocked();
+
+    // If locked and the lock state has changed, run the interrupt lock callback.
+    // Or if not locked and the lock state has changed, run the disable interrupt lock callback.
+    if (
+      currentlyLocked &&
+      this.previouslyLocked !== currentlyLocked &&
+      this.enableInterruptLockCallback
+    ) {
+      this.enableInterruptLockCallback();
+    } else if (
+      !currentlyLocked &&
+      this.previouslyLocked !== currentlyLocked &&
+      this.disableInterruptLockCallback
+    ) {
+      this.disableInterruptLockCallback();
+    }
+
+    this.previouslyLocked = currentlyLocked;
+  }
 }
 
 const isValidCreateObjectURLResultPayload = (

package/src/types.ts

@@ -203,3 +203,9 @@ export interface ChargeResponse {
 export interface Terminal {
   status: string;
 }
+
+export interface InterruptLock {
+  id: string;
+  expiresAt: number;
+  timeout: ReturnType<typeof setTimeout> | null;
+}

package/tasks/npm-publish.sh

@@ -10,4 +10,4 @@ mkdir build
 yarn build
 
 # Publish
-yarn publish --access public
+yarn publish --non-interactive --access public

package/build/PresentationWindow.test.d.ts

@@ -1 +0,0 @@
-export {};