@raydiant/playlist-window-manager 0.24.1 → 0.25.0

package/build/PresentationWindow.d.ts

@@ -68,6 +68,8 @@ export default class PresentationWindow {
     private paymentSubscriptions;
     private createObjectURLResolvers;
     private createObjectURLTimeouts;
+    private interruptLocks;
+    private previouslyLocked;
     constructor(options: PresentationWindowOptions);
     load(): Promise<void>;
     show(isFocused?: boolean): void;
@@ -147,4 +149,9 @@ export default class PresentationWindow {
     private isValidOpenChildWindowPayload;
     private shouldMute;
     private createObjectURLForEmbeddedApp;
+    private createInterruptLock;
+    private renewInterruptLock;
+    private releaseInterruptLock;
+    private createLockTimeout;
+    private runInterruptCallback;
 }

package/build/PresentationWindow.js

@@ -100,6 +100,22 @@ var isValidChargeRequest = function (value) {
         typeof value.requestId === 'string' &&
         typeof value.amount === 'number';
 };
+var isValidAcquireLockRequest = function (value) {
+    return value && typeof value === 'object' && typeof value.requestId === 'string';
+};
+var isValidRenewLockRequest = function (value) {
+    return value &&
+        typeof value === 'object' &&
+        typeof value.requestId === 'string' &&
+        typeof value.lockId === 'string';
+};
+var isValidReleaseLockRequest = function (value) {
+    return value &&
+        typeof value === 'object' &&
+        typeof value.requestId === 'string' &&
+        typeof value.lockId === 'string';
+};
+var lockDuration = 1000 * 60; // 1 minute
 var PresentationWindow = /** @class */ (function () {
     function PresentationWindow(options) {
         var _this = this;
@@ -131,8 +147,10 @@ var PresentationWindow = /** @class */ (function () {
         this.paymentSubscriptions = new Set();
         this.createObjectURLResolvers = {};
         this.createObjectURLTimeouts = {};
+        this.interruptLocks = {};
+        this.previouslyLocked = false;
         this.handleEmbeddedMessage = function (type, payload) { return __awaiter(_this, void 0, void 0, function () {
-            var windowId, workerState;
+            var windowId, workerState, lock, lock, lock;
             return __generator(this, function (_a) {
                 windowId = this.options.windowId;
                 switch (type) {
@@ -296,6 +314,48 @@ var PresentationWindow = /** @class */ (function () {
                         }
                         break;
                     }
+                    case 'runtime-acquire-interrupt-lock-request': {
+                        if (isValidAcquireLockRequest(payload)) {
+                            this.logInfo("Received 'runtime-acquire-interrupt-lock-request'");
+                            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: ".concat(payload));
+                        }
+                        break;
+                    }
+                    case 'runtime-renew-interrupt-lock-request': {
+                        if (isValidRenewLockRequest(payload)) {
+                            this.logInfo("Received 'runtime-renew-interrupt-lock-request'");
+                            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: ".concat(payload));
+                        }
+                        break;
+                    }
+                    case 'runtime-release-interrupt-lock-request': {
+                        if (isValidReleaseLockRequest(payload)) {
+                            this.logInfo("Received 'runtime-release-interrupt-lock-request'");
+                            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: ".concat(payload));
+                        }
+                        break;
+                    }
                     default: {
                         this.logWarning("Received unknown embedded message type: ".concat(type));
                     }
@@ -557,8 +617,29 @@ var PresentationWindow = /** @class */ (function () {
         return !!this.error;
     };
     PresentationWindow.prototype.isLocked = function () {
-        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 '".concat(this.options.windowId, "' is locked due to enableInterruptLock"));
+            return true;
+        }
+        if (Object.values(this.isChildWindowLocked).some(Boolean)) {
+            this.logDebug("Window '".concat(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).
+        var now = +new Date();
+        var isExpired = function (lock) { return lock.expiresAt < now; };
+        if (!Object.values(this.interruptLocks).every(isExpired)) {
+            this.logDebug("Window '".concat(this.options.windowId, "' is locked due to interrupt lock"));
+            return true;
+        }
+        if (Object.values(this.windowManagers).some(function (wm) { return wm.isLocked(); })) {
+            this.logDebug("Window '".concat(this.options.windowId, "' is locked due to interrupt lock on child windows"));
+            return true;
+        }
+        return false;
     };
     PresentationWindow.prototype.setPresentation = function (presentation, playlistWindowManagerState, ruleEngineState) {
         this.presentation = presentation;
@@ -952,8 +1033,24 @@ var PresentationWindow = /** @class */ (function () {
                             themeOverride: themeOverride,
                             forceMute: forceMute,
                             isPreview: isPreview,
-                            onEnableInterruptLock: function () { return _this.enableInteruptLock(windowName); },
-                            onDisableInterruptLock: function () { return _this.disableInteruptLock(windowName); },
+                            onEnableInterruptLock: function () {
+                                // 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: function () {
+                                if (_this.isEmbeddedApp()) {
+                                    _this.runInterruptCallback();
+                                }
+                                else {
+                                    _this.disableInteruptLock(windowName);
+                                }
+                            },
                             getTerminal: this.options.getTerminal,
                         });
                         // Hook up child window manager events to bubble up to the parent.
@@ -1015,6 +1112,8 @@ var PresentationWindow = /** @class */ (function () {
             this.logWarning("Failed to close child window manager for '".concat(windowName, "'."));
         }
     };
+    // Legacy enable interrupt lock for RaydiantKit apps (ie. Virtual Rooms). This has been
+    // replaced by createInterruptLock for embedded apps.
     PresentationWindow.prototype.enableInteruptLock = function (windowName) {
         if (windowName) {
             this.isChildWindowLocked[windowName] = true;
@@ -1022,11 +1121,12 @@ var PresentationWindow = /** @class */ (function () {
         else {
             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.
     PresentationWindow.prototype.disableInteruptLock = function (windowName) {
         if (windowName) {
             this.isChildWindowLocked[windowName] = false;
@@ -1034,7 +1134,6 @@ var PresentationWindow = /** @class */ (function () {
         else {
             this.isWindowLocked = false;
         }
-        // If the presentation is ready and unlocked, trigger the disable interrupt callback.
         if (this.isReady() &&
             !this.isLocked() &&
             this.disableInterruptLockCallback) {
@@ -1200,6 +1299,79 @@ var PresentationWindow = /** @class */ (function () {
             return '';
         });
     };
+    PresentationWindow.prototype.createInterruptLock = function () {
+        var lockId = (0, uuid_1.v4)();
+        var lock = {
+            id: lockId,
+            expiresAt: +new Date() + lockDuration,
+            timeout: this.createLockTimeout(lockId),
+        };
+        this.interruptLocks[lock.id] = lock;
+        this.runInterruptCallback();
+        return lock;
+    };
+    PresentationWindow.prototype.renewInterruptLock = function (id) {
+        var 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: id,
+                expiresAt: +new Date() + lockDuration,
+                timeout: this.createLockTimeout(id),
+            };
+            this.interruptLocks[lock.id] = lock;
+        }
+        this.runInterruptCallback();
+        return lock;
+    };
+    PresentationWindow.prototype.releaseInterruptLock = function (id) {
+        var 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: id, expiresAt: 0, timeout: null };
+        }
+        this.runInterruptCallback();
+        return lock;
+    };
+    PresentationWindow.prototype.createLockTimeout = function (id) {
+        var _this = this;
+        return setTimeout(function () {
+            _this.logInfo("Interrupt lock expired, releasing: ".concat(id));
+            _this.releaseInterruptLock(id);
+        }, lockDuration);
+    };
+    PresentationWindow.prototype.runInterruptCallback = function () {
+        var 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;
+    };
     return PresentationWindow;
 }());
 exports.default = PresentationWindow;

package/build/PresentationWindow.test.js

@@ -337,4 +337,70 @@ describe('payments', function () {
         });
     }); });
 });
+describe('interrupt locks', function () {
+    test('acquire, renew, release lock', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var testRenderer, onEnableInterruptLock, onDisableInterruptLock, window, sendMessageObjectCall, lock, renewLockSendMessageObjectCall, renewedLock, releaseLockSendMessageObjectCall, releasedLock;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    testRenderer = (0, testUtils_1.createRenderer)();
+                    onEnableInterruptLock = jest.fn();
+                    onDisableInterruptLock = jest.fn();
+                    window = (0, testUtils_1.createPresentationWindow)({
+                        windowId: 'test-interrupt-lock-window-id',
+                        presentation: (0, testUtils_1.createPresentation)(),
+                        applicationVersion: (0, testUtils_1.createApplicationVersion)({
+                            embeddedUrlFormat: 'http://test.local/:input',
+                        }),
+                        renderer: testRenderer,
+                    });
+                    window.onEnableInterruptLock(onEnableInterruptLock);
+                    window.onDisableInterruptLock(onDisableInterruptLock);
+                    return [4 /*yield*/, window.load()];
+                case 1:
+                    _a.sent();
+                    // Acquire lock.
+                    testRenderer.runReceiveMessageCallback('runtime-acquire-interrupt-lock-request', { requestId: 'acquire-request' });
+                    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');
+                    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.
+                    return [4 /*yield*/, delay(1)];
+                case 2:
+                    // Wait 1ms to make sure we have a different expiresAt value.
+                    _a.sent();
+                    // Renew lock.
+                    testRenderer.runReceiveMessageCallback('runtime-renew-interrupt-lock-request', { requestId: 'renew-request', lockId: lock.id });
+                    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');
+                    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 });
+                    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');
+                    releasedLock = releaseLockSendMessageObjectCall[2].lock;
+                    expect(releasedLock.id).toBe(lock.id);
+                    expect(releasedLock.expiresAt).toBe(renewedLock.expiresAt);
+                    // Ensure onDisableInterruptLock is called.
+                    expect(onDisableInterruptLock).toHaveBeenCalled();
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+});
 // TODO: Backfill tests for all legacy and embedded apps.

package/build/types.d.ts

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

package/package.json

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

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