wip

gleam.toml

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

manifest.toml

@@ -4,6 +4,7 @@
 packages = [
   { 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_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_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" },
@@ -12,6 +13,7 @@ packages = [
 
 [requirements]
 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_stdlib = { version = ">= 0.44.0 and < 2.0.0" }
 gleeunit = { version = ">= 1.0.0 and < 2.0.0" }

src/mpv/control.gleam

@@ -0,0 +1,73 @@
+import gleam/json
+import gleam/result
+import gleam/string
+
+import mpv/internal/control as internal_control
+import mpv/key.{type Key, Char}
+import tcp/reason.{type Reason}
+import 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 {
+    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)
+  })
+}

src/mpv/internal/control.gleam

@@ -0,0 +1,25 @@
+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)
+}

src/mpv/internal/key.gleam

@@ -0,0 +1,15 @@
+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_line/1
+@external(erlang, "io", "get_chars")
+fn io_get_chars(prompt: String, count: Int) -> String

src/mpv/key.gleam

@@ -1,6 +1,8 @@
 import gleam/erlang/atom
 import gleam/list
 
+import mpv/internal/key as internal_key
+
 pub type Key {
   Char(String)
 
@@ -38,29 +40,14 @@ pub fn from_list(l: List(String)) -> Key {
 pub fn start_raw_shell() {
   let no_shell = atom.create("noshell")
   let raw = atom.create("raw")
-  shell_start_interactive(#(no_shell, raw))
+  internal_key.shell_start_interactive(#(no_shell, raw))
 }
 
-// TODO map key to something like Control, to not leak `Continue` etc.
 pub fn read_input_until_key(l: List(String)) -> Key {
-  let l = read_input() |> list.wrap |> list.append(l, _)
+  let l = internal_key.read_input() |> list.wrap |> list.append(l, _)
 
   case from_list(l) {
     Continue -> read_input_until_key(l)
     k -> k
   }
 }
-
-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")
-fn shell_start_interactive(options: #(atom.Atom, atom.Atom)) -> NotUsed
-
-// https://www.erlang.org/doc/apps/stdlib/io.html#get_line/1
-@external(erlang, "io", "get_chars")
-fn io_get_chars(prompt: String, count: Int) -> String

src/mpv/mpv.gleam

@@ -1,15 +1,14 @@
 import gleam/erlang/process.{type Subject}
+import gleam/float
 import gleam/otp/actor
+import gleam/result
 import gleam/string
 
-import mpv/internal.{type Key, Char}
-import tcp/reason.{type Reason}
+import mpv/control.{type Control}
+import mpv/key
+import tcp/reason
 import tcp/tcp.{type Socket}
 
-pub type Message {
-  KeyPress(Key)
-}
-
 type State(socket, exit) {
   State(socket: Socket, exit: Subject(Nil))
 }
@@ -30,7 +29,7 @@ pub fn new(exit: Subject(Nil)) -> Result(Nil, String) {
           Error("Could not start actor: " <> string.inspect(start_error))
         Ok(actor.Started(data:, ..)) -> {
           echo "waiting for input"
-          internal.start_raw_shell()
+          key.start_raw_shell()
           process.spawn(fn() { read_input(data) })
           Ok(Nil)
         }
@@ -39,28 +38,41 @@ pub fn new(exit: Subject(Nil)) -> Result(Nil, String) {
   }
 }
 
-pub fn toggle_play_pause(socket: Socket) -> Result(Nil, Reason) {
-  tcp.send(socket, "{\"command\":[\"cycle\",\"pause\"]}\n")
-}
-
 fn handle_message(
   state: State(socket, exit),
-  message: Message,
-) -> actor.Next(State(socket, exit), Message) {
-  case message {
-    KeyPress(Char("q")) -> {
+  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()
     }
-    KeyPress(key) -> {
-      echo "key: " <> string.inspect(key)
-      actor.continue(state)
-    }
   }
 }
 
-fn read_input(subject: Subject(Message)) -> Nil {
-  internal.read_input_until_key([]) |> KeyPress |> process.send(subject, _)
+fn read_input(subject: Subject(Control)) -> Nil {
+  case
+    key.read_input_until_key([])
+    |> control.from_key
+  {
+    Error(_) -> Nil
+    Ok(control) -> process.send(subject, control)
+  }
 
   read_input(subject)
 }

test/mpv/control_test.gleam

@@ -0,0 +1,33 @@
+import gleam/list
+import gleeunit
+
+import mpv/control.{type Control}
+import mpv/internal/control as control_internal
+import mpv/key.{type Key, Char}
+
+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
+}

test/mpv/key_test.gleam

@@ -0,0 +1,29 @@
+import gleam/list
+import gleeunit
+
+import mpv/key.{type Key, Char, csi, esc}
+
+pub fn main() -> Nil {
+  gleeunit.main()
+}
+
+type TestCase {
+  TestCase(input: List(String), expected: Key)
+}
+
+pub fn key_from_list_test() {
+  let test_cases = [
+    TestCase(["c"], Char("c")),
+    TestCase([esc, csi, "D"], key.Left),
+    TestCase([esc, csi, "C"], key.Right),
+    TestCase([esc, csi, "A"], key.Up),
+    TestCase([esc, csi, "B"], key.Down),
+    TestCase([esc, csi], key.Continue),
+    TestCase([esc], key.Continue),
+    TestCase([], key.Continue),
+  ]
+
+  list.each(test_cases, fn(tc) {
+    assert tc.expected == key.from_list(tc.input)
+  })
+}

test/mpv/mpv_test.gleam

@@ -1,29 +0,0 @@
-import gleam/list
-import gleeunit
-
-import mpv/internal.{Char, csi, esc}
-
-pub fn main() -> Nil {
-  gleeunit.main()
-}
-
-type TestCase {
-  TestCase(input: List(String), expected: internal.Key)
-}
-
-pub fn mpv_key_from_list_test() {
-  let test_cases = [
-    TestCase(["c"], Char("c")),
-    TestCase([esc, csi, "D"], internal.Left),
-    TestCase([esc, csi, "C"], internal.Right),
-    TestCase([esc, csi, "A"], internal.Up),
-    TestCase([esc, csi, "B"], internal.Down),
-    TestCase([esc, csi], internal.Continue),
-    TestCase([esc], internal.Continue),
-    TestCase([], internal.Continue),
-  ]
-
-  list.each(test_cases, fn(tc) {
-    assert tc.expected == internal.from_list(tc.input)
-  })
-}