@warren-bank/fx_cast_bridge 0.3.1

package/js/src/bridge/components/cast/index.js

@@ -0,0 +1,107 @@
+"use strict";
+var __importDefault =
+    (this && this.__importDefault) ||
+    function (mod) {
+        return mod && mod.__esModule ? mod : { default: mod };
+    };
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handleCastMessage = handleCastMessage;
+const Session_1 = __importDefault(require("./Session"));
+const client_1 = __importDefault(require("./client"));
+const sessions = new Map();
+function handleCastMessage(messaging, message) {
+    switch (message.subject) {
+        case "bridge:createCastSession": {
+            const { appId, receiverDevice } = message.data;
+            const session = new Session_1.default(
+                appId,
+                receiverDevice,
+                messaging,
+                sessionId => {
+                    sessions.set(sessionId, session);
+                }
+            );
+            break;
+        }
+        case "bridge:sendCastReceiverMessage": {
+            const { sessionId, messageData, messageId } = message.data;
+            const session = sessions.get(sessionId);
+            if (!session) {
+                messaging.sendMessage({
+                    subject: "cast:impl_sendMessage",
+                    data: {
+                        error: "Session does not exist",
+                        sessionId,
+                        messageId
+                    }
+                });
+                break;
+            }
+            try {
+                session.sendReceiverMessage(messageData);
+            } catch (err) {
+                messaging.sendMessage({
+                    subject: "cast:impl_sendMessage",
+                    data: {
+                        error: `Failed to send message (${err})`,
+                        sessionId,
+                        messageId
+                    }
+                });
+                break;
+            }
+            messaging.sendMessage({
+                subject: "cast:impl_sendMessage",
+                data: { sessionId, messageId }
+            });
+            break;
+        }
+        case "bridge:sendCastSessionMessage": {
+            const { namespace, sessionId, messageId } = message.data;
+            const session = sessions.get(sessionId);
+            if (!session) {
+                messaging.sendMessage({
+                    subject: "cast:impl_sendMessage",
+                    data: {
+                        error: "Session does not exist",
+                        sessionId,
+                        messageId
+                    }
+                });
+                break;
+            }
+            try {
+                let { messageData } = message.data;
+                if (typeof messageData === "string") {
+                    messageData = JSON.parse(messageData);
+                }
+                session.sendMessage(namespace, messageData);
+            } catch (err) {
+                messaging.sendMessage({
+                    subject: "cast:impl_sendMessage",
+                    data: {
+                        error: `Failed to send message (${err})`,
+                        sessionId,
+                        messageId
+                    }
+                });
+                break;
+            }
+            messaging.sendMessage({
+                subject: "cast:impl_sendMessage",
+                data: { sessionId, messageId }
+            });
+            break;
+        }
+        case "bridge:stopCastSession": {
+            const { receiverDevice } = message.data;
+            const client = new client_1.default();
+            client
+                .connect(receiverDevice.host, { port: receiverDevice.port })
+                .then(() => {
+                    client.sendReceiverMessage({ type: "STOP" });
+                });
+            break;
+        }
+    }
+}

package/js/src/bridge/components/cast/remote.js

