Feat: isP2PDisabled

packages/p2p-media-loader-core/src/core.ts

@@ -32,6 +32,7 @@ export class Core<TStream extends Stream = Stream> {
   };
 
   static readonly DEFAULT_STREAM_CONFIG: StreamConfig = {
+    isP2PDisabled: false,
     simultaneousHttpDownloads: 3,
     simultaneousP2PDownloads: 3,
     highDemandTimeWindow: 15,
@@ -147,15 +148,25 @@ export class Core<TStream extends Stream = Stream> {
    * core.applyDynamicConfig(dynamicConfig);
    */
   applyDynamicConfig(dynamicConfig: DynamicCoreConfig) {
-    overrideConfig(this.commonCoreConfig, dynamicConfig);
-    overrideConfig(this.mainStreamConfig, dynamicConfig);
-    overrideConfig(this.secondaryStreamConfig, dynamicConfig);
+    const { mainStream, secondaryStream } = dynamicConfig;
+
+    this.overrideAllConfigs(dynamicConfig, mainStream, secondaryStream);
 
-    if (dynamicConfig.mainStream) {
-      overrideConfig(this.mainStreamConfig, dynamicConfig.mainStream);
+    if (
+      this.mainStreamConfig.isP2PDisabled &&
+      this.secondaryStreamConfig.isP2PDisabled
+    ) {
+      this.destroyStreamLoader("main");
+      this.destroyStreamLoader("secondary");
+      return;
     }
-    if (dynamicConfig.secondaryStream) {
-      overrideConfig(this.secondaryStreamConfig, dynamicConfig.secondaryStream);
+
+    if (this.mainStreamConfig.isP2PDisabled) {
+      this.destroyStreamLoader("main");
+    }
+
+    if (this.secondaryStreamConfig.isP2PDisabled) {
+      this.destroyStreamLoader("secondary");
     }
   }
 
@@ -282,6 +293,7 @@ export class Core<TStream extends Stream = Stream> {
     }
 
     const segment = this.identifySegment(segmentLocalId);
+
     const loader = this.getStreamHybridLoader(segment);
     void loader.loadSegment(segment, callbacks);
   }
@@ -330,6 +342,30 @@ export class Core<TStream extends Stream = Stream> {
     this.streamDetails.isLive = isLive;
   }
 
+  isSegmentLoadableByP2PCore(segmentLocalId: string): boolean {
+    try {
+      const segment = this.identifySegment(segmentLocalId);
+
+      if (
+        segment.stream.type === "main" &&
+        this.mainStreamConfig.isP2PDisabled
+      ) {
+        return false;
+      }
+
+      if (
+        segment.stream.type === "secondary" &&
+        this.secondaryStreamConfig.isP2PDisabled
+      ) {
+        return false;
+      }
+
+      return true;
+    } catch (e) {
+      return false;
+    }
+  }
+
   /**
    * Cleans up resources used by the Core instance, including destroying any active stream loaders
    * and clearing stored segments.
@@ -362,6 +398,34 @@ export class Core<TStream extends Stream = Stream> {
     return segment;
   }
 
+  private overrideAllConfigs(
+    dynamicConfig: DynamicCoreConfig,
+    mainStream?: Partial<StreamConfig>,
+    secondaryStream?: Partial<StreamConfig>,
+  ) {
+    overrideConfig(this.commonCoreConfig, dynamicConfig);
+    overrideConfig(this.mainStreamConfig, dynamicConfig);
+    overrideConfig(this.secondaryStreamConfig, dynamicConfig);
+
+    if (mainStream) {
+      overrideConfig(this.mainStreamConfig, mainStream);
+    }
+
+    if (secondaryStream) {
+      overrideConfig(this.secondaryStreamConfig, secondaryStream);
+    }
+  }
+
+  private destroyStreamLoader(streamType: "main" | "secondary") {
+    if (streamType === "main") {
+      this.mainStreamLoader?.destroy();
+      this.mainStreamLoader = undefined;
+    } else {
+      this.secondaryStreamLoader?.destroy();
+      this.secondaryStreamLoader = undefined;
+    }
+  }
+
   private getStreamHybridLoader(segment: SegmentWithStream) {
     if (segment.stream.type === "main") {
       this.mainStreamLoader ??= this.createNewHybridLoader(segment);

packages/p2p-media-loader-core/src/hybrid-loader.ts

@@ -544,6 +544,7 @@ export class HybridLoader {
     clearInterval(this.storageCleanUpIntervalId);
     clearInterval(this.randomHttpDownloadInterval);
     this.storageCleanUpIntervalId = undefined;
+    this.engineRequest?.abort();
     this.requests.destroy();
     this.p2pLoaders.destroy();
   }

packages/p2p-media-loader-core/src/p2p/peer.ts

@@ -62,8 +62,9 @@ export class Peer {
     eventTarget.getEventDispatcher("onPeerConnect")({
       peerId: this.id,
     });
-    connection.on("close", this.onPeerConnectionClosed);
-    connection.on("error", this.onConnectionError);
+
+    connection._channel.onerror = this.onConnectionError;
+    connection._channel.onclose = this.onPeerConnectionClosed;
   }
 
   get downloadingSegment(): SegmentWithStream | undefined {
@@ -301,10 +302,11 @@ export class Peer {
     this.destroy();
   };
 
-  private onConnectionError = (error: { code: string }) => {
-    this.logger(`peer connection error ${this.id} %O`, error);
+  private onConnectionError = (ev: Event) => {
+    this.logger(`peer connection error ${this.id} %O`, ev);
 
-    if (error.code === "ERR_DATA_CHANNEL") {
+    const event = ev as RTCErrorEvent;
+    if (event.error.errorDetail === "data-channel-failure") {
       this.destroy();
     }
   };

packages/p2p-media-loader-core/src/requests/request-container.ts

@@ -72,7 +72,12 @@ export class RequestsContainer {
 
   destroy() {
     for (const request of this.requests.values()) {
-      request.abortFromProcessQueue();
+      try {
+        request.abortFromProcessQueue();
+      } catch (error) {
+        // eslint-disable-next-line no-console
+        console.warn(error);
+      }
     }
     this.requests.clear();
   }

packages/p2p-media-loader-core/src/types.ts

@@ -77,7 +77,8 @@ export type DynamicStreamProperties =
   | "httpErrorRetries"
   | "p2pErrorRetries"
   | "validateP2PSegment"
-  | "httpRequestSetup";
+  | "httpRequestSetup"
+  | "isP2PDisabled";
 
 /**
  * Represents a dynamically modifiable configuration, allowing updates to selected CoreConfig properties at runtime.
@@ -138,9 +139,23 @@ export type CommonCoreConfig = {
  * Represents a set of configuration parameters that can be used to override or extend the
  * default configuration settings for a specific stream (main or secondary).
  *
- * @example
+ * @example Configuration for basic video stream
+ *
  * ```typescript
  * const config: CoreConfig = {
+ *  highDemandTimeWindow: 15,
+ *  httpDownloadTimeWindow: 3000,
+ *  p2pDownloadTimeWindow: 6000,
+ *  swarmId: "custom swarm ID for video stream",
+ *  cashedSegmentsCount: 1000,
+ * }
+ * ```
+ *
+ * @example Configuration for advanced video stream
+ *
+ * ```typescript
+ * const config: CoreConfig = {
+ *  // Configuration for both streams
  *  highDemandTimeWindow: 20,
  *  httpDownloadTimeWindow: 3000,
  *  p2pDownloadTimeWindow: 6000,
@@ -164,6 +179,16 @@ export type CoreConfig = Partial<StreamConfig> &
 
 /** Configuration options for the Core functionality, including network and processing parameters. */
 export type StreamConfig = {
+  /**
+   * Indicates whether Peer-to-Peer (P2P) functionality is disabled for the stream.
+   * If set to true, P2P functionality is disabled for the stream.
+   *
+   * @default
+   * ```typescript
+   * isP2PDisabled: false
+   * ```
+   */
+  isP2PDisabled: boolean;
   /**
    * Defines the duration of the time window, in seconds, during which segments are pre-loaded to ensure smooth playback.
    * This window helps prioritize the fetching of media segments that are imminent to playback.

packages/p2p-media-loader-hlsjs/src/fragment-loader.ts

@@ -56,9 +56,15 @@ export class FragmentLoaderBase implements Loader<FragmentLoaderContext> {
       start,
       end !== undefined ? end - 1 : undefined,
     );
+
     this.#segmentId = Utils.getSegmentLocalId(context.url, byteRange);
+    const isSegmentDownloadableByP2PCore =
+      this.#core.isSegmentLoadableByP2PCore(this.#segmentId);
 
-    if (!this.#core.hasSegment(this.#segmentId)) {
+    if (
+      !this.#core.hasSegment(this.#segmentId) ||
+      isSegmentDownloadableByP2PCore === false
+    ) {
       this.#defaultLoader = this.#createDefaultLoader();
       this.#defaultLoader.stats = this.stats;
       this.#defaultLoader?.load(context, config, callbacks);

packages/p2p-media-loader-shaka/src/loading-handler.ts

@@ -54,7 +54,13 @@ export class Loader {
     byteRangeString: string,
   ): LoadingHandlerResult {
     const segmentId = Utils.getSegmentLocalId(segmentUrl, byteRangeString);
-    if (!this.core.hasSegment(segmentId)) {
+    const isSegmentDownloadableByP2PCore =
+      this.core.isSegmentLoadableByP2PCore(segmentId);
+
+    if (
+      !this.core.hasSegment(segmentId) ||
+      isSegmentDownloadableByP2PCore === false
+    ) {
       return this.defaultLoad() as LoadingHandlerResult;
     }