Unable to skip tracks after using queue.push.uri("#{fname}") or interrupting_queue.push.uri("#{fname}")

[WittyWidget]

Dear @gAlleb,

When I use the /play or /play_now endpoints to play a track by pushing it to the queue or interrupting queue, I am unable to skip the track using the /skip endpoint. Additionally, I don't see any logs in the terminal when trying to skip.

1. Use /play?file=path/to/audiofile.mp3 or /play_now?file=path/to/audiofile.mp3 to play a track.
2. Try skipping the track using /skip.
3. Track doesn't skip, and no logs appear.

Audio Code

## Audio setup

# Declare the next_song variable to hold the next song's metadata
next_song = ref("")

# Next we set up check function that will check playlist for the next song and assign a string with data to `next_song` ref.
def check_next(r)
  if request.resolve(r) then
  m = request.metadata(r)
 
  title = m["title"]
  album = m["album"]
  year = m["year"]

  next_song := "#{title} - #{album} (#{year}) "

  true
  else
  false
  end
end

radio = playlist(audio_dir, check_next=check_next)
radio = mksafe(radio)

## Harbor Functions
# Register the status endpoint on port 8007 and route "/status"
harbor.http.register.simple(port=8007, "/status", status)

# If your source is radio:
# Skip - will be available via http://localhost:8007/skip
def skipper(_) =
  radio.skip()
  http.response(data="The current song was skipped!")
end

harbor.http.register.simple(port=8007, "/skip", skipper)

# Queue setup for normal playback
queue = request.queue()
radio = fallback(track_sensitive=true, [queue, radio])

# Endpoint to play a specific file
def play(request) =
  fname = request.query["file"]
  log.important("Requested file #{fname}.")

  if file.exists(fname) then
    log.important("File Request Accepted.")
    queue.push.uri("#{fname}")
    http.response(content_type="text/html", status_code=200, data="<p>Request pushed.</p>")
  else
    log.important("File Request Rejected: File Not Found.")
    http.response(content_type="text/html", status_code=404, data="<p>Invalid file: #{fname}</p>")
  end
end

harbor.http.register.simple("/play", play, port=8007, method="GET")

# Queue setup for interrupting playback (immediate play)
interrupting_queue = request.queue()
radio = fallback(track_sensitive=false, [interrupting_queue, radio])

# Endpoint to play a specific file immediately
def play_now(request) =
  fname = request.query["file"]
  log.important("Requested file #{fname}.")

  if file.exists(fname) then
    log.important("File Request Accepted.")
    interrupting_queue.push.uri("#{fname}")
    http.response(status_code=200, data="Request pushed.")
  else
    log.important("File Request Rejected: File Not Found.")
    http.response(status_code=404, data="Invalid file: #{fname}")
  end
end

harbor.http.register.simple("/play_now", play_now, port=8007, method="GET")

current_title = ref("")
#current_artist = ref("")
current_albumartist = ref("")

def update_current_song(m) =
  current_title := m["title"]
#  current_artist := m["artist"]
   current_albumartist := m["albumartist"]

end
radio.on_metadata(update_current_song)

def position() =
  source.elapsed(radio) / source.duration(radio)
end

def remaining() =
  time = source.remaining(radio)
  seconds = string.of_int(digits=2, int(time mod 60.))
  minutes = string.of_int(digits=2, int(time / 60.))
  "#{minutes}:#{seconds}"
end

How can I make the skip function work when 'play' or 'play_now' is used?

Thanks

[gAlleb]

Hi! Logic is very simple. Where you put your code along the chain of functions — it will be applied to the source right there.

If you put skip function before your fallbacks - skip simply won't be applied to them. Put you skip function after last fallback - radio = fallback(track_sensitive=false, [interrupting_queue, radio])

[WittyWidget]

@gAlleb, I will utilize this skip function (after fallback) so that the Super User can skip an audio file, even file was pushed to the queue by a user. However, I need to prevent normal users from skipping files, but only for those files queued by users, not for system-queued files.

Can I create another skip (/skip_user) endpoint before fallbacks to reject the user request for user queued files?

The below skip function (after fallback) is for Super User.

def skipper(_) =

  def null_list(key, _list)
    list.assoc.mem(key, _list) ? list.assoc(key, _list) : ""
  end

  m = radio.last_metadata() ?? []

      artist = null_list("artist", m)
      title = null_list("title", m)
      album = null_list("album", m)
      year = null_list("year", m)

  radio.skip()
  
  # JSON response data for successful skip
  response_data = {
    status = "success",
    message = "The current song: #{title} from #{artist} (#{album} - #{year}) was skipped successfully!"
  }

  http.response(
    content_type="application/json; charset=UTF-8",
    status_code=200,
    data=json.stringify(response_data)
  )
end

harbor.http.register.simple(port=8007, "/skip", skipper)

[gAlleb]

I suppose so, right below playlist

[WittyWidget]

Thanks @gAlleb. Can I get the queue number through play and play_now? For example, if someone requests to play a track through play or play_now, I would like to return a queue number of that specifically requested track, instead of just a static response like 'Request pushed'.

[gAlleb]

