@raydiant/playlist-window-manager 0.29.1 → 0.30.0

package/build/SurfaceBroker.js

@@ -0,0 +1,311 @@
+"use strict";
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SurfaceRefusal = exports.DEFAULT_SHOW_AFTER_REVEAL_MS = exports.DEFAULT_SURFACE_SWAP_DELAY_MS = exports.MAX_LIVE_SURFACES = exports.SURFACE_FIRST_FRAME_DEADLINE_MS = exports.SURFACE_OPEN_DEADLINE_MS = void 0;
+// How long the host's openVideo may take to resolve.
+exports.SURFACE_OPEN_DEADLINE_MS = 2000;
+// From openVideo resolving to first_frame. Inside the 30-second ready timeout,
+// with time left for the app to fall back to <video> and still be ready.
+exports.SURFACE_FIRST_FRAME_DEADLINE_MS = 10000;
+// One playing and one prepared.
+exports.MAX_LIVE_SURFACES = 2;
+// How long a surface swap waits for the incoming window's first paint, and
+// how long showing a surface may take, when closeWindowDelayMs is not set:
+// 1000 ms, the closeWindowDelayMs the player passes.
+exports.DEFAULT_SURFACE_SWAP_DELAY_MS = 1000;
+// SurfaceHost.showAfterRevealMs when the player sets none. On the Signage
+// Stick (Fire OS 8.4, Amazon WebView 136, portrait) the WebView takes about
+// 80-120 ms longer than a surface to put a reveal on screen: 60 ms left the
+// theme trailing the picture by up to 35 ms, and 100 ms put it ahead by up
+// to 54 ms.
+exports.DEFAULT_SHOW_AFTER_REVEAL_MS = 80;
+// Rejects an open. `closed` means the window gave the surface up before the
+// open finished, which needs no answer to the app.
+var SurfaceRefusal = /** @class */ (function (_super) {
+    __extends(SurfaceRefusal, _super);
+    function SurfaceRefusal(reason) {
+        var _this = _super.call(this, "Video surface refused: ".concat(reason)) || this;
+        _this.reason = reason;
+        _this.name = 'SurfaceRefusal';
+        Object.setPrototypeOf(_this, SurfaceRefusal.prototype);
+        return _this;
+    }
+    return SurfaceRefusal;
+}(Error));
+exports.SurfaceRefusal = SurfaceRefusal;
+// The host rejects with an Error whose message is a short machine code.
+var reasonOf = function (err) {
+    if (err instanceof SurfaceRefusal && err.reason !== 'closed') {
+        return err.reason;
+    }
+    var code = typeof err === 'string'
+        ? err
+        : err && typeof err === 'object'
+            ? err.message
+            : undefined;
+    return code === 'no_decoder' ? 'no_decoder' : 'unsupported';
+};
+// Holds every video surface one window manager has open, so the manager never
+// asks the host for more than two at once and opens the next only after the
+// outgoing one has closed, leaving the host an idle decoder to reuse.
+var SurfaceBroker = /** @class */ (function () {
+    function SurfaceBroker(host, logger) {
+        this.host = host;
+        this.logger = logger;
+        this.entries = {};
+    }
+    // Resolves once the host has opened a hidden surface. Rejects with a
+    // SurfaceRefusal. A first frame later than its deadline closes the surface
+    // and reports it through onRefused instead.
+    SurfaceBroker.prototype.open = function (windowId, opts, onEvent, onRefused) {
+        return __awaiter(this, void 0, void 0, function () {
+            var markClosed, closed, entry, pending_1, surface, retried, err_1, reason, pending_2;
+            var _this = this;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        markClosed = function () { return undefined; };
+                        closed = new Promise(function (resolve) {
+                            markClosed = resolve;
+                        });
+                        entry = {
+                            windowId: windowId,
+                            label: opts.label,
+                            surface: null,
+                            state: 'opening',
+                            leaving: false,
+                            firstFrameTimer: null,
+                            closePromise: null,
+                            closed: closed,
+                            markClosed: markClosed,
+                        };
+                        this.entries[windowId] = entry;
+                        _a.label = 1;
+                    case 1:
+                        this.throwIfGivenUp(entry);
+                        pending_1 = this.pendingCloses(entry);
+                        if (!(pending_1.length > 0)) return [3 /*break*/, 3];
+                        return [4 /*yield*/, Promise.all(pending_1)];
+                    case 2:
+                        _a.sent();
+                        return [3 /*break*/, 4];
+                    case 3:
+                        if (this.liveOthers(entry).length >= exports.MAX_LIVE_SURFACES) {
+                            throw this.refuse(entry, 'no_decoder');
+                        }
+                        return [3 /*break*/, 5];
+                    case 4: return [3 /*break*/, 1];
+                    case 5:
+                        retried = false;
+                        _a.label = 6;
+                    case 6:
+                        this.throwIfGivenUp(entry);
+                        _a.label = 7;
+                    case 7:
+                        _a.trys.push([7, 9, , 12]);
+                        return [4 /*yield*/, this.openWithDeadline(opts)];
+                    case 8:
+                        surface = _a.sent();
+                        return [3 /*break*/, 13];
+                    case 9:
+                        err_1 = _a.sent();
+                        this.throwIfGivenUp(entry);
+                        reason = reasonOf(err_1);
+                        pending_2 = this.pendingCloses(entry);
+                        if (!(reason === 'no_decoder' && !retried && pending_2.length > 0)) return [3 /*break*/, 11];
+                        retried = true;
+                        return [4 /*yield*/, Promise.all(pending_2)];
+                    case 10:
+                        _a.sent();
+                        return [3 /*break*/, 12];
+                    case 11: throw this.refuse(entry, reason);
+                    case 12: return [3 /*break*/, 6];
+                    case 13:
+                        if (entry.state === 'closed') {
+                            surface.close();
+                            throw new SurfaceRefusal('closed');
+                        }
+                        entry.surface = surface;
+                        entry.state = 'open';
+                        entry.firstFrameTimer = setTimeout(function () {
+                            entry.firstFrameTimer = null;
+                            _this.warnRefusal(entry, 'deadline');
+                            _this.close(windowId);
+                            onRefused('deadline');
+                        }, exports.SURFACE_FIRST_FRAME_DEADLINE_MS);
+                        surface.onEvent(function (e) {
+                            if (entry.state !== 'open')
+                                return;
+                            if (e.type === 'first_frame') {
+                                if (!entry.firstFrameTimer)
+                                    return;
+                                clearTimeout(entry.firstFrameTimer);
+                                entry.firstFrameTimer = null;
+                            }
+                            onEvent(e);
+                        });
+                        return [2 /*return*/, surface];
+                }
+            });
+        });
+    };
+    // A swap has started for this window's surface; its close follows.
+    SurfaceBroker.prototype.leaving = function (windowId) {
+        var entry = this.entries[windowId];
+        if (entry)
+            entry.leaving = true;
+    };
+    // Closes the window's surface, or gives up its open. Idempotent.
+    SurfaceBroker.prototype.close = function (windowId) {
+        var _this = this;
+        var entry = this.entries[windowId];
+        if (!entry)
+            return Promise.resolve();
+        if (entry.closePromise)
+            return entry.closePromise;
+        if (entry.firstFrameTimer) {
+            clearTimeout(entry.firstFrameTimer);
+            entry.firstFrameTimer = null;
+        }
+        var surface = entry.surface;
+        if (!surface) {
+            // Still opening: open() closes a handle that resolves from here on.
+            this.forget(entry);
+            return Promise.resolve();
+        }
+        entry.state = 'closing';
+        entry.closePromise = surface
+            .close()
+            .catch(function (err) {
+            _this.logger.warn("Failed to close video surface for window '".concat(windowId, "' with '").concat(err && err.message, "'"), { windowId: windowId, presentationId: entry.label });
+        })
+            .then(function () { return _this.forget(entry); });
+        return entry.closePromise;
+    };
+    SurfaceBroker.prototype.closeAll = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            var _this = this;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, Promise.all(Object.keys(this.entries).map(function (id) { return _this.close(id); }))];
+                    case 1:
+                        _a.sent();
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    // A window's hole opened or closed.
+    SurfaceBroker.prototype.onHole = function (open) {
+        this.host.onHole(open);
+    };
+    SurfaceBroker.prototype.openWithDeadline = function (opts) {
+        var _this = this;
+        return new Promise(function (resolve, reject) {
+            var settled = false;
+            var timer = setTimeout(function () {
+                settled = true;
+                reject(new SurfaceRefusal('deadline'));
+            }, exports.SURFACE_OPEN_DEADLINE_MS);
+            new Promise(function (r) { return r(_this.host.openVideo(opts)); }).then(function (surface) {
+                if (settled) {
+                    // A late handle never holds a decoder nobody uses.
+                    surface.close();
+                    return;
+                }
+                settled = true;
+                clearTimeout(timer);
+                resolve(surface);
+            }, function (err) {
+                if (settled)
+                    return;
+                settled = true;
+                clearTimeout(timer);
+                reject(err);
+            });
+        });
+    };
+    SurfaceBroker.prototype.throwIfGivenUp = function (entry) {
+        if (entry.state === 'closed') {
+            throw new SurfaceRefusal('closed');
+        }
+    };
+    SurfaceBroker.prototype.liveOthers = function (entry) {
+        var _this = this;
+        return Object.keys(this.entries)
+            .map(function (id) { return _this.entries[id]; })
+            .filter(function (e) { return e !== entry && e.state !== 'closed'; });
+    };
+    SurfaceBroker.prototype.pendingCloses = function (entry) {
+        return this.liveOthers(entry)
+            .filter(function (e) { return e.state === 'closing' || e.leaving; })
+            .map(function (e) { return e.closed; });
+    };
+    SurfaceBroker.prototype.refuse = function (entry, reason) {
+        this.forget(entry);
+        this.warnRefusal(entry, reason);
+        return new SurfaceRefusal(reason);
+    };
+    SurfaceBroker.prototype.warnRefusal = function (entry, reason) {
+        this.logger.warn("Sending 'video_refused' to window '".concat(entry.windowId, "', reason=").concat(reason), { windowId: entry.windowId, presentationId: entry.label, reason: reason });
+    };
+    SurfaceBroker.prototype.forget = function (entry) {
+        entry.state = 'closed';
+        if (this.entries[entry.windowId] === entry) {
+            delete this.entries[entry.windowId];
+        }
+        entry.markClosed();
+    };
+    return SurfaceBroker;
+}());
+exports.default = SurfaceBroker;

package/build/SurfaceBroker.test.d.ts

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