merged with latest master

renderer/controllers/media-controller.js

@@ -0,0 +1,56 @@
+const electron = require('electron')
+
+const ipcRenderer = electron.ipcRenderer
+
+// Controls local play back: the <video>/<audio> tag and VLC
+// Does not control remote casting (Chromecast etc)
+module.exports = class MediaController {
+  constructor (state) {
+    this.state = state
+  }
+
+  mediaSuccess () {
+    this.state.playing.result = 'success'
+  }
+
+  mediaStalled () {
+    this.state.playing.isStalled = true
+  }
+
+  mediaError (error) {
+    var state = this.state
+    if (state.location.url() === 'player') {
+      state.playing.result = 'error'
+      state.playing.location = 'error'
+      ipcRenderer.send('checkForVLC')
+      ipcRenderer.once('checkForVLC', function (e, isInstalled) {
+        state.modal = {
+          id: 'unsupported-media-modal',
+          error: error,
+          vlcInstalled: isInstalled
+        }
+      })
+    }
+  }
+
+  mediaTimeUpdate () {
+    this.state.playing.lastTimeUpdate = new Date().getTime()
+    this.state.playing.isStalled = false
+  }
+
+  mediaMouseMoved () {
+    this.state.playing.mouseStationarySince = new Date().getTime()
+  }
+
+  vlcPlay () {
+    ipcRenderer.send('vlcPlay', this.state.server.localURL)
+    this.state.playing.location = 'vlc'
+  }
+
+  vlcNotFound () {
+    var modal = this.state.modal
+    if (modal && modal.id === 'unsupported-media-modal') {
+      modal.vlcNotFound = true
+    }
+  }
+}

renderer/controllers/playback-controller.js

