@raydiant/playlist-window-manager 0.0.0-test36 → 0.0.1-test2

package/build/BrowserWindowRenderer.js

@@ -86,6 +86,11 @@ var BrowserWindowRenderer = /** @class */ (function () {
         // Create a hidden window to preload BrowserViews.
         this.offscreenWindow = new electron_1.BrowserWindow({
             show: false,
+            /**
+             * This option fixes window not being able to take fullscreen leaving
+             * 1px gap at the right and bottom of the screen.
+             */
+            resizable: false,
             frame: this.opts.frame,
             hasShadow: this.opts.hasShadow,
             webPreferences: {
@@ -124,6 +129,11 @@ var BrowserWindowRenderer = /** @class */ (function () {
                                 })
                                 : this.createOrGetPooledBrowserWindow(windowId, {
                                     show: false,
+                                    /**
+                                     * This option fixes window not being able to take fullscreen leaving
+                                     * 1px gap at the right and bottom of the screen.
+                                     */
+                                    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.
@@ -449,8 +459,6 @@ var BrowserWindowRenderer = /** @class */ (function () {
                 this.browserViewPool.add(browserView);
             }
         }
-        this.logger.info("Opening devTools", { windowId: windowId });
-        browserView.webContents.openDevTools();
         return browserView;
     };
     BrowserWindowRenderer.prototype.destroyOrUnloadPooledBrowserView = function (windowId, browserView) {

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

@@ -81,7 +81,7 @@ var PlaylistWindowManager_1 = __importDefault(require("./PlaylistWindowManager")
 var WindowTimeoutError_1 = __importDefault(require("./WindowTimeoutError"));
 var WindowLoadError_1 = __importDefault(require("./WindowLoadError"));
 // TODO: Automatically inject latest version when building in CI.
-var defaultAppRendererUrl = 'https://apps.raydiant.com/3.0.7/index.html';
+var defaultAppRendererUrl = 'https://apps.raydiant.com/3.1.0/index.html';
 var isValidNumber = function (value) {
     return typeof value === 'number' && !isNaN(value);
 };
@@ -98,8 +98,27 @@ var isValidChargeRequest = function (value) {
     return value &&
         typeof value === 'object' &&
         typeof value.requestId === 'string' &&
-        typeof value.amount === 'number';
+        typeof value.subTotal === 'number' &&
+        typeof value.tip === 'number' &&
+        typeof value.tax === 'number' &&
+        typeof value.total === '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 +150,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 +317,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 +620,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 +1036,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 +1115,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 +1124,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 +1137,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 +1302,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

@@ -260,11 +260,17 @@ describe('payments', function () {
                     _a.sent();
                     testRenderer.runReceiveMessageCallback('payments-charge-request', {
                         requestId: 'test',
-                        amount: 100,
+                        subTotal: 100,
+                        tip: 1,
+                        tax: 10,
+                        total: 111,
                     });
                     expect(callback).toHaveBeenCalledWith({
                         requestId: 'test',
-                        amount: 100,
+                        subTotal: 100,
+                        tip: 1,
+                        tax: 10,
+                        total: 111,
                     });
                     // Send charge response.
                     window.sendChargeResponse({
@@ -337,4 +343,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

@@ -142,14 +142,20 @@ export interface AnalyticsEvent {
     productCategory?: string | null;
 }
 export interface ChargeRequest {
+    orderId?: string;
     requestId: string;
-    amount: number;
+    subTotal: number;
+    tip: number;
+    tax: number;
+    total: number;
     items: Array<{
         name: string;
-        price: number;
         description?: string;
         sku?: string;
-        quantity?: number;
+        price: number;
+        quantity: number;
+        tax: number;
+        total: number;
     }>;
 }
 export interface Charge {
@@ -166,3 +172,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.0.0-test36",
+  "version": "0.0.1-test2",
   "description": "Window manager for playlist playback.",
   "main": "build/index.js",
   "scripts": {
@@ -12,7 +12,7 @@
   },
   "dependencies": {
     "fast-deep-equal": "^3.1.3",
-    "@raydiant/playlist-rule-engine": "3.2.2",
+    "@raydiant/playlist-rule-engine": "3.3.0",
     "raydiant-kit": "4.7.3",
     "uuid": "^8.3.0",
     "eventemitter3": "^4.0.7"
@@ -22,7 +22,7 @@
     "@types/jschannel": "^1.0.1",
     "@types/jest": "^24.0.15",
     "@types/uuid": "8.3.0",
-    "electron": "28.1.2",
+    "electron": "33.2.0",
     "jest": "^24.8.0",
     "ts-jest": "^24.0.2",
     "typescript": "^4.1.2"

package/src/BrowserWindowRenderer.ts

@@ -63,6 +63,11 @@ export default class BrowserWindowRenderer
   // Create a hidden window to preload BrowserViews.
   private offscreenWindow = new BrowserWindow({
     show: false,
+    /**
+     * This option fixes window not being able to take fullscreen leaving
+     * 1px gap at the right and bottom of the screen.
+     */
+    resizable: false,
     frame: this.opts.frame,
     hasShadow: this.opts.hasShadow,
     webPreferences: {
@@ -110,6 +115,11 @@ export default class BrowserWindowRenderer
             })
           : this.createOrGetPooledBrowserWindow(windowId, {
               show: false,
+              /**
+               * This option fixes window not being able to take fullscreen leaving
+               * 1px gap at the right and bottom of the screen.
+               */
+              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.
@@ -519,9 +529,6 @@ export default class BrowserWindowRenderer
       }
     }
 
-    this.logger.info(`Opening devTools`, { windowId });
-    browserView.webContents.openDevTools();
-
     return browserView;
   }
 

package/src/PresentationWindow.test.ts

@@ -238,12 +238,18 @@ describe('payments', () => {
 
     testRenderer.runReceiveMessageCallback('payments-charge-request', {
       requestId: 'test',
-      amount: 100,
+      subTotal: 100,
+      tip: 1,
+      tax: 10,
+      total: 111,
     });
 
     expect(callback).toHaveBeenCalledWith({
       requestId: 'test',
-      amount: 100,
+      subTotal: 100,
+      tip: 1,
+      tax: 10,
+      total: 111,
     });
 
     // Send charge response.
@@ -330,4 +336,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 {
@@ -61,7 +62,7 @@ export interface PresentationWindowOptions {
 }
 
 // TODO: Automatically inject latest version when building in CI.
-const defaultAppRendererUrl = 'https://apps.raydiant.com/3.0.7/index.html';
+const defaultAppRendererUrl = 'https://apps.raydiant.com/3.1.0/index.html';
 
 const isValidNumber = (value: any) =>
   typeof value === 'number' && !isNaN(value);
@@ -79,7 +80,33 @@ const isValidChargeRequest = (value: any): value is ChargeRequest =>
   value &&
   typeof value === 'object' &&
   typeof value.requestId === 'string' &&
-  typeof value.amount === 'number';
+  typeof value.subTotal === 'number' &&
+  typeof value.tip === 'number' &&
+  typeof value.tax === 'number' &&
+  typeof value.total === '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;
@@ -124,6 +151,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 +365,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 +842,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 +920,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 +929,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 +943,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 +1180,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 +1537,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

@@ -176,14 +176,20 @@ export interface AnalyticsEvent {
 }
 
 export interface ChargeRequest {
+  orderId?: string;
   requestId: string;
-  amount: number;
+  subTotal: number;
+  tip: number;
+  tax: number;
+  total: number;
   items: Array<{
     name: string;
-    price: number;
     description?: string;
     sku?: string;
-    quantity?: number;
+    price: number;
+    quantity: number;
+    tax: number;
+    total: number;
   }>;
 }
 
@@ -203,3 +209,9 @@ export interface ChargeResponse {
 export interface Terminal {
   status: string;
 }
+
+export interface InterruptLock {
+  id: string;
+  expiresAt: number;
+  timeout: ReturnType<typeof setTimeout> | null;
+}