p2p-media-loader-core/lib/p2p/loaders-container.js

P2P Media Loader core functionality

import { P2PLoader } from "./loader.js";
import debug from "debug";
import * as LoggerUtils from "../utils/logger.js";
import * as StreamUtils from "../utils/stream.js";
export class P2PLoadersContainer {
    constructor(streamManifestUrl, stream, requests, segmentStorage, config, eventTarget, onSegmentAnnouncement) {
        Object.defineProperty(this, "streamManifestUrl", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: streamManifestUrl
        });
        Object.defineProperty(this, "requests", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: requests
        });
        Object.defineProperty(this, "segmentStorage", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: segmentStorage
        });
        Object.defineProperty(this, "config", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: config
        });
        Object.defineProperty(this, "eventTarget", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: eventTarget
        });
        Object.defineProperty(this, "onSegmentAnnouncement", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: onSegmentAnnouncement
        });
        Object.defineProperty(this, "loaders", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: new Map()
        });
        Object.defineProperty(this, "_currentLoaderItem", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: void 0
        });
        Object.defineProperty(this, "logger", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: debug("p2pml-core:p2p-loaders-container")
        });
        this._currentLoaderItem = this.findOrCreateLoaderForStream(stream);
        this.logger(`set current p2p loader: ${LoggerUtils.getStreamString(stream)}`);
    }
    createLoader(stream) {
        if (this.loaders.has(stream.runtimeId)) {
            throw new Error("Loader for this stream already exists");
        }
        const loader = new P2PLoader(this.streamManifestUrl, stream, this.requests, this.segmentStorage, this.config, this.eventTarget, () => {
            if (this._currentLoaderItem.loader === loader) {
                this.onSegmentAnnouncement();
            }
        });
        const loggerInfo = LoggerUtils.getStreamString(stream);
        this.logger(`created new loader: ${loggerInfo}`);
        return {
            loader,
            stream,
            loggerInfo: LoggerUtils.getStreamString(stream),
        };
    }
    findOrCreateLoaderForStream(stream) {
        const loaderItem = this.loaders.get(stream.runtimeId);
        if (loaderItem) {
            clearTimeout(loaderItem.destroyTimeoutId);
            loaderItem.destroyTimeoutId = undefined;
            return loaderItem;
        }
        else {
            const loader = this.createLoader(stream);
            this.loaders.set(stream.runtimeId, loader);
            return loader;
        }
    }
    changeCurrentLoader(stream) {
        const swarmId = this.config.swarmId ?? this.streamManifestUrl;
        const streamSwarmId = StreamUtils.getStreamSwarmId(swarmId, this._currentLoaderItem.stream);
        const ids = this.segmentStorage.getStoredSegmentIds(swarmId, streamSwarmId);
        if (!ids.length)
            this.destroyAndRemoveLoader(this._currentLoaderItem);
        else
            this.setLoaderDestroyTimeout(this._currentLoaderItem);
        this._currentLoaderItem = this.findOrCreateLoaderForStream(stream);
        this.logger(`change current p2p loader: ${LoggerUtils.getStreamString(stream)}`);
    }
    setLoaderDestroyTimeout(item) {
        item.destroyTimeoutId = window.setTimeout(() => this.destroyAndRemoveLoader(item), this.config.p2pInactiveLoaderDestroyTimeoutMs);
    }
    destroyAndRemoveLoader(item) {
        item.loader.destroy();
        this.loaders.delete(item.stream.runtimeId);
        this.logger(`destroy p2p loader: `, item.loggerInfo);
    }
    get currentLoader() {
        return this._currentLoaderItem.loader;
    }
    destroy() {
        for (const { loader, destroyTimeoutId } of this.loaders.values()) {
            loader.destroy();
            clearTimeout(destroyTimeoutId);
        }
        this.loaders.clear();
    }
}
//# sourceMappingURL=loaders-container.js.map