@@ -0,0 +1,309 @@
+const electron = require('electron')
+const path = require('path')
+
+const Cast = require('../lib/cast')
+const {dispatch} = require('../lib/dispatcher')
+const telemetry = require('../lib/telemetry')
+const errors = require('../lib/errors')
+const sound = require('../lib/sound')
+const TorrentPlayer = require('../lib/torrent-player')
+const TorrentSummary = require('../lib/torrent-summary')
+const State = require('../lib/state')
+
+const ipcRenderer = electron.ipcRenderer
+
+// Controls playback of torrents and files within torrents
+// both local (<video>,<audio>,VLC) and remote (cast)
+module.exports = class PlaybackController {
+  constructor (state, config, update) {
+    this.state = state
+    this.config = config
+    this.update = update
+  }
+
+  // Play a file in a torrent.
+  // * Start torrenting, if necessary
+  // * Stream, if not already fully downloaded
+  // * If no file index is provided, pick the default file to play
+  playFile (infoHash, index /* optional */) {
+    this.state.location.go({
+      url: 'player',
+      onbeforeload: (cb) => {
+        this.play()
+        openPlayer(this.state, infoHash, index, cb)
+      },
+      onbeforeunload: (cb) => closePlayer(this.state, this.config, cb)
+    }, (err) => {
+      if (err) dispatch('error', err)
+    })
+  }
+
+  // Show a file in the OS, eg in Finder on a Mac
+  openItem (infoHash, index) {
+    var torrentSummary = torrentSummary.getByKey(this.state, infoHash)
+    var filePath = path.join(
+      torrentSummary.path,
+      torrentSummary.files[index].path)
+    ipcRenderer.send('openItem', filePath)
+  }
+
+  // Toggle (play or pause) the currently playing media
+  playPause () {
+    var state = this.state
+    if (state.location.url() !== 'player') return
+
+    // force rerendering if window is hidden,
+    // in order to bypass `raf` and play/pause media immediately
+    if (!state.window.isVisible) {
+      var mediaTag = document.querySelector('video,audio')
+      if (state.playing.isPaused) mediaTag.play()
+      else mediaTag.pause()
+    }
+
+    if (state.playing.isPaused) this.play()
+    else this.pause()
+  }
+
+  // Play (unpause) the current media
+  play () {
+    var state = this.state
+    if (!state.playing.isPaused) return
+    state.playing.isPaused = false
+    if (isCasting(state)) {
+      Cast.play()
+    }
+    ipcRenderer.send('onPlayerPlay')
+  }
+
+  // Pause the currently playing media
+  pause () {
+    var state = this.state
+    if (state.playing.isPaused) return
+    state.playing.isPaused = true
+    if (isCasting(state)) {
+      Cast.pause()
+    }
+    ipcRenderer.send('onPlayerPause')
+  }
+
+  // Skip specified number of seconds (backwards if negative)
+  skip (time) {
+    this.skipTo(this.state.playing.currentTime + time)
+  }
+
+  // Skip (aka seek) to a specific point, in seconds
+  skipTo (time) {
+    if (isCasting(this.state)) Cast.seek(time)
+    else this.state.playing.jumpToTime = time
+  }
+
+  // Change playback speed. 1 = faster, -1 = slower
+  // Playback speed ranges from 16 (fast forward) to 1 (normal playback)
+  // to 0.25 (quarter-speed playback), then goes to -0.25, -0.5, -1, -2, etc
+  // until -16 (fast rewind)
+  changePlaybackRate (direction) {
+    var state = this.state
+    var rate = state.playing.playbackRate
+    if (direction > 0 && rate >= 0.25 && rate < 2) {
+      rate += 0.25
+    } else if (direction < 0 && rate > 0.25 && rate <= 2) {
+      rate -= 0.25
+    } else if (direction < 0 && rate === 0.25) { /* when we set playback rate at 0 in html 5, playback hangs ;( */
+      rate = -1
+    } else if (direction > 0 && rate === -1) {
+      rate = 0.25
+    } else if ((direction > 0 && rate >= 1 && rate < 16) || (direction < 0 && rate > -16 && rate <= -1)) {
+      rate *= 2
+    } else if ((direction < 0 && rate > 1 && rate <= 16) || (direction > 0 && rate >= -16 && rate < -1)) {
+      rate /= 2
+    }
+    state.playing.playbackRate = rate
+    if (isCasting(state) && !Cast.setRate(rate)) {
+      state.playing.playbackRate = 1
+    }
+  }
+
+  // Change the volume, in range [0, 1], by some amount
+  // For example, volume muted (0), changeVolume (0.3) increases to 30% volume
+  changeVolume (delta) {
+    // change volume with delta value
+    this.setVolume(this.state.playing.volume + delta)
+  }
+
+  // Set the volume to some value in [0, 1]
+  setVolume (volume) {
+    // check if its in [0.0 - 1.0] range
+    volume = Math.max(0, Math.min(1, volume))
+
+    var state = this.state
+    if (isCasting(state)) {
+      Cast.setVolume(volume)
+    } else {
+      state.playing.setVolume = volume
+    }
+  }
+
+  // Hide player controls while playing video, if the mouse stays still for a while
+  // Never hide the controls when:
+  // * The mouse is over the controls or we're scrubbing (see CSS)
+  // * The video is paused
+  // * The video is playing remotely on Chromecast or Airplay
+  showOrHidePlayerControls () {
+    var state = this.state
+    var hideControls = state.location.url() === 'player' &&
+      state.playing.mouseStationarySince !== 0 &&
+      new Date().getTime() - state.playing.mouseStationarySince > 2000 &&
+      !state.playing.isPaused &&
+      state.playing.location === 'local'
+
+    if (hideControls !== state.playing.hideControls) {
+      state.playing.hideControls = hideControls
+      return true
+    }
+    return false
+  }
+}
+
+// Opens the video player to a specific torrent
+function openPlayer (state, infoHash, index, cb) {
+  var torrentSummary = TorrentSummary.getByKey(state, infoHash)
+
+  // automatically choose which file in the torrent to play, if necessary
+  if (index === undefined) index = torrentSummary.defaultPlayFileIndex
+  if (index === undefined) index = TorrentPlayer.pickFileToPlay(torrentSummary.files)
+  if (index === undefined) return cb(new errors.UnplayableError())
+
+  // update UI to show pending playback
+  if (torrentSummary.progress !== 1) sound.play('PLAY')
+  // TODO: remove torrentSummary.playStatus
+  torrentSummary.playStatus = 'requested'
+  this.update()
+
+  var timeout = setTimeout(() => {
+    telemetry.logPlayAttempt('timeout')
+    // TODO: remove torrentSummary.playStatus
+    torrentSummary.playStatus = 'timeout' /* no seeders available? */
+    sound.play('ERROR')
+    cb(new Error('Playback timed out. Try again.'))
+    this.update()
+  }, 10000) /* give it a few seconds */
+
+  if (torrentSummary.status === 'paused') {
+    dispatch('startTorrentingSummary', torrentSummary)
+    ipcRenderer.once('wt-ready-' + torrentSummary.infoHash,
+      () => openPlayerFromActiveTorrent(state, torrentSummary, index, timeout, cb))
+  } else {
+    openPlayerFromActiveTorrent(state, torrentSummary, index, timeout, cb)
+  }
+}
+
+function openPlayerFromActiveTorrent (state, torrentSummary, index, timeout, cb) {
+  var fileSummary = torrentSummary.files[index]
+
+  // update state
+  state.playing.infoHash = torrentSummary.infoHash
+  state.playing.fileIndex = index
+  state.playing.type = TorrentPlayer.isVideo(fileSummary) ? 'video'
+    : TorrentPlayer.isAudio(fileSummary) ? 'audio'
+    : 'other'
+
+  // pick up where we left off
+  if (fileSummary.currentTime) {
+    var fraction = fileSummary.currentTime / fileSummary.duration
+    var secondsLeft = fileSummary.duration - fileSummary.currentTime
+    if (fraction < 0.9 && secondsLeft > 10) {
+      state.playing.jumpToTime = fileSummary.currentTime
+    }
+  }
+
+  // if it's audio, parse out the metadata (artist, title, etc)
+  if (state.playing.type === 'audio' && !fileSummary.audioInfo) {
+    ipcRenderer.send('wt-get-audio-metadata', torrentSummary.infoHash, index)
+  }
+
+  // if it's video, check for subtitles files that are done downloading
+  dispatch('checkForSubtitles')
+
+  // enable previously selected subtitle track
+  if (fileSummary.selectedSubtitle) {
+    dispatch('addSubtitles', [fileSummary.selectedSubtitle], true)
+  }
+
+  ipcRenderer.send('wt-start-server', torrentSummary.infoHash, index)
+  ipcRenderer.once('wt-server-' + torrentSummary.infoHash, (e, info) => {
+    clearTimeout(timeout)
+
+    // if we timed out (user clicked play a long time ago), don't autoplay
+    var timedOut = torrentSummary.playStatus === 'timeout'
+    delete torrentSummary.playStatus
+    if (timedOut) {
+      ipcRenderer.send('wt-stop-server')
+      return this.update()
+    }
+
+    // otherwise, play the video
+    state.window.title = torrentSummary.files[state.playing.fileIndex].name
+    this.update()
+
+    ipcRenderer.send('onPlayerOpen')
+
+    cb()
+  })
+}
+
+function closePlayer (state, config, cb) {
+  console.log('closePlayer')
+
+  // Quit any external players, like Chromecast/Airplay/etc or VLC
+  if (isCasting(state)) {
+    Cast.stop()
+  }
+  if (state.playing.location === 'vlc') {
+    ipcRenderer.send('vlcQuit')
+  }
+
+  // Save volume (this session only, not in state.saved)
+  state.previousVolume = state.playing.volume
+
+  // Telemetry: track what happens after the user clicks play
+  var result = state.playing.result // 'success' or 'error'
+  if (result === 'success') telemetry.logPlayAttempt('success') // first frame displayed
+  else if (result === 'error') telemetry.logPlayAttempt('error') // codec missing, etc
+  else if (result === undefined) telemetry.logPlayAttempt('abandoned') // user exited before first frame
+  else console.error('Unknown state.playing.result', state.playing.result)
+
+  // Reset the window contents back to the home screen
+  state.window.title = config.APP_WINDOW_TITLE
+  state.playing = State.getDefaultPlayState()
+  state.server = null
+
+  // Reset the window size and location back to where it was
+  if (state.window.isFullScreen) {
+    dispatch('toggleFullScreen', false)
+  }
+  restoreBounds(state)
+
+  // Tell the WebTorrent process to kill the torrent-to-HTTP server
+  ipcRenderer.send('wt-stop-server')
+
+  ipcRenderer.send('onPlayerClose')
+
+  this.update()
+  cb()
+}
+
+// Checks whether we are connected and already casting
+// Returns false if we not casting (state.playing.location === 'local')
+// or if we're trying to connect but haven't yet ('chromecast-pending', etc)
+function isCasting (state) {
+  return state.playing.location === 'chromecast' ||
+    state.playing.location === 'airplay' ||
+    state.playing.location === 'dlna'
+}
+
+function restoreBounds (state) {
+  ipcRenderer.send('setAspectRatio', 0)
+  if (state.window.bounds) {
+    ipcRenderer.send('setBounds', state.window.bounds, false)
+  }
+}