@@ -0,0 +1,120 @@
+"use strict";
+var __importDefault =
+    (this && this.__importDefault) ||
+    function (mod) {
+        return mod && mod.__esModule ? mod : { default: mod };
+    };
+Object.defineProperty(exports, "__esModule", { value: true });
+const client_1 = __importDefault(require("./client"));
+const NS_MEDIA = "urn:x-cast:com.google.cast.media";
+class Remote extends client_1.default {
+    constructor(host, options) {
+        super();
+        this.host = host;
+        this.options = options;
+        super
+            .connect(host, {
+                port:
+                    options === null || options === void 0
+                        ? void 0
+                        : options.port,
+                onReceiverMessage: message => {
+                    this.onReceiverMessage(message);
+                }
+            })
+            .then(() => {
+                this.sendReceiverMessage({ type: "GET_STATUS" });
+            });
+    }
+    disconnect() {
+        var _a;
+        super.disconnect();
+        (_a = this.transportClient) === null || _a === void 0
+            ? void 0
+            : _a.disconnect();
+    }
+    sendMediaMessage(message) {
+        var _a;
+        (_a = this.transportClient) === null || _a === void 0
+            ? void 0
+            : _a.sendMediaMessage(message);
+    }
+    onReceiverMessage(message) {
+        var _a, _b, _c, _d, _e, _f, _g, _h;
+        if (message.type !== "RECEIVER_STATUS") {
+            return;
+        }
+        const application =
+            (_a = message.status.applications) === null || _a === void 0
+                ? void 0
+                : _a[0];
+        if (!application || application.isIdleScreen) {
+            if (this.transportClient) {
+                this.transportClient = undefined;
+                (_c =
+                    (_b = this.options) === null || _b === void 0
+                        ? void 0
+                        : _b.onApplicationClose) === null || _c === void 0
+                    ? void 0
+                    : _c.call(_b);
+            }
+        }
+        (_e =
+            (_d = this.options) === null || _d === void 0
+                ? void 0
+                : _d.onReceiverStatusUpdate) === null || _e === void 0
+            ? void 0
+            : _e.call(_d, message.status);
+        if (application && !this.transportClient) {
+            this.transportClient = new RemoteTransport(
+                application.transportId,
+                message => this.onMediaMessage(message)
+            );
+            this.transportClient
+                .connect(this.host, {
+                    port:
+                        (_f = this.options) === null || _f === void 0
+                            ? void 0
+                            : _f.port
+                })
+                .then(() => {
+                    var _a;
+                    (_a = this.transportClient) === null || _a === void 0
+                        ? void 0
+                        : _a.sendMediaMessage({
+                              type: "GET_STATUS",
+                              requestId: 0
+                          });
+                });
+            (_h =
+                (_g = this.options) === null || _g === void 0
+                    ? void 0
+                    : _g.onApplicationFound) === null || _h === void 0
+                ? void 0
+                : _h.call(_g);
+        }
+    }
+    onMediaMessage(message) {
+        var _a, _b;
+        if (message.type !== "MEDIA_STATUS") {
+            return;
+        }
+        (_b =
+            (_a = this.options) === null || _a === void 0
+                ? void 0
+                : _a.onMediaStatusUpdate) === null || _b === void 0
+            ? void 0
+            : _b.call(_a, message.status[0]);
+    }
+}
+exports.default = Remote;
+class RemoteTransport extends client_1.default {
+    constructor(transportId, onMediaMessage) {
+        super(undefined, transportId);
+        this.mediaChannel = this.createChannel(NS_MEDIA);
+        this.mediaChannel.on("message", message => onMediaMessage(message));
+    }
+    sendMediaMessage(message) {
+        this.mediaChannel.send(message);
+    }
+}

package/js/src/bridge/components/cast/types.js

