@edenware/dlnacasts 1.0.0

package/dist/src/index.cjs

@@ -0,0 +1,373 @@
+const MediaRenderer = require('upnp-mediarenderer-client')
+const events = require('events')
+const parallel = require('run-parallel')
+const parseString = require('xml2js').parseString
+const SSDP = require('node-ssdp').Client
+const { isIP } = require('node:net')
+const http = require('node:http')
+const agent = new http.Agent({ keepAlive: true, maxSockets: 5 })
+
+const SERVICE_TYPE = 'urn:schemas-upnp-org:device:MediaRenderer:1';
+const thunky = require('thunky')
+
+const noop = () => {}
+
+module.exports = () => {
+  const that = new events.EventEmitter()
+  const casts = {}
+  const ssdp = SSDP ? new SSDP({
+    unicastHost: '192.168.1.8',
+    log: true
+  }) : null
+
+  that.players = []
+
+  const emit = (cst) => {
+    if (!cst || !cst.host || cst.emitted) return
+    cst.emitted = true
+
+    const player = new events.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) => {
+        console.debug('[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', () => {
+        console.debug('[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) => {
+      console.debug('[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) {
+          console.debug('[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) {
+            console.debug('[DLNACASTS] Skipping getStatus: stopped=%s, playFailed=%s', stopped, playFailed)
+            return
+          }
+          if (!player.client) {
+            console.debug('[DLNACASTS] player.client is undefined in getStatus, attempting to reconnect')
+            connect((err) => {
+              if (err) {
+                console.debug('[DLNACASTS] Reconnect failed in getStatus:', err)
+                playFailed = true // Marcar falha se reconexão falhar
+                return
+              }
+              console.debug('[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) {
+        console.debug('[DLNACASTS] Skipping status: stopped=%s, playFailed=%s', stopped, playFailed)
+        return cb(null, player._status)
+      }
+      if (!player.client) {
+        console.debug('[DLNACASTS] player.client is undefined in status, attempting to reconnect')
+        connect((err) => {
+          if (err) {
+            console.debug('[DLNACASTS] Reconnect failed in status:', err)
+            playFailed = true // Marcar falha se reconexão falhar
+            return cb(err)
+          }
+          console.debug('[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) => {
+            console.debug('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) => {
+        console.debug('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 = () => {
+    console.debug('[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()
+
+                  console.debug('[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 = () => {
+    console.debug('[DLNACASTS] destroying ssdp...')
+    if (ssdp) {
+      ssdp.stop()
+    }
+  }
+
+  that.close = () => {
+    that.removeAllListeners('update')
+  }
+
+  return that
+}

package/package.json

@@ -0,0 +1,45 @@
+{
+  "name": "@edenware/dlnacasts",
+  "version": "1.0.0",
+  "description": "Query your local network for DLNA enabled renderers and have them play media",
+  "type": "module",
+  "main": "dist/index.cjs",
+  "exports": {
+    ".": {
+      "import": "./dist/index.mjs",
+      "require": "./dist/index.cjs"
+    }
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/EdenwareApps/dlnacasts4.git"
+  },
+  "keywords": [
+    "dlna",
+    "upnp",
+    "cast",
+    "client"
+  ],
+  "author": "Edenware",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/EdenwareApps/dlnacasts4/issues"
+  },
+  "homepage": "https://github.com/EdenwareApps/dlnacasts4#readme",
+  "scripts": {
+    "build": "node scripts/build.cjs",
+    "test": "node scripts/test.cjs"
+  },
+  "dependencies": {
+    "@edenware/ssdp": "^4.0.3",
+    "run-parallel": "^1.2.0",
+    "thunky": "^1.1.0",
+    "upnp-mediarenderer-client": "^1.4.0",
+    "xml2js": "^0.6.2"
+  }
+}