renderer/controllers/prefs-controller.js

@@ -0,0 +1,51 @@
+const State = require('../lib/state')
+
+// Controls the Preferences screen
+module.exports = class PrefsController {
+  constructor (state, config) {
+    this.state = state
+    this.config = config
+  }
+
+  // Goes to the Preferences screen
+  show () {
+    var state = this.state
+    state.location.go({
+      url: 'preferences',
+      onbeforeload: function (cb) {
+        // initialize preferences
+        state.window.title = 'Preferences'
+        state.unsaved = Object.assign(state.unsaved || {}, {prefs: state.saved.prefs || {}})
+        cb()
+      },
+      onbeforeunload: (cb) => {
+        // save state after preferences
+        this.save()
+        state.window.title = this.config.APP_WINDOW_TITLE
+        cb()
+      }
+    })
+  }
+
+  // Updates a single property in the UNSAVED prefs
+  // For example: updatePreferences("foo.bar", "baz")
+  // Call savePreferences to save to config.json
+  update (property, value) {
+    var path = property.split('.')
+    var key = this.state.unsaved.prefs
+    for (var i = 0; i < path.length - 1; i++) {
+      if (typeof key[path[i]] === 'undefined') {
+        key[path[i]] = {}
+      }
+      key = key[path[i]]
+    }
+    key[path[i]] = value
+  }
+
+  // All unsaved prefs take effect atomically, and are saved to config.json
+  save () {
+    var state = this.state
+    state.saved.prefs = Object.assign(state.saved.prefs || {}, state.unsaved.prefs)
+    State.save(state)
+  }
+}

renderer/controllers/subtitles-controller.js

