alex/musicplayer
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Compare commits

base: alex:main
Branches Tags
alex:main alex:musicplayer-module alex:ui-mpv-input-communication alex:ui
..
compare: alex:2af591489acc8e169ee8e09a28eb40d614f78455
Branches Tags
alex:musicplayer-module alex:main alex:ui-mpv-input-communication alex:ui

3 Commits
main ... 2af591489a

Author SHA1 Message Date
Alexander Heldt
2af591489a TCP echo server 2025-11-12 22:31:25 +01:00
Alexander Heldt
c76d1aaa53 Send some messages 2025-11-10 20:21:50 +01:00
Alexander Heldt
d69be40dcd Add tcp module 2025-11-10 20:21:50 +01:00
17 changed files with 43 additions and 473 deletions
Expand all files Collapse all files

1
gleam.toml
View File

@@ -17,7 +17,6 @@ gleam_stdlib = ">= 0.44.0 and < 2.0.0"
gleam_otp = ">= 1.2.0 and < 2.0.0" gleam_otp = ">= 1.2.0 and < 2.0.0"
gleam_erlang = ">= 1.3.0 and < 2.0.0" gleam_erlang = ">= 1.3.0 and < 2.0.0"
simplifile = ">= 2.3.1 and < 3.0.0" simplifile = ">= 2.3.1 and < 3.0.0"
gleam_json = ">= 3.1.0 and < 4.0.0"
[dev-dependencies] [dev-dependencies]
gleeunit = ">= 1.0.0 and < 2.0.0" gleeunit = ">= 1.0.0 and < 2.0.0"

2
manifest.toml
View File

