Implement spotify-player's CLI commands (#159)

Resolves #111.
Partially #103.

## Changes
Added CLI commands and subcommands:
- `get`: 
```
Get spotify data

Usage: spotify_player get <COMMAND>

Commands:
  key      Get data by key
  context  Get context data
  help     Print this message or the help of the given subcommand(s)

Options:
  -h, --help  Print help
``` 
- `get key`:
```
Get data by key

Usage: spotify_player get key <key>

Arguments:
  <key>  [possible values: playback, devices, user-playlists, user-liked-tracks, user-saved-albums, user-followed-artists, user-top-tracks, queue]

Options:
  -h, --help  Print help
```
- `get context`
```
Get context data

Usage: spotify_player get context <context_type> <context_id>

Arguments:
  <context_type>  [possible values: playlist, album, artist]
  <context_id>

Options:
  -h, --help  Print help
```
- `playback`
```
Interact with the playback

Usage: spotify_player playback <COMMAND>

Commands:
  play      Start a playback
  resume    Resume the playback
  pause     Pause the playback
  next      Next track
  previous  Previous track
  shuffle   Toggle the shuffle mode
  repeat    Cycle the repeat mode
  volume    Set playback's volume percentage
  seek      Seek the playback by an offset
  help      Print this message or the help of the given subcommand(s)

Options:
  -h, --help  Print help
```

Author: aome510

Cargo.lock

@@ -11,7 +11,7 @@ readme = "../README.md"
 
 [dependencies]
 anyhow = "1.0.70"
-clap = "4.2.0"
+clap = { version = "4.2.0", features = ["derive"] }
 config_parser2 = "0.1.4"
 crossterm = "0.26.1"
 dirs-next = "2.0.0"

spotify_player/Cargo.toml

@@ -0,0 +1,67 @@
+use clap::{builder::EnumValueParser, value_parser, Arg, Command};
+
+use super::{ContextType, Key};
+
+pub fn init_get_subcommand() -> Command {
+    Command::new("get")
+        .about("Get spotify data")
+        .subcommand_required(true)
+        .subcommand(
+            Command::new("key").about("Get data by key").arg(
+                Arg::new("key")
+                    .value_parser(EnumValueParser::<Key>::new())
+                    .required(true),
+            ),
+        )
+        .subcommand(
+            Command::new("context")
+                .about("Get context data")
+                .arg(
+                    Arg::new("context_type")
+                        .value_parser(EnumValueParser::<ContextType>::new())
+                        .required(true),
+                )
+                .arg(Arg::new("context_id").required(true)),
+        )
+}
+
+fn init_playback_start_subcommand() -> Command {
+    Command::new("start")
+        .about("Start a context playback")
+        .arg(
+            Arg::new("context_type")
+                .value_parser(EnumValueParser::<ContextType>::new())
+                .required(true),
+        )
+        .arg(Arg::new("context_id").required(true))
+}
+
+pub fn init_playback_subcommand() -> Command {
+    Command::new("playback")
+        .about("Interact with the playback")
+        .subcommand_required(true)
+        .subcommand(init_playback_start_subcommand())
+        .subcommand(Command::new("play-pause").about("Toggle between play and pause"))
+        .subcommand(Command::new("next").about("Skip to the next track"))
+        .subcommand(Command::new("previous").about("Skip to the previous track"))
+        .subcommand(Command::new("shuffle").about("Toggle the shuffle mode"))
+        .subcommand(Command::new("repeat").about("Cycle the repeat mode"))
+        .subcommand(
+            Command::new("volume")
+                .about("Set the volume percentage")
+                .arg(
+                    Arg::new("percent")
+                        .value_parser(value_parser!(u8).range(0..=100))
+                        .required(true),
+                ),
+        )
+        .subcommand(
+            Command::new("seek")
+                .about("Seek by an offset milliseconds")
+                .arg(
+                    Arg::new("position_offset_ms")
+                        .value_parser(value_parser!(i32))
+                        .required(true),
+                ),
+        )
+}

spotify_player/src/cli/commands.rs