@@ -0,0 +1,137 @@
+const electron = require('electron')
+const fs = require('fs-extra')
+const path = require('path')
+const parallel = require('run-parallel')
+
+const {dispatch} = require('../lib/dispatcher')
+
+module.exports = class SubtitlesController {
+  constructor (state) {
+    this.state = state
+  }
+
+  openSubtitles () {
+    electron.remote.dialog.showOpenDialog({
+      title: 'Select a subtitles file.',
+      filters: [ { name: 'Subtitles', extensions: ['vtt', 'srt'] } ],
+      properties: [ 'openFile' ]
+    }, (filenames) => {
+      if (!Array.isArray(filenames)) return
+      this.addSubtitles(filenames, true)
+    })
+  }
+
+  selectSubtitle (ix) {
+    this.state.playing.subtitles.selectedIndex = ix
+  }
+
+  toggleSubtitlesMenu () {
+    var subtitles = this.state.playing.subtitles
+    subtitles.showMenu = !subtitles.showMenu
+  }
+
+  addSubtitles (files, autoSelect) {
+    var state = this.state
+    // Subtitles are only supported when playing video files
+    if (state.playing.type !== 'video') return
+    if (files.length === 0) return
+    var subtitles = state.playing.subtitles
+
+    // Read the files concurrently, then add all resulting subtitle tracks
+    var tasks = files.map((file) => (cb) => loadSubtitle(file, cb))
+    parallel(tasks, function (err, tracks) {
+      if (err) return dispatch('error', err)
+
+      for (var i = 0; i < tracks.length; i++) {
+        // No dupes allowed
+        var track = tracks[i]
+        var trackIndex = state.playing.subtitles.tracks
+          .findIndex((t) => track.filePath === t.filePath)
+
+        // Add the track
+        if (trackIndex === -1) {
+          trackIndex = state.playing.subtitles.tracks.push(track) - 1
+        }
+
+        // If we're auto-selecting a track, try to find one in the user's language
+        if (autoSelect && (i === 0 || isSystemLanguage(track.language))) {
+          state.playing.subtitles.selectedIndex = trackIndex
+        }
+      }
+
+      // Finally, make sure no two tracks have the same label
+      relabelSubtitles(subtitles)
+    })
+  }
+
+  checkForSubtitles () {
+    if (this.state.playing.type !== 'video') return
+    var torrentSummary = this.state.getPlayingTorrentSummary()
+    if (!torrentSummary || !torrentSummary.progress) return
+
+    torrentSummary.progress.files.forEach((fp, ix) => {
+      if (fp.numPieces !== fp.numPiecesPresent) return // ignore incomplete files
+      var file = torrentSummary.files[ix]
+      if (!this.isSubtitle(file.name)) return
+      var filePath = path.join(torrentSummary.path, file.path)
+      this.addSubtitles([filePath], false)
+    })
+  }
+
+  isSubtitle (file) {
+    var name = typeof file === 'string' ? file : file.name
+    var ext = path.extname(name).toLowerCase()
+    return ext === '.srt' || ext === '.vtt'
+  }
+}
+
+function loadSubtitle (file, cb) {
+  // Lazy load to keep startup fast
+  var concat = require('simple-concat')
+  var LanguageDetect = require('languagedetect')
+  var srtToVtt = require('srt-to-vtt')
+
+  // Read the .SRT or .VTT file, parse it, add subtitle track
+  var filePath = file.path || file
+
+  var vttStream = fs.createReadStream(filePath).pipe(srtToVtt())
+
+  concat(vttStream, function (err, buf) {
+    if (err) return dispatch('error', 'Can\'t parse subtitles file.')
+
+    // Detect what language the subtitles are in
+    var vttContents = buf.toString().replace(/(.*-->.*)/g, '')
+    var langDetected = (new LanguageDetect()).detect(vttContents, 2)
+    langDetected = langDetected.length ? langDetected[0][0] : 'subtitle'
+    langDetected = langDetected.slice(0, 1).toUpperCase() + langDetected.slice(1)
+
+    var track = {
+      buffer: 'data:text/vtt;base64,' + buf.toString('base64'),
+      language: langDetected,
+      label: langDetected,
+      filePath: filePath
+    }
+
+    cb(null, track)
+  })
+}
+
+// Checks whether a language name like "English" or "German" matches the system
+// language, aka the current locale
+function isSystemLanguage (language) {
+  var iso639 = require('iso-639-1')
+  var osLangISO = window.navigator.language.split('-')[0] // eg "en"
+  var langIso = iso639.getCode(language) // eg "de" if language is "German"
+  return langIso === osLangISO
+}
+
+// Make sure we don't have two subtitle tracks with the same label
+// Labels each track by language, eg "German", "English", "English 2", ...
+function relabelSubtitles (subtitles) {
+  var counts = {}
+  subtitles.tracks.forEach(function (track) {
+    var lang = track.language
+    counts[lang] = (counts[lang] || 0) + 1
+    track.label = counts[lang] > 1 ? (lang + ' ' + counts[lang]) : lang
+  })
+}

renderer/controllers/torrent-list-controller.js

