Don't seed on cellular networks

client/src/app/shared/renderer/markdown.service.ts

@@ -85,8 +85,6 @@ export class MarkdownService {
     let html = this.markdownParsers[ name ].render(markdown)
     html = this.avoidTruncatedTags(html)
 
-    console.log(html)
-
     if (config.escape) return this.htmlRenderer.toSafeHtml(html)
 
     return html

client/src/assets/player/peertube-player-manager.ts

@@ -208,10 +208,8 @@ export class PeertubePlayerManager {
 
   private static getVideojsOptions (mode: PlayerMode, options: PeertubePlayerManagerOptions, p2pMediaLoaderModule?: any) {
     const commonOptions = options.common
-    const webtorrentOptions = options.webtorrent
-    const p2pMediaLoaderOptions = options.p2pMediaLoader
 
-    let autoplay = options.common.autoplay
+    let autoplay = commonOptions.autoplay
     let html5 = {}
 
     const plugins: VideoJSPluginOptions = {
@@ -227,7 +225,72 @@ export class PeertubePlayerManager {
       }
     }
 
+    if (commonOptions.enableHotkeys === true) {
+      PeertubePlayerManager.addHotkeysOptions(plugins)
+    }
+
     if (mode === 'p2p-media-loader') {
+      const { streamrootHls } = PeertubePlayerManager.addP2PMediaLoaderOptions(plugins, options, p2pMediaLoaderModule)
+
+      html5 = streamrootHls.html5
+    }
+
+    if (mode === 'webtorrent') {
+      PeertubePlayerManager.addWebTorrentOptions(plugins, options)
+
+      // WebTorrent plugin handles autoplay, because we do some hackish stuff in there
+      autoplay = false
+    }
+
+    const videojsOptions = {
+      html5,
+
+      // We don't use text track settings for now
+      textTrackSettings: false,
+      controls: commonOptions.controls !== undefined ? commonOptions.controls : true,
+      loop: commonOptions.loop !== undefined ? commonOptions.loop : false,
+
+      muted: commonOptions.muted !== undefined
+        ? commonOptions.muted
+        : undefined, // Undefined so the player knows it has to check the local storage
+
+      autoplay: autoplay === true
+        ? 'any' // Use 'any' instead of true to get notifier by videojs if autoplay fails
+        : autoplay,
+
+      poster: commonOptions.poster,
+      inactivityTimeout: commonOptions.inactivityTimeout,
+      playbackRates: [ 0.5, 0.75, 1, 1.25, 1.5, 2 ],
+
+      plugins,
+
+      controlBar: {
+        children: this.getControlBarChildren(mode, {
+          captions: commonOptions.captions,
+          peertubeLink: commonOptions.peertubeLink,
+          theaterButton: commonOptions.theaterButton
+        })
+      }
+    }
+
+    if (commonOptions.language && !isDefaultLocale(commonOptions.language)) {
+      Object.assign(videojsOptions, { language: commonOptions.language })
+    }
+
+    return videojsOptions
+  }
+
+  private static addP2PMediaLoaderOptions (
+    plugins: VideoJSPluginOptions,
+    options: PeertubePlayerManagerOptions,
+    p2pMediaLoaderModule: any
+  ) {
+    const p2pMediaLoaderOptions = options.p2pMediaLoader
+    const commonOptions = options.common
+
+    const trackerAnnounce = p2pMediaLoaderOptions.trackerAnnounce
+                                                 .filter(t => t.startsWith('ws'))
+
     const redundancyUrlManager = new RedundancyUrlManager(options.p2pMediaLoader.redundancyBaseUrls)
 
     const p2pMediaLoader: P2PMediaLoaderPluginOptions = {
@@ -237,8 +300,12 @@ export class PeertubePlayerManager {
       src: p2pMediaLoaderOptions.playlistUrl
     }
 
-      const trackerAnnounce = p2pMediaLoaderOptions.trackerAnnounce
-        .filter(t => t.startsWith('ws'))
+    let consumeOnly = false
+    // FIXME: typings
+    if (navigator && (navigator as any).connection && (navigator as any).connection.effectiveType === 'cellular') {
+      console.log('We are on a cellular connection: disabling seeding.')
+      consumeOnly = true
+    }
 
     const p2pMediaLoaderConfig = {
       loader: {
@@ -247,7 +314,8 @@ export class PeertubePlayerManager {
         rtcConfig: getRtcConfig(),
         requiredSegmentsPriority: 5,
         segmentUrlBuilder: segmentUrlBuilderFactory(redundancyUrlManager),
-          useP2P: getStoredP2PEnabled()
+        useP2P: getStoredP2PEnabled(),
+        consumeOnly
       },
       segments: {
         swarmId: p2pMediaLoaderOptions.playlistUrl
@@ -272,112 +340,25 @@ export class PeertubePlayerManager {
       }
     }
 
-      Object.assign(plugins, { p2pMediaLoader, streamrootHls })
-      html5 = streamrootHls.html5
+    const toAssign = { p2pMediaLoader, streamrootHls }
+    Object.assign(plugins, toAssign)
+
+    return toAssign
   }
 
-    if (mode === 'webtorrent') {
+  private static addWebTorrentOptions (plugins: VideoJSPluginOptions, options: PeertubePlayerManagerOptions) {
+    const commonOptions = options.common
+    const webtorrentOptions = options.webtorrent
+
     const webtorrent = {
-        autoplay,
+      autoplay: commonOptions.autoplay,
       videoDuration: commonOptions.videoDuration,
       playerElement: commonOptions.playerElement,
       videoFiles: webtorrentOptions.videoFiles,
       startTime: commonOptions.startTime
     }
+
     Object.assign(plugins, { webtorrent })
-
-      // WebTorrent plugin handles autoplay, because we do some hackish stuff in there
-      autoplay = false
-    }
-
-    const videojsOptions = {
-      html5,
-
-      // We don't use text track settings for now
-      textTrackSettings: false,
-      controls: commonOptions.controls !== undefined ? commonOptions.controls : true,
-      loop: commonOptions.loop !== undefined ? commonOptions.loop : false,
-
-      muted: commonOptions.muted !== undefined
-        ? commonOptions.muted
-        : undefined, // Undefined so the player knows it has to check the local storage
-
-      poster: commonOptions.poster,
-      autoplay: autoplay === true ? 'any' : autoplay, // Use 'any' instead of true to get notifier by videojs if autoplay fails
-      inactivityTimeout: commonOptions.inactivityTimeout,
-      playbackRates: [ 0.5, 0.75, 1, 1.25, 1.5, 2 ],
-      plugins,
-      controlBar: {
-        children: this.getControlBarChildren(mode, {
-          captions: commonOptions.captions,
-          peertubeLink: commonOptions.peertubeLink,
-          theaterButton: commonOptions.theaterButton
-        })
-      }
-    }
-
-    if (commonOptions.enableHotkeys === true) {
-      Object.assign(videojsOptions.plugins, {
-        hotkeys: {
-          enableVolumeScroll: false,
-          enableModifiersForNumbers: false,
-
-          fullscreenKey: function (event: KeyboardEvent) {
-            // fullscreen with the f key or Ctrl+Enter
-            return event.key === 'f' || (event.ctrlKey && event.key === 'Enter')
-          },
-
-          seekStep: function (event: KeyboardEvent) {
-            // mimic VLC seek behavior, and default to 5 (original value is 5).
-            if (event.ctrlKey && event.altKey) {
-              return 5 * 60
-            } else if (event.ctrlKey) {
-              return 60
-            } else if (event.altKey) {
-              return 10
-            } else {
-              return 5
-            }
-          },
-
-          customKeys: {
-            increasePlaybackRateKey: {
-              key: function (event: KeyboardEvent) {
-                return event.key === '>'
-              },
-              handler: function (player: videojs.Player) {
-                player.playbackRate((player.playbackRate() + 0.1).toFixed(2))
-              }
-            },
-            decreasePlaybackRateKey: {
-              key: function (event: KeyboardEvent) {
-                return event.key === '<'
-              },
-              handler: function (player: videojs.Player) {
-                player.playbackRate((player.playbackRate() - 0.1).toFixed(2))
-              }
-            },
-            frameByFrame: {
-              key: function (event: KeyboardEvent) {
-                return event.key === '.'
-              },
-              handler: function (player: videojs.Player) {
-                player.pause()
-                // Calculate movement distance (assuming 30 fps)
-                const dist = 1 / 30
-                player.currentTime(player.currentTime() + dist)
-              }
-            }
-          }
-        }
-      })
-    }
-
-    if (commonOptions.language && !isDefaultLocale(commonOptions.language)) {
-      Object.assign(videojsOptions, { language: commonOptions.language })
-    }
-
-    return videojsOptions
   }
 
   private static getControlBarChildren (mode: PlayerMode, options: {
@@ -481,6 +462,63 @@ export class PeertubePlayerManager {
     player.contextmenuUI({ content })
   }
 
+  private static addHotkeysOptions (plugins: VideoJSPluginOptions) {
+    Object.assign(plugins, {
+      hotkeys: {
+        enableVolumeScroll: false,
+        enableModifiersForNumbers: false,
+
+        fullscreenKey: function (event: KeyboardEvent) {
+          // fullscreen with the f key or Ctrl+Enter
+          return event.key === 'f' || (event.ctrlKey && event.key === 'Enter')
+        },
+
+        seekStep: function (event: KeyboardEvent) {
+          // mimic VLC seek behavior, and default to 5 (original value is 5).
+          if (event.ctrlKey && event.altKey) {
+            return 5 * 60
+          } else if (event.ctrlKey) {
+            return 60
+          } else if (event.altKey) {
+            return 10
+          } else {
+            return 5
+          }
+        },
+
+        customKeys: {
+          increasePlaybackRateKey: {
+            key: function (event: KeyboardEvent) {
+              return event.key === '>'
+            },
+            handler: function (player: videojs.Player) {
+              player.playbackRate((player.playbackRate() + 0.1).toFixed(2))
+            }
+          },
+          decreasePlaybackRateKey: {
+            key: function (event: KeyboardEvent) {
+              return event.key === '<'
+            },
+            handler: function (player: videojs.Player) {
+              player.playbackRate((player.playbackRate() - 0.1).toFixed(2))
+            }
+          },
+          frameByFrame: {
+            key: function (event: KeyboardEvent) {
+              return event.key === '.'
+            },
+            handler: function (player: videojs.Player) {
+              player.pause()
+              // Calculate movement distance (assuming 30 fps)
+              const dist = 1 / 30
+              player.currentTime(player.currentTime() + dist)
+            }
+          }
+        }
+      }
+    })
+  }
+
   private static getLocalePath (serverUrl: string, locale: string) {
     const completeLocale = getCompleteLocale(locale)