@@ -0,0 +1,102 @@
+use super::*;
+use anyhow::Result;
+use clap::ArgMatches;
+use std::net::UdpSocket;
+
+fn receive_data(socket: &UdpSocket) -> Result<Vec<u8>> {
+    // read response from the server's socket, which can be splitted into
+    // smaller chunks of data
+    let mut data = Vec::new();
+    let mut buf = [0; 4096];
+    loop {
+        let (n_bytes, _) = socket.recv_from(&mut buf)?;
+        if n_bytes == 0 {
+            // end of chunk
+            break;
+        }
+        data.extend_from_slice(&buf[..n_bytes]);
+    }
+
+    Ok(data)
+}
+
+fn handle_get_subcommand(args: &ArgMatches, socket: UdpSocket) -> Result<()> {
+    let (cmd, args) = args.subcommand().expect("playback subcommand is required");
+
+    let request = match cmd {
+        "key" => {
+            let key = args
+                .get_one::<Key>("key")
+                .expect("key is required")
+                .to_owned();
+            Request::Get(GetRequest::Key(key))
+        }
+        "context" => {
+            let context_id = args
+                .get_one::<String>("context_id")
+                .expect("context_id is required")
+                .to_owned();
+            let context_type = args
+                .get_one::<ContextType>("context_type")
+                .expect("context_type is required")
+                .to_owned();
+            Request::Get(GetRequest::Context(context_id, context_type))
+        }
+        _ => unreachable!(),
+    };
+
+    socket.send(&serde_json::to_vec(&request)?)?;
+    let data = receive_data(&socket)?;
+    println!("{}", String::from_utf8_lossy(&data));
+
+    Ok(())
+}
+
+fn handle_playback_subcommand(args: &ArgMatches, socket: UdpSocket) -> Result<()> {
+    let (cmd, args) = args.subcommand().expect("playback subcommand is required");
+    let command = match cmd {
+        "start" => {
+            let context_id = args
+                .get_one::<String>("context_id")
+                .expect("context_id is required");
+            let context_type = args
+                .get_one::<ContextType>("context_type")
+                .expect("context_type is required");
+            Command::Start(context_id.to_owned(), context_type.to_owned())
+        }
+        "play-pause" => Command::PlayPause,
+        "next" => Command::Next,
+        "previous" => Command::Previous,
+        "shuffle" => Command::Shuffle,
+        "repeat" => Command::Repeat,
+        "volume" => {
+            let percent = args
+                .get_one::<u8>("percent")
+                .expect("percent arg is required");
+            Command::Volume(*percent)
+        }
+        "seek" => {
+            let position_offset_ms = args
+                .get_one::<i32>("position_offset_ms")
+                .expect("position_offset_ms is required");
+            Command::Seek(*position_offset_ms)
+        }
+        _ => unreachable!(),
+    };
+
+    let request = Request::Playback(command);
+    socket.send(&serde_json::to_vec(&request)?)?;
+
+    Ok(())
+}
+
+pub fn handle_cli_subcommand(cmd: &str, args: &ArgMatches, client_port: u16) -> Result<()> {
+    let socket = UdpSocket::bind("127.0.0.1:0")?;
+    socket.connect(("127.0.0.1", client_port))?;
+
+    match cmd {
+        "get" => handle_get_subcommand(args, socket),
+        "playback" => handle_playback_subcommand(args, socket),
+        _ => unreachable!(),
+    }
+}

spotify_player/src/cli/handlers.rs

@@ -0,0 +1,52 @@
+mod commands;
+mod handlers;
+mod socket;
+
+use serde::{Deserialize, Serialize};
+
+pub use commands::{init_get_subcommand, init_playback_subcommand};
+pub use handlers::handle_cli_subcommand;
+pub use socket::start_socket;
+
+#[derive(Debug, Serialize, Deserialize, clap::ValueEnum, Clone)]
+pub enum Key {
+    Playback,
+    Devices,
+    UserPlaylists,
+    UserLikedTracks,
+    UserSavedAlbums,
+    UserFollowedArtists,
+    UserTopTracks,
+    Queue,
+}
+
+#[derive(Debug, Serialize, Deserialize, clap::ValueEnum, Clone)]
+pub enum ContextType {
+    Playlist,
+    Album,
+    Artist,
+}
+
+#[derive(Debug, Serialize, Deserialize)]
+pub enum GetRequest {
+    Key(Key),
+    Context(String, ContextType),
+}
+
+#[derive(Debug, Serialize, Deserialize)]
+pub enum Command {
+    Start(String, ContextType),
+    PlayPause,
+    Next,
+    Previous,
+    Shuffle,
+    Repeat,
+    Volume(u8),
+    Seek(i32),
+}
+
+#[derive(Debug, Serialize, Deserialize)]
+pub enum Request {
+    Get(GetRequest),
+    Playback(Command),
+}