@@ -0,0 +1,282 @@
+const fs = require('fs')
+const path = require('path')
+const electron = require('electron')
+
+const {dispatch} = require('../lib/dispatcher')
+const State = require('../lib/state')
+const sound = require('../lib/sound')
+const TorrentSummary = require('../lib/torrent-summary')
+
+const ipcRenderer = electron.ipcRenderer
+
+const instantIoRegex = /^(https:\/\/)?instant\.io\/#/
+
+// Controls the torrent list: creating, adding, deleting, & manipulating torrents
+module.exports = class TorrentListController {
+  constructor (state) {
+    this.state = state
+  }
+
+  // Adds a torrent to the list, starts downloading/seeding. TorrentID can be a
+  // magnet URI, infohash, or torrent file: https://github.com/feross/webtorrent#clientaddtorrentid-opts-function-ontorrent-torrent-
+  addTorrent (torrentId) {
+    if (torrentId.path) {
+      // Use path string instead of W3C File object
+      torrentId = torrentId.path
+    }
+    // Allow a instant.io link to be pasted
+    // TODO: remove this once support is added to webtorrent core
+    if (typeof torrentId === 'string' && instantIoRegex.test(torrentId)) {
+      torrentId = torrentId.slice(torrentId.indexOf('#') + 1)
+    }
+
+    var torrentKey = this.state.nextTorrentKey++
+    var path = this.state.saved.prefs.downloadPath
+
+    ipcRenderer.send('wt-start-torrenting', torrentKey, torrentId, path)
+
+    dispatch('backToList')
+  }
+
+  // Shows the Create Torrent page with options to seed a given file or folder
+  showCreateTorrent (files) {
+    // Files will either be an array of file objects, which we can send directly
+    // to the create-torrent screen
+    if (files.length === 0 || typeof files[0] !== 'string') {
+      this.state.location.go({
+        url: 'create-torrent',
+        files: files
+      })
+      return
+    }
+
+    // ... or it will be an array of mixed file and folder paths. We have to walk
+    // through all the folders and find the files
+    findFilesRecursive(files, (allFiles) => this.showCreateTorrent(allFiles))
+  }
+
+  // Switches between the advanced and simple Create Torrent UI
+  toggleCreateTorrentAdvanced () {
+    var info = this.state.location.current()
+    if (info.url !== 'create-torrent') return
+    info.showAdvanced = !info.showAdvanced
+  }
+
+  // Creates a new torrent and start seeeding
+  createTorrent (options) {
+    var state = this.state
+    var torrentKey = state.nextTorrentKey++
+    ipcRenderer.send('wt-create-torrent', torrentKey, options)
+    state.location.backToFirst(function () {
+      state.location.clearForward('create-torrent')
+    })
+  }
+
+  // Starts downloading and/or seeding a given torrentSummary.
+  startTorrentingSummary (torrentSummary) {
+    var s = torrentSummary
+
+    // Backward compatibility for config files save before we had torrentKey
+    if (!s.torrentKey) s.torrentKey = this.state.nextTorrentKey++
+
+    // Use Downloads folder by default
+    if (!s.path) s.path = this.state.saved.prefs.downloadPath
+
+    ipcRenderer.send('wt-start-torrenting',
+                      s.torrentKey,
+                      TorrentSummary.getTorrentID(s),
+                      s.path,
+                      s.fileModtimes,
+                      s.selections)
+  }
+
+  // TODO: use torrentKey, not infoHash
+  toggleTorrent (infoHash) {
+    var torrentSummary = TorrentSummary.getByKey(this.state, infoHash)
+    if (torrentSummary.status === 'paused') {
+      torrentSummary.status = 'new'
+      this.startTorrentingSummary(torrentSummary)
+      sound.play('ENABLE')
+    } else {
+      torrentSummary.status = 'paused'
+      ipcRenderer.send('wt-stop-torrenting', torrentSummary.infoHash)
+      sound.play('DISABLE')
+    }
+  }
+
+  toggleTorrentFile (infoHash, index) {
+    var torrentSummary = TorrentSummary.getByKey(this.state, infoHash)
+    torrentSummary.selections[index] = !torrentSummary.selections[index]
+
+    // Let the WebTorrent process know to start or stop fetching that file
+    ipcRenderer.send('wt-select-files', infoHash, torrentSummary.selections)
+  }
+
+  confirmDeleteTorrent (infoHash, deleteData) {
+    this.state.modal = {
+      id: 'remove-torrent-modal',
+      infoHash,
+      deleteData
+    }
+  }
+
+  // TODO: use torrentKey, not infoHash
+  deleteTorrent (infoHash, deleteData) {
+    ipcRenderer.send('wt-stop-torrenting', infoHash)
+
+    var index = this.state.saved.torrents.findIndex((x) => x.infoHash === infoHash)
+
+    if (index > -1) {
+      var summary = this.state.saved.torrents[index]
+
+      // remove torrent and poster file
+      deleteFile(TorrentSummary.getTorrentPath(summary))
+      deleteFile(TorrentSummary.getPosterPath(summary)) // TODO: will the css path hack affect windows?
+
+      // optionally delete the torrent data
+      if (deleteData) moveItemToTrash(summary)
+
+      // remove torrent from saved list
+      this.state.saved.torrents.splice(index, 1)
+      State.saveThrottled(this.state)
+    }
+
+    this.state.location.clearForward('player') // prevent user from going forward to a deleted torrent
+    sound.play('DELETE')
+  }
+
+  toggleSelectTorrent (infoHash) {
+    if (this.state.selectedInfoHash === infoHash) {
+      this.state.selectedInfoHash = null
+    } else {
+      this.state.selectedInfoHash = infoHash
+    }
+  }
+
+  openTorrentContextMenu (infoHash) {
+    var torrentSummary = TorrentSummary.getByKey(this.state, infoHash)
+    var menu = new electron.remote.Menu()
+
+    menu.append(new electron.remote.MenuItem({
+      label: 'Remove From List',
+      click: () => dispatch('confirmDeleteTorrent', torrentSummary.infoHash, false)
+    }))
+
+    menu.append(new electron.remote.MenuItem({
+      label: 'Remove Data File',
+      click: () => dispatch('confirmDeleteTorrent', torrentSummary.infoHash, true)
+    }))
+
+    menu.append(new electron.remote.MenuItem({
+      type: 'separator'
+    }))
+
+    if (torrentSummary.files) {
+      menu.append(new electron.remote.MenuItem({
+        label: process.platform === 'darwin' ? 'Show in Finder' : 'Show in Folder',
+        click: () => showItemInFolder(torrentSummary)
+      }))
+      menu.append(new electron.remote.MenuItem({
+        type: 'separator'
+      }))
+    }
+
+    menu.append(new electron.remote.MenuItem({
+      label: 'Copy Magnet Link to Clipboard',
+      click: () => electron.clipboard.writeText(torrentSummary.magnetURI)
+    }))
+
+    menu.append(new electron.remote.MenuItem({
+      label: 'Copy Instant.io Link to Clipboard',
+      click: () => electron.clipboard.writeText(`https://instant.io/#${torrentSummary.infoHash}`)
+    }))
+
+    menu.append(new electron.remote.MenuItem({
+      label: 'Save Torrent File As...',
+      click: () => saveTorrentFileAs(torrentSummary)
+    }))
+
+    menu.popup(electron.remote.getCurrentWindow())
+  }
+}
+
+// Recursively finds {name, path, size} for all files in a folder
+// Calls `cb` on success, calls `onError` on failure
+function findFilesRecursive (paths, cb) {
+  if (paths.length > 1) {
+    var numComplete = 0
+    var ret = []
+    paths.forEach(function (path) {
+      findFilesRecursive([path], function (fileObjs) {
+        ret = ret.concat(fileObjs)
+        if (++numComplete === paths.length) {
+          ret.sort((a, b) => a.path < b.path ? -1 : a.path > b.path)
+          cb(ret)
+        }
+      })
+    })
+    return
+  }
+
+  var fileOrFolder = paths[0]
+  fs.stat(fileOrFolder, function (err, stat) {
+    if (err) return dispatch('error', err)
+
+    // Files: return name, path, and size
+    if (!stat.isDirectory()) {
+      var filePath = fileOrFolder
+      return cb([{
+        name: path.basename(filePath),
+        path: filePath,
+        size: stat.size
+      }])
+    }
+
+    // Folders: recurse, make a list of all the files
+    var folderPath = fileOrFolder
+    fs.readdir(folderPath, function (err, fileNames) {
+      if (err) return dispatch('error', err)
+      var paths = fileNames.map((fileName) => path.join(folderPath, fileName))
+      findFilesRecursive(paths, cb)
+    })
+  })
+}
+
+function deleteFile (path) {
+  if (!path) return
+  fs.unlink(path, function (err) {
+    if (err) dispatch('error', err)
+  })
+}
+
+// Delete all files in a torrent
+function moveItemToTrash (torrentSummary) {
+  var filePath = TorrentSummary.getFileOrFolder(torrentSummary)
+  ipcRenderer.send('moveItemToTrash', filePath)
+}
+
+function showItemInFolder (torrentSummary) {
+  ipcRenderer.send('showItemInFolder', TorrentSummary.getFileOrFolder(torrentSummary))
+}
+
+function saveTorrentFileAs (torrentSummary) {
+  var downloadPath = this.state.saved.prefs.downloadPath
+  var newFileName = path.parse(torrentSummary.name).name + '.torrent'
+  var opts = {
+    title: 'Save Torrent File',
+    defaultPath: path.join(downloadPath, newFileName),
+    filters: [
+      { name: 'Torrent Files', extensions: ['torrent'] },
+      { name: 'All Files', extensions: ['*'] }
+    ]
+  }
+  electron.remote.dialog.showSaveDialog(electron.remote.getCurrentWindow(), opts, function (savePath) {
+    var torrentPath = TorrentSummary.getTorrentPath(torrentSummary)
+    fs.readFile(torrentPath, function (err, torrentFile) {
+      if (err) return dispatch('error', err)
+      fs.writeFile(savePath, torrentFile, function (err) {
+        if (err) return dispatch('error', err)
+      })
+    })
+  })
+}

