client/src/standalone/videos/embed.ts

   1 import './embed.scss'
   2
   3 import { peertubeTranslate, ResultList, ServerConfig, VideoDetails } from '../../../../shared'
   4 import { VideoJSCaption } from '../../assets/player/peertube-videojs-typings'
   5 import { VideoCaption } from '../../../../shared/models/videos/caption/video-caption.model'
   6 import {
   7   P2PMediaLoaderOptions,
   8   PeertubePlayerManager,
   9   PeertubePlayerManagerOptions,
  10   PlayerMode
  11 } from '../../assets/player/peertube-player-manager'
  12 import { VideoStreamingPlaylistType } from '../../../../shared/models/videos/video-streaming-playlist.type'
  13 import { PeerTubeEmbedApi } from './embed-api'
  14
  15 export class PeerTubeEmbed {
  16   videoElement: HTMLVideoElement
  17   player: any
  18   playerOptions: any
  19   api: PeerTubeEmbedApi = null
  20   autoplay: boolean
  21   controls: boolean
  22   muted: boolean
  23   loop: boolean
  24   subtitle: string
  25   enableApi = false
  26   startTime: number | string = 0
  27   stopTime: number | string
  28
  29   title: boolean
  30   warningTitle: boolean
  31   bigPlayBackgroundColor: string
  32   foregroundColor: string
  33
  34   mode: PlayerMode
  35   scope = 'peertube'
  36
  37   static async main () {
  38     const videoContainerId = 'video-container'
  39     const embed = new PeerTubeEmbed(videoContainerId)
  40     await embed.init()
  41   }
  42
  43   constructor (private videoContainerId: string) {
  44     this.videoElement = document.getElementById(videoContainerId) as HTMLVideoElement
  45   }
  46
  47   getVideoUrl (id: string) {
  48     return window.location.origin + '/api/v1/videos/' + id
  49   }
  50
  51   loadVideoInfo (videoId: string): Promise<Response> {
  52     return fetch(this.getVideoUrl(videoId))
  53   }
  54
  55   loadVideoCaptions (videoId: string): Promise<Response> {
  56     return fetch(this.getVideoUrl(videoId) + '/captions')
  57   }
  58
  59   loadConfig (): Promise<Response> {
  60     return fetch('/api/v1/config')
  61   }
  62
  63   removeElement (element: HTMLElement) {
  64     element.parentElement.removeChild(element)
  65   }
  66
  67   displayError (text: string, translations?: { [ id: string ]: string }) {
  68     // Remove video element
  69     if (this.videoElement) this.removeElement(this.videoElement)
  70
  71     const translatedText = peertubeTranslate(text, translations)
  72     const translatedSorry = peertubeTranslate('Sorry', translations)
  73
  74     document.title = translatedSorry + ' - ' + translatedText
  75
  76     const errorBlock = document.getElementById('error-block')
  77     errorBlock.style.display = 'flex'
  78
  79     const errorTitle = document.getElementById('error-title')
  80     errorTitle.innerHTML = peertubeTranslate('Sorry', translations)
  81
  82     const errorText = document.getElementById('error-content')
  83     errorText.innerHTML = translatedText
  84   }
  85
  86   videoNotFound (translations?: { [ id: string ]: string }) {
  87     const text = 'This video does not exist.'
  88     this.displayError(text, translations)
  89   }
  90
  91   videoFetchError (translations?: { [ id: string ]: string }) {
  92     const text = 'We cannot fetch the video. Please try again later.'
  93     this.displayError(text, translations)
  94   }
  95
  96   getParamToggle (params: URLSearchParams, name: string, defaultValue?: boolean) {
  97     return params.has(name) ? (params.get(name) === '1' || params.get(name) === 'true') : defaultValue
  98   }
  99
 100   getParamString (params: URLSearchParams, name: string, defaultValue?: string) {
 101     return params.has(name) ? params.get(name) : defaultValue
 102   }
 103
 104   async init () {
 105     try {
 106       await this.initCore()
 107     } catch (e) {
 108       console.error(e)
 109     }
 110   }
 111
 112   private initializeApi () {
 113     if (!this.enableApi) return
 114
 115     this.api = new PeerTubeEmbedApi(this)
 116     this.api.initialize()
 117   }
 118
 119   private loadParams (video: VideoDetails) {
 120     try {
 121       const params = new URL(window.location.toString()).searchParams
 122
 123       this.autoplay = this.getParamToggle(params, 'autoplay', false)
 124       this.controls = this.getParamToggle(params, 'controls', true)
 125       this.muted = this.getParamToggle(params, 'muted', false)
 126       this.loop = this.getParamToggle(params, 'loop', false)
 127       this.title = this.getParamToggle(params, 'title', true)
 128       this.enableApi = this.getParamToggle(params, 'api', this.enableApi)
 129       this.warningTitle = this.getParamToggle(params, 'warningTitle', true)
 130
 131       this.scope = this.getParamString(params, 'scope', this.scope)
 132       this.subtitle = this.getParamString(params, 'subtitle')
 133       this.startTime = this.getParamString(params, 'start')
 134       this.stopTime = this.getParamString(params, 'stop')
 135
 136       this.bigPlayBackgroundColor = this.getParamString(params, 'bigPlayBackgroundColor')
 137       this.foregroundColor = this.getParamString(params, 'foregroundColor')
 138
 139       const modeParam = this.getParamString(params, 'mode')
 140
 141       if (modeParam) {
 142         if (modeParam === 'p2p-media-loader') this.mode = 'p2p-media-loader'
 143         else this.mode = 'webtorrent'
 144       } else {
 145         if (Array.isArray(video.streamingPlaylists) && video.streamingPlaylists.length !== 0) this.mode = 'p2p-media-loader'
 146         else this.mode = 'webtorrent'
 147       }
 148     } catch (err) {
 149       console.error('Cannot get params from URL.', err)
 150     }
 151   }
 152
 153   private async initCore () {
 154     const urlParts = window.location.pathname.split('/')
 155     const videoId = urlParts[ urlParts.length - 1 ]
 156
 157     const [ serverTranslations, videoResponse, captionsResponse, configResponse ] = await Promise.all([
 158       PeertubePlayerManager.getServerTranslations(window.location.origin, navigator.language),
 159       this.loadVideoInfo(videoId),
 160       this.loadVideoCaptions(videoId),
 161       this.loadConfig()
 162     ])
 163
 164     if (!videoResponse.ok) {
 165       if (videoResponse.status === 404) return this.videoNotFound(serverTranslations)
 166
 167       return this.videoFetchError(serverTranslations)
 168     }
 169
 170     const videoInfo: VideoDetails = await videoResponse.json()
 171     const videoCaptions = await this.buildCaptions(serverTranslations, captionsResponse)
 172
 173     this.loadParams(videoInfo)
 174
 175     const options: PeertubePlayerManagerOptions = {
 176       common: {
 177         autoplay: this.autoplay,
 178         controls: this.controls,
 179         muted: this.muted,
 180         loop: this.loop,
 181         captions: videoCaptions.length !== 0,
 182         startTime: this.startTime,
 183         stopTime: this.stopTime,
 184         subtitle: this.subtitle,
 185
 186         videoCaptions,
 187         inactivityTimeout: 1500,
 188         videoViewUrl: this.getVideoUrl(videoId) + '/views',
 189
 190         playerElement: this.videoElement,
 191         onPlayerElementChange: (element: HTMLVideoElement) => this.videoElement = element,
 192
 193         videoDuration: videoInfo.duration,
 194         enableHotkeys: true,
 195         peertubeLink: true,
 196         poster: window.location.origin + videoInfo.previewPath,
 197         theaterButton: false,
 198
 199         serverUrl: window.location.origin,
 200         language: navigator.language,
 201         embedUrl: window.location.origin + videoInfo.embedPath
 202       },
 203
 204       webtorrent: {
 205         videoFiles: videoInfo.files
 206       }
 207     }
 208
 209     if (this.mode === 'p2p-media-loader') {
 210       const hlsPlaylist = videoInfo.streamingPlaylists.find(p => p.type === VideoStreamingPlaylistType.HLS)
 211
 212       Object.assign(options, {
 213         p2pMediaLoader: {
 214           playlistUrl: hlsPlaylist.playlistUrl,
 215           segmentsSha256Url: hlsPlaylist.segmentsSha256Url,
 216           redundancyBaseUrls: hlsPlaylist.redundancies.map(r => r.baseUrl),
 217           trackerAnnounce: videoInfo.trackerUrls,
 218           videoFiles: hlsPlaylist.files
 219         } as P2PMediaLoaderOptions
 220       })
 221     }
 222
 223     this.player = await PeertubePlayerManager.initialize(this.mode, options, player => this.player = player)
 224     this.player.on('customError', (event: any, data: any) => this.handleError(data.err, serverTranslations))
 225
 226     window[ 'videojsPlayer' ] = this.player
 227
 228     this.buildCSS()
 229
 230     await this.buildDock(videoInfo, configResponse)
 231
 232     this.initializeApi()
 233   }
 234
 235   private handleError (err: Error, translations?: { [ id: string ]: string }) {
 236     if (err.message.indexOf('from xs param') !== -1) {
 237       this.player.dispose()
 238       this.videoElement = null
 239       this.displayError('This video is not available because the remote instance is not responding.', translations)
 240       return
 241     }
 242   }
 243
 244   private async buildDock (videoInfo: VideoDetails, configResponse: Response) {
 245     if (this.controls) {
 246       const title = this.title ? videoInfo.name : undefined
 247
 248       const config: ServerConfig = await configResponse.json()
 249       const description = config.tracker.enabled && this.warningTitle
 250         ? '<span class="text">' + this.player.localize('Watching this video may reveal your IP address to others.') + '</span>'
 251         : undefined
 252
 253       this.player.dock({
 254         title,
 255         description
 256       })
 257     }
 258   }
 259
 260   private buildCSS () {
 261     const body = document.getElementById('custom-css')
 262
 263     if (this.bigPlayBackgroundColor) {
 264       body.style.setProperty('--embedBigPlayBackgroundColor', this.bigPlayBackgroundColor)
 265     }
 266
 267     if (this.foregroundColor) {
 268       body.style.setProperty('--embedForegroundColor', this.foregroundColor)
 269     }
 270   }
 271
 272   private async buildCaptions (serverTranslations: any, captionsResponse: Response): Promise<VideoJSCaption[]> {
 273     if (captionsResponse.ok) {
 274       const { data } = (await captionsResponse.json()) as ResultList<VideoCaption>
 275
 276       return data.map(c => ({
 277         label: peertubeTranslate(c.language.label, serverTranslations),
 278         language: c.language.id,
 279         src: window.location.origin + c.captionPath
 280       }))
 281     }
 282
 283     return []
 284   }
 285 }
 286
 287 PeerTubeEmbed.main()
 288   .catch(err => console.error('Cannot init embed.', err))