@@ -4,7 +4,6 @@
packages = [ packages = [
{ name = "filepath", version = "1.1.2", build_tools = ["gleam"], requirements = ["gleam_stdlib"], otp_app = "filepath", source = "hex", outer_checksum = "B06A9AF0BF10E51401D64B98E4B627F1D2E48C154967DA7AF4D0914780A6D40A" }, { name = "filepath", version = "1.1.2", build_tools = ["gleam"], requirements = ["gleam_stdlib"], otp_app = "filepath", source = "hex", outer_checksum = "B06A9AF0BF10E51401D64B98E4B627F1D2E48C154967DA7AF4D0914780A6D40A" },
{ name = "gleam_erlang", version = "1.3.0", build_tools = ["gleam"], requirements = ["gleam_stdlib"], otp_app = "gleam_erlang", source = "hex", outer_checksum = "1124AD3AA21143E5AF0FC5CF3D9529F6DB8CA03E43A55711B60B6B7B3874375C" }, { name = "gleam_erlang", version = "1.3.0", build_tools = ["gleam"], requirements = ["gleam_stdlib"], otp_app = "gleam_erlang", source = "hex", outer_checksum = "1124AD3AA21143E5AF0FC5CF3D9529F6DB8CA03E43A55711B60B6B7B3874375C" },
{ name = "gleam_json", version = "3.1.0", build_tools = ["gleam"], requirements = ["gleam_stdlib"], otp_app = "gleam_json", source = "hex", outer_checksum = "44FDAA8847BE8FC48CA7A1C089706BD54BADCC4C45B237A992EDDF9F2CDB2836" },
{ name = "gleam_otp", version = "1.2.0", build_tools = ["gleam"], requirements = ["gleam_erlang", "gleam_stdlib"], otp_app = "gleam_otp", source = "hex", outer_checksum = "BA6A294E295E428EC1562DC1C11EA7530DCB981E8359134BEABC8493B7B2258E" }, { name = "gleam_otp", version = "1.2.0", build_tools = ["gleam"], requirements = ["gleam_erlang", "gleam_stdlib"], otp_app = "gleam_otp", source = "hex", outer_checksum = "BA6A294E295E428EC1562DC1C11EA7530DCB981E8359134BEABC8493B7B2258E" },
{ name = "gleam_stdlib", version = "0.65.0", build_tools = ["gleam"], requirements = [], otp_app = "gleam_stdlib", source = "hex", outer_checksum = "7C69C71D8C493AE11A5184828A77110EB05A7786EBF8B25B36A72F879C3EE107" }, { name = "gleam_stdlib", version = "0.65.0", build_tools = ["gleam"], requirements = [], otp_app = "gleam_stdlib", source = "hex", outer_checksum = "7C69C71D8C493AE11A5184828A77110EB05A7786EBF8B25B36A72F879C3EE107" },
{ name = "gleeunit", version = "1.9.0", build_tools = ["gleam"], requirements = ["gleam_stdlib"], otp_app = "gleeunit", source = "hex", outer_checksum = "DA9553CE58B67924B3C631F96FE3370C49EB6D6DC6B384EC4862CC4AAA718F3C" }, { name = "gleeunit", version = "1.9.0", build_tools = ["gleam"], requirements = ["gleam_stdlib"], otp_app = "gleeunit", source = "hex", outer_checksum = "DA9553CE58B67924B3C631F96FE3370C49EB6D6DC6B384EC4862CC4AAA718F3C" },
@@ -13,7 +12,6 @@ packages = [
[requirements] [requirements]
gleam_erlang = { version = ">= 1.3.0 and < 2.0.0" } gleam_erlang = { version = ">= 1.3.0 and < 2.0.0" }
gleam_json = { version = ">= 3.1.0 and < 4.0.0" }
gleam_otp = { version = ">= 1.2.0 and < 2.0.0" } gleam_otp = { version = ">= 1.2.0 and < 2.0.0" }
gleam_stdlib = { version = ">= 0.44.0 and < 2.0.0" } gleam_stdlib = { version = ">= 0.44.0 and < 2.0.0" }
gleeunit = { version = ">= 1.0.0 and < 2.0.0" } gleeunit = { version = ">= 1.0.0 and < 2.0.0" }

21
src/musicplayer.gleam
View File

@@ -1,22 +1,5 @@
import gleam/erlang/process.{type Name} import gleam/io
import musicplayer/input/input.{type Listener}
import musicplayer/input/key.{type Key}
import musicplayer/mpv/mpv
pub fn main() -> Nil { pub fn main() -> Nil {
let exit = process.new_subject() io.println("musicplayer")
// `inject_input` is created by name to allow the `input` process that
// owns `read_input` to be able to register and receive from it,
// while the any other processes can use the name reference to
// inject input
let inject_input_name: Name(Key) = process.new_name("inject_input")
let assert Ok(mpv_listener) = mpv.new(exit)
let listeners: List(Listener) = [mpv_listener]
input.new(listeners, inject_input_name)
process.receive_forever(exit)
} }

59
src/musicplayer/input/input.gleam
View File

@@ -1,59 +0,0 @@
import gleam/erlang/process.{type Name, type Subject}
import gleam/list
import gleam/option.{type Option, None, Some}
import musicplayer/input/key.{type Key}
pub type Listener {
InputListener(final: Subject(Key), tap: Option(Subject(List(String))))
}
/// `new` accepts a list of listeners that are composed of two subjects;
/// - one to get the final `Key` and
/// - one to tap the input as it is read from i/o
/// and
/// - a subject name that is used to create a `Subject` that other processes
/// know they can inject a `Key` into the input with
pub fn new(listeners: List(Listener), inject_input_name: Name(Key)) -> Nil {
let _ =
process.spawn(fn() {
let inject_input: Subject(Key) = process.named_subject(inject_input_name)
let assert Ok(_) = process.register(process.self(), inject_input_name)
// Extract all finals and taps (that are defined)
let #(finals, taps) =
list.fold(listeners, #([], []), fn(acc, listener) {
let #(finals, taps) = acc
let finals = [listener.final, ..finals]
let taps = case listener.tap {
Some(t) -> [t, ..taps]
None -> taps
}
#(finals, taps)
})
read_input(finals, taps, inject_input)
})
Nil
}
fn read_input(
finals: List(Subject(Key)),
taps: List(Subject(List(String))),
inject_input: Subject(Key),
) -> Nil {
let buffer = case process.receive(inject_input, 1) {
Ok(key.Continue(buffer)) -> buffer
Ok(_) | Error(_) -> []
}
let _ =
key.read_input_until_key(buffer, taps)
|> fn(k) { list.each(finals, process.send(_, k)) }
read_input(finals, taps, inject_input)
}

15
src/musicplayer/input/internal.gleam
View File

@@ -1,15 +0,0 @@
import gleam/erlang/atom
pub fn read_input() -> String {
io_get_chars("", 1)
}
pub type NotUsed
// https://www.erlang.org/doc/apps/stdlib/shell.html#start_interactive/1
@external(erlang, "shell", "start_interactive")
pub fn shell_start_interactive(options: #(atom.Atom, atom.Atom)) -> NotUsed
// https://www.erlang.org/doc/apps/stdlib/io.html#get_chars/2
@external(erlang, "io", "get_chars")
fn io_get_chars(prompt: String, count: Int) -> String

79
src/musicplayer/input/key.gleam
View File

@@ -1,79 +0,0 @@
import gleam/erlang/atom
import gleam/erlang/process.{type Subject}
import gleam/list
import gleam/string
import musicplayer/input/internal as internal_input
pub type Key {
Char(String)
Input(String)
Left
Right
Up
Down
Continue(buffer: List(String))
Unknown
}
pub const esc = "\u{001B}"
// control sequence introducer
pub const csi = "["
// input introducer
pub const input_introducer = "::"
pub fn from_list(l: List(String)) -> Key {
case l {
[e, c, "D"] if e == esc && c == csi -> Left
[e, c, "C"] if e == esc && c == csi -> Right
[e, c, "A"] if e == esc && c == csi -> Up
[e, c, "B"] if e == esc && c == csi -> Down
[e, c] if e == esc && c == csi -> Continue(l)
[ci] | [ci, _] if ci == input_introducer -> Continue(l)
[ii, cmd, tail] if ii == input_introducer -> {
case tail {
// Return
"\r" -> Input(cmd)
// Backspace
"\u{007F}" -> Continue([ii, string.drop_end(cmd, 1)])
_ -> Continue([ii, cmd <> tail])
}
}
[e] if e == esc -> Continue(l)
[char] -> Char(char)
[] -> Continue([])
_ -> Unknown
}
}
pub fn start_raw_shell() {
let no_shell = atom.create("noshell")
let raw = atom.create("raw")
internal_input.shell_start_interactive(#(no_shell, raw))
}
pub fn read_input_until_key(
l: List(String),
taps: List(Subject(List(String))),
) -> Key {
case
internal_input.read_input()
|> list.wrap
|> list.append(l, _)
|> from_list
{
Continue(l) -> {
list.each(taps, process.send(_, l))
read_input_until_key(l, taps)
}
k -> k
}
}

74
src/musicplayer/mpv/control.gleam
View File

@@ -1,74 +0,0 @@
import gleam/json
import gleam/result
import gleam/string
import musicplayer/input/key.{type Key}
import musicplayer/mpv/internal as internal_control
import musicplayer/tcp/reason.{type Reason}
import musicplayer/tcp/tcp.{type Socket}
pub type Control {
TogglePlayPause
Exit
}
pub type ControlError {
ControlError(details: String)
}
pub fn from_key(key: Key) -> Result(Control, Nil) {
case key {
key.Char(char) -> char_control(char)
_ -> Error(Nil)
}
}
fn char_control(char: String) -> Result(Control, Nil) {
case char {
" " -> Ok(TogglePlayPause)
"q" -> Ok(Exit)
_ -> Error(Nil)
}
}
pub fn toggle_play_pause(socket: Socket) -> Result(Nil, ControlError) {
let command =
json.object([#("command", json.array(["cycle", "pause"], of: json.string))])
case send_command(socket, command) {
Error(r) -> Error(ControlError(reason.to_string(r)))
Ok(_) -> Ok(Nil)
}
}
// https://mpv.io/manual/master/#command-interface-playback-time
pub type PlaybackTime {
PlaybackTime(data: Float)
}
pub fn get_playback_time(socket: Socket) -> Result(PlaybackTime, ControlError) {
let command =
json.object([
#(
"command",
json.array(["get_property_string", "playback-time"], of: json.string),
),
])
case send_command(socket, command) {
Error(r) -> Error(ControlError(reason.to_string(r)))
Ok(json_string) ->
case internal_control.parse_playback_time(json_string) {
Error(e) -> Error(ControlError(string.inspect(e)))
Ok(data) -> Ok(PlaybackTime(data))
}
}
}
fn send_command(socket: Socket, command: json.Json) -> Result(String, Reason) {
result.try(tcp.send(socket, json.to_string(command) <> "\n"), fn(_) {
let timeout_ms = 10_000
tcp.receive(socket, timeout_ms)
})
}

25
src/musicplayer/mpv/internal.gleam
View File

@@ -1,25 +0,0 @@
import gleam/dynamic/decode
import gleam/float
import gleam/json
import gleam/string
pub fn parse_playback_time(
json_string: String,
) -> Result(Float, json.DecodeError) {
let decoder = {
let float_dececoder = fn(data_string) {
case float.parse(data_string) {
Error(_) -> decode.failure(0.0, "data")
Ok(float_value) -> decode.success(float_value)
}
}
use data <- decode.field(
"data",
decode.then(decode.string, float_dececoder),
)
decode.success(data)
}
json.parse(from: string.trim(json_string), using: decoder)
}

89
src/musicplayer/mpv/mpv.gleam
View File

@@ -1,89 +0,0 @@
import gleam/erlang/process.{type Subject}
import gleam/float
import gleam/option.{None}
import gleam/otp/actor
import gleam/result
import gleam/string
import musicplayer/input/input.{type Listener, InputListener}
import musicplayer/input/key.{type Key}
import musicplayer/mpv/control.{type Control}
import musicplayer/tcp/reason
import musicplayer/tcp/tcp.{type Socket}
type State(socket, exit) {
State(socket: Socket, exit: Subject(Nil))
}
pub fn new(exit: Subject(Nil)) -> Result(Listener, String) {
// TODO start up mvp here, currently hi-jacking `naviterm`s socket
let socket_path = "/tmp/naviterm_mpv"
case tcp.connect(socket_path) {
Error(r) -> Error("Could not connect to mpv: " <> reason.to_string(r))
Ok(socket) -> {
let final_input_name = process.new_name("mpv_final_input")
let final_input: Subject(Key) = process.named_subject(final_input_name)
case
actor.new(State(socket, exit))
|> actor.on_message(handle_message)
|> actor.start
{
Error(start_error) ->
Error("Could not start actor: " <> string.inspect(start_error))
Ok(actor.Started(data:, ..)) -> {
echo "waiting for input"
key.start_raw_shell()
process.spawn(fn() {
let assert Ok(_) =
process.register(process.self(), final_input_name)
handle_key(final_input, data)
})
Ok(InputListener(final: final_input, tap: None))
}
}
}
}
}
fn handle_message(
state: State(socket, exit),
control: Control,
) -> actor.Next(State(socket, exit), Control) {
case control {
control.TogglePlayPause -> {
echo "toggling play/pause"
let _ =
result.map_error(control.toggle_play_pause(state.socket), fn(err) {
echo "Could not toggle play/pause: " <> err.details
})
let _ =
result.map(control.get_playback_time(state.socket), fn(playback) {
echo "playback: " <> float.to_string(playback.data)
})
actor.continue(state)
}
control.Exit -> {
process.send(state.exit, Nil)
actor.stop()
}
}
}
/// `handle_key` listens to a subject onto which `input` will send messages with
/// parsed `Key`s which will be mapped to `Control`s (if possible)
fn handle_key(final_input: Subject(Key), subject: Subject(Control)) -> Nil {
let _ =
process.receive_forever(final_input)
|> control.from_key
|> result.map(process.send(subject, _))
handle_key(final_input, subject)
}

4
test/echo_server.gleam → src/tcp/echo_server.gleam
View File

@@ -4,8 +4,8 @@ import gleam/otp/actor
import gleam/result import gleam/result
import gleam/string import gleam/string
import musicplayer/tcp/reason.{type Reason} import tcp/reason.{type Reason}
import musicplayer/tcp/tcp import tcp/tcp
pub type Message { pub type Message {
Shutdown Shutdown

3
src/musicplayer/tcp/reason.gleam → src/tcp/reason.gleam
View File

@@ -4,6 +4,8 @@ pub type Reason {
/// from `send` /// from `send`
Closed Closed
Overflow
/// Address already in use /// Address already in use
Eaddrinuse Eaddrinuse
/// Cannot assign requested address /// Cannot assign requested address
@@ -158,6 +160,7 @@ pub type Reason {
pub fn to_string(reason: Reason) -> String { pub fn to_string(reason: Reason) -> String {
case reason { case reason {
Overflow -> "overflow"
Closed -> "Connection closed (closed)" Closed -> "Connection closed (closed)"
Eacces -> "Permission denied (eacces)" Eacces -> "Permission denied (eacces)"
Eaddrinuse -> "Address already in use (eaddrinuse)" Eaddrinuse -> "Address already in use (eaddrinuse)"

6
src/musicplayer/tcp/tcp.gleam → src/tcp/tcp.gleam
View File

@@ -2,7 +2,7 @@ import gleam/bit_array
import gleam/erlang/atom import gleam/erlang/atom
import gleam/result import gleam/result
import musicplayer/tcp/reason.{type Reason} import tcp/reason.{type Reason}
pub type Socket pub type Socket
@@ -105,7 +105,7 @@ fn gen_tcp_connect(
) -> Result(Socket, Reason) ) -> Result(Socket, Reason)
// https://www.erlang.org/doc/apps/kernel/gen_tcp.html#send/2 // https://www.erlang.org/doc/apps/kernel/gen_tcp.html#send/2
@external(erlang, "tcp_ffi", "send") @external(erlang, "ipc_ffi", "send")
fn gen_tcp_send(socket: Socket, packet: BitArray) -> Result(Nil, Reason) fn gen_tcp_send(socket: Socket, packet: BitArray) -> Result(Nil, Reason)
// https://www.erlang.org/doc/apps/kernel/gen_tcp.html#close/1 // https://www.erlang.org/doc/apps/kernel/gen_tcp.html#close/1
@@ -113,5 +113,5 @@ fn gen_tcp_send(socket: Socket, packet: BitArray) -> Result(Nil, Reason)
fn gen_tcp_close(socket: Socket) -> Nil fn gen_tcp_close(socket: Socket) -> Nil
// https://www.erlang.org/doc/apps/kernel/gen_tcp.html#shutdown/2 // https://www.erlang.org/doc/apps/kernel/gen_tcp.html#shutdown/2
@external(erlang, "tcp_ffi", "shutdown") @external(erlang, "gen_tcp", "shutdown")
fn gen_tcp_shutdown(socket: Socket, how: atom.Atom) -> Result(Nil, Reason) fn gen_tcp_shutdown(socket: Socket, how: atom.Atom) -> Result(Nil, Reason)

0
src/musicplayer/tcp/tcp_ffi.erl → src/tcp/tcp_ffi.erl
View File

42
test/musicplayer/input/input_test.gleam
View File

@@ -1,42 +0,0 @@
import gleam/list
import gleeunit
import musicplayer/input/key.{type Key, Char, csi, esc, input_introducer as ii}
pub fn main() -> Nil {
gleeunit.main()
}
type TestCase {
TestCase(input: List(String), expected: Key)
}
pub fn key_from_list_test() {
let base_tests = [TestCase([], key.Continue([]))]
let char_tests = [TestCase(["c"], Char("c"))]
let escape_tests = [
TestCase([esc, csi], key.Continue([esc, csi])),
TestCase([esc], key.Continue([esc])),
TestCase([esc, csi, "D"], key.Left),
TestCase([esc, csi, "C"], key.Right),
TestCase([esc, csi, "A"], key.Up),
TestCase([esc, csi, "B"], key.Down),
]
let input_tests = [
TestCase([ii], key.Continue([ii])),
TestCase([ii, "a"], key.Continue([ii, "a"])),
TestCase([ii, "a", "b"], key.Continue([ii, "ab"])),
TestCase([ii, "ab", "\u{007F}"], key.Continue([ii, "a"])),
TestCase([ii, "ab", "\r"], key.Input("ab")),
]
let test_cases = [base_tests, char_tests, escape_tests, input_tests]
list.each(list.flatten(test_cases), fn(tc) {
assert tc.expected == key.from_list(tc.input)
})
}

33
test/musicplayer/mpv/control_test.gleam
View File

@@ -1,33 +0,0 @@
import gleam/list
import gleeunit
import musicplayer/input/key.{type Key, Char}
import musicplayer/mpv/control.{type Control}
import musicplayer/mpv/internal as control_internal
pub fn main() -> Nil {
gleeunit.main()
}
type TestCase {
TestCase(key: Key, expected: Result(Control, Nil))
}
pub fn control_from_key_test() {
let test_cases = [
TestCase(Char(" "), Ok(control.TogglePlayPause)),
TestCase(Char("q"), Ok(control.Exit)),
]
list.each(test_cases, fn(tc) {
assert tc.expected == control.from_key(tc.key)
})
}
pub fn parse_playback_time_test() {
let json_string =
"{\"data\":\"123.456789\",\"request_id\":0,\"error\":\"success\"}\n"
let assert Ok(data) = control_internal.parse_playback_time(json_string)
assert data == 123.456789
}

30
test/musicplayer/tcp/tcp_test.gleam
View File

@@ -1,30 +0,0 @@
import gleam/list
import gleeunit
import simplifile
import echo_server
import musicplayer/tcp/tcp
pub fn main() -> Nil {
gleeunit.main()
}
pub fn tcp_send_shutdown_receive_test() {
let socket_path = "/tmp/musicplayer-test.sock"
let assert Ok(_) = echo_server.new(socket_path)
let assert Ok(socket) = tcp.connect(socket_path)
let messages = ["hello, ", "world!\n"]
list.each(messages, fn(message) {
let assert Ok(_) = tcp.send(socket, message)
})
let assert Ok(_) = tcp.shutdown(socket)
let timeout_ms = 100
assert Ok("hello, world!\n") == tcp.receive(socket, timeout_ms)
// TODO find better way to always do cleanup
simplifile.delete(socket_path)
}

33
test/musicplayer_test.gleam
View File

@@ -1,5 +1,38 @@
import gleam/list
import gleeunit import gleeunit
import simplifile
import tcp/echo_server
import tcp/tcp
pub fn main() -> Nil { pub fn main() -> Nil {
gleeunit.main() gleeunit.main()
} }
pub fn foo_test() {
let socket_path = "/tmp/musicplayer-test.sock"
let assert Ok(_) = echo_server.new(socket_path)
let assert Ok(socket) = tcp.connect(socket_path)
let messages = ["hello, ", "world!\n"]
list.each(messages, fn(message) {
let assert Ok(_) = tcp.send(socket, message)
})
// TODO not valid syntax?
// let assert Ok(Nil) = tcp.shutdown(socket)
//
// test: musicplayer_test.foo_test
// code: let assert Ok(Nil) = tcp.shutdown(socket)
// value: Ok
// info: Pattern match failed, no pattern matched the value.
let _ = tcp.shutdown(socket)
let timeout_ms = 100
assert Ok("hello, world!\n") == tcp.receive(socket, timeout_ms)
// TODO find better way to always do cleanup
simplifile.delete(socket_path)
}