renderer/controllers/update-controller.js

@@ -0,0 +1,26 @@
+const State = require('../lib/state')
+
+// Controls the UI checking for new versions of the app, prompting install
+module.exports = class UpdateController {
+  constructor (state) {
+    this.state = state
+  }
+
+  // Shows a modal saying that we have an update
+  updateAvailable (version) {
+    var skipped = this.state.saved.skippedVersions
+    if (skipped && skipped.includes(version)) {
+      console.log('new version skipped by user: v' + version)
+      return
+    }
+    this.state.modal = { id: 'update-available-modal', version: version }
+  }
+
+  // Don't show the modal again until the next version
+  skipVersion (version) {
+    var skipped = this.state.saved.skippedVersions
+    if (!skipped) skipped = this.state.saved.skippedVersions = []
+    skipped.push(version)
+    State.saveThrottled(this.state)
+  }
+}

renderer/lib/cast.js

@@ -13,9 +13,8 @@ module.exports = {
   setRate
 }
 
-var airplayer = require('airplayer')()
-var chromecasts = require('chromecasts')()
-var dlnacasts = require('dlnacasts')()
+// Lazy load these for a ~300ms improvement in startup time
+var airplayer, chromecasts, dlnacasts
 
 var config = require('../../config')
 
@@ -33,6 +32,11 @@ function init (appState, callback) {
   state = appState
   update = callback
 
+  // Load modules, scan the network for devices
+  airplayer = require('airplayer')()
+  chromecasts = require('chromecasts')()
+  dlnacasts = require('dlnacasts')()
+
   state.devices.chromecast = chromecastPlayer()
   state.devices.dlna = dlnaPlayer()
   state.devices.airplay = airplayPlayer()

renderer/lib/state.js

@@ -1,15 +1,17 @@
-module.exports = {
-  getDefaultPlayState,
-  load,
-  save
-}
-
 var appConfig = require('application-config')('WebTorrent')
 var path = require('path')
+var {EventEmitter} = require('events')
 
 var config = require('../../config')
 var migrations = require('./migrations')
 
+var State = module.exports = Object.assign(new EventEmitter(), {
+  getDefaultPlayState,
+  load,
+  save,
+  saveThrottled
+})
+
 appConfig.filePath = path.join(config.CONFIG_PATH, 'config.json')
 
 function getDefaultState () {
@@ -180,8 +182,7 @@ function load (cb) {
 // Write state.saved to the JSON state file
 function save (state, cb) {
   console.log('Saving state to ' + appConfig.filePath)
-
-  var electron = require('electron')
+  delete state.saveStateTimeout
 
   // Clean up, so that we're not saving any pending state
   var copy = Object.assign({}, state.saved)
@@ -203,10 +204,17 @@ function save (state, cb) {
       return torrent
     })
 
-  appConfig.write(copy, function (err) {
+  appConfig.write(copy, (err) => {
     if (err) console.error(err)
-
-    // TODO: this doesn't belong here
-    electron.ipcRenderer.send('savedState')
+    else State.emit('savedState')
   })
 }
+
+// Write, but no more than once a second
+function saveThrottled (state) {
+  if (state.saveStateTimeout) return
+  state.saveStateTimeout = setTimeout(function () {
+    if (!state.saveStateTimeout) return
+    save(state)
+  }, 1000)
+}

renderer/lib/telemetry.js

@@ -30,7 +30,13 @@ function init (state) {
   telemetry.system = getSystemInfo()
   telemetry.approxNumTorrents = getApproxNumTorrents(state)
 
-  postToServer(telemetry)
+  if (config.IS_PRODUCTION) {
+    postToServer()
+  } else {
+    // Development: telemetry used only for local debugging
+    // Empty uncaught errors, etc at the start of every run
+    reset()
+  }
 }
 
 function reset () {
@@ -110,13 +116,19 @@ function getApproxNumTorrents (state) {
 
 // An uncaught error happened in the main process or in one of the windows
 function logUncaughtError (procName, err) {
+  console.error('uncaught error', procName, err)
+
+  // Not initialized yet? Ignore.
+  // Hopefully uncaught errors immediately on startup are fixed in dev
+  if (!telemetry) return
+
   var message, stack
-  if (typeof err === 'string') {
-    message = err
-    stack = ''
-  } else {
+  if (err instanceof Error) {
     message = err.message
     stack = err.stack
+  } else {
+    message = String(err)
+    stack = ''
   }
 
   // We need to POST the telemetry object, make sure it stays < 100kb

renderer/lib/torrent-player.js

@@ -2,7 +2,8 @@ module.exports = {
   isPlayable,
   isVideo,
   isAudio,
-  isPlayableTorrent
+  isPlayableTorrent,
+  pickFileToPlay
 }
 
 var path = require('path')
@@ -43,3 +44,25 @@ function isAudio (file) {
 function isPlayableTorrent (torrentSummary) {
   return torrentSummary.files && torrentSummary.files.some(isPlayable)
 }
+
+// Picks the default file to play from a list of torrent or torrentSummary files
+// Returns an index or undefined, if no files are playable
+function pickFileToPlay (files) {
+  // first, try to find the biggest video file
+  var videoFiles = files.filter(isVideo)
+  if (videoFiles.length > 0) {
+    var largestVideoFile = videoFiles.reduce(function (a, b) {
+      return a.length > b.length ? a : b
+    })
+    return files.indexOf(largestVideoFile)
+  }
+
+  // if there are no videos, play the first audio file
+  var audioFiles = files.filter(isAudio)
+  if (audioFiles.length > 0) {
+    return files.indexOf(audioFiles[0])
+  }
+
+  // no video or audio means nothing is playable
+  return undefined
+}

renderer/lib/torrent-summary.js

@@ -1,6 +1,9 @@
 module.exports = {
   getPosterPath,
-  getTorrentPath
+  getTorrentPath,
+  getByKey,
+  getTorrentID,
+  getFileOrFolder
 }
 
 var path = require('path')
@@ -22,3 +25,32 @@ function getPosterPath (torrentSummary) {
   // Backslashes in URLS in CSS cause bizarre string encoding issues
   return posterPath.replace(/\\/g, '/')
 }
+
+// Expects a torrentSummary
+// Returns a torrentID: filename, magnet URI, or infohash
+function getTorrentID (torrentSummary) {
+  var s = torrentSummary
+  if (s.torrentFileName) { // Load torrent file from disk
+    return getTorrentPath(s)
+  } else { // Load torrent from DHT
+    return s.magnetURI || s.infoHash
+  }
+}
+
+// Expects a torrentKey or infoHash
+// Returns the corresponding torrentSummary, or undefined
+function getByKey (state, torrentKey) {
+  if (!torrentKey) return undefined
+  return state.saved.torrents.find((x) =>
+    x.torrentKey === torrentKey || x.infoHash === torrentKey)
+}
+
+// Returns the path to either the file (in a single-file torrent) or the root
+// folder (in  multi-file torrent)
+// WARNING: assumes that multi-file torrents consist of a SINGLE folder.
+// TODO: make this assumption explicit, enforce it in the `create-torrent`
+// module. Store root folder explicitly to avoid hacky path processing below.
+function getFileOrFolder (torrentSummary) {
+  var ts = torrentSummary
+  return path.join(ts.path, ts.files[0].path.split('/')[0])
+}

renderer/main.css

@@ -326,7 +326,6 @@ table {
 }
 
 .create-torrent input.torrent-is-private {
-  width: initial;
   margin: 0;
 }
 
@@ -404,7 +403,7 @@ button.button-raised:active {
  * OTHER FORM ELEMENT DEFAULTS
  */
 
-input {
+input[type='text'] {
   background: transparent;
   width: 300px;
   padding: 6px;

renderer/views/app.js

@@ -4,7 +4,7 @@ var hx = require('../lib/hx')
 var Header = require('./header')
 
 var Views = {
-  'home': require('./home'),
+  'home': require('./torrent-list'),
   'player': require('./player'),
   'create-torrent': require('./create-torrent'),
   'preferences': require('./preferences')
@@ -12,6 +12,7 @@ var Views = {
 
 var Modals = {
   'open-torrent-address-modal': require('./open-torrent-address-modal'),
+  'remove-torrent-modal': require('./remove-torrent-modal'),
   'update-available-modal': require('./update-available-modal'),
   'unsupported-media-modal': require('./unsupported-media-modal')
 }

renderer/views/create-torrent.js

@@ -65,7 +65,8 @@ function CreateTorrentPage (state) {
         <label>Path:</label>
         <div class='torrent-attribute'>${pathPrefix}</div>
       </p>
-      <div class='expand-collapse ${collapsedClass}' onclick=${handleToggleShowAdvanced}>
+      <div class='expand-collapse ${collapsedClass}'
+           onclick=${dispatcher('toggleCreateTorrentAdvanced')}>
         ${info.showAdvanced ? 'Basic' : 'Advanced'}
       </div>
       <div class="create-torrent-advanced ${collapsedClass}">
@@ -87,7 +88,7 @@ function CreateTorrentPage (state) {
         </p>
       </div>
       <p class="float-right">
-        <button class='button-flat light' onclick=${handleCancel}>Cancel</button>
+        <button class='button-flat light' onclick=${dispatcher('back')}>Cancel</button>
         <button class='button-raised' onclick=${handleOK}>Create Torrent</button>
       </p>
     </div>
@@ -114,17 +115,6 @@ function CreateTorrentPage (state) {
     }
     dispatch('createTorrent', options)
   }
-
-  function handleCancel () {
-    dispatch('back')
-  }
-
-  function handleToggleShowAdvanced () {
-    // TODO: what's the clean way to handle this?
-    // Should every button on every screen have its own dispatch()?
-    info.showAdvanced = !info.showAdvanced
-    dispatch('update')
-  }
 }
 
 function CreateTorrentErrorPage () {

renderer/views/player.js

@@ -43,7 +43,7 @@ function renderMedia (state) {
       mediaElement.play()
     }
     // When the user clicks or drags on the progress bar, jump to that position
-    if (state.playing.jumpToTime) {
+    if (state.playing.jumpToTime != null) {
       mediaElement.currentTime = state.playing.jumpToTime
       state.playing.jumpToTime = null
     }
@@ -73,6 +73,15 @@ function renderMedia (state) {
     var file = state.getPlayingFileSummary()
     file.currentTime = state.playing.currentTime = mediaElement.currentTime
     file.duration = state.playing.duration = mediaElement.duration
+
+    // Save selected subtitle
+    if (state.playing.subtitles.selectedIndex !== -1) {
+      var index = state.playing.subtitles.selectedIndex
+      file.selectedSubtitle = state.playing.subtitles.tracks[index].filePath
+    } else if (file.selectedSubtitle != null) {
+      delete file.selectedSubtitle
+    }
+
     state.playing.volume = mediaElement.volume
   }
 
@@ -519,7 +528,7 @@ function renderPlayerControls (state) {
     var windowWidth = document.querySelector('body').clientWidth
     var fraction = e.clientX / windowWidth
     var position = fraction * state.playing.duration /* seconds */
-    dispatch('playbackJump', position)
+    dispatch('skipTo', position)
   }
 
   // Handles volume muting and Unmuting

renderer/views/remove-torrent-modal.js

@@ -0,0 +1,26 @@
+module.exports = RemoveTorrentModal
+
+var {dispatch, dispatcher} = require('../lib/dispatcher')
+var hx = require('../lib/hx')
+
+function RemoveTorrentModal (state) {
+  var message = state.modal.deleteData
+    ? 'Are you sure you want to remove this torrent from the list and delete the data file?'
+    : 'Are you sure you want to remove this torrent from the list?'
+  var buttonText = state.modal.deleteData ? 'Remove Data' : 'Remove'
+
+  return hx`
+    <div>
+      <p><strong>${message}</strong></p>
+      <p class='float-right'>
+        <button class='button button-flat' onclick=${dispatcher('exitModal')}>Cancel</button>
+        <button class='button button-raised' onclick=${handleRemove}>${buttonText}</button>
+      </p>
+    </div>
+  `
+
+  function handleRemove () {
+    dispatch('deleteTorrent', state.modal.infoHash, state.modal.deleteData)
+    dispatch('exitModal')
+  }
+}

renderer/views/torrent-list.js

@@ -153,7 +153,7 @@ function TorrentList (state) {
         <i.button-round.icon.play
           title=${playTooltip}
           class=${playClass}
-          onclick=${dispatcher('play', infoHash)}>
+          onclick=${dispatcher('playFile', infoHash)}>
           ${playIcon}
         </i>
       `
@@ -172,7 +172,7 @@ function TorrentList (state) {
         <i
           class='icon delete'
           title='Remove torrent'
-          onclick=${dispatcher('deleteTorrent', infoHash)}>
+          onclick=${dispatcher('confirmDeleteTorrent', infoHash, false)}>
           close
         </i>
       </div>
@@ -242,7 +242,7 @@ function TorrentList (state) {
     var handleClick
     if (isPlayable) {
       icon = 'play_arrow' /* playable? add option to play */
-      handleClick = dispatcher('play', infoHash, index)
+      handleClick = dispatcher('playFile', infoHash, index)
     } else {
       icon = 'description' /* file icon, opens in OS default app */
       handleClick = dispatcher('openItem', infoHash, index)