I'm not sure what are you talking about exactly. You can alter your function like this. E.g. your first queue:

# Queue setup for normal playback
queue = request.queue(id="main_queue")
radio = fallback(track_sensitive=false, [queue, radio])

######
number_queue1 = ref(0)
######

# Endpoint to play a specific file
def play(request) =
  fname = request.query["file"]
  log.important("Requested file #{fname}.")

  if file.exists(fname) then
    log.important("File Request Accepted.")
    queue.push.uri("#{fname}")

######
    number_queue1 := number_queue1() + 1
    q = queue.queue()
#######
    http.response(content_type="text/html", status_code=200, data="<p>Pushed:<br/> #{fname}.<br/> It is #{number_queue1()} pushed track since start.<br/>Number of tracks still left in queue: #{list.length(q)}</p>")
#######

  else
    log.important("File Request Rejected: File Not Found.")
    http.response(content_type="text/html", status_code=404, data="<p>Invalid file: #{fname}</p>")
  end
end

harbor.http.register.simple("/play", play, port=8007, method="GET")

it will give you:

Pushed:
/music/file.mp3.
It is 4 pushed track since start.
Number of tracks still left in queue: 3

[WittyWidget]

Thanks @gAlleb. I have tried to change the response format to JSON which is producing parse error.

# Queue setup for normal playback
queue = request.queue(id="main_queue")
radio = fallback(track_sensitive=false, [queue, radio])

number_queue1 = ref(0)

# Endpoint to play a specific file
def play(request) =
  fname = request.query["file"]
  log.important("Requested file #{fname}.")
  if file.exists(fname) then
    log.important("File Request Accepted.")
    queue.push.uri("#{fname}")
    number_queue1 := number_queue1() + 1
    q = queue.queue()
    http.response(content_type="application/json; charset=UTF-8", status_code=200, data=json.stringify({"status": "success", "message": "Pushed: #{fname}.", "pushed_track_count": number_queue1(), "remaining_tracks_in_queue": list.length(q)}))
  else
    log.important("File Request Rejected: File Not Found.")
    http.response(content_type="application/json; charset=UTF-8", status_code=404, data=json.stringify({"status": "error", "message": "Invalid file: #{fname}"}))
  end
end

harbor.http.register.simple("/play", play, port=8007, method="GET")

[gAlleb]

# Endpoint to play a specific file
def play(request) =
  fname = request.query["file"]
  log.important("Requested file #{fname}.")
  if file.exists(fname) then
    log.important("File Request Accepted.")
    queue.push.uri("#{fname}")
    number_queue1 := number_queue1() + 1
    q = queue.queue()
    http.response(content_type="application/json; charset=UTF-8", status_code=200, data=json.stringify({status = "success", message = "Pushed: #{fname}.", pushed_track_count = number_queue1(), remaining_tracks_in_queue = list.length(q)}))
  else
    log.important("File Request Rejected: File Not Found.")
    http.response(content_type="application/json; charset=UTF-8", status_code=404, data=json.stringify({status = "error", message = "Invalid file: #{fname}"}))
  end
end

[WittyWidget]

# Endpoint to play a specific file
def play(request) =
  fname = request.query["file"]
  log.important("Requested file #{fname}.")
  if file.exists(fname) then
    log.important("File Request Accepted.")
    queue.push.uri("#{fname}")
    number_queue1 := number_queue1() + 1
    q = queue.queue()
    http.response(content_type="application/json; charset=UTF-8", status_code=200, data=json.stringify({status = "success", message = "Pushed: #{fname}.", pushed_track_count = number_queue1(), remaining_tracks_in_queue = list.length(q)}))
  else
    log.important("File Request Rejected: File Not Found.")
    http.response(content_type="application/json; charset=UTF-8", status_code=404, data=json.stringify({status = "error", message = "Invalid file: #{fname}"}))
  end
end

@gAlleb, can we push multiple files at once through /play?

[gAlleb]

Hello. Multiple files = playlist. You can modify a function to accept not only files but playlists (.m3u, .txt files)

# Endpoint to play a specific file
def play(request) =
  fname = request.query["file"]
  log.important("Requested file #{fname}.")
  option = request.query["playlist"]

  if file.exists(fname) then

      if option == "true" then
         
          tracks = list.iter(fun (x) -> begin
          let (_, uri) = x
          queue.push.uri(uri)
          end, playlist.parse("#{fname}"))

          number_queue1 := number_queue1() + list.length(playlist.files(fname))

          q = queue.queue()
          http.response(content_type="application/json; charset=UTF-8", status_code=200, 
          data=json.stringify({
          status = "success", message = "Pushed: #{fname}.", 
          pushed_track_count = number_queue1(), 
          remaining_tracks_in_queue = list.length(q), 
          files_pushed = playlist.files(fname)
          }))
     
       else

          queue.push.uri("#{fname}")
          number_queue1 := number_queue1() + 1
          q = queue.queue()
          http.response(content_type="application/json; charset=UTF-8", status_code=200, data=json.stringify({status = "success", message = "Pushed: #{fname}.", pushed_track_count = number_queue1(), remaining_tracks_in_queue = list.length(q)}))
     
       end

  else
    log.important("File/Playlist Request Rejected: File Not Found.")
    http.response(content_type="application/json; charset=UTF-8", status_code=404, data=json.stringify({status = "error", message = "Invalid file: #{fname}"}))
  end