@@ -0,0 +1,96 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UserAction = exports.HlsVideoSegmentFormat = void 0;
+var Capability;
+(function (Capability) {
+    Capability["VIDEO_OUT"] = "video_out";
+    Capability["AUDIO_OUT"] = "audio_out";
+    Capability["VIDEO_IN"] = "video_in";
+    Capability["AUDIO_IN"] = "audio_in";
+    Capability["MULTIZONE_GROUP"] = "multizone_group";
+})(Capability || (Capability = {}));
+var ReceiverType;
+(function (ReceiverType) {
+    ReceiverType["CAST"] = "cast";
+    ReceiverType["DIAL"] = "dial";
+    ReceiverType["HANGOUT"] = "hangout";
+    ReceiverType["CUSTOM"] = "custom";
+})(ReceiverType || (ReceiverType = {}));
+var VolumeControlType;
+(function (VolumeControlType) {
+    VolumeControlType["ATTENUATION"] = "attenuation";
+    VolumeControlType["FIXED"] = "fixed";
+    VolumeControlType["MASTER"] = "master";
+})(VolumeControlType || (VolumeControlType = {}));
+var IdleReason;
+(function (IdleReason) {
+    IdleReason["CANCELLED"] = "CANCELLED";
+    IdleReason["INTERRUPTED"] = "INTERRUPTED";
+    IdleReason["FINISHED"] = "FINISHED";
+    IdleReason["ERROR"] = "ERROR";
+})(IdleReason || (IdleReason = {}));
+var HlsSegmentFormat;
+(function (HlsSegmentFormat) {
+    HlsSegmentFormat["AAC"] = "aac";
+    HlsSegmentFormat["AC3"] = "ac3";
+    HlsSegmentFormat["MP3"] = "mp3";
+    HlsSegmentFormat["TS"] = "ts";
+    HlsSegmentFormat["TS_AAC"] = "ts_aac";
+    HlsSegmentFormat["E_AC3"] = "e_ac3";
+    HlsSegmentFormat["FMP4"] = "fmp4";
+})(HlsSegmentFormat || (HlsSegmentFormat = {}));
+var HlsVideoSegmentFormat;
+(function (HlsVideoSegmentFormat) {
+    HlsVideoSegmentFormat["MPEG2_TS"] = "mpeg2_ts";
+    HlsVideoSegmentFormat["FMP4"] = "fmp4";
+})(
+    HlsVideoSegmentFormat ||
+        (exports.HlsVideoSegmentFormat = HlsVideoSegmentFormat = {})
+);
+var MetadataType;
+(function (MetadataType) {
+    MetadataType[(MetadataType["GENERIC"] = 0)] = "GENERIC";
+    MetadataType[(MetadataType["MOVIE"] = 1)] = "MOVIE";
+    MetadataType[(MetadataType["TV_SHOW"] = 2)] = "TV_SHOW";
+    MetadataType[(MetadataType["MUSIC_TRACK"] = 3)] = "MUSIC_TRACK";
+    MetadataType[(MetadataType["PHOTO"] = 4)] = "PHOTO";
+    MetadataType[(MetadataType["AUDIOBOOK_CHAPTER"] = 5)] = "AUDIOBOOK_CHAPTER";
+})(MetadataType || (MetadataType = {}));
+var PlayerState;
+(function (PlayerState) {
+    PlayerState["IDLE"] = "IDLE";
+    PlayerState["PLAYING"] = "PLAYING";
+    PlayerState["PAUSED"] = "PAUSED";
+    PlayerState["BUFFERING"] = "BUFFERING";
+})(PlayerState || (PlayerState = {}));
+var RepeatMode;
+(function (RepeatMode) {
+    RepeatMode["OFF"] = "REPEAT_OFF";
+    RepeatMode["ALL"] = "REPEAT_ALL";
+    RepeatMode["SINGLE"] = "REPEAT_SINGLE";
+    RepeatMode["ALL_AND_SHUFFLE"] = "REPEAT_ALL_AND_SHUFFLE";
+})(RepeatMode || (RepeatMode = {}));
+var ResumeState;
+(function (ResumeState) {
+    ResumeState["PLAYBACK_START"] = "PLAYBACK_START";
+    ResumeState["PLAYBACK_PAUSE"] = "PLAYBACK_PAUSE";
+})(ResumeState || (ResumeState = {}));
+var StreamType;
+(function (StreamType) {
+    StreamType["BUFFERED"] = "BUFFERED";
+    StreamType["LIVE"] = "LIVE";
+    StreamType["OTHER"] = "OTHER";
+})(StreamType || (StreamType = {}));
+var TrackType;
+(function (TrackType) {
+    TrackType["TEXT"] = "TEXT";
+    TrackType["AUDIO"] = "AUDIO";
+    TrackType["VIDEO"] = "VIDEO";
+})(TrackType || (TrackType = {}));
+var UserAction;
+(function (UserAction) {
+    UserAction["LIKE"] = "LIKE";
+    UserAction["DISLIKE"] = "DISLIKE";
+    UserAction["FOLLOW"] = "FOLLOW";
+    UserAction["UNFOLLOW"] = "UNFOLLOW";
+})(UserAction || (exports.UserAction = UserAction = {}));

package/js/src/bridge/components/mediaServer.js

