@edenware/dlnacasts 1.0.0

package/dist/index.mjs

@@ -0,0 +1,390 @@
+import MediaRenderer from 'upnp-mediarenderer-client'
+import { EventEmitter } from 'events'
+import parallel from 'run-parallel'
+import { parseString } from 'xml2js'
+import { Client as SSDP } from 'node-ssdp'
+import { isIP } from 'node:net'
+import * as http from 'node:http'
+const os = require('os')
+const agent = new http.Agent({ keepAlive: true, maxSockets: 5 })
+
+const SERVICE_TYPE = 'urn:schemas-upnp-org:device:MediaRenderer:1';
+import thunky from 'thunky'
+
+const noop = () => {}
+
+export default (options = {}) => {
+  const log = options.log ? console.debug : () => {}
+
+  // Find local IP
+  const interfaces = os.networkInterfaces()
+  let localIP = '192.168.1.8' // fallback
+  for (const name of Object.keys(interfaces)) {
+    for (const iface of interfaces[name]) {
+      if (iface.family === 'IPv4' && !iface.internal) {
+        localIP = iface.address
+        break
+      }
+    }
+    if (localIP !== '192.168.1.8') break
+  }
+  log('Local IP:', localIP)
+
+  const that = new EventEmitter()
+  const casts = {}
+  const ssdp = SSDP ? new SSDP({
+    unicastHost: localIP,
+    log: true
+  }) : null
+
+  that.players = []
+
+  const emit = (cst) => {
+    if (!cst || !cst.host || cst.emitted) return
+    cst.emitted = true
+
+    const player = new EventEmitter()
+    let getStatus = undefined
+    let stopped = false // Flag para rastrear se stop foi chamado
+    let playFailed = false // Flag para rastrear se play falhou
+
+    const connect = thunky(function reconnect (cb) {
+      const client = new MediaRenderer(player.xml)
+
+      client.on('error', (err) => {
+        log('[DLNACASTS] Client error, clearing player.client:', err)
+        try { clearInterval(getStatus) } catch(e) {}
+        player.client = undefined
+        player.emit('error', err)
+      })
+
+      client.on('loading', (err) => {
+        player.emit('loading', err)
+      })
+
+      client.on('close', () => {
+        log('[DLNACASTS] Client closed, clearing player.client')
+        try { clearInterval(getStatus) } catch(e) {}
+        player.client = undefined
+        connect = thunky(reconnect) // Reset thunky para permitir nova reconexão
+      })
+
+      player.client = client
+      cb(null, player.client)
+    })
+
+    const parseTime = (time) => {
+      if (!time || time.indexOf(':') === -1) return 0
+      const parts = time.split(':').map(Number)
+      return parts[0] * 3600 + parts[1] * 60 + parts[2]
+    }
+
+    player.name = cst.name
+    player.host = cst.host
+    player.xml = cst.xml
+    player._status = {}
+    player.MAX_VOLUME = 100
+
+    player.connect = connect
+
+    player.close = (cb = noop) => {
+      log('[DLNACASTS] Closing player, clearing player.client')
+      try { clearInterval(getStatus) } catch(e) {}
+      if (player.client) {
+        for (let e of ["error", "status", "loading", "close"]) {
+          player.client.removeAllListeners(e)
+        }
+        player.client = undefined
+      }
+      stopped = true // Marcar que stop foi chamado
+      cb()
+    }
+
+    player.play = (url, opts, cb = noop) => {
+      if (typeof opts === 'function') return player.play(url, null, opts)
+      if (!opts) opts = {}
+      if (!url) return player.resume(cb)
+      
+      stopped = false // Resetar stopped ao chamar play
+      playFailed = false // Resetar playFailed ao chamar play
+      player.subtitles = opts.subtitles
+
+      connect((err, p) => {
+        if (err) {
+          log('[DLNACASTS] Connect failed in play:', err)
+          playFailed = true // Marcar que play falhou
+          return cb(err)
+        }
+
+        try { clearInterval(getStatus) } catch(e) {}
+
+        const media = {
+          autoplay: opts.autoPlay !== false,
+          contentType: opts.type || 'video/mp4',
+          metadata: opts.metadata || {
+            title: opts.title || '',
+            type: 'video', // can be 'video', 'audio' or 'image'
+            subtitlesUrl: player.subtitles && player.subtitles.length ? player.subtitles[0] : null
+          }
+        }
+        if (opts.dlnaFeatures) {
+          media.dlnaFeatures = opts.dlnaFeatures || 'DLNA.ORG_OP=01;DLNA.ORG_CI=0;DLNA.ORG_FLAGS=01500000000000000000000000000000'
+          //media.dlnaFeatures = opts.dlnaFeatures; // for LG WebOS 'DLNA.ORG_OP=01;DLNA.ORG_FLAGS=01100000000000000000000000000000' allows seeking
+        }
+
+        let callback = cb
+        if (opts.seek) {
+          callback = (err) => {
+            if (err) {
+              playFailed = true // Marcar que play falhou
+              return cb(err)
+            }
+            player.seek(opts.seek, cb)
+          }
+        }
+
+        getStatus = setInterval(() => {
+          if (stopped || playFailed) {
+            log('[DLNACASTS] Skipping getStatus: stopped=%s, playFailed=%s', stopped, playFailed)
+            return
+          }
+          if (!player.client) {
+            log('[DLNACASTS] player.client is undefined in getStatus, attempting to reconnect')
+            connect((err) => {
+              if (err) {
+                log('[DLNACASTS] Reconnect failed in getStatus:', err)
+                playFailed = true // Marcar falha se reconexão falhar
+                return
+              }
+              log('[DLNACASTS] Reconnected successfully in getStatus')
+              player.client.callAction('AVTransport', 'GetTransportInfo', {
+                InstanceID: player.client.instanceId
+              }, (err, res) => {
+                if (err) return
+                const newStatus = res.CurrentTransportState
+                if (newStatus !== player._status.playerState) {
+                  player._status.playerState = newStatus
+                  player.status((err, status) => {
+                    if (err) return
+                    player.emit('status', status)
+                  })
+                }
+              })
+            })
+            return
+          }
+          player.client.callAction('AVTransport', 'GetTransportInfo', {
+            InstanceID: player.client.instanceId
+          }, (err, res) => {
+            if (err) return
+            const newStatus = res.CurrentTransportState
+            if (newStatus !== player._status.playerState) {
+              player._status.playerState = newStatus
+              player.status((err, status) => {
+                if (err) return
+                player.emit('status', status)
+              })
+            }
+          })
+        }, 1000)
+
+        p.load(url, media, callback)
+      })
+    }
+
+    player.resume = (cb = noop) => {
+      player.client.play(cb)
+    }
+
+    player.pause = (cb = noop) => {
+      player.client.pause(cb)
+    }
+
+    player.stop = (cb = noop) => {
+      try { clearInterval(getStatus) } catch(e) {}
+      stopped = true // Marcar que stop foi chamado
+      player.client.stop(cb)
+    }
+
+    player.status = (cb = noop) => {
+      if (stopped || playFailed) {
+        log('[DLNACASTS] Skipping status: stopped=%s, playFailed=%s', stopped, playFailed)
+        return cb(null, player._status)
+      }
+      if (!player.client) {
+        log('[DLNACASTS] player.client is undefined in status, attempting to reconnect')
+        connect((err) => {
+          if (err) {
+            log('[DLNACASTS] Reconnect failed in status:', err)
+            playFailed = true // Marcar falha se reconexão falhar
+            return cb(err)
+          }
+          log('[DLNACASTS] Reconnected successfully in status')
+          parallel({
+            currentTime: (acb) => {
+              player.client.callAction('AVTransport', 'GetPositionInfo', {
+                InstanceID: player.client.instanceId
+              }, (err, res) => {
+                if (err) return acb()
+                acb(null, parseTime(res.AbsTime) | parseTime(res.RelTime))
+              })
+            },
+            volume: (acb) => {
+              player.getVolume(acb)
+            }
+          }, (err, results) => {
+            log('dlnacasts player.status results: %o', results)
+            player._status.currentTime = results.currentTime
+            player._status.volume = { level: results.volume / player.MAX_VOLUME }
+            return cb(err, player._status)
+          })
+        })
+        return
+      }
+
+      parallel({
+        currentTime: (acb) => {
+          player.client.callAction('AVTransport', 'GetPositionInfo', {
+            InstanceID: player.client.instanceId
+          }, (err, res) => {
+            if (err) return acb()
+            acb(null, parseTime(res.AbsTime) | parseTime(res.RelTime))
+          })
+        },
+        volume: (acb) => {
+          player.getVolume(acb)
+        }
+      }, (err, results) => {
+        log('dlnacasts player.status results: %o', results)
+        player._status.currentTime = results.currentTime
+        player._status.volume = { level: results.volume / player.MAX_VOLUME }
+        return cb(err, player._status)
+      })
+    }
+
+    player.getVolume = (cb) => {
+      player.client.callAction('RenderingControl', 'GetVolume', {
+        InstanceID: player.client.instanceId,
+        Channel: 'Master'
+      }, (err, res) => {
+        if (err) return cb()
+        cb(null, res.CurrentVolume ? parseInt(res.CurrentVolume) : 0)
+      })
+    }
+
+    player.setVolume = (vol, cb = noop) => {
+      player.client.callAction('RenderingControl', 'SetVolume', {
+        InstanceID: player.client.instanceId,
+        Channel: 'Master',
+        DesiredVolume: vol
+      }, cb)
+    }
+
+    player.request = (target, action, data, cb = noop) => {
+      if (data.InstanceID === null) {
+        data.InstanceID = player.client.instanceId
+      }
+      player.client.callAction(target, action, data, cb)
+    }
+
+    player.seek = (time, cb = noop) => {
+      player.client.seek(time, cb)
+    }
+
+    that.players.push(player)
+    that.emit('update', player)
+  }
+
+  if (ssdp) {
+    // Response handler moved to update()
+  }
+
+  that.validate = (name, host, xml) => {
+    if (!casts[name]) {
+      http.get(xml, { agent }, res => {
+        const {statusCode} = res
+        if (statusCode == 200) {
+          if (!casts[name]) {
+            casts[name] = {name, host, xml}
+            emit(casts[name])
+          } else if (isIP(casts[name].host) != 4 && isIP(host) == 4) {
+            casts[name].host = host
+            casts[name].xml = xml
+            emit(casts[name])
+          }
+        }
+        res.resume()
+      }).on('error', e => {})
+    }
+  }
+
+  that.update = () => {
+    log('[DLNACASTS] querying ssdp')
+    if (ssdp) {
+      const tasks = []
+      const responseHandler = (headers, statusCode, info) => {
+        if (!headers.LOCATION) return
+        if (headers.ST !== SERVICE_TYPE) return
+
+        tasks.push((cb) => {
+          http.get(headers.LOCATION, { agent }, (res) => {
+            if (res.statusCode !== 200) return cb()
+            let body = ''
+            res.on('data', (chunk) => { body += chunk })
+            res.on('end', () => {
+              parseString(body, {explicitArray: false, explicitRoot: false},
+                (err, service) => {
+                  if (err) return cb()
+                  if (!service.device) return cb()
+
+                  log('[DLNACASTS] ssdp device:', service.device)
+
+                  const name = service.device.friendlyName
+
+                  if (!name) return cb()
+
+                  const host = info.address
+                  const xml = headers.LOCATION
+
+                  if (!casts[name]) {
+                    casts[name] = {name: name, host: host, xml: xml}
+                    emit(casts[name])
+                  } else if (casts[name] && !casts[name].host) {
+                    casts[name].host = host
+                    casts[name].xml = xml
+                    emit(casts[name])
+                  }
+                  cb()
+                })
+            })
+          }).on('error', () => cb())
+        })
+      }
+      ssdp.on('response', responseHandler)
+      ssdp.search(SERVICE_TYPE)
+      setTimeout(() => {
+        ssdp.removeListener('response', responseHandler)
+        parallel(tasks, () => {})
+      }, 10000)
+    }
+  }
+
+  that.on('removeListener', () => {
+    if (ssdp && that.listenerCount('update') === 0) {
+      ssdp.stop()
+    }
+  })
+
+  that.destroy = () => {
+    log('[DLNACASTS] destroying ssdp...')
+    if (ssdp) {
+      ssdp.stop()
+    }
+  }
+
+  that.close = () => {
+    that.removeAllListeners('update')
+  }
+
+  return that
+}