end

Now if you do http://localhost:8007/play?file=/path/to/file.flac - you'll queue a file.
If you want to queue a playlist of files you use playlist=true in you url and do: http://localhost:8007/play?playlist=true&file=/path/to/playlist.m3u

[WittyWidget]

Hi @gAlleb, as mentioned in the Liquidsoap book, I have added an endpoint to retrieve the current track metadata. However, the issue is that it returns a large set of album cover image data, which slows down the API request. I would like to exclude the cover from the JSON response. Is it possible to specify only the metadata tags we need?

# Endpoint to get current track information
last_metadata = ref([])

radio.on_track(fun (m) -> last_metadata := m)

def show_metadata(_) =
  http.response(
    content_type="application/json; charset=UTF-8",
    data=metadata.json.stringify(last_metadata())
  )
end

harbor.http.register.simple(port=8007, "/metadata", show_metadata)

{
  "cover": "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAoAAAAKAC.....................nnnnnnnn",
  "album": "Witty",
  "date": "2023",
  "year": "2023",
  "artist": "Witty",
  "title": "Title",
  "genre": "filmi",
  "tracknumber": "1/2"
}

Thanks.

[gAlleb]

you can use another function instead:

def get_metadata(_)

  def null_float(f)
    f == infinity ? null() : f
  end

  def null_list(key, _list)
    list.assoc.mem(key, _list) ? list.assoc(key, _list) : ""
  end

  m = radio.last_metadata() ?? []

  data = {
    now_playing = {
      duration = null_float(source.duration(radio)),
      elapsed = null_float(source.elapsed(radio)),
      remaining = null_float(source.remaining(radio)),
      filename = null_list("filename", m),
      artist = null_list("artist", m),
      title = null_list("title", m),
      album = null_list("album", m),
      genre = null_list("genre", m),
     }
  }
 try
  http.response(
    status_code=200,
    headers=[
                ("Content-Type", "application/json")
            ],
    content_type="application/json; charset=UTF-8",
    data=json.stringify(data, compact=true)
  )

 catch error do
  log.severe(error.message, label="http")
  http.response(
    status_code=500,
    content_type="application/json; charset=UTF-8",
    data='{"status":"error","message":"Failed to serialize response data"}' ^ "\n"
  )
  end
end

harbor.http.register.simple("/metadata", get_metadata, port=8007, method="GET")

[WittyWidget]

@gAlleb, Can we adapt the same now_playing functionality in the skip function? For example, when skip is called, it should check the now_playing data, and the skip response should be something like Title from Album skipped successfully instead of a static text (The current song was skipped successfully!).

def skipper(_) =
  radio.skip()
  
  # JSON response data for successful skip
  response_data = {
    status = "success",
    message = "The current song was skipped successfully!"
  }

  http.response(
    content_type="application/json; charset=UTF-8",
    status_code=200,
    data=json.stringify(response_data)
  )
end

harbor.http.register.simple(port=8007, "/skip", skipper)

# Endpoint to get current track information
def get_metadata(_)

  def null_float(f)
    f == infinity ? null() : f
  end

  def null_list(key, _list)
    list.assoc.mem(key, _list) ? list.assoc(key, _list) : ""
  end

  m = radio.last_metadata() ?? []

  data = {
    now_playing = {
      duration = null_float(source.duration(radio)),
      elapsed = null_float(source.elapsed(radio)),
      remaining = null_float(source.remaining(radio)),
      filename = null_list("filename", m),
      artist = null_list("artist", m),
      title = null_list("title", m),
      album = null_list("album", m),
      year = null_list("year", m),
      genre = null_list("genre", m),
     }
  }
 try
  http.response(
    status_code=200,
    headers=[
                ("Content-Type", "application/json")
            ],
    content_type="application/json; charset=UTF-8",
    data=json.stringify(data, compact=true)
  )

 catch error do
  log.severe(error.message, label="http")
  http.response(
    status_code=500,
    content_type="application/json; charset=UTF-8",
    data='{"status":"error","message":"Failed to serialize response data"}' ^ "\n"
  )
  end
end

harbor.http.register.simple("/nowplaying", get_metadata, port=8007, method="GET")

[gAlleb]

it is basically the same:

def skipper(_) =

  def null_list(key, _list)
    list.assoc.mem(key, _list) ? list.assoc(key, _list) : ""
  end

  m = radio.last_metadata() ?? []

      artist = null_list("artist", m)
      title = null_list("title", m)
      album = null_list("album", m)
      year = null_list("year", m)

  radio.skip()
  
  # JSON response data for successful skip
  response_data = {
    status = "success",
    message = "The current song: #{title} from #{artist} (#{album} - #{year}) was skipped successfully!"
  }

  http.response(
    content_type="application/json; charset=UTF-8",
    status_code=200,
    data=json.stringify(response_data)
  )
end

harbor.http.register.simple(port=8007, "/skip", skipper)