@@ -0,0 +1,231 @@
+"use strict";
+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 __importDefault =
+    (this && this.__importDefault) ||
+    function (mod) {
+        return mod && mod.__esModule ? mod : { default: mod };
+    };
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mediaServer = void 0;
+exports.startMediaServer = startMediaServer;
+exports.stopMediaServer = stopMediaServer;
+const fs_1 = __importDefault(require("fs"));
+const http_1 = __importDefault(require("http"));
+const os_1 = __importDefault(require("os"));
+const path_1 = __importDefault(require("path"));
+const stream_1 = __importDefault(require("stream"));
+const mime_types_1 = __importDefault(require("mime-types"));
+const subtitles_1 = require("../lib/subtitles");
+function startMediaServer(messaging, filePath, port) {
+    return __awaiter(this, void 0, void 0, function* () {
+        if (
+            exports.mediaServer === null || exports.mediaServer === void 0
+                ? void 0
+                : exports.mediaServer.listening
+        ) {
+            yield stopMediaServer();
+        }
+        let fileDir;
+        let fileName;
+        let fileSize;
+        try {
+            const stat = yield fs_1.default.promises.lstat(filePath);
+            if (stat.isFile()) {
+                fileDir = path_1.default.dirname(filePath);
+                fileName = path_1.default.basename(filePath);
+                fileSize = stat.size;
+            } else {
+                messaging.sendMessage({
+                    subject: "mediaCast:mediaServerError",
+                    data: "Media path is not a file."
+                });
+                return;
+            }
+        } catch (err) {
+            messaging.sendMessage({
+                subject: "mediaCast:mediaServerError",
+                data: "Failed to find media path."
+            });
+            return;
+        }
+        const contentType = mime_types_1.default.lookup(filePath);
+        if (!contentType) {
+            messaging.sendMessage({
+                subject: "mediaCast:mediaServerError",
+                data: "Failed to find media type."
+            });
+            return;
+        }
+        const subtitles = new Map();
+        try {
+            const dirEntries = yield fs_1.default.promises.readdir(fileDir, {
+                withFileTypes: true
+            });
+            for (const dirEntry of dirEntries) {
+                if (
+                    dirEntry.isFile() &&
+                    mime_types_1.default.lookup(dirEntry.name) ===
+                        "application/x-subrip"
+                ) {
+                    subtitles.set(
+                        dirEntry.name,
+                        yield (0, subtitles_1.convertSrtToVtt)(
+                            path_1.default.join(fileDir, dirEntry.name)
+                        )
+                    );
+                }
+            }
+        } catch (err) {
+            console.error(
+                `Error: Failed to find/convert subtitles (${filePath}).`
+            );
+        }
+        exports.mediaServer = http_1.default.createServer((req, res) =>
+            __awaiter(this, void 0, void 0, function* () {
+                if (!req.url) {
+                    return;
+                }
+                let decodedUrl = decodeURIComponent(req.url);
+                if (decodedUrl.startsWith("/")) {
+                    decodedUrl = decodedUrl.slice(1);
+                }
+                switch (decodedUrl) {
+                    case fileName: {
+                        const { range } = req.headers;
+                        if (range) {
+                            const bounds = range.substring(6).split("-");
+                            const start = parseInt(bounds[0]);
+                            const end = bounds[1]
+                                ? parseInt(bounds[1])
+                                : fileSize - 1;
+                            res.writeHead(206, {
+                                "Accept-Ranges": "bytes",
+                                "Content-Range": `bytes ${start}-${end}/${fileSize}`,
+                                "Content-Length": end - start + 1,
+                                "Content-Type": contentType
+                            });
+                            fs_1.default
+                                .createReadStream(filePath, { start, end })
+                                .pipe(res);
+                        } else {
+                            res.writeHead(200, {
+                                "Content-Length": fileSize,
+                                "Content-Type": contentType
+                            });
+                            fs_1.default.createReadStream(filePath).pipe(res);
+                        }
+                        break;
+                    }
+                    default: {
+                        if (subtitles.has(req.url)) {
+                            const vttSource = subtitles.get(req.url);
+                            const vttStream =
+                                stream_1.default.Readable.from(vttSource);
+                            res.setHeader("Access-Control-Allow-Origin", "*");
+                            vttStream.pipe(res);
+                        }
+                        break;
+                    }
+                }
+            })
+        );
+        exports.mediaServer.on("close", () => {
+            messaging.sendMessage({
+                subject: "mediaCast:mediaServerStopped"
+            });
+        });
+        exports.mediaServer.on("error", err => {
+            messaging.sendMessage({
+                subject: "mediaCast:mediaServerError",
+                data: err.message
+            });
+        });
+        exports.mediaServer.listen(port, () => {
+            const localAddresses = [];
+            for (const iface of Object.values(
+                os_1.default.networkInterfaces()
+            )) {
+                const matchingIface =
+                    iface === null || iface === void 0
+                        ? void 0
+                        : iface.find(
+                              details =>
+                                  details.family === "IPv4" && !details.internal
+                          );
+                if (matchingIface) {
+                    localAddresses.push(matchingIface.address);
+                }
+            }
+            if (!localAddresses.length) {
+                messaging.sendMessage({
+                    subject: "mediaCast:mediaServerError",
+                    data: "Failed to get local address."
+                });
+                stopMediaServer();
+                return;
+            }
+            messaging.sendMessage({
+                subject: "mediaCast:mediaServerStarted",
+                data: {
+                    mediaPath: fileName,
+                    subtitlePaths: Array.from(subtitles.keys()),
+                    localAddress: localAddresses[0]
+                }
+            });
+        });
+    });
+}
+function stopMediaServer() {
+    return new Promise((resolve, reject) => {
+        if (
+            !(exports.mediaServer === null || exports.mediaServer === void 0
+                ? void 0
+                : exports.mediaServer.listening)
+        ) {
+            resolve();
+            return;
+        }
+        exports.mediaServer.close(err => {
+            if (err) {
+                reject();
+            } else {
+                resolve();
+            }
+        });
+        exports.mediaServer = undefined;
+    });
+}