[rocksky] control rockbox remotely with rocksky web ui (websocket)

Cargo.lock

···
  "mime",
  "percent-encoding",
  "pin-project-lite",
- "rand",
+ "rand 0.8.5",
  "sha1",
  "smallvec",
  "tokio",
···
 checksum = "e89da841a80418a9b391ebaea17f5c112ffaaa96f621d2c285b5174da76b9011"
 dependencies = [
  "cfg-if 1.0.0",
- "getrandom",
+ "getrandom 0.2.15",
  "once_cell",
  "version_check",
- "zerocopy",
+ "zerocopy 0.7.35",
 ]
 
 [[package]]
···
 
 [[package]]
 name = "bytes"
-version = "1.7.1"
+version = "1.10.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8318a53db07bb3f8dca91a600466bdb3f2eaadeedfdbcf02e1accbad9271ba50"
+checksum = "d71b6127be86fdcfddb610f7182ac57211d4b18a3e9c82eb2d17662f2227ad6a"
 dependencies = [
  "serde",
 ]
···
 checksum = "0dc92fb57ca44df6db8059111ab3af99a63d5d0f8375d9972e319a379c6bab76"
 dependencies = [
  "generic-array",
- "rand_core",
+ "rand_core 0.6.4",
  "subtle",
  "zeroize",
 ]
···
 checksum = "1bfb12502f3fc46cca1bb51ac28df9d618d813cdc3d2f25b9fe775a34af26bb3"
 dependencies = [
  "generic-array",
- "rand_core",
+ "rand_core 0.6.4",
  "typenum",
 ]
 
···
  "hostname 0.4.0",
  "num",
  "once_cell",
- "rand",
+ "rand 0.8.5",
  "uuid",
 ]
 
···
 checksum = "50e281dc36864ea88fae2ec4e21eb280e8239487acb1ddc59b528b0afa7997bd"
 dependencies = [
  "cuid-util",
- "getrandom",
+ "getrandom 0.2.15",
  "num",
- "rand",
+ "rand 0.8.5",
  "sha3",
 ]
 
···
  "pretty_assertions",
  "pretty_yaml",
  "quick-junit",
- "rand",
+ "rand 0.8.5",
  "regex",
  "ring",
  "runtimelib",
···
  "p256",
  "p384",
  "p521",
- "rand",
+ "rand 0.8.5",
  "ring",
  "rsa",
  "sec1",
···
  "junction",
  "libc",
  "nix 0.27.1",
- "rand",
+ "rand 0.8.5",
  "rayon",
  "serde",
  "thiserror 2.0.9",
···
  "percent-encoding",
  "phf",
  "pin-project",
- "rand",
+ "rand 0.8.5",
  "ring",
  "scopeguard",
  "serde",
···
  "os_pipe",
  "parking_lot",
  "pin-project",
- "rand",
+ "rand 0.8.5",
  "tokio",
  "uuid",
  "winapi",
···
  "num-bigint",
  "prost",
  "prost-build",
- "rand",
+ "rand 0.8.5",
  "rusqlite",
  "serde",
  "thiserror 2.0.9",
···
  "pbkdf2",
  "pin-project-lite",
  "pkcs8",
- "rand",
+ "rand 0.8.5",
  "regex",
  "ring",
  "ripemd",
···
  "log",
  "parking_lot",
  "percent-encoding",
- "rand",
+ "rand 0.8.5",
  "ring",
  "serde_json",
  "tar",
···
  "http 1.1.0",
  "log",
  "prost",
- "rand",
+ "rand 0.8.5",
  "serde",
  "serde_json",
  "tokio",
···
  "hex",
  "log",
  "num-bigint",
- "rand",
+ "rand 0.8.5",
  "rusqlite",
  "serde_json",
  "thiserror 1.0.63",
···
 dependencies = [
  "curve25519-dalek",
  "ed25519",
- "rand_core",
+ "rand_core 0.6.4",
  "serde",
  "sha2",
  "signature",
···
  "indexmap 2.5.0",
  "log",
  "thiserror 1.0.63",
- "zerocopy",
+ "zerocopy 0.7.35",
 ]
 
 [[package]]
···
  "hkdf",
  "pem-rfc7468",
  "pkcs8",
- "rand_core",
+ "rand_core 0.6.4",
  "sec1",
  "serde_json",
  "serdect",
···
  "hyper 1.4.1",
  "hyper-util",
  "pin-project",
- "rand",
+ "rand 0.8.5",
  "sha1",
  "simdutf8",
  "thiserror 1.0.63",
···
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "ded41244b729663b1e574f1b4fb731469f69f79c17667b5d776b16cda0479449"
 dependencies = [
- "rand_core",
+ "rand_core 0.6.4",
  "subtle",
 ]
 
···
  "cfg-if 1.0.0",
  "js-sys",
  "libc",
- "wasi",
+ "wasi 0.11.0+wasi-snapshot-preview1",
  "wasm-bindgen",
 ]
 
 [[package]]
+name = "getrandom"
+version = "0.3.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "73fea8450eea4bac3940448fb7ae50d91f034f941199fcd9d909a5a07aa455f0"
+dependencies = [
+ "cfg-if 1.0.0",
+ "libc",
+ "r-efi",
+ "wasi 0.14.2+wasi-0.2.4",
+]
+
+[[package]]
 name = "ghash"
 version = "0.5.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
···
 checksum = "f0f9ef7462f7c099f518d754361858f86d8a07af53ba9af0fe635bbccb151a63"
 dependencies = [
  "ff",
- "rand_core",
+ "rand_core 0.6.4",
  "subtle",
 ]
 
···
  "idna",
  "ipnet",
  "once_cell",
- "rand",
+ "rand 0.8.5",
  "serde",
  "thiserror 2.0.9",
  "tinyvec",
···
  "moka",
  "once_cell",
  "parking_lot",
- "rand",
+ "rand 0.8.5",
  "resolv-conf",
  "serde",
  "smallvec",
···
  "if-addrs 0.12.0",
  "log",
  "multimap",
- "rand",
+ "rand 0.8.5",
  "socket2 0.5.7",
  "thiserror 1.0.63",
  "tokio",
···
  "libc",
  "sha2",
  "windows-sys 0.48.0",
- "zerocopy",
+ "zerocopy 0.7.35",
 ]
 
 [[package]]
···
 dependencies = [
  "libc",
  "log",
- "wasi",
+ "wasi 0.11.0+wasi-snapshot-preview1",
  "windows-sys 0.48.0",
 ]
 
···
  "hermit-abi 0.3.9",
  "libc",
  "log",
- "wasi",
+ "wasi 0.11.0+wasi-snapshot-preview1",
  "windows-sys 0.52.0",
 ]
 
···
 dependencies = [
  "num-integer",
  "num-traits",
- "rand",
+ "rand 0.8.5",
  "serde",
 ]
 
···
  "num-integer",
  "num-iter",
  "num-traits",
- "rand",
+ "rand 0.8.5",
  "serde",
  "smallvec",
  "zeroize",
···
  "glob",
  "opentelemetry",
  "percent-encoding",
- "rand",
+ "rand 0.8.5",
  "serde_json",
  "thiserror 1.0.63",
  "tracing",
···
  "ecdsa",
  "elliptic-curve",
  "primeorder",
- "rand_core",
+ "rand_core 0.6.4",
  "sha2",
 ]
 
···
 checksum = "346f04948ba92c43e8469c1ee6736c7563d71012b17d40745260fe106aac2166"
 dependencies = [
  "base64ct",
- "rand_core",
+ "rand_core 0.6.4",
  "subtle",
 ]
 
···
 checksum = "48e4cc64c2ad9ebe670cb8fd69dd50ae301650392e81c05f9bfcb2d5bdbc24b0"
 dependencies = [
  "phf_shared",
- "rand",
+ "rand 0.8.5",
 ]
 
 [[package]]
···
 dependencies = [
  "der",
  "pkcs5",
- "rand_core",
+ "rand_core 0.6.4",
  "spki",
 ]
 
···
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "77957b295656769bb8ad2b6a6b09d897d94f05c41b069aede1fcdaa675eaea04"
 dependencies = [
- "zerocopy",
+ "zerocopy 0.7.35",
 ]
 
 [[package]]
···
  "libc",
  "once_cell",
  "raw-cpuid",
- "wasi",
+ "wasi 0.11.0+wasi-snapshot-preview1",
  "web-sys",
  "winapi",
 ]
···
 checksum = "a2fe5ef3495d7d2e377ff17b1a8ce2ee2ec2a18cde8b6ad6619d65d0701c135d"
 dependencies = [
  "bytes",
- "getrandom",
- "rand",
+ "getrandom 0.2.15",
+ "rand 0.8.5",
  "ring",
  "rustc-hash 2.0.0",
  "rustls 0.23.13",
···
 ]
 
 [[package]]
+name = "r-efi"
+version = "5.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "74765f6d916ee2faa39bc8e68e4f3ed8949b48cccdac59983d287a7cb71ce9c5"
+
+[[package]]
 name = "radium"
 version = "0.7.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
···
 checksum = "34af8d1a0e25924bc5b7c43c079c942339d8f0a8b57c39049bef581b46327404"
 dependencies = [
  "libc",
- "rand_chacha",
- "rand_core",
+ "rand_chacha 0.3.1",
+ "rand_core 0.6.4",
+]
+
+[[package]]
+name = "rand"
+version = "0.9.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3779b94aeb87e8bd4e834cee3650289ee9e0d5677f976ecdb6d219e5f4f6cd94"
+dependencies = [
+ "rand_chacha 0.9.0",
+ "rand_core 0.9.3",
+ "zerocopy 0.8.24",
 ]
 
 [[package]]
···
 checksum = "e6c10a63a0fa32252be49d21e7709d4d4baf8d231c2dbce1eaa8141b9b127d88"
 dependencies = [
  "ppv-lite86",
- "rand_core",
+ "rand_core 0.6.4",
+]
+
+[[package]]
+name = "rand_chacha"
+version = "0.9.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d3022b5f1df60f26e1ffddd6c66e8aa15de382ae63b3a0c1bfc0e4d3e3f325cb"
+dependencies = [
+ "ppv-lite86",
+ "rand_core 0.9.3",
 ]
 
 [[package]]
···
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "ec0be4795e2f6a28069bec0b5ff3e2ac9bafc99e6a9a7dc3547996c5c816922c"
 dependencies = [
- "getrandom",
+ "getrandom 0.2.15",
+]
+
+[[package]]
+name = "rand_core"
+version = "0.9.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "99d9a13982dcf210057a8a78572b2217b667c3beacbf3a0d8b454f6f82837d38"
+dependencies = [
+ "getrandom 0.3.2",
 ]
 
 [[package]]
···
 checksum = "32cb0b9bc82b0a0876c2dd994a7e7a2683d3e7390ca40e6886785ef0c7e3ee31"
 dependencies = [
  "num-traits",
- "rand",
+ "rand 0.8.5",
 ]
 
 [[package]]
···
  "once_cell",
  "paste",
  "profiling",
- "rand",
- "rand_chacha",
+ "rand 0.8.5",
+ "rand_chacha 0.3.1",
  "simd_helpers",
  "system-deps 6.2.2",
  "thiserror 1.0.63",
···
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "ba009ff324d1fc1b900bd1fdb31564febe58a8ccc8a6fdbb93b543d33b13ca43"
 dependencies = [
- "getrandom",
+ "getrandom 0.2.15",
  "libredox",
  "thiserror 1.0.63",
 ]
···
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "dd6f9d3d47bdd2ad6945c5015a226ec6155d0bcdfd8f7cd29f86b71f8de99d2b"
 dependencies = [
- "getrandom",
+ "getrandom 0.2.15",
  "libredox",
  "thiserror 2.0.9",
 ]
···
 dependencies = [
  "cc",
  "cfg-if 1.0.0",
- "getrandom",
+ "getrandom 0.2.15",
  "libc",
  "spin",
  "untrusted",
···
  "clap",
  "owo-colors 4.1.0",
  "rockbox-library",
+ "rockbox-rocksky",
  "rockbox-search",
  "rockbox-settings",
  "tokio",
···
 dependencies = [
  "anyhow",
  "dirs 6.0.0",
+ "futures-util",
  "lofty",
+ "prost",
  "reqwest",
  "rockbox-library",
  "serde",
  "serde_json",
  "sha256",
  "tokio",
+ "tokio-stream",
+ "tokio-tungstenite 0.26.2",
+ "tonic",
+ "tonic-build",
+ "tonic-reflection",
+ "tonic-web",
+ "tungstenite 0.26.2",
 ]
 
 [[package]]
···
  "md5",
  "owo-colors 4.1.0",
  "queryst",
- "rand",
+ "rand 0.8.5",
  "reqwest",
  "rockbox-chromecast",
  "rockbox-discovery",
···
 name = "rockbox-tracklist"
 version = "0.1.0"
 dependencies = [
- "rand",
+ "rand 0.8.5",
  "rockbox-traits",
 ]
 
···
  "num-traits",
  "pkcs1",
  "pkcs8",
- "rand_core",
+ "rand_core 0.6.4",
  "signature",
  "spki",
  "subtle",
···
  "futures",
  "glob",
  "jupyter-serde",
- "rand",
+ "rand 0.8.5",
  "ring",
  "serde",
  "serde_json",
···
 checksum = "77549399552de45a898a580c1b41d445bf730df867cc44e6c0233bbc4b8329de"
 dependencies = [
  "digest",
- "rand_core",
+ "rand_core 0.6.4",
 ]
 
 [[package]]
···
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "aa2bcf6c6e164e81bc7a5d49fc6988b3d515d9e8c07457d7b74ffb9324b9cd40"
 dependencies = [
- "getrandom",
+ "getrandom 0.2.15",
  "halfbrown",
  "ref-cast",
  "serde",
···
  "memchr",
  "once_cell",
  "percent-encoding",
- "rand",
+ "rand 0.8.5",
  "rsa",
  "serde",
  "sha1",
···
  "md-5",
  "memchr",
  "once_cell",
- "rand",
+ "rand 0.8.5",
  "serde",
  "serde_json",
  "sha2",
···
 
 [[package]]
 name = "tokio-stream"
-version = "0.1.16"
+version = "0.1.17"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4f4e6ce100d0eb49a2734f8c0812bcd324cf357d21810932c5df6b96ef2b86f1"
+checksum = "eca58d7bba4a75707817a2c44174253f9236b2d5fbd055602e9d5c07c139a047"
 dependencies = [
  "futures-core",
  "pin-project-lite",
···
  "futures-util",
  "log",
  "tokio",
- "tungstenite",
+ "tungstenite 0.21.0",
+]
+
+[[package]]
+name = "tokio-tungstenite"
+version = "0.26.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7a9daff607c6d2bf6c16fd681ccb7eecc83e4e2cdc1ca067ffaadfca5de7f084"
+dependencies = [
+ "futures-util",
+ "log",
+ "rustls 0.23.13",
+ "rustls-pki-types",
+ "tokio",
+ "tokio-rustls",
+ "tungstenite 0.26.2",
+ "webpki-roots 0.26.3",
 ]
 
 [[package]]
···
  "indexmap 1.9.3",
  "pin-project",
  "pin-project-lite",
- "rand",
+ "rand 0.8.5",
  "slab",
  "tokio",
  "tokio-util",
···
  "http 1.1.0",
  "httparse",
  "log",
- "rand",
+ "rand 0.8.5",
  "sha1",
  "thiserror 1.0.63",
  "url",
···
 ]
 
 [[package]]
+name = "tungstenite"
+version = "0.26.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4793cb5e56680ecbb1d843515b23b6de9a75eb04b66643e256a396d43be33c13"
+dependencies = [
+ "bytes",
+ "data-encoding",
+ "http 1.1.0",
+ "httparse",
+ "log",
+ "rand 0.9.0",
+ "rustls 0.23.13",
+ "rustls-pki-types",
+ "sha1",
+ "thiserror 2.0.9",
+ "utf-8",
+]
+
+[[package]]
 name = "twox-hash"
 version = "1.6.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "97fee6b57c6a41524a810daee9286c02d7752c4253064d0b05472833a438f675"
 dependencies = [
  "cfg-if 1.0.0",
- "rand",
+ "rand 0.8.5",
  "static_assertions",
 ]
 
···
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "81dfa00651efa65069b0b6b651f4aaa31ba9e3c3ce0137aaad053604ee7e0314"
 dependencies = [
- "getrandom",
+ "getrandom 0.2.15",
  "serde",
  "sha1_smol",
 ]
···
  "serde_json",
  "serde_urlencoded",
  "tokio",
- "tokio-tungstenite",
+ "tokio-tungstenite 0.21.0",
  "tokio-util",
  "tower-service",
  "tracing",
···
 version = "0.11.0+wasi-snapshot-preview1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "9c8d87e72b64a3b4db28d11ce29237c246188f4f51057d65a7eab63b7987e423"
+
+[[package]]
+name = "wasi"
+version = "0.14.2+wasi-0.2.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9683f9a5a998d873c0d21fcbe3c083009670149a8fab228644b8bd36b2c48cb3"
+dependencies = [
+ "wit-bindgen-rt",
+]
 
 [[package]]
 name = "wasite"
···
 checksum = "d135d17ab770252ad95e9a872d365cf3090e3be864a34ab46f48555993efc904"
 
 [[package]]
+name = "wit-bindgen-rt"
+version = "0.39.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6f42320e61fe2cfd34354ecb597f86f413484a798ba44a8ca1165c58d42da6c1"
+dependencies = [
+ "bitflags 2.6.0",
+]
+
+[[package]]
 name = "write16"
 version = "1.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
···
 checksum = "c7e468321c81fb07fa7f4c636c3972b9100f0346e5b6a9f2bd0603a52f7ed277"
 dependencies = [
  "curve25519-dalek",
- "rand_core",
+ "rand_core 0.6.4",
  "serde",
  "zeroize",
 ]
···
  "hex",
  "nix 0.29.0",
  "ordered-stream",
- "rand",
+ "rand 0.8.5",
  "serde",
  "serde_repr",
  "sha1",
···
 checksum = "1b9b4fd18abc82b8136838da5d50bae7bdea537c574d8dc1a34ed098d6c166f0"
 dependencies = [
  "byteorder",
- "zerocopy-derive",
+ "zerocopy-derive 0.7.35",
+]
+
+[[package]]
+name = "zerocopy"
+version = "0.8.24"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2586fea28e186957ef732a5f8b3be2da217d65c5969d4b1e17f973ebbe876879"
+dependencies = [
+ "zerocopy-derive 0.8.24",
 ]
 
 [[package]]
···
 version = "0.7.35"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "fa4f8080344d4671fb4e831a13ad1e68092748387dfc4f55e356242fae12ce3e"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.91",
+]
+
+[[package]]
+name = "zerocopy-derive"
+version = "0.8.24"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a996a8f63c5c4448cd959ac1bab0aaa3306ccfd060472f85943ee0750f0169be"
 dependencies = [
  "proc-macro2",
  "quote",
···
  "num-traits",
  "once_cell",
  "parking_lot",
- "rand",
+ "rand 0.8.5",
  "regex",
  "thiserror 1.0.63",
  "tokio",

crates/cli/Cargo.toml

···
 rockbox-library = {path = "../library"}
 rockbox-search = {path = "../search"}
 rockbox-settings = {path = "../settings"}
+rockbox-rocksky = {path = "../rocksky"}
 tokio = {version = "1.36.0", features = ["full"]}

crates/cli/src/lib.rs

···
 use rockbox_search::artist::Artist;
 use rockbox_search::track::Track;
 use rockbox_search::{create_indexes, delete_all_documents, index_entity};
+use std::thread::sleep;
+use std::time::Duration;
 use std::{env, ffi::CStr};
 use std::{fs, thread};
 
···
             Ok::<(), Error>(())
         })
         .unwrap();
+
+        thread::spawn(move || {
+            sleep(Duration::from_secs(5));
+            match rockbox_rocksky::register_rockbox() {
+                Ok(_) => println!("Successfully registered Rockbox with Rocksky server"),
+                Err(e) => eprintln!("Failed to register Rockbox with Rocksky server: {}", e),
+            };
+        });
 
         const BANNER: &str = r#"
           __________               __   ___.

crates/rocksky/Cargo.toml

···
 anyhow.workspace = true
 lofty = "0.21.1"
 dirs = "6.0.0"
+prost = "0.13.2"
 rockbox-library = { path = "../library" }
 reqwest = { version = "0.12.5", features = [
   "rustls-tls",
···
 serde_json = "1.0.128"
 sha256 = "1.5.0"
 tokio = { version = "1.36.0", features = ["full"] }
+tonic = "0.12.3"
+tonic-reflection = "0.12.3"
+tonic-web = "0.12.3"
+tungstenite = { version = "0.26.2", features = ["rustls"] }
+tokio-tungstenite = { version = "0.26.2", features = ["tokio-rustls", "rustls-tls-webpki-roots"] }
+futures-util = "0.3.31"
+tokio-stream = "0.1.17"
+
+[build-dependencies]
+tonic-build = "0.12.3"

crates/rocksky/build.rs

···
+fn main() -> Result<(), Box<dyn std::error::Error>> {
+    tonic_build::configure()
+        .out_dir("src/api")
+        .file_descriptor_set_path("src/api/rockbox_descriptor.bin")
+        .compile_protos(
+            &[
+                "proto/rockbox/v1alpha1/browse.proto",
+                "proto/rockbox/v1alpha1/library.proto",
+                "proto/rockbox/v1alpha1/metadata.proto",
+                "proto/rockbox/v1alpha1/playback.proto",
+                "proto/rockbox/v1alpha1/playlist.proto",
+                "proto/rockbox/v1alpha1/settings.proto",
+                "proto/rockbox/v1alpha1/sound.proto",
+                "proto/rockbox/v1alpha1/system.proto",
+            ],
+            &["proto"],
+        )?;
+    Ok(())
+}

crates/rocksky/proto

···
+../../crates/rpc/proto

crates/rocksky/src/api/rockbox.v1alpha1.rs

···
+// This file is @generated by prost-build.
+#[derive(Clone, Copy, PartialEq, ::prost::Message)]
+pub struct RockboxBrowseRequest {}
+#[derive(Clone, Copy, PartialEq, ::prost::Message)]
+pub struct RockboxBrowseResponse {}
+#[derive(Clone, Copy, PartialEq, ::prost::Message)]
+pub struct TreeGetContextRequest {}
+#[derive(Clone, Copy, PartialEq, ::prost::Message)]
+pub struct TreeGetContextResponse {}
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct TreeGetEntriesRequest {
+    #[prost(string, optional, tag = "1")]
+    pub path: ::core::option::Option<::prost::alloc::string::String>,
+}
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct Entry {
+    #[prost(string, tag = "1")]
+    pub name: ::prost::alloc::string::String,
+    #[prost(int32, tag = "2")]
+    pub attr: i32,
+    #[prost(uint32, tag = "3")]
+    pub time_write: u32,
+    #[prost(int32, tag = "4")]
+    pub customaction: i32,
+}
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct TreeGetEntriesResponse {
+    #[prost(message, repeated, tag = "1")]
+    pub entries: ::prost::alloc::vec::Vec<Entry>,
+}
+#[derive(Clone, Copy, PartialEq, ::prost::Message)]
+pub struct TreeGetEntryAtRequest {}
+#[derive(Clone, Copy, PartialEq, ::prost::Message)]
+pub struct TreeGetEntryAtResponse {}
+#[derive(Clone, Copy, PartialEq, ::prost::Message)]
+pub struct BrowseId3Request {}
+#[derive(Clone, Copy, PartialEq, ::prost::Message)]
+pub struct BrowseId3Response {}
+/// Generated client implementations.
+pub mod browse_service_client {
+    #![allow(
+        unused_variables,
+        dead_code,
+        missing_docs,
+        clippy::wildcard_imports,
+        clippy::let_unit_value,
+    )]
+    use tonic::codegen::*;
+    use tonic::codegen::http::Uri;
+    #[derive(Debug, Clone)]
+    pub struct BrowseServiceClient<T> {
+        inner: tonic::client::Grpc<T>,
+    }
+    impl BrowseServiceClient<tonic::transport::Channel> {
+        /// Attempt to create a new client by connecting to a given endpoint.
+        pub async fn connect<D>(dst: D) -> Result<Self, tonic::transport::Error>
+        where
+            D: TryInto<tonic::transport::Endpoint>,
+            D::Error: Into<StdError>,
+        {
+            let conn = tonic::transport::Endpoint::new(dst)?.connect().await?;
+            Ok(Self::new(conn))
+        }
+    }
+    impl<T> BrowseServiceClient<T>
+    where
+        T: tonic::client::GrpcService<tonic::body::BoxBody>,
+        T::Error: Into<StdError>,
+        T::ResponseBody: Body<Data = Bytes> + std::marker::Send + 'static,
+        <T::ResponseBody as Body>::Error: Into<StdError> + std::marker::Send,
+    {
+        pub fn new(inner: T) -> Self {
+            let inner = tonic::client::Grpc::new(inner);
+            Self { inner }
+        }
+        pub fn with_origin(inner: T, origin: Uri) -> Self {
+            let inner = tonic::client::Grpc::with_origin(inner, origin);
+            Self { inner }
+        }
+        pub fn with_interceptor<F>(
+            inner: T,
+            interceptor: F,
+        ) -> BrowseServiceClient<InterceptedService<T, F>>
+        where
+            F: tonic::service::Interceptor,
+            T::ResponseBody: Default,
+            T: tonic::codegen::Service<
+                http::Request<tonic::body::BoxBody>,
+                Response = http::Response<
+                    <T as tonic::client::GrpcService<tonic::body::BoxBody>>::ResponseBody,
+                >,
+            >,
+            <T as tonic::codegen::Service<
+                http::Request<tonic::body::BoxBody>,
+            >>::Error: Into<StdError> + std::marker::Send + std::marker::Sync,
+        {
+            BrowseServiceClient::new(InterceptedService::new(inner, interceptor))
+        }
+        /// Compress requests with the given encoding.
+        ///
+        /// This requires the server to support it otherwise it might respond with an
+        /// error.
+        #[must_use]
+        pub fn send_compressed(mut self, encoding: CompressionEncoding) -> Self {
+            self.inner = self.inner.send_compressed(encoding);
+            self
+        }
+        /// Enable decompressing responses.
+        #[must_use]
+        pub fn accept_compressed(mut self, encoding: CompressionEncoding) -> Self {
+            self.inner = self.inner.accept_compressed(encoding);
+            self
+        }
+        /// Limits the maximum size of a decoded message.
+        ///
+        /// Default: `4MB`
+        #[must_use]
+        pub fn max_decoding_message_size(mut self, limit: usize) -> Self {
+            self.inner = self.inner.max_decoding_message_size(limit);
+            self
+        }
+        /// Limits the maximum size of an encoded message.
+        ///
+        /// Default: `usize::MAX`
+        #[must_use]
+        pub fn max_encoding_message_size(mut self, limit: usize) -> Self {
+            self.inner = self.inner.max_encoding_message_size(limit);
+            self
+        }
+        pub async fn tree_get_entries(
+            &mut self,
+            request: impl tonic::IntoRequest<super::TreeGetEntriesRequest>,
+        ) -> std::result::Result<
+            tonic::Response<super::TreeGetEntriesResponse>,
+            tonic::Status,
+        > {
+            self.inner
+                .ready()
+                .await
+                .map_err(|e| {
+                    tonic::Status::unknown(
+                        format!("Service was not ready: {}", e.into()),
+                    )
+                })?;
+            let codec = tonic::codec::ProstCodec::default();
+            let path = http::uri::PathAndQuery::from_static(
+                "/rockbox.v1alpha1.BrowseService/TreeGetEntries",
+            );
+            let mut req = request.into_request();
+            req.extensions_mut()
+                .insert(
+                    GrpcMethod::new("rockbox.v1alpha1.BrowseService", "TreeGetEntries"),
+                );
+            self.inner.unary(req, path, codec).await
+        }
+    }
+}
+/// Generated server implementations.
+pub mod browse_service_server {
+    #![allow(
+        unused_variables,
+        dead_code,
+        missing_docs,
+        clippy::wildcard_imports,
+        clippy::let_unit_value,
+    )]
+    use tonic::codegen::*;
+    /// Generated trait containing gRPC methods that should be implemented for use with BrowseServiceServer.
+    #[async_trait]
+    pub trait BrowseService: std::marker::Send + std::marker::Sync + 'static {
+        async fn tree_get_entries(
+            &self,
+            request: tonic::Request<super::TreeGetEntriesRequest>,
+        ) -> std::result::Result<
+            tonic::Response<super::TreeGetEntriesResponse>,
+            tonic::Status,
+        >;
+    }
+    #[derive(Debug)]
+    pub struct BrowseServiceServer<T> {
+        inner: Arc<T>,
+        accept_compression_encodings: EnabledCompressionEncodings,
+        send_compression_encodings: EnabledCompressionEncodings,
+        max_decoding_message_size: Option<usize>,
+        max_encoding_message_size: Option<usize>,
+    }
+    impl<T> BrowseServiceServer<T> {
+        pub fn new(inner: T) -> Self {
+            Self::from_arc(Arc::new(inner))
+        }
+        pub fn from_arc(inner: Arc<T>) -> Self {
+            Self {
+                inner,
+                accept_compression_encodings: Default::default(),
+                send_compression_encodings: Default::default(),
+                max_decoding_message_size: None,
+                max_encoding_message_size: None,
+            }
+        }
+        pub fn with_interceptor<F>(
+            inner: T,
+            interceptor: F,
+        ) -> InterceptedService<Self, F>
+        where
+            F: tonic::service::Interceptor,
+        {
+            InterceptedService::new(Self::new(inner), interceptor)
+        }
+        /// Enable decompressing requests with the given encoding.
+        #[must_use]
+        pub fn accept_compressed(mut self, encoding: CompressionEncoding) -> Self {
+            self.accept_compression_encodings.enable(encoding);
+            self
+        }
+        /// Compress responses with the given encoding, if the client supports it.
+        #[must_use]
+        pub fn send_compressed(mut self, encoding: CompressionEncoding) -> Self {
+            self.send_compression_encodings.enable(encoding);
+            self
+        }
+        /// Limits the maximum size of a decoded message.
+        ///
+        /// Default: `4MB`
+        #[must_use]
+        pub fn max_decoding_message_size(mut self, limit: usize) -> Self {
+            self.max_decoding_message_size = Some(limit);
+            self
+        }
+        /// Limits the maximum size of an encoded message.
+        ///
+        /// Default: `usize::MAX`
+        #[must_use]
+        pub fn max_encoding_message_size(mut self, limit: usize) -> Self {
+            self.max_encoding_message_size = Some(limit);
+            self
+        }
+    }
+    impl<T, B> tonic::codegen::Service<http::Request<B>> for BrowseServiceServer<T>
+    where
+        T: BrowseService,
+        B: Body + std::marker::Send + 'static,
+        B::Error: Into<StdError> + std::marker::Send + 'static,
+    {
+        type Response = http::Response<tonic::body::BoxBody>;
+        type Error = std::convert::Infallible;
+        type Future = BoxFuture<Self::Response, Self::Error>;
+        fn poll_ready(
+            &mut self,
+            _cx: &mut Context<'_>,
+        ) -> Poll<std::result::Result<(), Self::Error>> {
+            Poll::Ready(Ok(()))
+        }
+        fn call(&mut self, req: http::Request<B>) -> Self::Future {
+            match req.uri().path() {
+                "/rockbox.v1alpha1.BrowseService/TreeGetEntries" => {
+                    #[allow(non_camel_case_types)]
+                    struct TreeGetEntriesSvc<T: BrowseService>(pub Arc<T>);
+                    impl<
+                        T: BrowseService,
+                    > tonic::server::UnaryService<super::TreeGetEntriesRequest>
+                    for TreeGetEntriesSvc<T> {
+                        type Response = super::TreeGetEntriesResponse;
+                        type Future = BoxFuture<
+                            tonic::Response<Self::Response>,
+                            tonic::Status,
+                        >;
+                        fn call(
+                            &mut self,
+                            request: tonic::Request<super::TreeGetEntriesRequest>,
+                        ) -> Self::Future {
+                            let inner = Arc::clone(&self.0);
+                            let fut = async move {
+                                <T as BrowseService>::tree_get_entries(&inner, request)
+                                    .await
+                            };
+                            Box::pin(fut)
+                        }
+                    }
+                    let accept_compression_encodings = self.accept_compression_encodings;
+                    let send_compression_encodings = self.send_compression_encodings;
+                    let max_decoding_message_size = self.max_decoding_message_size;
+                    let max_encoding_message_size = self.max_encoding_message_size;
+                    let inner = self.inner.clone();
+                    let fut = async move {
+                        let method = TreeGetEntriesSvc(inner);
+                        let codec = tonic::codec::ProstCodec::default();
+                        let mut grpc = tonic::server::Grpc::new(codec)
+                            .apply_compression_config(
+                                accept_compression_encodings,
+                                send_compression_encodings,
+                            )
+                            .apply_max_message_size_config(
+                                max_decoding_message_size,
+                                max_encoding_message_size,
+                            );
+                        let res = grpc.unary(method, req).await;
+                        Ok(res)
+                    };
+                    Box::pin(fut)
+                }
+                _ => {
+                    Box::pin(async move {
+                        let mut response = http::Response::new(empty_body());
+                        let headers = response.headers_mut();
+                        headers
+                            .insert(
+                                tonic::Status::GRPC_STATUS,
+                                (tonic::Code::Unimplemented as i32).into(),
+                            );
+                        headers
+                            .insert(
+                                http::header::CONTENT_TYPE,
+                                tonic::metadata::GRPC_CONTENT_TYPE,
+                            );
+                        Ok(response)
+                    })
+                }
+            }
+        }
+    }
+    impl<T> Clone for BrowseServiceServer<T> {
+        fn clone(&self) -> Self {
+            let inner = self.inner.clone();
+            Self {
+                inner,
+                accept_compression_encodings: self.accept_compression_encodings,
+                send_compression_encodings: self.send_compression_encodings,
+                max_decoding_message_size: self.max_decoding_message_size,
+                max_encoding_message_size: self.max_encoding_message_size,
+            }
+        }
+    }
+    /// Generated gRPC service name
+    pub const SERVICE_NAME: &str = "rockbox.v1alpha1.BrowseService";
+    impl<T> tonic::server::NamedService for BrowseServiceServer<T> {
+        const NAME: &'static str = SERVICE_NAME;
+    }
+}
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct Track {
+    #[prost(string, tag = "1")]
+    pub id: ::prost::alloc::string::String,
+    #[prost(string, tag = "2")]
+    pub path: ::prost::alloc::string::String,
+    #[prost(string, tag = "3")]
+    pub title: ::prost::alloc::string::String,
+    #[prost(string, tag = "4")]
+    pub artist: ::prost::alloc::string::String,
+    #[prost(string, tag = "5")]
+    pub album: ::prost::alloc::string::String,
+    #[prost(string, tag = "6")]
+    pub album_artist: ::prost::alloc::string::String,
+    #[prost(uint32, tag = "7")]
+    pub bitrate: u32,
+    #[prost(string, tag = "8")]
+    pub composer: ::prost::alloc::string::String,
+    #[prost(uint32, tag = "9")]
+    pub disc_number: u32,
+    #[prost(uint32, tag = "10")]
+    pub filesize: u32,
+    #[prost(uint32, tag = "11")]
+    pub frequency: u32,
+    #[prost(uint32, tag = "12")]
+    pub length: u32,
+    #[prost(uint32, tag = "13")]
+    pub track_number: u32,
+    #[prost(uint32, tag = "14")]
+    pub year: u32,
+    #[prost(string, tag = "15")]
+    pub year_string: ::prost::alloc::string::String,
+    #[prost(string, tag = "16")]
+    pub genre: ::prost::alloc::string::String,
+    #[prost(string, tag = "17")]
+    pub md5: ::prost::alloc::string::String,
+    #[prost(string, optional, tag = "18")]
+    pub album_art: ::core::option::Option<::prost::alloc::string::String>,
+    #[prost(string, optional, tag = "19")]
+    pub artist_id: ::core::option::Option<::prost::alloc::string::String>,
+    #[prost(string, optional, tag = "20")]
+    pub album_id: ::core::option::Option<::prost::alloc::string::String>,
+    #[prost(string, optional, tag = "21")]
+    pub genre_id: ::core::option::Option<::prost::alloc::string::String>,
+    #[prost(string, tag = "22")]
+    pub created_at: ::prost::alloc::string::String,
+    #[prost(string, tag = "23")]
+    pub updated_at: ::prost::alloc::string::String,
+}
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct Artist {
+    #[prost(string, tag = "1")]
+    pub id: ::prost::alloc::string::String,
+    #[prost(string, tag = "2")]
+    pub name: ::prost::alloc::string::String,
+    #[prost(string, optional, tag = "3")]
+    pub bio: ::core::option::Option<::prost::alloc::string::String>,
+    #[prost(string, optional, tag = "4")]
+    pub image: ::core::option::Option<::prost::alloc::string::String>,
+    #[prost(message, repeated, tag = "5")]
+    pub albums: ::prost::alloc::vec::Vec<Album>,
+    #[prost(message, repeated, tag = "6")]
+    pub tracks: ::prost::alloc::vec::Vec<Track>,
+}
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct Album {
+    #[prost(string, tag = "1")]
+    pub id: ::prost::alloc::string::String,
+    #[prost(string, tag = "2")]
+    pub title: ::prost::alloc::string::String,
+    #[prost(string, tag = "3")]
+    pub artist: ::prost::alloc::string::String,
+    #[prost(uint32, tag = "4")]
+    pub year: u32,
+    #[prost(string, tag = "5")]
+    pub year_string: ::prost::alloc::string::String,
+    #[prost(string, optional, tag = "6")]
+    pub album_art: ::core::option::Option<::prost::alloc::string::String>,
+    #[prost(string, tag = "7")]
+    pub md5: ::prost::alloc::string::String,
+    #[prost(string, tag = "8")]
+    pub artist_id: ::prost::alloc::string::String,
+    #[prost(message, repeated, tag = "9")]
+    pub tracks: ::prost::alloc::vec::Vec<Track>,
+}
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct GetAlbumRequest {
+    #[prost(string, tag = "1")]
+    pub id: ::prost::alloc::string::String,
+}
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct GetAlbumResponse {
+    #[prost(message, optional, tag = "1")]
+    pub album: ::core::option::Option<Album>,
+}
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct GetArtistRequest {
+    #[prost(string, tag = "1")]
+    pub id: ::prost::alloc::string::String,
+}
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct GetArtistResponse {
+    #[prost(message, optional, tag = "1")]
+    pub artist: ::core::option::Option<Artist>,
+}
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct GetTrackRequest {
+    #[prost(string, tag = "1")]
+    pub id: ::prost::alloc::string::String,
+}
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct GetTrackResponse {
+    #[prost(message, optional, tag = "1")]
+    pub track: ::core::option::Option<Track>,
+}
+#[derive(Clone, Copy, PartialEq, ::prost::Message)]
+pub struct GetAlbumsRequest {}
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct GetAlbumsResponse {
+    #[prost(message, repeated, tag = "1")]
+    pub albums: ::prost::alloc::vec::Vec<Album>,
+}
+#[derive(Clone, Copy, PartialEq, ::prost::Message)]
+pub struct GetArtistsRequest {}
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct GetArtistsResponse {
+    #[prost(message, repeated, tag = "1")]
+    pub artists: ::prost::alloc::vec::Vec<Artist>,
+}
+#[derive(Clone, Copy, PartialEq, ::prost::Message)]
+pub struct GetTracksRequest {}
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct GetTracksResponse {
+    #[prost(message, repeated, tag = "1")]
+    pub tracks: ::prost::alloc::vec::Vec<Track>,
+}
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct LikeTrackRequest {
+    #[prost(string, tag = "1")]
+    pub id: ::prost::alloc::string::String,
+}
+#[derive(Clone, Copy, PartialEq, ::prost::Message)]
+pub struct LikeTrackResponse {}
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct LikeAlbumRequest {
+    #[prost(string, tag = "1")]
+    pub id: ::prost::alloc::string::String,
+}
+#[derive(Clone, Copy, PartialEq, ::prost::Message)]
+pub struct LikeAlbumResponse {}
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct UnlikeTrackRequest {
+    #[prost(string, tag = "1")]
+    pub id: ::prost::alloc::string::String,
+}
+#[derive(Clone, Copy, PartialEq, ::prost::Message)]
+pub struct UnlikeTrackResponse {}
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct UnlikeAlbumRequest {
+    #[prost(string, tag = "1")]
+    pub id: ::prost::alloc::string::String,
+}
+#[derive(Clone, Copy, PartialEq, ::prost::Message)]
+pub struct UnlikeAlbumResponse {}
+#[derive(Clone, Copy, PartialEq, ::prost::Message)]
+pub struct GetLikedTracksRequest {}
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct GetLikedTracksResponse {
+    #[prost(message, repeated, tag = "1")]
+    pub tracks: ::prost::alloc::vec::Vec<Track>,
+}
+#[derive(Clone, Copy, PartialEq, ::prost::Message)]
+pub struct GetLikedAlbumsRequest {}
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct GetLikedAlbumsResponse {
+    #[prost(message, repeated, tag = "1")]
+    pub albums: ::prost::alloc::vec::Vec<Album>,
+}
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct ScanLibraryRequest {
+    #[prost(string, optional, tag = "1")]
+    pub path: ::core::option::Option<::prost::alloc::string::String>,
+}
+#[derive(Clone, Copy, PartialEq, ::prost::Message)]
+pub struct ScanLibraryResponse {}
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct SearchRequest {
+    #[prost(string, tag = "1")]
+    pub term: ::prost::alloc::string::String,
+}
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct SearchResponse {
+    #[prost(message, repeated, tag = "1")]
+    pub tracks: ::prost::alloc::vec::Vec<Track>,
+    #[prost(message, repeated, tag = "2")]
+    pub albums: ::prost::alloc::vec::Vec<Album>,
+    #[prost(message, repeated, tag = "3")]
+    pub artists: ::prost::alloc::vec::Vec<Artist>,
+}
+/// Generated client implementations.
+pub mod library_service_client {
+    #![allow(
+        unused_variables,
+        dead_code,
+        missing_docs,
+        clippy::wildcard_imports,
+        clippy::let_unit_value,
+    )]
+    use tonic::codegen::*;
+    use tonic::codegen::http::Uri;
+    #[derive(Debug, Clone)]
+    pub struct LibraryServiceClient<T> {
+        inner: tonic::client::Grpc<T>,
+    }
+    impl LibraryServiceClient<tonic::transport::Channel> {
+        /// Attempt to create a new client by connecting to a given endpoint.
+        pub async fn connect<D>(dst: D) -> Result<Self, tonic::transport::Error>
+        where
+            D: TryInto<tonic::transport::Endpoint>,
+            D::Error: Into<StdError>,
+        {
+            let conn = tonic::transport::Endpoint::new(dst)?.connect().await?;
+            Ok(Self::new(conn))
+        }
+    }
+    impl<T> LibraryServiceClient<T>
+    where
+        T: tonic::client::GrpcService<tonic::body::BoxBody>,
+        T::Error: Into<StdError>,
+        T::ResponseBody: Body<Data = Bytes> + std::marker::Send + 'static,
+        <T::ResponseBody as Body>::Error: Into<StdError> + std::marker::Send,
+    {
+        pub fn new(inner: T) -> Self {
+            let inner = tonic::client::Grpc::new(inner);
+            Self { inner }
+        }
+        pub fn with_origin(inner: T, origin: Uri) -> Self {
+            let inner = tonic::client::Grpc::with_origin(inner, origin);
+            Self { inner }
+        }
+        pub fn with_interceptor<F>(
+            inner: T,
+            interceptor: F,
+        ) -> LibraryServiceClient<InterceptedService<T, F>>
+        where
+            F: tonic::service::Interceptor,
+            T::ResponseBody: Default,
+            T: tonic::codegen::Service<
+                http::Request<tonic::body::BoxBody>,
+                Response = http::Response<
+                    <T as tonic::client::GrpcService<tonic::body::BoxBody>>::ResponseBody,
+                >,
+            >,
+            <T as tonic::codegen::Service<
+                http::Request<tonic::body::BoxBody>,
+            >>::Error: Into<StdError> + std::marker::Send + std::marker::Sync,
+        {
+            LibraryServiceClient::new(InterceptedService::new(inner, interceptor))
+        }
+        /// Compress requests with the given encoding.
+        ///
+        /// This requires the server to support it otherwise it might respond with an
+        /// error.
+        #[must_use]
+        pub fn send_compressed(mut self, encoding: CompressionEncoding) -> Self {
+            self.inner = self.inner.send_compressed(encoding);
+            self
+        }
+        /// Enable decompressing responses.
+        #[must_use]
+        pub fn accept_compressed(mut self, encoding: CompressionEncoding) -> Self {
+            self.inner = self.inner.accept_compressed(encoding);
+            self
+        }
+        /// Limits the maximum size of a decoded message.
+        ///
+        /// Default: `4MB`
+        #[must_use]
+        pub fn max_decoding_message_size(mut self, limit: usize) -> Self {
+            self.inner = self.inner.max_decoding_message_size(limit);
+            self
+        }
+        /// Limits the maximum size of an encoded message.
+        ///
+        /// Default: `usize::MAX`
+        #[must_use]
+        pub fn max_encoding_message_size(mut self, limit: usize) -> Self {
+            self.inner = self.inner.max_encoding_message_size(limit);
+            self
+        }
+        pub async fn get_albums(
+            &mut self,
+            request: impl tonic::IntoRequest<super::GetAlbumsRequest>,
+        ) -> std::result::Result<
+            tonic::Response<super::GetAlbumsResponse>,
+            tonic::Status,
+        > {
+            self.inner
+                .ready()
+                .await
+                .map_err(|e| {
+                    tonic::Status::unknown(
+                        format!("Service was not ready: {}", e.into()),
+                    )
+                })?;
+            let codec = tonic::codec::ProstCodec::default();
+            let path = http::uri::PathAndQuery::from_static(
+                "/rockbox.v1alpha1.LibraryService/GetAlbums",
+            );
+            let mut req = request.into_request();
+            req.extensions_mut()
+                .insert(GrpcMethod::new("rockbox.v1alpha1.LibraryService", "GetAlbums"));
+            self.inner.unary(req, path, codec).await
+        }
+        pub async fn get_artists(
+            &mut self,
+            request: impl tonic::IntoRequest<super::GetArtistsRequest>,
+        ) -> std::result::Result<
+            tonic::Response<super::GetArtistsResponse>,
+            tonic::Status,
+        > {
+            self.inner
+                .ready()
+                .await
+                .map_err(|e| {
+                    tonic::Status::unknown(
+                        format!("Service was not ready: {}", e.into()),
+                    )
+                })?;
+            let codec = tonic::codec::ProstCodec::default();
+            let path = http::uri::PathAndQuery::from_static(
+                "/rockbox.v1alpha1.LibraryService/GetArtists",
+            );
+            let mut req = request.into_request();
+            req.extensions_mut()
+                .insert(
+                    GrpcMethod::new("rockbox.v1alpha1.LibraryService", "GetArtists"),
+                );
+            self.inner.unary(req, path, codec).await
+        }
+        pub async fn get_tracks(
+            &mut self,
+            request: impl tonic::IntoRequest<super::GetTracksRequest>,
+        ) -> std::result::Result<
+            tonic::Response<super::GetTracksResponse>,
+            tonic::Status,
+        > {
+            self.inner
+                .ready()
+                .await
+                .map_err(|e| {
+                    tonic::Status::unknown(
+                        format!("Service was not ready: {}", e.into()),
+                    )
+                })?;
+            let codec = tonic::codec::ProstCodec::default();
+            let path = http::uri::PathAndQuery::from_static(
+                "/rockbox.v1alpha1.LibraryService/GetTracks",
+            );
+            let mut req = request.into_request();
+            req.extensions_mut()
+                .insert(GrpcMethod::new("rockbox.v1alpha1.LibraryService", "GetTracks"));
+            self.inner.unary(req, path, codec).await
+        }
+        pub async fn get_album(
+            &mut self,
+            request: impl tonic::IntoRequest<super::GetAlbumRequest>,
+        ) -> std::result::Result<
+            tonic::Response<super::GetAlbumResponse>,
+            tonic::Status,
+        > {
+            self.inner
+                .ready()
+                .await
+                .map_err(|e| {
+                    tonic::Status::unknown(
+                        format!("Service was not ready: {}", e.into()),
+                    )
+                })?;
+            let codec = tonic::codec::ProstCodec::default();
+            let path = http::uri::PathAndQuery::from_static(
+                "/rockbox.v1alpha1.LibraryService/GetAlbum",
+            );
+            let mut req = request.into_request();
+            req.extensions_mut()
+                .insert(GrpcMethod::new("rockbox.v1alpha1.LibraryService", "GetAlbum"));
+            self.inner.unary(req, path, codec).await
+        }
+        pub async fn get_artist(
+            &mut self,
+            request: impl tonic::IntoRequest<super::GetArtistRequest>,
+        ) -> std::result::Result<
+            tonic::Response<super::GetArtistResponse>,
+            tonic::Status,
+        > {
+            self.inner
+                .ready()
+                .await
+                .map_err(|e| {
+                    tonic::Status::unknown(
+                        format!("Service was not ready: {}", e.into()),
+                    )
+                })?;
+            let codec = tonic::codec::ProstCodec::default();
+            let path = http::uri::PathAndQuery::from_static(
+                "/rockbox.v1alpha1.LibraryService/GetArtist",
+            );
+            let mut req = request.into_request();
+            req.extensions_mut()
+                .insert(GrpcMethod::new("rockbox.v1alpha1.LibraryService", "GetArtist"));
+            self.inner.unary(req, path, codec).await
+        }
+        pub async fn get_track(
+            &mut self,
+            request: impl tonic::IntoRequest<super::GetTrackRequest>,
+        ) -> std::result::Result<
+            tonic::Response<super::GetTrackResponse>,
+            tonic::Status,
+        > {
+            self.inner
+                .ready()
+                .await
+                .map_err(|e| {
+                    tonic::Status::unknown(
+                        format!("Service was not ready: {}", e.into()),
+                    )
+                })?;
+            let codec = tonic::codec::ProstCodec::default();
+            let path = http::uri::PathAndQuery::from_static(
+                "/rockbox.v1alpha1.LibraryService/GetTrack",
+            );
+            let mut req = request.into_request();
+            req.extensions_mut()
+                .insert(GrpcMethod::new("rockbox.v1alpha1.LibraryService", "GetTrack"));
+            self.inner.unary(req, path, codec).await
+        }
+        pub async fn like_track(
+            &mut self,
+            request: impl tonic::IntoRequest<super::LikeTrackRequest>,
+        ) -> std::result::Result<
+            tonic::Response<super::LikeTrackResponse>,
+            tonic::Status,
+        > {
+            self.inner
+                .ready()
+                .await
+                .map_err(|e| {
+                    tonic::Status::unknown(
+                        format!("Service was not ready: {}", e.into()),
+                    )
+                })?;
+            let codec = tonic::codec::ProstCodec::default();
+            let path = http::uri::PathAndQuery::from_static(
+                "/rockbox.v1alpha1.LibraryService/LikeTrack",
+            );
+            let mut req = request.into_request();
+            req.extensions_mut()
+                .insert(GrpcMethod::new("rockbox.v1alpha1.LibraryService", "LikeTrack"));
+            self.inner.unary(req, path, codec).await
+        }
+        pub async fn unlike_track(
+            &mut self,
+            request: impl tonic::IntoRequest<super::UnlikeTrackRequest>,
+        ) -> std::result::Result<
+            tonic::Response<super::UnlikeTrackResponse>,
+            tonic::Status,
+        > {
+            self.inner
+                .ready()
+                .await
+                .map_err(|e| {
+                    tonic::Status::unknown(
+                        format!("Service was not ready: {}", e.into()),
+                    )
+                })?;
+            let codec = tonic::codec::ProstCodec::default();
+            let path = http::uri::PathAndQuery::from_static(
+                "/rockbox.v1alpha1.LibraryService/UnlikeTrack",
+            );
+            let mut req = request.into_request();
+            req.extensions_mut()
+                .insert(
+                    GrpcMethod::new("rockbox.v1alpha1.LibraryService", "UnlikeTrack"),
+                );
+            self.inner.unary(req, path, codec).await
+        }
+        pub async fn like_album(
+            &mut self,
+            request: impl tonic::IntoRequest<super::LikeAlbumRequest>,
+        ) -> std::result::Result<
+            tonic::Response<super::LikeAlbumResponse>,
+            tonic::Status,
+        > {
+            self.inner
+                .ready()
+                .await
+                .map_err(|e| {
+                    tonic::Status::unknown(
+                        format!("Service was not ready: {}", e.into()),
+                    )
+                })?;
+            let codec = tonic::codec::ProstCodec::default();
+            let path = http::uri::PathAndQuery::from_static(
+                "/rockbox.v1alpha1.LibraryService/LikeAlbum",
+            );
+            let mut req = request.into_request();
+            req.extensions_mut()
+                .insert(GrpcMethod::new("rockbox.v1alpha1.LibraryService", "LikeAlbum"));
+            self.inner.unary(req, path, codec).await
+        }
+        pub async fn unlike_album(
+            &mut self,
+            request: impl tonic::IntoRequest<super::UnlikeAlbumRequest>,
+        ) -> std::result::Result<
+            tonic::Response<super::UnlikeAlbumResponse>,
+            tonic::Status,
+        > {
+            self.inner
+                .ready()
+                .await
+                .map_err(|e| {
+                    tonic::Status::unknown(
+                        format!("Service was not ready: {}", e.into()),
+                    )
+                })?;
+            let codec = tonic::codec::ProstCodec::default();
+            let path = http::uri::PathAndQuery::from_static(
+                "/rockbox.v1alpha1.LibraryService/UnlikeAlbum",
+            );
+            let mut req = request.into_request();
+            req.extensions_mut()
+                .insert(
+                    GrpcMethod::new("rockbox.v1alpha1.LibraryService", "UnlikeAlbum"),
+                );
+            self.inner.unary(req, path, codec).await
+        }
+        pub async fn get_liked_tracks(
+            &mut self,
+            request: impl tonic::IntoRequest<super::GetLikedTracksRequest>,
+        ) -> std::result::Result<
+            tonic::Response<super::GetLikedTracksResponse>,
+            tonic::Status,
+        > {
+            self.inner
+                .ready()
+                .await
+                .map_err(|e| {
+                    tonic::Status::unknown(
+                        format!("Service was not ready: {}", e.into()),
+                    )
+                })?;
+            let codec = tonic::codec::ProstCodec::default();
+            let path = http::uri::PathAndQuery::from_static(
+                "/rockbox.v1alpha1.LibraryService/GetLikedTracks",
+            );
+            let mut req = request.into_request();
+            req.extensions_mut()
+                .insert(
+                    GrpcMethod::new("rockbox.v1alpha1.LibraryService", "GetLikedTracks"),
+                );
+            self.inner.unary(req, path, codec).await
+        }
+        pub async fn get_liked_albums(
+            &mut self,
+            request: impl tonic::IntoRequest<super::GetLikedAlbumsRequest>,
+        ) -> std::result::Result<
+            tonic::Response<super::GetLikedAlbumsResponse>,
+            tonic::Status,
+        > {
+            self.inner
+                .ready()
+                .await
+                .map_err(|e| {
+                    tonic::Status::unknown(
+                        format!("Service was not ready: {}", e.into()),
+                    )
+                })?;
+            let codec = tonic::codec::ProstCodec::default();
+            let path = http::uri::PathAndQuery::from_static(
+                "/rockbox.v1alpha1.LibraryService/GetLikedAlbums",
+            );
+            let mut req = request.into_request();
+            req.extensions_mut()
+                .insert(
+                    GrpcMethod::new("rockbox.v1alpha1.LibraryService", "GetLikedAlbums"),
+                );
+            self.inner.unary(req, path, codec).await
+        }
+        pub async fn scan_library(
+            &mut self,
+            request: impl tonic::IntoRequest<super::ScanLibraryRequest>,
+        ) -> std::result::Result<
+            tonic::Response<super::ScanLibraryResponse>,
+            tonic::Status,
+        > {
+            self.inner
+                .ready()
+                .await
+                .map_err(|e| {
+                    tonic::Status::unknown(
+                        format!("Service was not ready: {}", e.into()),
+                    )
+                })?;
+            let codec = tonic::codec::ProstCodec::default();
+            let path = http::uri::PathAndQuery::from_static(
+                "/rockbox.v1alpha1.LibraryService/ScanLibrary",
+            );
+            let mut req = request.into_request();
+            req.extensions_mut()
+                .insert(
+                    GrpcMethod::new("rockbox.v1alpha1.LibraryService", "ScanLibrary"),
+                );
+            self.inner.unary(req, path, codec).await
+        }
+        pub async fn search(
+            &mut self,
+            request: impl tonic::IntoRequest<super::SearchRequest>,
+        ) -> std::result::Result<tonic::Response<super::SearchResponse>, tonic::Status> {
+            self.inner
+                .ready()
+                .await
+                .map_err(|e| {
+                    tonic::Status::unknown(
+                        format!("Service was not ready: {}", e.into()),
+                    )
+                })?;
+            let codec = tonic::codec::ProstCodec::default();
+            let path = http::uri::PathAndQuery::from_static(
+                "/rockbox.v1alpha1.LibraryService/Search",
+            );
+            let mut req = request.into_request();
+            req.extensions_mut()
+                .insert(GrpcMethod::new("rockbox.v1alpha1.LibraryService", "Search"));
+            self.inner.unary(req, path, codec).await
+        }
+    }
+}
+/// Generated server implementations.
+pub mod library_service_server {
+    #![allow(
+        unused_variables,
+        dead_code,
+        missing_docs,
+        clippy::wildcard_imports,
+        clippy::let_unit_value,
+    )]
+    use tonic::codegen::*;
+    /// Generated trait containing gRPC methods that should be implemented for use with LibraryServiceServer.
+    #[async_trait]
+    pub trait LibraryService: std::marker::Send + std::marker::Sync + 'static {
+        async fn get_albums(
+            &self,
+            request: tonic::Request<super::GetAlbumsRequest>,
+        ) -> std::result::Result<
+            tonic::Response<super::GetAlbumsResponse>,
+            tonic::Status,
+        >;
+        async fn get_artists(
+            &self,
+            request: tonic::Request<super::GetArtistsRequest>,
+        ) -> std::result::Result<
+            tonic::Response<super::GetArtistsResponse>,
+            tonic::Status,
+        >;
+        async fn get_tracks(
+            &self,
+            request: tonic::Request<super::GetTracksRequest>,
+        ) -> std::result::Result<
+            tonic::Response<super::GetTracksResponse>,
+            tonic::Status,
+        >;
+        async fn get_album(
+            &self,
+            request: tonic::Request<super::GetAlbumRequest>,
+        ) -> std::result::Result<
+            tonic::Response<super::GetAlbumResponse>,
+            tonic::Status,
+        >;
+        async fn get_artist(
+            &self,
+            request: tonic::Request<super::GetArtistRequest>,
+        ) -> std::result::Result<
+            tonic::Response<super::GetArtistResponse>,
+            tonic::Status,
+        >;
+        async fn get_track(
+            &self,
+            request: tonic::Request<super::GetTrackRequest>,
+        ) -> std::result::Result<
+            tonic::Response<super::GetTrackResponse>,
+            tonic::Status,
+        >;
+        async fn like_track(
+            &self,
+            request: tonic::Request<super::LikeTrackRequest>,
+        ) -> std::result::Result<
+            tonic::Response<super::LikeTrackResponse>,
+            tonic::Status,
+        >;
+        async fn unlike_track(
+            &self,
+            request: tonic::Request<super::UnlikeTrackRequest>,
+        ) -> std::result::Result<
+            tonic::Response<super::UnlikeTrackResponse>,
+            tonic::Status,
+        >;
+        async fn like_album(
+            &self,
+            request: tonic::Request<super::LikeAlbumRequest>,
+        ) -> std::result::Result<
+            tonic::Response<super::LikeAlbumResponse>,
+            tonic::Status,
+        >;
+        async fn unlike_album(
+            &self,
+            request: tonic::Request<super::UnlikeAlbumRequest>,
+        ) -> std::result::Result<
+            tonic::Response<super::UnlikeAlbumResponse>,
+            tonic::Status,
+        >;
+        async fn get_liked_tracks(
+            &self,
+            request: tonic::Request<super::GetLikedTracksRequest>,
+        ) -> std::result::Result<
+            tonic::Response<super::GetLikedTracksResponse>,
+            tonic::Status,
+        >;
+        async fn get_liked_albums(
+            &self,
+            request: tonic::Request<super::GetLikedAlbumsRequest>,
+        ) -> std::result::Result<
+            tonic::Response<super::GetLikedAlbumsResponse>,
+            tonic::Status,
+        >;
+        async fn scan_library(
+            &self,
+            request: tonic::Request<super::ScanLibraryRequest>,
+        ) -> std::result::Result<
+            tonic::Response<super::ScanLibraryResponse>,
+            tonic::Status,
+        >;
+        async fn search(
+            &self,
+            request: tonic::Request<super::SearchRequest>,
+        ) -> std::result::Result<tonic::Response<super::SearchResponse>, tonic::Status>;
+    }
+    #[derive(Debug)]
+    pub struct LibraryServiceServer<T> {
+        inner: Arc<T>,
+        accept_compression_encodings: EnabledCompressionEncodings,
+        send_compression_encodings: EnabledCompressionEncodings,
+        max_decoding_message_size: Option<usize>,
+        max_encoding_message_size: Option<usize>,
+    }
+    impl<T> LibraryServiceServer<T> {
+        pub fn new(inner: T) -> Self {
+            Self::from_arc(Arc::new(inner))
+        }
+        pub fn from_arc(inner: Arc<T>) -> Self {
+            Self {
+                inner,
+                accept_compression_encodings: Default::default(),
+                send_compression_encodings: Default::default(),
+                max_decoding_message_size: None,
+                max_encoding_message_size: None,
+            }
+        }
+        pub fn with_interceptor<F>(
+            inner: T,
+            interceptor: F,
+        ) -> InterceptedService<Self, F>
+        where
+            F: tonic::service::Interceptor,
+        {
+            InterceptedService::new(Self::new(inner), interceptor)
+        }
+        /// Enable decompressing requests with the given encoding.
+        #[must_use]
+        pub fn accept_compressed(mut self, encoding: CompressionEncoding) -> Self {
+            self.accept_compression_encodings.enable(encoding);
+            self
+        }
+        /// Compress responses with the given encoding, if the client supports it.
+        #[must_use]
+        pub fn send_compressed(mut self, encoding: CompressionEncoding) -> Self {
+            self.send_compression_encodings.enable(encoding);
+            self
+        }
+        /// Limits the maximum size of a decoded message.
+        ///
+        /// Default: `4MB`
+        #[must_use]
+        pub fn max_decoding_message_size(mut self, limit: usize) -> Self {
+            self.max_decoding_message_size = Some(limit);
+            self
+        }
+        /// Limits the maximum size of an encoded message.
+        ///
+        /// Default: `usize::MAX`
+        #[must_use]
+        pub fn max_encoding_message_size(mut self, limit: usize) -> Self {
+            self.max_encoding_message_size = Some(limit);
+            self
+        }
+    }
+    impl<T, B> tonic::codegen::Service<http::Request<B>> for LibraryServiceServer<T>
+    where
+        T: LibraryService,
+        B: Body + std::marker::Send + 'static,
+        B::Error: Into<StdError> + std::marker::Send + 'static,
+    {
+        type Response = http::Response<tonic::body::BoxBody>;
+        type Error = std::convert::Infallible;
+        type Future = BoxFuture<Self::Response, Self::Error>;
+        fn poll_ready(
+            &mut self,
+            _cx: &mut Context<'_>,
+        ) -> Poll<std::result::Result<(), Self::Error>> {
+            Poll::Ready(Ok(()))
+        }
+        fn call(&mut self, req: http::Request<B>) -> Self::Future {
+            match req.uri().path() {
+                "/rockbox.v1alpha1.LibraryService/GetAlbums" => {
+                    #[allow(non_camel_case_types)]
+                    struct GetAlbumsSvc<T: LibraryService>(pub Arc<T>);
+                    impl<
+                        T: LibraryService,
+                    > tonic::server::UnaryService<super::GetAlbumsRequest>
+                    for GetAlbumsSvc<T> {
+                        type Response = super::GetAlbumsResponse;
+                        type Future = BoxFuture<
+                            tonic::Response<Self::Response>,
+                            tonic::Status,
+                        >;
+                        fn call(
+                            &mut self,
+                            request: tonic::Request<super::GetAlbumsRequest>,
+                        ) -> Self::Future {
+                            let inner = Arc::clone(&self.0);
+                            let fut = async move {
+                                <T as LibraryService>::get_albums(&inner, request).await
+                            };
+                            Box::pin(fut)
+                        }
+                    }
+                    let accept_compression_encodings = self.accept_compression_encodings;
+                    let send_compression_encodings = self.send_compression_encodings;
+                    let max_decoding_message_size = self.max_decoding_message_size;
+                    let max_encoding_message_size = self.max_encoding_message_size;
+                    let inner = self.inner.clone();
+                    let fut = async move {
+                        let method = GetAlbumsSvc(inner);
+                        let codec = tonic::codec::ProstCodec::default();
+                        let mut grpc = tonic::server::Grpc::new(codec)
+                            .apply_compression_config(
+                                accept_compression_encodings,
+                                send_compression_encodings,
+                            )
+                            .apply_max_message_size_config(
+                                max_decoding_message_size,
+                                max_encoding_message_size,
+                            );
+                        let res = grpc.unary(method, req).await;
+                        Ok(res)
+                    };
+                    Box::pin(fut)
+                }
+                "/rockbox.v1alpha1.LibraryService/GetArtists" => {
+                    #[allow(non_camel_case_types)]
+                    struct GetArtistsSvc<T: LibraryService>(pub Arc<T>);
+                    impl<
+                        T: LibraryService,
+                    > tonic::server::UnaryService<super::GetArtistsRequest>
+                    for GetArtistsSvc<T> {
+                        type Response = super::GetArtistsResponse;
+                        type Future = BoxFuture<
+                            tonic::Response<Self::Response>,
+                            tonic::Status,
+                        >;
+                        fn call(
+                            &mut self,
+                            request: tonic::Request<super::GetArtistsRequest>,
+                        ) -> Self::Future {
+                            let inner = Arc::clone(&self.0);
+                            let fut = async move {
+                                <T as LibraryService>::get_artists(&inner, request).await
+                            };
+                            Box::pin(fut)
+                        }
+                    }
+                    let accept_compression_encodings = self.accept_compression_encodings;
+                    let send_compression_encodings = self.send_compression_encodings;
+                    let max_decoding_message_size = self.max_decoding_message_size;
+                    let max_encoding_message_size = self.max_encoding_message_size;
+                    let inner = self.inner.clone();
+                    let fut = async move {
+                        let method = GetArtistsSvc(inner);
+                        let codec = tonic::codec::ProstCodec::default();
+                        let mut grpc = tonic::server::Grpc::new(codec)
+                            .apply_compression_config(
+                                accept_compression_encodings,
+                                send_compression_encodings,
+                            )
+                            .apply_max_message_size_config(
+                                max_decoding_message_size,
+                                max_encoding_message_size,
+                            );
+                        let res = grpc.unary(method, req).await;
+                        Ok(res)
+                    };
+                    Box::pin(fut)
+                }
+                "/rockbox.v1alpha1.LibraryService/GetTracks" => {
+                    #[allow(non_camel_case_types)]
+                    struct GetTracksSvc<T: LibraryService>(pub Arc<T>);
+                    impl<
+                        T: LibraryService,
+                    > tonic::server::UnaryService<super::GetTracksRequest>
+                    for GetTracksSvc<T> {
+                        type Response = super::GetTracksResponse;
+                        type Future = BoxFuture<
+                            tonic::Response<Self::Response>,
+                            tonic::Status,
+                        >;
+                        fn call(
+                            &mut self,
+                            request: tonic::Request<super::GetTracksRequest>,
+                        ) -> Self::Future {
+                            let inner = Arc::clone(&self.0);
+                            let fut = async move {
+                                <T as LibraryService>::get_tracks(&inner, request).await
+                            };
+                            Box::pin(fut)
+                        }
+                    }
+                    let accept_compression_encodings = self.accept_compression_encodings;
+                    let send_compression_encodings = self.send_compression_encodings;
+                    let max_decoding_message_size = self.max_decoding_message_size;
+                    let max_encoding_message_size = self.max_encoding_message_size;
+                    let inner = self.inner.clone();
+                    let fut = async move {
+                        let method = GetTracksSvc(inner);
+                        let codec = tonic::codec::ProstCodec::default();
+                        let mut grpc = tonic::server::Grpc::new(codec)
+                            .apply_compression_config(
+                                accept_compression_encodings,
+                                send_compression_encodings,
+                            )
+                            .apply_max_message_size_config(
+                                max_decoding_message_size,
+                                max_encoding_message_size,
+                            );
+                        let res = grpc.unary(method, req).await;
+                        Ok(res)
+                    };
+                    Box::pin(fut)
+                }
+                "/rockbox.v1alpha1.LibraryService/GetAlbum" => {
+                    #[allow(non_camel_case_types)]
+                    struct GetAlbumSvc<T: LibraryService>(pub Arc<T>);
+                    impl<
+                        T: LibraryService,
+                    > tonic::server::UnaryService<super::GetAlbumRequest>
+                    for GetAlbumSvc<T> {
+                        type Response = super::GetAlbumResponse;
+                        type Future = BoxFuture<
+                            tonic::Response<Self::Response>,
+                            tonic::Status,
+                        >;
+                        fn call(
+                            &mut self,
+                            request: tonic::Request<super::GetAlbumRequest>,
+                        ) -> Self::Future {
+                            let inner = Arc::clone(&self.0);
+                            let fut = async move {
+                                <T as LibraryService>::get_album(&inner, request).await
+                            };
+                            Box::pin(fut)
+                        }
+                    }
+                    let accept_compression_encodings = self.accept_compression_encodings;
+                    let send_compression_encodings = self.send_compression_encodings;
+                    let max_decoding_message_size = self.max_decoding_message_size;
+                    let max_encoding_message_size = self.max_encoding_message_size;
+                    let inner = self.inner.clone();
+                    let fut = async move {
+                        let method = GetAlbumSvc(inner);
+                        let codec = tonic::codec::ProstCodec::default();
+                        let mut grpc = tonic::server::Grpc::new(codec)
+                            .apply_compression_config(
+                                accept_compression_encodings,
+                                send_compression_encodings,
+                            )
+                            .apply_max_message_size_config(
+                                max_decoding_message_size,
+                                max_encoding_message_size,
+                            );
+                        let res = grpc.unary(method, req).await;
+                        Ok(res)
+                    };
+                    Box::pin(fut)
+                }
+                "/rockbox.v1alpha1.LibraryService/GetArtist" => {
+                    #[allow(non_camel_case_types)]
+                    struct GetArtistSvc<T: LibraryService>(pub Arc<T>);
+                    impl<
+                        T: LibraryService,
+                    > tonic::server::UnaryService<super::GetArtistRequest>
+                    for GetArtistSvc<T> {
+                        type Response = super::GetArtistResponse;
+                        type Future = BoxFuture<
+                            tonic::Response<Self::Response>,
+                            tonic::Status,
+                        >;
+                        fn call(
+                            &mut self,
+                            request: tonic::Request<super::GetArtistRequest>,
+                        ) -> Self::Future {
+                            let inner = Arc::clone(&self.0);
+                            let fut = async move {
+                                <T as LibraryService>::get_artist(&inner, request).await
+                            };
+                            Box::pin(fut)
+                        }
+                    }
+                    let accept_compression_encodings = self.accept_compression_encodings;
+                    let send_compression_encodings = self.send_compression_encodings;
+                    let max_decoding_message_size = self.max_decoding_message_size;
+                    let max_encoding_message_size = self.max_encoding_message_size;
+                    let inner = self.inner.clone();
+                    let fut = async move {
+                        let method = GetArtistSvc(inner);
+                        let codec = tonic::codec::ProstCodec::default();
+                        let mut grpc = tonic::server::Grpc::new(codec)
+                            .apply_compression_config(
+                                accept_compression_encodings,
+                                send_compression_encodings,
+                            )
+                            .apply_max_message_size_config(
+                                max_decoding_message_size,
+                                max_encoding_message_size,
+                            );
+                        let res = grpc.unary(method, req).await;
+                        Ok(res)
+                    };
+                    Box::pin(fut)
+                }
+                "/rockbox.v1alpha1.LibraryService/GetTrack" => {
+                    #[allow(non_camel_case_types)]
+                    struct GetTrackSvc<T: LibraryService>(pub Arc<T>);
+                    impl<
+                        T: LibraryService,
+                    > tonic::server::UnaryService<super::GetTrackRequest>
+                    for GetTrackSvc<T> {
+                        type Response = super::GetTrackResponse;
+                        type Future = BoxFuture<
+                            tonic::Response<Self::Response>,
+                            tonic::Status,
+                        >;
+                        fn call(
+                            &mut self,
+                            request: tonic::Request<super::GetTrackRequest>,
+                        ) -> Self::Future {
+                            let inner = Arc::clone(&self.0);
+                            let fut = async move {
+                                <T as LibraryService>::get_track(&inner, request).await
+                            };
+                            Box::pin(fut)
+                        }
+                    }
+                    let accept_compression_encodings = self.accept_compression_encodings;
+                    let send_compression_encodings = self.send_compression_encodings;
+                    let max_decoding_message_size = self.max_decoding_message_size;
+                    let max_encoding_message_size = self.max_encoding_message_size;
+                    let inner = self.inner.clone();
+                    let fut = async move {
+                        let method = GetTrackSvc(inner);
+                        let codec = tonic::codec::ProstCodec::default();
+                        let mut grpc = tonic::server::Grpc::new(codec)
+                            .apply_compression_config(
+                                accept_compression_encodings,
+                                send_compression_encodings,
+                            )
+                            .apply_max_message_size_config(
+                                max_decoding_message_size,
+                                max_encoding_message_size,
+                            );
+                        let res = grpc.unary(method, req).await;
+                        Ok(res)
+                    };
+                    Box::pin(fut)
+                }
+                "/rockbox.v1alpha1.LibraryService/LikeTrack" => {
+                    #[allow(non_camel_case_types)]
+                    struct LikeTrackSvc<T: LibraryService>(pub Arc<T>);
+                    impl<
+                        T: LibraryService,
+                    > tonic::server::UnaryService<super::LikeTrackRequest>
+                    for LikeTrackSvc<T> {
+                        type Response = super::LikeTrackResponse;
+                        type Future = BoxFuture<
+                            tonic::Response<Self::Response>,
+                            tonic::Status,
+                        >;
+                        fn call(
+                            &mut self,
+                            request: tonic::Request<super::LikeTrackRequest>,
+                        ) -> Self::Future {
+                            let inner = Arc::clone(&self.0);
+                            let fut = async move {
+                                <T as LibraryService>::like_track(&inner, request).await
+                            };
+                            Box::pin(fut)
+                        }
+                    }
+                    let accept_compression_encodings = self.accept_compression_encodings;
+                    let send_compression_encodings = self.send_compression_encodings;
+                    let max_decoding_message_size = self.max_decoding_message_size;
+                    let max_encoding_message_size = self.max_encoding_message_size;
+                    let inner = self.inner.clone();
+                    let fut = async move {
+                        let method = LikeTrackSvc(inner);
+                        let codec = tonic::codec::ProstCodec::default();
+                        let mut grpc = tonic::server::Grpc::new(codec)
+                            .apply_compression_config(
+                                accept_compression_encodings,
+                                send_compression_encodings,
+                            )
+                            .apply_max_message_size_config(
+                                max_decoding_message_size,
+                                max_encoding_message_size,
+                            );
+                        let res = grpc.unary(method, req).await;
+                        Ok(res)
+                    };
+                    Box::pin(fut)
+                }
+                "/rockbox.v1alpha1.LibraryService/UnlikeTrack" => {
+                    #[allow(non_camel_case_types)]
+                    struct UnlikeTrackSvc<T: LibraryService>(pub Arc<T>);
+                    impl<
+                        T: LibraryService,
+                    > tonic::server::UnaryService<super::UnlikeTrackRequest>
+                    for UnlikeTrackSvc<T> {
+                        type Response = super::UnlikeTrackResponse;
+                        type Future = BoxFuture<
+                            tonic::Response<Self::Response>,
+                            tonic::Status,
+                        >;
+                        fn call(
+                            &mut self,
+                            request: tonic::Request<super::UnlikeTrackRequest>,
+                        ) -> Self::Future {
+                            let inner = Arc::clone(&self.0);
+                            let fut = async move {
+                                <T as LibraryService>::unlike_track(&inner, request).await
+                            };
+                            Box::pin(fut)
+                        }
+                    }
+                    let accept_compression_encodings = self.accept_compression_encodings;
+                    let send_compression_encodings = self.send_compression_encodings;
+                    let max_decoding_message_size = self.max_decoding_message_size;
+                    let max_encoding_message_size = self.max_encoding_message_size;
+                    let inner = self.inner.clone();
+                    let fut = async move {
+                        let method = UnlikeTrackSvc(inner);
+                        let codec = tonic::codec::ProstCodec::default();
+                        let mut grpc = tonic::server::Grpc::new(codec)
+                            .apply_compression_config(
+                                accept_compression_encodings,
+                                send_compression_encodings,
+                            )
+                            .apply_max_message_size_config(
+                                max_decoding_message_size,
+                                max_encoding_message_size,
+                            );
+                        let res = grpc.unary(method, req).await;
+                        Ok(res)
+                    };
+                    Box::pin(fut)
+                }
+                "/rockbox.v1alpha1.LibraryService/LikeAlbum" => {
+                    #[allow(non_camel_case_types)]
+                    struct LikeAlbumSvc<T: LibraryService>(pub Arc<T>);
+                    impl<
+                        T: LibraryService,
+                    > tonic::server::UnaryService<super::LikeAlbumRequest>
+                    for LikeAlbumSvc<T> {
+                        type Response = super::LikeAlbumResponse;
+                        type Future = BoxFuture<
+                            tonic::Response<Self::Response>,
+                            tonic::Status,
+                        >;
+                        fn call(
+                            &mut self,
+                            request: tonic::Request<super::LikeAlbumRequest>,
+                        ) -> Self::Future {
+                            let inner = Arc::clone(&self.0);
+                            let fut = async move {
+                                <T as LibraryService>::like_album(&inner, request).await
+                            };
+                            Box::pin(fut)
+                        }
+                    }
+                    let accept_compression_encodings = self.accept_compression_encodings;
+                    let send_compression_encodings = self.send_compression_encodings;
+                    let max_decoding_message_size = self.max_decoding_message_size;
+                    let max_encoding_message_size = self.max_encoding_message_size;
+                    let inner = self.inner.clone();
+                    let fut = async move {
+                        let method = LikeAlbumSvc(inner);
+                        let codec = tonic::codec::ProstCodec::default();
+                        let mut grpc = tonic::server::Grpc::new(codec)
+                            .apply_compression_config(
+                                accept_compression_encodings,
+                                send_compression_encodings,
+                            )
+                            .apply_max_message_size_config(
+                                max_decoding_message_size,
+                                max_encoding_message_size,
+                            );
+                        let res = grpc.unary(method, req).await;
+                        Ok(res)
+                    };
+                    Box::pin(fut)
+                }
+                "/rockbox.v1alpha1.LibraryService/UnlikeAlbum" => {
+                    #[allow(non_camel_case_types)]
+                    struct UnlikeAlbumSvc<T: LibraryService>(pub Arc<T>);
+                    impl<
+                        T: LibraryService,
+                    > tonic::server::UnaryService<super::UnlikeAlbumRequest>
+                    for UnlikeAlbumSvc<T> {
+                        type Response = super::UnlikeAlbumResponse;
+                        type Future = BoxFuture<
+                            tonic::Response<Self::Response>,
+                            tonic::Status,
+                        >;
+                        fn call(
+                            &mut self,
+                            request: tonic::Request<super::UnlikeAlbumRequest>,
+                        ) -> Self::Future {
+                            let inner = Arc::clone(&self.0);
+                            let fut = async move {
+                                <T as LibraryService>::unlike_album(&inner, request).await
+                            };
+                            Box::pin(fut)
+                        }
+                    }
+                    let accept_compression_encodings = self.accept_compression_encodings;
+                    let send_compression_encodings = self.send_compression_encodings;
+                    let max_decoding_message_size = self.max_decoding_message_size;
+                    let max_encoding_message_size = self.max_encoding_message_size;
+                    let inner = self.inner.clone();
+                    let fut = async move {
+                        let method = UnlikeAlbumSvc(inner);
+                        let codec = tonic::codec::ProstCodec::default();
+                        let mut grpc = tonic::server::Grpc::new(codec)
+                            .apply_compression_config(
+                                accept_compression_encodings,
+                                send_compression_encodings,
+                            )
+                            .apply_max_message_size_config(
+                                max_decoding_message_size,
+                                max_encoding_message_size,
+                            );
+                        let res = grpc.unary(method, req).await;
+                        Ok(res)
+                    };
+                    Box::pin(fut)
+                }
+                "/rockbox.v1alpha1.LibraryService/GetLikedTracks" => {
+                    #[allow(non_camel_case_types)]
+                    struct GetLikedTracksSvc<T: LibraryService>(pub Arc<T>);
+                    impl<
+                        T: LibraryService,
+                    > tonic::server::UnaryService<super::GetLikedTracksRequest>
+                    for GetLikedTracksSvc<T> {
+                        type Response = super::GetLikedTracksResponse;
+                        type Future = BoxFuture<
+                            tonic::Response<Self::Response>,
+                            tonic::Status,
+                        >;
+                        fn call(
+                            &mut self,
+                            request: tonic::Request<super::GetLikedTracksRequest>,
+                        ) -> Self::Future {
+                            let inner = Arc::clone(&self.0);
+                            let fut = async move {
+                                <T as LibraryService>::get_liked_tracks(&inner, request)
+                                    .await
+                            };
+                            Box::pin(fut)
+                        }
+                    }
+                    let accept_compression_encodings = self.accept_compression_encodings;
+                    let send_compression_encodings = self.send_compression_encodings;
+                    let max_decoding_message_size = self.max_decoding_message_size;
+                    let max_encoding_message_size = self.max_encoding_message_size;
+                    let inner = self.inner.clone();
+                    let fut = async move {
+                        let method = GetLikedTracksSvc(inner);
+                        let codec = tonic::codec::ProstCodec::default();
+                        let mut grpc = tonic::server::Grpc::new(codec)
+                            .apply_compression_config(
+                                accept_compression_encodings,
+                                send_compression_encodings,
+                            )
+                            .apply_max_message_size_config(
+                                max_decoding_message_size,
+                                max_encoding_message_size,
+                            );
+                        let res = grpc.unary(method, req).await;
+                        Ok(res)
+                    };
+                    Box::pin(fut)
+                }
+                "/rockbox.v1alpha1.LibraryService/GetLikedAlbums" => {
+                    #[allow(non_camel_case_types)]
+                    struct GetLikedAlbumsSvc<T: LibraryService>(pub Arc<T>);
+                    impl<
+                        T: LibraryService,
+                    > tonic::server::UnaryService<super::GetLikedAlbumsRequest>
+                    for GetLikedAlbumsSvc<T> {
+                        type Response = super::GetLikedAlbumsResponse;
+                        type Future = BoxFuture<
+                            tonic::Response<Self::Response>,
+                            tonic::Status,
+                        >;
+                        fn call(
+                            &mut self,
+                            request: tonic::Request<super::GetLikedAlbumsRequest>,
+                        ) -> Self::Future {
+                            let inner = Arc::clone(&self.0);
+                            let fut = async move {
+                                <T as LibraryService>::get_liked_albums(&inner, request)
+                                    .await
+                            };
+                            Box::pin(fut)
+                        }
+                    }
+                    let accept_compression_encodings = self.accept_compression_encodings;
+                    let send_compression_encodings = self.send_compression_encodings;
+                    let max_decoding_message_size = self.max_decoding_message_size;
+                    let max_encoding_message_size = self.max_encoding_message_size;
+                    let inner = self.inner.clone();
+                    let fut = async move {
+                        let method = GetLikedAlbumsSvc(inner);
+                        let codec = tonic::codec::ProstCodec::default();
+                        let mut grpc = tonic::server::Grpc::new(codec)
+                            .apply_compression_config(
+                                accept_compression_encodings,
+                                send_compression_encodings,
+                            )
+                            .apply_max_message_size_config(
+                                max_decoding_message_size,
+                                max_encoding_message_size,
+                            );
+                        let res = grpc.unary(method, req).await;
+                        Ok(res)
+                    };
+                    Box::pin(fut)
+                }
+                "/rockbox.v1alpha1.LibraryService/ScanLibrary" => {
+                    #[allow(non_camel_case_types)]
+                    struct ScanLibrarySvc<T: LibraryService>(pub Arc<T>);
+                    impl<
+                        T: LibraryService,
+                    > tonic::server::UnaryService<super::ScanLibraryRequest>
+                    for ScanLibrarySvc<T> {
+                        type Response = super::ScanLibraryResponse;
+                        type Future = BoxFuture<
+                            tonic::Response<Self::Response>,
+                            tonic::Status,
+                        >;
+                        fn call(
+                            &mut self,
+                            request: tonic::Request<super::ScanLibraryRequest>,
+                        ) -> Self::Future {
+                            let inner = Arc::clone(&self.0);
+                            let fut = async move {
+                                <T as LibraryService>::scan_library(&inner, request).await
+                            };
+                            Box::pin(fut)
+                        }
+                    }
+                    let accept_compression_encodings = self.accept_compression_encodings;
+                    let send_compression_encodings = self.send_compression_encodings;
+                    let max_decoding_message_size = self.max_decoding_message_size;
+                    let max_encoding_message_size = self.max_encoding_message_size;
+                    let inner = self.inner.clone();
+                    let fut = async move {
+                        let method = ScanLibrarySvc(inner);
+                        let codec = tonic::codec::ProstCodec::default();
+                        let mut grpc = tonic::server::Grpc::new(codec)
+                            .apply_compression_config(
+                                accept_compression_encodings,
+                                send_compression_encodings,
+                            )
+                            .apply_max_message_size_config(
+                                max_decoding_message_size,
+                                max_encoding_message_size,
+                            );
+                        let res = grpc.unary(method, req).await;
+                        Ok(res)
+                    };
+                    Box::pin(fut)
+                }
+                "/rockbox.v1alpha1.LibraryService/Search" => {
+                    #[allow(non_camel_case_types)]
+                    struct SearchSvc<T: LibraryService>(pub Arc<T>);
+                    impl<
+                        T: LibraryService,
+                    > tonic::server::UnaryService<super::SearchRequest>
+                    for SearchSvc<T> {
+                        type Response = super::SearchResponse;
+                        type Future = BoxFuture<
+                            tonic::Response<Self::Response>,
+                            tonic::Status,
+                        >;
+                        fn call(
+                            &mut self,
+                            request: tonic::Request<super::SearchRequest>,
+                        ) -> Self::Future {
+                            let inner = Arc::clone(&self.0);
+                            let fut = async move {
+                                <T as LibraryService>::search(&inner, request).await
+                            };
+                            Box::pin(fut)
+                        }
+                    }
+                    let accept_compression_encodings = self.accept_compression_encodings;
+                    let send_compression_encodings = self.send_compression_encodings;
+                    let max_decoding_message_size = self.max_decoding_message_size;
+                    let max_encoding_message_size = self.max_encoding_message_size;
+                    let inner = self.inner.clone();
+                    let fut = async move {
+                        let method = SearchSvc(inner);
+                        let codec = tonic::codec::ProstCodec::default();
+                        let mut grpc = tonic::server::Grpc::new(codec)
+                            .apply_compression_config(
+                                accept_compression_encodings,
+                                send_compression_encodings,
+                            )
+                            .apply_max_message_size_config(
+                                max_decoding_message_size,
+                                max_encoding_message_size,
+                            );
+                        let res = grpc.unary(method, req).await;
+                        Ok(res)
+                    };
+                    Box::pin(fut)
+                }
+                _ => {
+                    Box::pin(async move {
+                        let mut response = http::Response::new(empty_body());
+                        let headers = response.headers_mut();
+                        headers
+                            .insert(
+                                tonic::Status::GRPC_STATUS,
+                                (tonic::Code::Unimplemented as i32).into(),
+                            );
+                        headers
+                            .insert(
+                                http::header::CONTENT_TYPE,
+                                tonic::metadata::GRPC_CONTENT_TYPE,
+                            );
+                        Ok(response)
+                    })
+                }
+            }
+        }
+    }
+    impl<T> Clone for LibraryServiceServer<T> {
+        fn clone(&self) -> Self {
+            let inner = self.inner.clone();
+            Self {
+                inner,
+                accept_compression_encodings: self.accept_compression_encodings,
+                send_compression_encodings: self.send_compression_encodings,
+                max_decoding_message_size: self.max_decoding_message_size,
+                max_encoding_message_size: self.max_encoding_message_size,
+            }
+        }
+    }
+    /// Generated gRPC service name
+    pub const SERVICE_NAME: &str = "rockbox.v1alpha1.LibraryService";
+    impl<T> tonic::server::NamedService for LibraryServiceServer<T> {
+        const NAME: &'static str = SERVICE_NAME;
+    }
+}
+/// Generated client implementations.
+pub mod metadata_service_client {
+    #![allow(
+        unused_variables,
+        dead_code,
+        missing_docs,
+        clippy::wildcard_imports,
+        clippy::let_unit_value,
+    )]
+    use tonic::codegen::*;
+    use tonic::codegen::http::Uri;
+    #[derive(Debug, Clone)]
+    pub struct MetadataServiceClient<T> {
+        inner: tonic::client::Grpc<T>,
+    }
+    impl MetadataServiceClient<tonic::transport::Channel> {
+        /// Attempt to create a new client by connecting to a given endpoint.
+        pub async fn connect<D>(dst: D) -> Result<Self, tonic::transport::Error>
+        where
+            D: TryInto<tonic::transport::Endpoint>,
+            D::Error: Into<StdError>,
+        {
+            let conn = tonic::transport::Endpoint::new(dst)?.connect().await?;
+            Ok(Self::new(conn))
+        }
+    }
+    impl<T> MetadataServiceClient<T>
+    where
+        T: tonic::client::GrpcService<tonic::body::BoxBody>,
+        T::Error: Into<StdError>,
+        T::ResponseBody: Body<Data = Bytes> + std::marker::Send + 'static,
+        <T::ResponseBody as Body>::Error: Into<StdError> + std::marker::Send,
+    {
+        pub fn new(inner: T) -> Self {
+            let inner = tonic::client::Grpc::new(inner);
+            Self { inner }
+        }
+        pub fn with_origin(inner: T, origin: Uri) -> Self {
+            let inner = tonic::client::Grpc::with_origin(inner, origin);
+            Self { inner }
+        }
+        pub fn with_interceptor<F>(
+            inner: T,
+            interceptor: F,
+        ) -> MetadataServiceClient<InterceptedService<T, F>>
+        where
+            F: tonic::service::Interceptor,
+            T::ResponseBody: Default,
+            T: tonic::codegen::Service<
+                http::Request<tonic::body::BoxBody>,
+                Response = http::Response<
+                    <T as tonic::client::GrpcService<tonic::body::BoxBody>>::ResponseBody,
+                >,
+            >,
+            <T as tonic::codegen::Service<
+                http::Request<tonic::body::BoxBody>,
+            >>::Error: Into<StdError> + std::marker::Send + std::marker::Sync,
+        {
+            MetadataServiceClient::new(InterceptedService::new(inner, interceptor))
+        }
+        /// Compress requests with the given encoding.
+        ///
+        /// This requires the server to support it otherwise it might respond with an
+        /// error.
+        #[must_use]
+        pub fn send_compressed(mut self, encoding: CompressionEncoding) -> Self {
+            self.inner = self.inner.send_compressed(encoding);
+            self
+        }
+        /// Enable decompressing responses.
+        #[must_use]
+        pub fn accept_compressed(mut self, encoding: CompressionEncoding) -> Self {
+            self.inner = self.inner.accept_compressed(encoding);
+            self
+        }
+        /// Limits the maximum size of a decoded message.
+        ///
+        /// Default: `4MB`
+        #[must_use]
+        pub fn max_decoding_message_size(mut self, limit: usize) -> Self {
+            self.inner = self.inner.max_decoding_message_size(limit);
+            self
+        }
+        /// Limits the maximum size of an encoded message.
+        ///
+        /// Default: `usize::MAX`
+        #[must_use]
+        pub fn max_encoding_message_size(mut self, limit: usize) -> Self {
+            self.inner = self.inner.max_encoding_message_size(limit);
+            self
+        }
+    }
+}
+/// Generated server implementations.
+pub mod metadata_service_server {
+    #![allow(
+        unused_variables,
+        dead_code,
+        missing_docs,
+        clippy::wildcard_imports,
+        clippy::let_unit_value,
+    )]
+    use tonic::codegen::*;
+    /// Generated trait containing gRPC methods that should be implemented for use with MetadataServiceServer.
+    #[async_trait]
+    pub trait MetadataService: std::marker::Send + std::marker::Sync + 'static {}
+    #[derive(Debug)]
+    pub struct MetadataServiceServer<T> {
+        inner: Arc<T>,
+        accept_compression_encodings: EnabledCompressionEncodings,
+        send_compression_encodings: EnabledCompressionEncodings,
+        max_decoding_message_size: Option<usize>,
+        max_encoding_message_size: Option<usize>,
+    }
+    impl<T> MetadataServiceServer<T> {
+        pub fn new(inner: T) -> Self {
+            Self::from_arc(Arc::new(inner))
+        }
+        pub fn from_arc(inner: Arc<T>) -> Self {
+            Self {
+                inner,
+                accept_compression_encodings: Default::default(),
+                send_compression_encodings: Default::default(),
+                max_decoding_message_size: None,
+                max_encoding_message_size: None,
+            }
+        }
+        pub fn with_interceptor<F>(
+            inner: T,
+            interceptor: F,
+        ) -> InterceptedService<Self, F>
+        where
+            F: tonic::service::Interceptor,
+        {
+            InterceptedService::new(Self::new(inner), interceptor)
+        }
+        /// Enable decompressing requests with the given encoding.
+        #[must_use]
+        pub fn accept_compressed(mut self, encoding: CompressionEncoding) -> Self {
+            self.accept_compression_encodings.enable(encoding);
+            self
+        }
+        /// Compress responses with the given encoding, if the client supports it.
+        #[must_use]
+        pub fn send_compressed(mut self, encoding: CompressionEncoding) -> Self {
+            self.send_compression_encodings.enable(encoding);
+            self
+        }
+        /// Limits the maximum size of a decoded message.
+        ///
+        /// Default: `4MB`
+        #[must_use]
+        pub fn max_decoding_message_size(mut self, limit: usize) -> Self {
+            self.max_decoding_message_size = Some(limit);
+            self
+        }
+        /// Limits the maximum size of an encoded message.
+        ///
+        /// Default: `usize::MAX`
+        #[must_use]
+        pub fn max_encoding_message_size(mut self, limit: usize) -> Self {
+            self.max_encoding_message_size = Some(limit);
+            self
+        }
+    }
+    impl<T, B> tonic::codegen::Service<http::Request<B>> for MetadataServiceServer<T>
+    where
+        T: MetadataService,
+        B: Body + std::marker::Send + 'static,
+        B::Error: Into<StdError> + std::marker::Send + 'static,
+    {
+        type Response = http::Response<tonic::body::BoxBody>;
+        type Error = std::convert::Infallible;
+        type Future = BoxFuture<Self::Response, Self::Error>;
+        fn poll_ready(
+            &mut self,
+            _cx: &mut Context<'_>,
+        ) -> Poll<std::result::Result<(), Self::Error>> {
+            Poll::Ready(Ok(()))
+        }
+        fn call(&mut self, req: http::Request<B>) -> Self::Future {
+            match req.uri().path() {
+                _ => {
+                    Box::pin(async move {
+                        let mut response = http::Response::new(empty_body());
+                        let headers = response.headers_mut();
+                        headers
+                            .insert(
+                                tonic::Status::GRPC_STATUS,
+                                (tonic::Code::Unimplemented as i32).into(),
+                            );
+                        headers
+                            .insert(
+                                http::header::CONTENT_TYPE,
+                                tonic::metadata::GRPC_CONTENT_TYPE,
+                            );
+                        Ok(response)
+                    })
+                }
+            }
+        }
+    }
+    impl<T> Clone for MetadataServiceServer<T> {
+        fn clone(&self) -> Self {
+            let inner = self.inner.clone();
+            Self {
+                inner,
+                accept_compression_encodings: self.accept_compression_encodings,
+                send_compression_encodings: self.send_compression_encodings,
+                max_decoding_message_size: self.max_decoding_message_size,
+                max_encoding_message_size: self.max_encoding_message_size,
+            }
+        }
+    }
+    /// Generated gRPC service name
+    pub const SERVICE_NAME: &str = "rockbox.v1alpha1.MetadataService";
+    impl<T> tonic::server::NamedService for MetadataServiceServer<T> {
+        const NAME: &'static str = SERVICE_NAME;
+    }
+}
+#[derive(Clone, Copy, PartialEq, ::prost::Message)]
+pub struct PlayRequest {
+    #[prost(int64, tag = "1")]
+    pub elapsed: i64,
+    #[prost(int64, tag = "2")]
+    pub offset: i64,
+}
+#[derive(Clone, Copy, PartialEq, ::prost::Message)]
+pub struct PlayResponse {}
+#[derive(Clone, Copy, PartialEq, ::prost::Message)]
+pub struct PauseRequest {}
+#[derive(Clone, Copy, PartialEq, ::prost::Message)]
+pub struct PlayOrPauseRequest {}
+#[derive(Clone, Copy, PartialEq, ::prost::Message)]
+pub struct PlayOrPauseResponse {}
+#[derive(Clone, Copy, PartialEq, ::prost::Message)]
+pub struct PauseResponse {}
+#[derive(Clone, Copy, PartialEq, ::prost::Message)]
+pub struct ResumeRequest {}
+#[derive(Clone, Copy, PartialEq, ::prost::Message)]
+pub struct ResumeResponse {}
+#[derive(Clone, Copy, PartialEq, ::prost::Message)]
+pub struct NextRequest {}
+#[derive(Clone, Copy, PartialEq, ::prost::Message)]
+pub struct NextResponse {}
+#[derive(Clone, Copy, PartialEq, ::prost::Message)]
+pub struct PreviousRequest {}
+#[derive(Clone, Copy, PartialEq, ::prost::Message)]
+pub struct PreviousResponse {}
+#[derive(Clone, Copy, PartialEq, ::prost::Message)]
+pub struct FastForwardRewindRequest {
+    #[prost(int32, tag = "1")]
+    pub new_time: i32,
+}
+#[derive(Clone, Copy, PartialEq, ::prost::Message)]
+pub struct FastForwardRewindResponse {}
+#[derive(Clone, Copy, PartialEq, ::prost::Message)]
+pub struct StatusRequest {}
+#[derive(Clone, Copy, PartialEq, ::prost::Message)]
+pub struct StreamStatusRequest {}
+#[derive(Clone, Copy, PartialEq, ::prost::Message)]
+pub struct StatusResponse {
+    #[prost(int32, tag = "1")]
+    pub status: i32,
+}
+#[derive(Clone, Copy, PartialEq, ::prost::Message)]
+pub struct CurrentTrackRequest {}
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct CurrentTrackResponse {
+    #[prost(string, tag = "1")]
+    pub title: ::prost::alloc::string::String,
+    #[prost(string, tag = "2")]
+    pub artist: ::prost::alloc::string::String,
+    #[prost(string, tag = "3")]
+    pub album: ::prost::alloc::string::String,
+    #[prost(string, tag = "4")]
+    pub genre: ::prost::alloc::string::String,
+    #[prost(string, tag = "5")]
+    pub disc: ::prost::alloc::string::String,
+    #[prost(string, tag = "6")]
+    pub track_string: ::prost::alloc::string::String,
+    #[prost(string, tag = "7")]
+    pub year_string: ::prost::alloc::string::String,
+    #[prost(string, tag = "8")]
+    pub composer: ::prost::alloc::string::String,
+    #[prost(string, tag = "9")]
+    pub comment: ::prost::alloc::string::String,
+    #[prost(string, tag = "10")]
+    pub album_artist: ::prost::alloc::string::String,
+    #[prost(string, tag = "11")]
+    pub grouping: ::prost::alloc::string::String,
+    #[prost(int32, tag = "12")]
+    pub discnum: i32,
+    #[prost(int32, tag = "13")]
+    pub tracknum: i32,
+    #[prost(int32, tag = "14")]
+    pub layer: i32,
+    #[prost(int32, tag = "15")]
+    pub year: i32,
+    #[prost(uint32, tag = "16")]
+    pub bitrate: u32,
+    #[prost(uint64, tag = "17")]
+    pub frequency: u64,
+    #[prost(uint64, tag = "18")]
+    pub filesize: u64,
+    #[prost(uint64, tag = "19")]
+    pub length: u64,
+    #[prost(uint64, tag = "20")]
+    pub elapsed: u64,
+    #[prost(string, tag = "21")]
+    pub path: ::prost::alloc::string::String,
+    #[prost(string, optional, tag = "22")]
+    pub album_art: ::core::option::Option<::prost::alloc::string::String>,
+    #[prost(string, tag = "23")]
+    pub album_id: ::prost::alloc::string::String,
+    #[prost(string, tag = "24")]
+    pub artist_id: ::prost::alloc::string::String,
+    #[prost(string, tag = "25")]
+    pub id: ::prost::alloc::string::String,
+}
+#[derive(Clone, Copy, PartialEq, ::prost::Message)]
+pub struct StreamCurrentTrackRequest {}
+#[derive(Clone, Copy, PartialEq, ::prost::Message)]
+pub struct NextTrackRequest {}
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct NextTrackResponse {
+    #[prost(string, tag = "1")]
+    pub title: ::prost::alloc::string::String,
+    #[prost(string, tag = "2")]
+    pub artist: ::prost::alloc::string::String,
+    #[prost(string, tag = "3")]
+    pub album: ::prost::alloc::string::String,
+    #[prost(string, tag = "4")]
+    pub genre: ::prost::alloc::string::String,
+    #[prost(string, tag = "5")]
+    pub disc: ::prost::alloc::string::String,
+    #[prost(string, tag = "6")]
+    pub track_string: ::prost::alloc::string::String,
+    #[prost(string, tag = "7")]
+    pub year_string: ::prost::alloc::string::String,
+    #[prost(string, tag = "8")]
+    pub composer: ::prost::alloc::string::String,
+    #[prost(string, tag = "9")]
+    pub comment: ::prost::alloc::string::String,
+    #[prost(string, tag = "10")]
+    pub album_artist: ::prost::alloc::string::String,
+    #[prost(string, tag = "11")]
+    pub grouping: ::prost::alloc::string::String,
+    #[prost(int32, tag = "12")]
+    pub discnum: i32,
+    #[prost(int32, tag = "13")]
+    pub tracknum: i32,
+    #[prost(int32, tag = "14")]
+    pub layer: i32,
+    #[prost(int32, tag = "15")]
+    pub year: i32,
+    #[prost(uint32, tag = "16")]
+    pub bitrate: u32,
+    #[prost(uint64, tag = "17")]
+    pub frequency: u64,
+    #[prost(uint64, tag = "18")]
+    pub filesize: u64,
+    #[prost(uint64, tag = "19")]
+    pub length: u64,
+    #[prost(uint64, tag = "20")]
+    pub elapsed: u64,
+    #[prost(string, tag = "21")]
+    pub path: ::prost::alloc::string::String,
+}
+#[derive(Clone, Copy, PartialEq, ::prost::Message)]
+pub struct FlushAndReloadTracksRequest {}
+#[derive(Clone, Copy, PartialEq, ::prost::Message)]
+pub struct FlushAndReloadTracksResponse {}
+#[derive(Clone, Copy, PartialEq, ::prost::Message)]
+pub struct GetFilePositionRequest {}
+#[derive(Clone, Copy, PartialEq, ::prost::Message)]
+pub struct GetFilePositionResponse {
+    #[prost(int32, tag = "1")]
+    pub position: i32,
+}
+#[derive(Clone, Copy, PartialEq, ::prost::Message)]
+pub struct HardStopRequest {}
+#[derive(Clone, Copy, PartialEq, ::prost::Message)]
+pub struct HardStopResponse {}
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct PlayAlbumRequest {
+    #[prost(string, tag = "1")]
+    pub album_id: ::prost::alloc::string::String,
+    #[prost(bool, optional, tag = "2")]
+    pub shuffle: ::core::option::Option<bool>,
+    #[prost(int32, optional, tag = "3")]
+    pub position: ::core::option::Option<i32>,
+}
+#[derive(Clone, Copy, PartialEq, ::prost::Message)]
+pub struct PlayAlbumResponse {}
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct PlayArtistTracksRequest {
+    #[prost(string, tag = "1")]
+    pub artist_id: ::prost::alloc::string::String,
+    #[prost(bool, optional, tag = "2")]
+    pub shuffle: ::core::option::Option<bool>,
+    #[prost(int32, optional, tag = "3")]
+    pub position: ::core::option::Option<i32>,
+}
+#[derive(Clone, Copy, PartialEq, ::prost::Message)]
+pub struct PlayArtistTracksResponse {}
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct PlayPlaylistRequest {
+    #[prost(string, tag = "1")]
+    pub playlist_id: ::prost::alloc::string::String,
+    #[prost(bool, optional, tag = "2")]
+    pub shuffle: ::core::option::Option<bool>,
+}
+#[derive(Clone, Copy, PartialEq, ::prost::Message)]
+pub struct PlayPlaylistResponse {}
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct PlayDirectoryRequest {
+    #[prost(string, tag = "1")]
+    pub path: ::prost::alloc::string::String,
+    #[prost(bool, optional, tag = "2")]
+    pub shuffle: ::core::option::Option<bool>,
+    #[prost(bool, optional, tag = "3")]
+    pub recurse: ::core::option::Option<bool>,
+    #[prost(int32, optional, tag = "4")]
+    pub position: ::core::option::Option<i32>,
+}
+#[derive(Clone, Copy, PartialEq, ::prost::Message)]
+pub struct PlayDirectoryResponse {}
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct PlayTrackRequest {
+    #[prost(string, tag = "1")]
+    pub path: ::prost::alloc::string::String,
+}
+#[derive(Clone, Copy, PartialEq, ::prost::Message)]
+pub struct PlayTrackResponse {}
+#[derive(Clone, Copy, PartialEq, ::prost::Message)]
+pub struct PlayLikedTracksRequest {
+    #[prost(bool, optional, tag = "1")]
+    pub shuffle: ::core::option::Option<bool>,
+    #[prost(int32, optional, tag = "2")]
+    pub position: ::core::option::Option<i32>,
+}
+#[derive(Clone, Copy, PartialEq, ::prost::Message)]
+pub struct PlayLikedTracksResponse {}
+#[derive(Clone, Copy, PartialEq, ::prost::Message)]
+pub struct PlayAllTracksRequest {
+    #[prost(bool, optional, tag = "1")]
+    pub shuffle: ::core::option::Option<bool>,
+    #[prost(int32, optional, tag = "2")]
+    pub position: ::core::option::Option<i32>,
+}
+#[derive(Clone, Copy, PartialEq, ::prost::Message)]
+pub struct PlayAllTracksResponse {}
+#[derive(Clone, Copy, PartialEq, ::prost::Message)]
+pub struct StreamPlaylistRequest {}
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct PlaylistResponse {
+    #[prost(int32, tag = "1")]
+    pub index: i32,
+    #[prost(int32, tag = "2")]
+    pub amount: i32,
+    #[prost(message, repeated, tag = "3")]
+    pub tracks: ::prost::alloc::vec::Vec<CurrentTrackResponse>,
+}
+/// Generated client implementations.
+pub mod playback_service_client {
+    #![allow(
+        unused_variables,
+        dead_code,
+        missing_docs,
+        clippy::wildcard_imports,
+        clippy::let_unit_value,
+    )]
+    use tonic::codegen::*;
+    use tonic::codegen::http::Uri;
+    #[derive(Debug, Clone)]
+    pub struct PlaybackServiceClient<T> {
+        inner: tonic::client::Grpc<T>,
+    }
+    impl PlaybackServiceClient<tonic::transport::Channel> {
+        /// Attempt to create a new client by connecting to a given endpoint.
+        pub async fn connect<D>(dst: D) -> Result<Self, tonic::transport::Error>
+        where
+            D: TryInto<tonic::transport::Endpoint>,
+            D::Error: Into<StdError>,
+        {
+            let conn = tonic::transport::Endpoint::new(dst)?.connect().await?;
+            Ok(Self::new(conn))
+        }
+    }
+    impl<T> PlaybackServiceClient<T>
+    where
+        T: tonic::client::GrpcService<tonic::body::BoxBody>,
+        T::Error: Into<StdError>,
+        T::ResponseBody: Body<Data = Bytes> + std::marker::Send + 'static,
+        <T::ResponseBody as Body>::Error: Into<StdError> + std::marker::Send,
+    {
+        pub fn new(inner: T) -> Self {
+            let inner = tonic::client::Grpc::new(inner);
+            Self { inner }
+        }
+        pub fn with_origin(inner: T, origin: Uri) -> Self {
+            let inner = tonic::client::Grpc::with_origin(inner, origin);
+            Self { inner }
+        }
+        pub fn with_interceptor<F>(
+            inner: T,
+            interceptor: F,
+        ) -> PlaybackServiceClient<InterceptedService<T, F>>
+        where
+            F: tonic::service::Interceptor,
+            T::ResponseBody: Default,
+            T: tonic::codegen::Service<
+                http::Request<tonic::body::BoxBody>,
+                Response = http::Response<
+                    <T as tonic::client::GrpcService<tonic::body::BoxBody>>::ResponseBody,
+                >,
+            >,
+            <T as tonic::codegen::Service<
+                http::Request<tonic::body::BoxBody>,
+            >>::Error: Into<StdError> + std::marker::Send + std::marker::Sync,
+        {
+            PlaybackServiceClient::new(InterceptedService::new(inner, interceptor))
+        }
+        /// Compress requests with the given encoding.
+        ///
+        /// This requires the server to support it otherwise it might respond with an
+        /// error.
+        #[must_use]
+        pub fn send_compressed(mut self, encoding: CompressionEncoding) -> Self {
+            self.inner = self.inner.send_compressed(encoding);
+            self
+        }
+        /// Enable decompressing responses.
+        #[must_use]
+        pub fn accept_compressed(mut self, encoding: CompressionEncoding) -> Self {
+            self.inner = self.inner.accept_compressed(encoding);
+            self
+        }
+        /// Limits the maximum size of a decoded message.
+        ///
+        /// Default: `4MB`
+        #[must_use]
+        pub fn max_decoding_message_size(mut self, limit: usize) -> Self {
+            self.inner = self.inner.max_decoding_message_size(limit);
+            self
+        }
+        /// Limits the maximum size of an encoded message.
+        ///
+        /// Default: `usize::MAX`
+        #[must_use]
+        pub fn max_encoding_message_size(mut self, limit: usize) -> Self {
+            self.inner = self.inner.max_encoding_message_size(limit);
+            self
+        }
+        pub async fn play(
+            &mut self,
+            request: impl tonic::IntoRequest<super::PlayRequest>,
+        ) -> std::result::Result<tonic::Response<super::PlayResponse>, tonic::Status> {
+            self.inner
+                .ready()
+                .await
+                .map_err(|e| {
+                    tonic::Status::unknown(
+                        format!("Service was not ready: {}", e.into()),
+                    )
+                })?;
+            let codec = tonic::codec::ProstCodec::default();
+            let path = http::uri::PathAndQuery::from_static(
+                "/rockbox.v1alpha1.PlaybackService/Play",
+            );
+            let mut req = request.into_request();
+            req.extensions_mut()
+                .insert(GrpcMethod::new("rockbox.v1alpha1.PlaybackService", "Play"));
+            self.inner.unary(req, path, codec).await
+        }
+        pub async fn pause(
+            &mut self,
+            request: impl tonic::IntoRequest<super::PauseRequest>,
+        ) -> std::result::Result<tonic::Response<super::PauseResponse>, tonic::Status> {
+            self.inner
+                .ready()
+                .await
+                .map_err(|e| {
+                    tonic::Status::unknown(
+                        format!("Service was not ready: {}", e.into()),
+                    )
+                })?;
+            let codec = tonic::codec::ProstCodec::default();
+            let path = http::uri::PathAndQuery::from_static(
+                "/rockbox.v1alpha1.PlaybackService/Pause",
+            );
+            let mut req = request.into_request();
+            req.extensions_mut()
+                .insert(GrpcMethod::new("rockbox.v1alpha1.PlaybackService", "Pause"));
+            self.inner.unary(req, path, codec).await
+        }
+        pub async fn play_or_pause(
+            &mut self,
+            request: impl tonic::IntoRequest<super::PlayOrPauseRequest>,
+        ) -> std::result::Result<
+            tonic::Response<super::PlayOrPauseResponse>,
+            tonic::Status,
+        > {
+            self.inner
+                .ready()
+                .await
+                .map_err(|e| {
+                    tonic::Status::unknown(
+                        format!("Service was not ready: {}", e.into()),
+                    )
+                })?;
+            let codec = tonic::codec::ProstCodec::default();
+            let path = http::uri::PathAndQuery::from_static(
+                "/rockbox.v1alpha1.PlaybackService/PlayOrPause",
+            );
+            let mut req = request.into_request();
+            req.extensions_mut()
+                .insert(
+                    GrpcMethod::new("rockbox.v1alpha1.PlaybackService", "PlayOrPause"),
+                );
+            self.inner.unary(req, path, codec).await
+        }
+        pub async fn resume(
+            &mut self,
+            request: impl tonic::IntoRequest<super::ResumeRequest>,
+        ) -> std::result::Result<tonic::Response<super::ResumeResponse>, tonic::Status> {
+            self.inner
+                .ready()
+                .await
+                .map_err(|e| {
+                    tonic::Status::unknown(
+                        format!("Service was not ready: {}", e.into()),
+                    )
+                })?;
+            let codec = tonic::codec::ProstCodec::default();
+            let path = http::uri::PathAndQuery::from_static(
+                "/rockbox.v1alpha1.PlaybackService/Resume",
+            );
+            let mut req = request.into_request();
+            req.extensions_mut()
+                .insert(GrpcMethod::new("rockbox.v1alpha1.PlaybackService", "Resume"));
+            self.inner.unary(req, path, codec).await
+        }
+        pub async fn next(
+            &mut self,
+            request: impl tonic::IntoRequest<super::NextRequest>,
+        ) -> std::result::Result<tonic::Response<super::NextResponse>, tonic::Status> {
+            self.inner
+                .ready()
+                .await
+                .map_err(|e| {
+                    tonic::Status::unknown(
+                        format!("Service was not ready: {}", e.into()),
+                    )
+                })?;
+            let codec = tonic::codec::ProstCodec::default();
+            let path = http::uri::PathAndQuery::from_static(
+                "/rockbox.v1alpha1.PlaybackService/Next",
+            );
+            let mut req = request.into_request();
+            req.extensions_mut()
+                .insert(GrpcMethod::new("rockbox.v1alpha1.PlaybackService", "Next"));
+            self.inner.unary(req, path, codec).await
+        }
+        pub async fn previous(
+            &mut self,
+            request: impl tonic::IntoRequest<super::PreviousRequest>,
+        ) -> std::result::Result<
+            tonic::Response<super::PreviousResponse>,
+            tonic::Status,
+        > {
+            self.inner
+                .ready()
+                .await
+                .map_err(|e| {
+                    tonic::Status::unknown(
+                        format!("Service was not ready: {}", e.into()),
+                    )
+                })?;
+            let codec = tonic::codec::ProstCodec::default();
+            let path = http::uri::PathAndQuery::from_static(
+                "/rockbox.v1alpha1.PlaybackService/Previous",
+            );
+            let mut req = request.into_request();
+            req.extensions_mut()
+                .insert(GrpcMethod::new("rockbox.v1alpha1.PlaybackService", "Previous"));
+            self.inner.unary(req, path, codec).await
+        }
+        pub async fn fast_forward_rewind(
+            &mut self,
+            request: impl tonic::IntoRequest<super::FastForwardRewindRequest>,
+        ) -> std::result::Result<
+            tonic::Response<super::FastForwardRewindResponse>,
+            tonic::Status,
+        > {
+            self.inner
+                .ready()
+                .await
+                .map_err(|e| {
+                    tonic::Status::unknown(
+                        format!("Service was not ready: {}", e.into()),
+                    )
+                })?;
+            let codec = tonic::codec::ProstCodec::default();
+            let path = http::uri::PathAndQuery::from_static(
+                "/rockbox.v1alpha1.PlaybackService/FastForwardRewind",
+            );
+            let mut req = request.into_request();
+            req.extensions_mut()
+                .insert(
+                    GrpcMethod::new(
+                        "rockbox.v1alpha1.PlaybackService",
+                        "FastForwardRewind",
+                    ),
+                );
+            self.inner.unary(req, path, codec).await
+        }
+        pub async fn status(
+            &mut self,
+            request: impl tonic::IntoRequest<super::StatusRequest>,
+        ) -> std::result::Result<tonic::Response<super::StatusResponse>, tonic::Status> {
+            self.inner
+                .ready()
+                .await
+                .map_err(|e| {
+                    tonic::Status::unknown(
+                        format!("Service was not ready: {}", e.into()),
+                    )
+                })?;
+            let codec = tonic::codec::ProstCodec::default();
+            let path = http::uri::PathAndQuery::from_static(
+                "/rockbox.v1alpha1.PlaybackService/Status",
+            );
+            let mut req = request.into_request();
+            req.extensions_mut()
+                .insert(GrpcMethod::new("rockbox.v1alpha1.PlaybackService", "Status"));
+            self.inner.unary(req, path, codec).await
+        }
+        pub async fn current_track(
+            &mut self,
+            request: impl tonic::IntoRequest<super::CurrentTrackRequest>,
+        ) -> std::result::Result<
+            tonic::Response<super::CurrentTrackResponse>,
+            tonic::Status,
+        > {
+            self.inner
+                .ready()
+                .await
+                .map_err(|e| {
+                    tonic::Status::unknown(
+                        format!("Service was not ready: {}", e.into()),
+                    )
+                })?;
+            let codec = tonic::codec::ProstCodec::default();
+            let path = http::uri::PathAndQuery::from_static(
+                "/rockbox.v1alpha1.PlaybackService/CurrentTrack",
+            );
+            let mut req = request.into_request();
+            req.extensions_mut()
+                .insert(
+                    GrpcMethod::new("rockbox.v1alpha1.PlaybackService", "CurrentTrack"),
+                );
+            self.inner.unary(req, path, codec).await
+        }
+        pub async fn next_track(
+            &mut self,
+            request: impl tonic::IntoRequest<super::NextTrackRequest>,
+        ) -> std::result::Result<
+            tonic::Response<super::NextTrackResponse>,
+            tonic::Status,
+        > {
+            self.inner
+                .ready()
+                .await
+                .map_err(|e| {
+                    tonic::Status::unknown(
+                        format!("Service was not ready: {}", e.into()),
+                    )
+                })?;
+            let codec = tonic::codec::ProstCodec::default();
+            let path = http::uri::PathAndQuery::from_static(
+                "/rockbox.v1alpha1.PlaybackService/NextTrack",
+            );
+            let mut req = request.into_request();
+            req.extensions_mut()
+                .insert(
+                    GrpcMethod::new("rockbox.v1alpha1.PlaybackService", "NextTrack"),
+                );
+            self.inner.unary(req, path, codec).await
+        }
+        pub async fn flush_and_reload_tracks(
+            &mut self,
+            request: impl tonic::IntoRequest<super::FlushAndReloadTracksRequest>,
+        ) -> std::result::Result<
+            tonic::Response<super::FlushAndReloadTracksResponse>,
+            tonic::Status,
+        > {
+            self.inner
+                .ready()
+                .await
+                .map_err(|e| {
+                    tonic::Status::unknown(
+                        format!("Service was not ready: {}", e.into()),
+                    )
+                })?;
+            let codec = tonic::codec::ProstCodec::default();
+            let path = http::uri::PathAndQuery::from_static(
+                "/rockbox.v1alpha1.PlaybackService/FlushAndReloadTracks",
+            );
+            let mut req = request.into_request();
+            req.extensions_mut()
+                .insert(
+                    GrpcMethod::new(
+                        "rockbox.v1alpha1.PlaybackService",
+                        "FlushAndReloadTracks",
+                    ),
+                );
+            self.inner.unary(req, path, codec).await
+        }
+        pub async fn get_file_position(
+            &mut self,
+            request: impl tonic::IntoRequest<super::GetFilePositionRequest>,
+        ) -> std::result::Result<
+            tonic::Response<super::GetFilePositionResponse>,
+            tonic::Status,
+        > {
+            self.inner
+                .ready()
+                .await
+                .map_err(|e| {
+                    tonic::Status::unknown(
+                        format!("Service was not ready: {}", e.into()),
+                    )
+                })?;
+            let codec = tonic::codec::ProstCodec::default();
+            let path = http::uri::PathAndQuery::from_static(
+                "/rockbox.v1alpha1.PlaybackService/GetFilePosition",
+            );
+            let mut req = request.into_request();
+            req.extensions_mut()
+                .insert(
+                    GrpcMethod::new(
+                        "rockbox.v1alpha1.PlaybackService",
+                        "GetFilePosition",
+                    ),
+                );
+            self.inner.unary(req, path, codec).await
+        }
+        pub async fn hard_stop(
+            &mut self,
+            request: impl tonic::IntoRequest<super::HardStopRequest>,
+        ) -> std::result::Result<
+            tonic::Response<super::HardStopResponse>,
+            tonic::Status,
+        > {
+            self.inner
+                .ready()
+                .await
+                .map_err(|e| {
+                    tonic::Status::unknown(
+                        format!("Service was not ready: {}", e.into()),
+                    )
+                })?;
+            let codec = tonic::codec::ProstCodec::default();
+            let path = http::uri::PathAndQuery::from_static(
+                "/rockbox.v1alpha1.PlaybackService/HardStop",
+            );
+            let mut req = request.into_request();
+            req.extensions_mut()
+                .insert(GrpcMethod::new("rockbox.v1alpha1.PlaybackService", "HardStop"));
+            self.inner.unary(req, path, codec).await
+        }
+        pub async fn play_album(
+            &mut self,
+            request: impl tonic::IntoRequest<super::PlayAlbumRequest>,
+        ) -> std::result::Result<
+            tonic::Response<super::PlayAlbumResponse>,
+            tonic::Status,
+        > {
+            self.inner
+                .ready()
+                .await
+                .map_err(|e| {
+                    tonic::Status::unknown(
+                        format!("Service was not ready: {}", e.into()),
+                    )
+                })?;
+            let codec = tonic::codec::ProstCodec::default();
+            let path = http::uri::PathAndQuery::from_static(
+                "/rockbox.v1alpha1.PlaybackService/PlayAlbum",
+            );
+            let mut req = request.into_request();
+            req.extensions_mut()
+                .insert(
+                    GrpcMethod::new("rockbox.v1alpha1.PlaybackService", "PlayAlbum"),
+                );
+            self.inner.unary(req, path, codec).await
+        }
+        pub async fn play_artist_tracks(
+            &mut self,
+            request: impl tonic::IntoRequest<super::PlayArtistTracksRequest>,
+        ) -> std::result::Result<
+            tonic::Response<super::PlayArtistTracksResponse>,
+            tonic::Status,
+        > {
+            self.inner
+                .ready()
+                .await
+                .map_err(|e| {
+                    tonic::Status::unknown(
+                        format!("Service was not ready: {}", e.into()),
+                    )
+                })?;
+            let codec = tonic::codec::ProstCodec::default();
+            let path = http::uri::PathAndQuery::from_static(
+                "/rockbox.v1alpha1.PlaybackService/PlayArtistTracks",
+            );
+            let mut req = request.into_request();
+            req.extensions_mut()
+                .insert(
+                    GrpcMethod::new(
+                        "rockbox.v1alpha1.PlaybackService",
+                        "PlayArtistTracks",
+                    ),
+                );
+            self.inner.unary(req, path, codec).await
+        }
+        pub async fn play_playlist(
+            &mut self,
+            request: impl tonic::IntoRequest<super::PlayPlaylistRequest>,
+        ) -> std::result::Result<
+            tonic::Response<super::PlayPlaylistResponse>,
+            tonic::Status,
+        > {
+            self.inner
+                .ready()
+                .await
+                .map_err(|e| {
+                    tonic::Status::unknown(
+                        format!("Service was not ready: {}", e.into()),
+                    )
+                })?;
+            let codec = tonic::codec::ProstCodec::default();
+            let path = http::uri::PathAndQuery::from_static(
+                "/rockbox.v1alpha1.PlaybackService/PlayPlaylist",
+            );
+            let mut req = request.into_request();
+            req.extensions_mut()
+                .insert(
+                    GrpcMethod::new("rockbox.v1alpha1.PlaybackService", "PlayPlaylist"),
+                );
+            self.inner.unary(req, path, codec).await
+        }
+        pub async fn play_directory(
+            &mut self,
+            request: impl tonic::IntoRequest<super::PlayDirectoryRequest>,
+        ) -> std::result::Result<
+            tonic::Response<super::PlayDirectoryResponse>,
+            tonic::Status,
+        > {
+            self.inner
+                .ready()
+                .await
+                .map_err(|e| {
+                    tonic::Status::unknown(
+                        format!("Service was not ready: {}", e.into()),
+                    )
+                })?;
+            let codec = tonic::codec::ProstCodec::default();
+            let path = http::uri::PathAndQuery::from_static(
+                "/rockbox.v1alpha1.PlaybackService/PlayDirectory",
+            );
+            let mut req = request.into_request();
+            req.extensions_mut()
+                .insert(
+                    GrpcMethod::new("rockbox.v1alpha1.PlaybackService", "PlayDirectory"),
+                );
+            self.inner.unary(req, path, codec).await
+        }
+        pub async fn play_track(
+            &mut self,
+            request: impl tonic::IntoRequest<super::PlayTrackRequest>,
+        ) -> std::result::Result<
+            tonic::Response<super::PlayTrackResponse>,
+            tonic::Status,
+        > {
+            self.inner
+                .ready()
+                .await
+                .map_err(|e| {
+                    tonic::Status::unknown(
+                        format!("Service was not ready: {}", e.into()),
+                    )
+                })?;
+            let codec = tonic::codec::ProstCodec::default();
+            let path = http::uri::PathAndQuery::from_static(
+                "/rockbox.v1alpha1.PlaybackService/PlayTrack",
+            );
+            let mut req = request.into_request();
+            req.extensions_mut()
+                .insert(
+                    GrpcMethod::new("rockbox.v1alpha1.PlaybackService", "PlayTrack"),
+                );
+            self.inner.unary(req, path, codec).await
+        }
+        pub async fn play_liked_tracks(
+            &mut self,
+            request: impl tonic::IntoRequest<super::PlayLikedTracksRequest>,
+        ) -> std::result::Result<
+            tonic::Response<super::PlayLikedTracksResponse>,
+            tonic::Status,
+        > {
+            self.inner
+                .ready()
+                .await
+                .map_err(|e| {
+                    tonic::Status::unknown(
+                        format!("Service was not ready: {}", e.into()),
+                    )
+                })?;
+            let codec = tonic::codec::ProstCodec::default();
+            let path = http::uri::PathAndQuery::from_static(
+                "/rockbox.v1alpha1.PlaybackService/PlayLikedTracks",
+            );
+            let mut req = request.into_request();
+            req.extensions_mut()
+                .insert(
+                    GrpcMethod::new(
+                        "rockbox.v1alpha1.PlaybackService",
+                        "PlayLikedTracks",
+                    ),
+                );
+            self.inner.unary(req, path, codec).await
+        }
+        pub async fn play_all_tracks(
+            &mut self,
+            request: impl tonic::IntoRequest<super::PlayAllTracksRequest>,
+        ) -> std::result::Result<
+            tonic::Response<super::PlayAllTracksResponse>,
+            tonic::Status,
+        > {
+            self.inner
+                .ready()
+                .await
+                .map_err(|e| {
+                    tonic::Status::unknown(
+                        format!("Service was not ready: {}", e.into()),
+                    )
+                })?;
+            let codec = tonic::codec::ProstCodec::default();
+            let path = http::uri::PathAndQuery::from_static(
+                "/rockbox.v1alpha1.PlaybackService/PlayAllTracks",
+            );
+            let mut req = request.into_request();
+            req.extensions_mut()
+                .insert(
+                    GrpcMethod::new("rockbox.v1alpha1.PlaybackService", "PlayAllTracks"),
+                );
+            self.inner.unary(req, path, codec).await
+        }
+        pub async fn stream_current_track(
+            &mut self,
+            request: impl tonic::IntoRequest<super::StreamCurrentTrackRequest>,
+        ) -> std::result::Result<
+            tonic::Response<tonic::codec::Streaming<super::CurrentTrackResponse>>,
+            tonic::Status,
+        > {
+            self.inner
+                .ready()
+                .await
+                .map_err(|e| {
+                    tonic::Status::unknown(
+                        format!("Service was not ready: {}", e.into()),
+                    )
+                })?;
+            let codec = tonic::codec::ProstCodec::default();
+            let path = http::uri::PathAndQuery::from_static(
+                "/rockbox.v1alpha1.PlaybackService/StreamCurrentTrack",
+            );
+            let mut req = request.into_request();
+            req.extensions_mut()
+                .insert(
+                    GrpcMethod::new(
+                        "rockbox.v1alpha1.PlaybackService",
+                        "StreamCurrentTrack",
+                    ),
+                );
+            self.inner.server_streaming(req, path, codec).await
+        }
+        pub async fn stream_status(
+            &mut self,
+            request: impl tonic::IntoRequest<super::StreamStatusRequest>,
+        ) -> std::result::Result<
+            tonic::Response<tonic::codec::Streaming<super::StatusResponse>>,
+            tonic::Status,
+        > {
+            self.inner
+                .ready()
+                .await
+                .map_err(|e| {
+                    tonic::Status::unknown(
+                        format!("Service was not ready: {}", e.into()),
+                    )
+                })?;
+            let codec = tonic::codec::ProstCodec::default();
+            let path = http::uri::PathAndQuery::from_static(
+                "/rockbox.v1alpha1.PlaybackService/StreamStatus",
+            );
+            let mut req = request.into_request();
+            req.extensions_mut()
+                .insert(
+                    GrpcMethod::new("rockbox.v1alpha1.PlaybackService", "StreamStatus"),
+                );
+            self.inner.server_streaming(req, path, codec).await
+        }
+        pub async fn stream_playlist(
+            &mut self,
+            request: impl tonic::IntoRequest<super::StreamPlaylistRequest>,
+        ) -> std::result::Result<
+            tonic::Response<tonic::codec::Streaming<super::PlaylistResponse>>,
+            tonic::Status,
+        > {
+            self.inner
+                .ready()
+                .await
+                .map_err(|e| {
+                    tonic::Status::unknown(
+                        format!("Service was not ready: {}", e.into()),
+                    )
+                })?;
+            let codec = tonic::codec::ProstCodec::default();
+            let path = http::uri::PathAndQuery::from_static(
+                "/rockbox.v1alpha1.PlaybackService/StreamPlaylist",
+            );
+            let mut req = request.into_request();
+            req.extensions_mut()
+                .insert(
+                    GrpcMethod::new("rockbox.v1alpha1.PlaybackService", "StreamPlaylist"),
+                );
+            self.inner.server_streaming(req, path, codec).await
+        }
+    }
+}
+/// Generated server implementations.
+pub mod playback_service_server {
+    #![allow(
+        unused_variables,
+        dead_code,
+        missing_docs,
+        clippy::wildcard_imports,
+        clippy::let_unit_value,
+    )]
+    use tonic::codegen::*;
+    /// Generated trait containing gRPC methods that should be implemented for use with PlaybackServiceServer.
+    #[async_trait]
+    pub trait PlaybackService: std::marker::Send + std::marker::Sync + 'static {
+        async fn play(
+            &self,
+            request: tonic::Request<super::PlayRequest>,
+        ) -> std::result::Result<tonic::Response<super::PlayResponse>, tonic::Status>;
+        async fn pause(
+            &self,
+            request: tonic::Request<super::PauseRequest>,
+        ) -> std::result::Result<tonic::Response<super::PauseResponse>, tonic::Status>;
+        async fn play_or_pause(
+            &self,
+            request: tonic::Request<super::PlayOrPauseRequest>,
+        ) -> std::result::Result<
+            tonic::Response<super::PlayOrPauseResponse>,
+            tonic::Status,
+        >;
+        async fn resume(
+            &self,
+            request: tonic::Request<super::ResumeRequest>,
+        ) -> std::result::Result<tonic::Response<super::ResumeResponse>, tonic::Status>;
+        async fn next(
+            &self,
+            request: tonic::Request<super::NextRequest>,
+        ) -> std::result::Result<tonic::Response<super::NextResponse>, tonic::Status>;
+        async fn previous(
+            &self,
+            request: tonic::Request<super::PreviousRequest>,
+        ) -> std::result::Result<
+            tonic::Response<super::PreviousResponse>,
+            tonic::Status,
+        >;
+        async fn fast_forward_rewind(
+            &self,
+            request: tonic::Request<super::FastForwardRewindRequest>,
+        ) -> std::result::Result<
+            tonic::Response<super::FastForwardRewindResponse>,
+            tonic::Status,
+        >;
+        async fn status(
+            &self,
+            request: tonic::Request<super::StatusRequest>,
+        ) -> std::result::Result<tonic::Response<super::StatusResponse>, tonic::Status>;
+        async fn current_track(
+            &self,
+            request: tonic::Request<super::CurrentTrackRequest>,
+        ) -> std::result::Result<
+            tonic::Response<super::CurrentTrackResponse>,
+            tonic::Status,
+        >;
+        async fn next_track(
+            &self,
+            request: tonic::Request<super::NextTrackRequest>,
+        ) -> std::result::Result<
+            tonic::Response<super::NextTrackResponse>,
+            tonic::Status,
+        >;
+        async fn flush_and_reload_tracks(
+            &self,
+            request: tonic::Request<super::FlushAndReloadTracksRequest>,
+        ) -> std::result::Result<
+            tonic::Response<super::FlushAndReloadTracksResponse>,
+            tonic::Status,
+        >;
+        async fn get_file_position(
+            &self,
+            request: tonic::Request<super::GetFilePositionRequest>,
+        ) -> std::result::Result<
+            tonic::Response<super::GetFilePositionResponse>,
+            tonic::Status,
+        >;
+        async fn hard_stop(
+            &self,
+            request: tonic::Request<super::HardStopRequest>,
+        ) -> std::result::Result<
+            tonic::Response<super::HardStopResponse>,
+            tonic::Status,
+        >;
+        async fn play_album(
+            &self,
+            request: tonic::Request<super::PlayAlbumRequest>,
+        ) -> std::result::Result<
+            tonic::Response<super::PlayAlbumResponse>,
+            tonic::Status,
+        >;
+        async fn play_artist_tracks(
+            &self,
+            request: tonic::Request<super::PlayArtistTracksRequest>,
+        ) -> std::result::Result<
+            tonic::Response<super::PlayArtistTracksResponse>,
+            tonic::Status,
+        >;
+        async fn play_playlist(
+            &self,
+            request: tonic::Request<super::PlayPlaylistRequest>,
+        ) -> std::result::Result<
+            tonic::Response<super::PlayPlaylistResponse>,
+            tonic::Status,
+        >;
+        async fn play_directory(
+            &self,
+            request: tonic::Request<super::PlayDirectoryRequest>,
+        ) -> std::result::Result<
+            tonic::Response<super::PlayDirectoryResponse>,
+            tonic::Status,
+        >;
+        async fn play_track(
+            &self,
+            request: tonic::Request<super::PlayTrackRequest>,
+        ) -> std::result::Result<
+            tonic::Response<super::PlayTrackResponse>,
+            tonic::Status,
+        >;
+        async fn play_liked_tracks(
+            &self,
+            request: tonic::Request<super::PlayLikedTracksRequest>,
+        ) -> std::result::Result<
+            tonic::Response<super::PlayLikedTracksResponse>,
+            tonic::Status,
+        >;
+        async fn play_all_tracks(
+            &self,
+            request: tonic::Request<super::PlayAllTracksRequest>,
+        ) -> std::result::Result<
+            tonic::Response<super::PlayAllTracksResponse>,
+            tonic::Status,
+        >;
+        /// Server streaming response type for the StreamCurrentTrack method.
+        type StreamCurrentTrackStream: tonic::codegen::tokio_stream::Stream<
+                Item = std::result::Result<super::CurrentTrackResponse, tonic::Status>,
+            >
+            + std::marker::Send
+            + 'static;
+        async fn stream_current_track(
+            &self,
+            request: tonic::Request<super::StreamCurrentTrackRequest>,
+        ) -> std::result::Result<
+            tonic::Response<Self::StreamCurrentTrackStream>,
+            tonic::Status,
+        >;
+        /// Server streaming response type for the StreamStatus method.
+        type StreamStatusStream: tonic::codegen::tokio_stream::Stream<
+                Item = std::result::Result<super::StatusResponse, tonic::Status>,
+            >
+            + std::marker::Send
+            + 'static;
+        async fn stream_status(
+            &self,
+            request: tonic::Request<super::StreamStatusRequest>,
+        ) -> std::result::Result<
+            tonic::Response<Self::StreamStatusStream>,
+            tonic::Status,
+        >;
+        /// Server streaming response type for the StreamPlaylist method.
+        type StreamPlaylistStream: tonic::codegen::tokio_stream::Stream<
+                Item = std::result::Result<super::PlaylistResponse, tonic::Status>,
+            >
+            + std::marker::Send
+            + 'static;
+        async fn stream_playlist(
+            &self,
+            request: tonic::Request<super::StreamPlaylistRequest>,
+        ) -> std::result::Result<
+            tonic::Response<Self::StreamPlaylistStream>,
+            tonic::Status,
+        >;
+    }
+    #[derive(Debug)]
+    pub struct PlaybackServiceServer<T> {
+        inner: Arc<T>,
+        accept_compression_encodings: EnabledCompressionEncodings,
+        send_compression_encodings: EnabledCompressionEncodings,
+        max_decoding_message_size: Option<usize>,
+        max_encoding_message_size: Option<usize>,
+    }
+    impl<T> PlaybackServiceServer<T> {
+        pub fn new(inner: T) -> Self {
+            Self::from_arc(Arc::new(inner))
+        }
+        pub fn from_arc(inner: Arc<T>) -> Self {
+            Self {
+                inner,
+                accept_compression_encodings: Default::default(),
+                send_compression_encodings: Default::default(),
+                max_decoding_message_size: None,
+                max_encoding_message_size: None,
+            }
+        }
+        pub fn with_interceptor<F>(
+            inner: T,
+            interceptor: F,
+        ) -> InterceptedService<Self, F>
+        where
+            F: tonic::service::Interceptor,
+        {
+            InterceptedService::new(Self::new(inner), interceptor)
+        }
+        /// Enable decompressing requests with the given encoding.
+        #[must_use]
+        pub fn accept_compressed(mut self, encoding: CompressionEncoding) -> Self {
+            self.accept_compression_encodings.enable(encoding);
+            self
+        }
+        /// Compress responses with the given encoding, if the client supports it.
+        #[must_use]
+        pub fn send_compressed(mut self, encoding: CompressionEncoding) -> Self {
+            self.send_compression_encodings.enable(encoding);
+            self
+        }
+        /// Limits the maximum size of a decoded message.
+        ///
+        /// Default: `4MB`
+        #[must_use]
+        pub fn max_decoding_message_size(mut self, limit: usize) -> Self {
+            self.max_decoding_message_size = Some(limit);
+            self
+        }
+        /// Limits the maximum size of an encoded message.
+        ///
+        /// Default: `usize::MAX`
+        #[must_use]
+        pub fn max_encoding_message_size(mut self, limit: usize) -> Self {
+            self.max_encoding_message_size = Some(limit);
+            self
+        }
+    }
+    impl<T, B> tonic::codegen::Service<http::Request<B>> for PlaybackServiceServer<T>
+    where
+        T: PlaybackService,
+        B: Body + std::marker::Send + 'static,
+        B::Error: Into<StdError> + std::marker::Send + 'static,
+    {
+        type Response = http::Response<tonic::body::BoxBody>;
+        type Error = std::convert::Infallible;
+        type Future = BoxFuture<Self::Response, Self::Error>;
+        fn poll_ready(
+            &mut self,
+            _cx: &mut Context<'_>,
+        ) -> Poll<std::result::Result<(), Self::Error>> {
+            Poll::Ready(Ok(()))
+        }
+        fn call(&mut self, req: http::Request<B>) -> Self::Future {
+            match req.uri().path() {
+                "/rockbox.v1alpha1.PlaybackService/Play" => {
+                    #[allow(non_camel_case_types)]
+                    struct PlaySvc<T: PlaybackService>(pub Arc<T>);
+                    impl<
+                        T: PlaybackService,
+                    > tonic::server::UnaryService<super::PlayRequest> for PlaySvc<T> {
+                        type Response = super::PlayResponse;
+                        type Future = BoxFuture<
+                            tonic::Response<Self::Response>,
+                            tonic::Status,
+                        >;
+                        fn call(
+                            &mut self,
+                            request: tonic::Request<super::PlayRequest>,
+                        ) -> Self::Future {
+                            let inner = Arc::clone(&self.0);
+                            let fut = async move {
+                                <T as PlaybackService>::play(&inner, request).await
+                            };
+                            Box::pin(fut)
+                        }
+                    }
+                    let accept_compression_encodings = self.accept_compression_encodings;
+                    let send_compression_encodings = self.send_compression_encodings;
+                    let max_decoding_message_size = self.max_decoding_message_size;
+                    let max_encoding_message_size = self.max_encoding_message_size;
+                    let inner = self.inner.clone();
+                    let fut = async move {
+                        let method = PlaySvc(inner);
+                        let codec = tonic::codec::ProstCodec::default();
+                        let mut grpc = tonic::server::Grpc::new(codec)
+                            .apply_compression_config(
+                                accept_compression_encodings,
+                                send_compression_encodings,
+                            )
+                            .apply_max_message_size_config(
+                                max_decoding_message_size,
+                                max_encoding_message_size,
+                            );
+                        let res = grpc.unary(method, req).await;
+                        Ok(res)
+                    };
+                    Box::pin(fut)
+                }
+                "/rockbox.v1alpha1.PlaybackService/Pause" => {
+                    #[allow(non_camel_case_types)]
+                    struct PauseSvc<T: PlaybackService>(pub Arc<T>);
+                    impl<
+                        T: PlaybackService,
+                    > tonic::server::UnaryService<super::PauseRequest> for PauseSvc<T> {
+                        type Response = super::PauseResponse;
+                        type Future = BoxFuture<
+                            tonic::Response<Self::Response>,
+                            tonic::Status,
+                        >;
+                        fn call(
+                            &mut self,
+                            request: tonic::Request<super::PauseRequest>,
+                        ) -> Self::Future {
+                            let inner = Arc::clone(&self.0);
+                            let fut = async move {
+                                <T as PlaybackService>::pause(&inner, request).await
+                            };
+                            Box::pin(fut)
+                        }
+                    }
+                    let accept_compression_encodings = self.accept_compression_encodings;
+                    let send_compression_encodings = self.send_compression_encodings;
+                    let max_decoding_message_size = self.max_decoding_message_size;
+                    let max_encoding_message_size = self.max_encoding_message_size;
+                    let inner = self.inner.clone();
+                    let fut = async move {
+                        let method = PauseSvc(inner);
+                        let codec = tonic::codec::ProstCodec::default();
+                        let mut grpc = tonic::server::Grpc::new(codec)
+                            .apply_compression_config(
+                                accept_compression_encodings,
+                                send_compression_encodings,
+                            )
+                            .apply_max_message_size_config(
+                                max_decoding_message_size,
+                                max_encoding_message_size,
+                            );
+                        let res = grpc.unary(method, req).await;
+                        Ok(res)
+                    };
+                    Box::pin(fut)
+                }
+                "/rockbox.v1alpha1.PlaybackService/PlayOrPause" => {
+                    #[allow(non_camel_case_types)]
+                    struct PlayOrPauseSvc<T: PlaybackService>(pub Arc<T>);
+                    impl<
+                        T: PlaybackService,
+                    > tonic::server::UnaryService<super::PlayOrPauseRequest>
+                    for PlayOrPauseSvc<T> {
+                        type Response = super::PlayOrPauseResponse;
+                        type Future = BoxFuture<
+                            tonic::Response<Self::Response>,
+                            tonic::Status,
+                        >;
+                        fn call(
+                            &mut self,
+                            request: tonic::Request<super::PlayOrPauseRequest>,
+                        ) -> Self::Future {
+                            let inner = Arc::clone(&self.0);
+                            let fut = async move {
+                                <T as PlaybackService>::play_or_pause(&inner, request).await
+                            };
+                            Box::pin(fut)
+                        }
+                    }
+                    let accept_compression_encodings = self.accept_compression_encodings;
+                    let send_compression_encodings = self.send_compression_encodings;
+                    let max_decoding_message_size = self.max_decoding_message_size;
+                    let max_encoding_message_size = self.max_encoding_message_size;
+                    let inner = self.inner.clone();
+                    let fut = async move {
+                        let method = PlayOrPauseSvc(inner);
+                        let codec = tonic::codec::ProstCodec::default();
+                        let mut grpc = tonic::server::Grpc::new(codec)
+                            .apply_compression_config(
+                                accept_compression_encodings,
+                                send_compression_encodings,
+                            )
+                            .apply_max_message_size_config(
+                                max_decoding_message_size,
+                                max_encoding_message_size,
+                            );
+                        let res = grpc.unary(method, req).await;
+                        Ok(res)
+                    };
+                    Box::pin(fut)
+                }
+                "/rockbox.v1alpha1.PlaybackService/Resume" => {
+                    #[allow(non_camel_case_types)]
+                    struct ResumeSvc<T: PlaybackService>(pub Arc<T>);
+                    impl<
+                        T: PlaybackService,
+                    > tonic::server::UnaryService<super::ResumeRequest>
+                    for ResumeSvc<T> {
+                        type Response = super::ResumeResponse;
+                        type Future = BoxFuture<
+                            tonic::Response<Self::Response>,
+                            tonic::Status,
+                        >;
+                        fn call(
+                            &mut self,
+                            request: tonic::Request<super::ResumeRequest>,
+                        ) -> Self::Future {
+                            let inner = Arc::clone(&self.0);
+                            let fut = async move {
+                                <T as PlaybackService>::resume(&inner, request).await
+                            };
+                            Box::pin(fut)
+                        }
+                    }
+                    let accept_compression_encodings = self.accept_compression_encodings;
+                    let send_compression_encodings = self.send_compression_encodings;
+                    let max_decoding_message_size = self.max_decoding_message_size;
+                    let max_encoding_message_size = self.max_encoding_message_size;
+                    let inner = self.inner.clone();
+                    let fut = async move {
+                        let method = ResumeSvc(inner);
+                        let codec = tonic::codec::ProstCodec::default();
+                        let mut grpc = tonic::server::Grpc::new(codec)
+                            .apply_compression_config(
+                                accept_compression_encodings,
+                                send_compression_encodings,
+                            )
+                            .apply_max_message_size_config(
+                                max_decoding_message_size,
+                                max_encoding_message_size,
+                            );
+                        let res = grpc.unary(method, req).await;
+                        Ok(res)
+                    };
+                    Box::pin(fut)
+                }
+                "/rockbox.v1alpha1.PlaybackService/Next" => {
+                    #[allow(non_camel_case_types)]
+                    struct NextSvc<T: PlaybackService>(pub Arc<T>);
+                    impl<
+                        T: PlaybackService,
+                    > tonic::server::UnaryService<super::NextRequest> for NextSvc<T> {
+                        type Response = super::NextResponse;
+                        type Future = BoxFuture<
+                            tonic::Response<Self::Response>,
+                            tonic::Status,
+                        >;
+                        fn call(
+                            &mut self,
+                            request: tonic::Request<super::NextRequest>,
+                        ) -> Self::Future {
+                            let inner = Arc::clone(&self.0);
+                            let fut = async move {
+                                <T as PlaybackService>::next(&inner, request).await
+                            };
+                            Box::pin(fut)
+                        }
+                    }
+                    let accept_compression_encodings = self.accept_compression_encodings;
+                    let send_compression_encodings = self.send_compression_encodings;
+                    let max_decoding_message_size = self.max_decoding_message_size;
+                    let max_encoding_message_size = self.max_encoding_message_size;
+                    let inner = self.inner.clone();
+                    let fut = async move {
+                        let method = NextSvc(inner);
+                        let codec = tonic::codec::ProstCodec::default();
+                        let mut grpc = tonic::server::Grpc::new(codec)
+                            .apply_compression_config(
+                                accept_compression_encodings,
+                                send_compression_encodings,
+                            )
+                            .apply_max_message_size_config(
+                                max_decoding_message_size,
+                                max_encoding_message_size,
+                            );
+                        let res = grpc.unary(method, req).await;
+                        Ok(res)
+                    };
+                    Box::pin(fut)
+                }
+                "/rockbox.v1alpha1.PlaybackService/Previous" => {
+                    #[allow(non_camel_case_types)]
+                    struct PreviousSvc<T: PlaybackService>(pub Arc<T>);
+                    impl<
+                        T: PlaybackService,
+                    > tonic::server::UnaryService<super::PreviousRequest>
+                    for PreviousSvc<T> {
+                        type Response = super::PreviousResponse;
+                        type Future = BoxFuture<
+                            tonic::Response<Self::Response>,
+                            tonic::Status,
+                        >;
+                        fn call(
+                            &mut self,
+                            request: tonic::Request<super::PreviousRequest>,
+                        ) -> Self::Future {
+                            let inner = Arc::clone(&self.0);
+                            let fut = async move {
+                                <T as PlaybackService>::previous(&inner, request).await
+                            };
+                            Box::pin(fut)
+                        }
+                    }
+                    let accept_compression_encodings = self.accept_compression_encodings;
+                    let send_compression_encodings = self.send_compression_encodings;
+                    let max_decoding_message_size = self.max_decoding_message_size;
+                    let max_encoding_message_size = self.max_encoding_message_size;
+                    let inner = self.inner.clone();
+                    let fut = async move {
+                        let method = PreviousSvc(inner);
+                        let codec = tonic::codec::ProstCodec::default();
+                        let mut grpc = tonic::server::Grpc::new(codec)
+                            .apply_compression_config(
+                                accept_compression_encodings,
+                                send_compression_encodings,
+                            )
+                            .apply_max_message_size_config(
+                                max_decoding_message_size,
+                                max_encoding_message_size,
+                            );
+                        let res = grpc.unary(method, req).await;
+                        Ok(res)
+                    };
+                    Box::pin(fut)
+                }
+                "/rockbox.v1alpha1.PlaybackService/FastForwardRewind" => {
+                    #[allow(non_camel_case_types)]
+                    struct FastForwardRewindSvc<T: PlaybackService>(pub Arc<T>);
+                    impl<
+                        T: PlaybackService,
+                    > tonic::server::UnaryService<super::FastForwardRewindRequest>
+                    for FastForwardRewindSvc<T> {
+                        type Response = super::FastForwardRewindResponse;
+                        type Future = BoxFuture<
+                            tonic::Response<Self::Response>,
+                            tonic::Status,
+                        >;
+                        fn call(
+                            &mut self,
+                            request: tonic::Request<super::FastForwardRewindRequest>,
+                        ) -> Self::Future {
+                            let inner = Arc::clone(&self.0);
+                            let fut = async move {
+                                <T as PlaybackService>::fast_forward_rewind(&inner, request)
+                                    .await
+                            };
+                            Box::pin(fut)
+                        }
+                    }
+                    let accept_compression_encodings = self.accept_compression_encodings;
+                    let send_compression_encodings = self.send_compression_encodings;
+                    let max_decoding_message_size = self.max_decoding_message_size;
+                    let max_encoding_message_size = self.max_encoding_message_size;
+                    let inner = self.inner.clone();
+                    let fut = async move {
+                        let method = FastForwardRewindSvc(inner);
+                        let codec = tonic::codec::ProstCodec::default();
+                        let mut grpc = tonic::server::Grpc::new(codec)
+                            .apply_compression_config(
+                                accept_compression_encodings,
+                                send_compression_encodings,
+                            )
+                            .apply_max_message_size_config(
+                                max_decoding_message_size,
+                                max_encoding_message_size,
+                            );
+                        let res = grpc.unary(method, req).await;
+                        Ok(res)
+                    };
+                    Box::pin(fut)
+                }
+                "/rockbox.v1alpha1.PlaybackService/Status" => {
+                    #[allow(non_camel_case_types)]
+                    struct StatusSvc<T: PlaybackService>(pub Arc<T>);
+                    impl<
+                        T: PlaybackService,
+                    > tonic::server::UnaryService<super::StatusRequest>
+                    for StatusSvc<T> {
+                        type Response = super::StatusResponse;
+                        type Future = BoxFuture<
+                            tonic::Response<Self::Response>,
+                            tonic::Status,
+                        >;
+                        fn call(
+                            &mut self,
+                            request: tonic::Request<super::StatusRequest>,
+                        ) -> Self::Future {
+                            let inner = Arc::clone(&self.0);
+                            let fut = async move {
+                                <T as PlaybackService>::status(&inner, request).await
+                            };
+                            Box::pin(fut)
+                        }
+                    }
+                    let accept_compression_encodings = self.accept_compression_encodings;
+                    let send_compression_encodings = self.send_compression_encodings;
+                    let max_decoding_message_size = self.max_decoding_message_size;
+                    let max_encoding_message_size = self.max_encoding_message_size;
+                    let inner = self.inner.clone();
+                    let fut = async move {
+                        let method = StatusSvc(inner);
+                        let codec = tonic::codec::ProstCodec::default();
+                        let mut grpc = tonic::server::Grpc::new(codec)
+                            .apply_compression_config(
+                                accept_compression_encodings,
+                                send_compression_encodings,
+                            )
+                            .apply_max_message_size_config(
+                                max_decoding_message_size,
+                                max_encoding_message_size,
+                            );
+                        let res = grpc.unary(method, req).await;
+                        Ok(res)
+                    };
+                    Box::pin(fut)
+                }
+                "/rockbox.v1alpha1.PlaybackService/CurrentTrack" => {
+                    #[allow(non_camel_case_types)]
+                    struct CurrentTrackSvc<T: PlaybackService>(pub Arc<T>);
+                    impl<
+                        T: PlaybackService,
+                    > tonic::server::UnaryService<super::CurrentTrackRequest>
+                    for CurrentTrackSvc<T> {
+                        type Response = super::CurrentTrackResponse;
+                        type Future = BoxFuture<
+                            tonic::Response<Self::Response>,
+                            tonic::Status,
+                        >;
+                        fn call(
+                            &mut self,
+                            request: tonic::Request<super::CurrentTrackRequest>,
+                        ) -> Self::Future {
+                            let inner = Arc::clone(&self.0);
+                            let fut = async move {
+                                <T as PlaybackService>::current_track(&inner, request).await
+                            };
+                            Box::pin(fut)
+                        }
+                    }
+                    let accept_compression_encodings = self.accept_compression_encodings;
+                    let send_compression_encodings = self.send_compression_encodings;
+                    let max_decoding_message_size = self.max_decoding_message_size;
+                    let max_encoding_message_size = self.max_encoding_message_size;
+                    let inner = self.inner.clone();
+                    let fut = async move {
+                        let method = CurrentTrackSvc(inner);
+                        let codec = tonic::codec::ProstCodec::default();
+                        let mut grpc = tonic::server::Grpc::new(codec)
+                            .apply_compression_config(
+                                accept_compression_encodings,
+                                send_compression_encodings,
+                            )
+                            .apply_max_message_size_config(
+                                max_decoding_message_size,
+                                max_encoding_message_size,
+                            );
+                        let res = grpc.unary(method, req).await;
+                        Ok(res)
+                    };
+                    Box::pin(fut)
+                }
+                "/rockbox.v1alpha1.PlaybackService/NextTrack" => {
+                    #[allow(non_camel_case_types)]
+                    struct NextTrackSvc<T: PlaybackService>(pub Arc<T>);
+                    impl<
+                        T: PlaybackService,
+                    > tonic::server::UnaryService<super::NextTrackRequest>
+                    for NextTrackSvc<T> {
+                        type Response = super::NextTrackResponse;
+                        type Future = BoxFuture<
+                            tonic::Response<Self::Response>,
+                            tonic::Status,
+                        >;
+                        fn call(
+                            &mut self,
+                            request: tonic::Request<super::NextTrackRequest>,
+                        ) -> Self::Future {
+                            let inner = Arc::clone(&self.0);
+                            let fut = async move {
+                                <T as PlaybackService>::next_track(&inner, request).await
+                            };
+                            Box::pin(fut)
+                        }
+                    }
+                    let accept_compression_encodings = self.accept_compression_encodings;
+                    let send_compression_encodings = self.send_compression_encodings;
+                    let max_decoding_message_size = self.max_decoding_message_size;
+                    let max_encoding_message_size = self.max_encoding_message_size;
+                    let inner = self.inner.clone();
+                    let fut = async move {
+                        let method = NextTrackSvc(inner);
+                        let codec = tonic::codec::ProstCodec::default();
+                        let mut grpc = tonic::server::Grpc::new(codec)
+                            .apply_compression_config(
+                                accept_compression_encodings,
+                                send_compression_encodings,
+                            )
+                            .apply_max_message_size_config(
+                                max_decoding_message_size,
+                                max_encoding_message_size,
+                            );
+                        let res = grpc.unary(method, req).await;
+                        Ok(res)
+                    };
+                    Box::pin(fut)
+                }
+                "/rockbox.v1alpha1.PlaybackService/FlushAndReloadTracks" => {
+                    #[allow(non_camel_case_types)]
+                    struct FlushAndReloadTracksSvc<T: PlaybackService>(pub Arc<T>);
+                    impl<
+                        T: PlaybackService,
+                    > tonic::server::UnaryService<super::FlushAndReloadTracksRequest>
+                    for FlushAndReloadTracksSvc<T> {
+                        type Response = super::FlushAndReloadTracksResponse;
+                        type Future = BoxFuture<
+                            tonic::Response<Self::Response>,
+                            tonic::Status,
+                        >;
+                        fn call(
+                            &mut self,
+                            request: tonic::Request<super::FlushAndReloadTracksRequest>,
+                        ) -> Self::Future {
+                            let inner = Arc::clone(&self.0);
+                            let fut = async move {
+                                <T as PlaybackService>::flush_and_reload_tracks(
+                                        &inner,
+                                        request,
+                                    )
+                                    .await
+                            };
+                            Box::pin(fut)
+                        }
+                    }
+                    let accept_compression_encodings = self.accept_compression_encodings;
+                    let send_compression_encodings = self.send_compression_encodings;
+                    let max_decoding_message_size = self.max_decoding_message_size;
+                    let max_encoding_message_size = self.max_encoding_message_size;
+                    let inner = self.inner.clone();
+                    let fut = async move {
+                        let method = FlushAndReloadTracksSvc(inner);
+                        let codec = tonic::codec::ProstCodec::default();
+                        let mut grpc = tonic::server::Grpc::new(codec)
+                            .apply_compression_config(
+                                accept_compression_encodings,
+                                send_compression_encodings,
+                            )
+                            .apply_max_message_size_config(
+                                max_decoding_message_size,
+                                max_encoding_message_size,
+                            );
+                        let res = grpc.unary(method, req).await;
+                        Ok(res)
+                    };
+                    Box::pin(fut)
+                }
+                "/rockbox.v1alpha1.PlaybackService/GetFilePosition" => {
+                    #[allow(non_camel_case_types)]
+                    struct GetFilePositionSvc<T: PlaybackService>(pub Arc<T>);
+                    impl<
+                        T: PlaybackService,
+                    > tonic::server::UnaryService<super::GetFilePositionRequest>
+                    for GetFilePositionSvc<T> {
+                        type Response = super::GetFilePositionResponse;
+                        type Future = BoxFuture<
+                            tonic::Response<Self::Response>,
+                            tonic::Status,
+                        >;
+                        fn call(
+                            &mut self,
+                            request: tonic::Request<super::GetFilePositionRequest>,
+                        ) -> Self::Future {
+                            let inner = Arc::clone(&self.0);
+                            let fut = async move {
+                                <T as PlaybackService>::get_file_position(&inner, request)
+                                    .await
+                            };
+                            Box::pin(fut)
+                        }
+                    }
+                    let accept_compression_encodings = self.accept_compression_encodings;
+                    let send_compression_encodings = self.send_compression_encodings;
+                    let max_decoding_message_size = self.max_decoding_message_size;
+                    let max_encoding_message_size = self.max_encoding_message_size;
+                    let inner = self.inner.clone();
+                    let fut = async move {
+                        let method = GetFilePositionSvc(inner);
+                        let codec = tonic::codec::ProstCodec::default();
+                        let mut grpc = tonic::server::Grpc::new(codec)
+                            .apply_compression_config(
+                                accept_compression_encodings,
+                                send_compression_encodings,
+                            )
+                            .apply_max_message_size_config(
+                                max_decoding_message_size,
+                                max_encoding_message_size,
+                            );
+                        let res = grpc.unary(method, req).await;
+                        Ok(res)
+                    };
+                    Box::pin(fut)
+                }
+                "/rockbox.v1alpha1.PlaybackService/HardStop" => {
+                    #[allow(non_camel_case_types)]
+                    struct HardStopSvc<T: PlaybackService>(pub Arc<T>);
+                    impl<
+                        T: PlaybackService,
+                    > tonic::server::UnaryService<super::HardStopRequest>
+                    for HardStopSvc<T> {
+                        type Response = super::HardStopResponse;
+                        type Future = BoxFuture<
+                            tonic::Response<Self::Response>,
+                            tonic::Status,
+                        >;
+                        fn call(
+                            &mut self,
+                            request: tonic::Request<super::HardStopRequest>,
+                        ) -> Self::Future {
+                            let inner = Arc::clone(&self.0);
+                            let fut = async move {
+                                <T as PlaybackService>::hard_stop(&inner, request).await
+                            };
+                            Box::pin(fut)
+                        }
+                    }
+                    let accept_compression_encodings = self.accept_compression_encodings;
+                    let send_compression_encodings = self.send_compression_encodings;
+                    let max_decoding_message_size = self.max_decoding_message_size;
+                    let max_encoding_message_size = self.max_encoding_message_size;
+                    let inner = self.inner.clone();
+                    let fut = async move {
+                        let method = HardStopSvc(inner);
+                        let codec = tonic::codec::ProstCodec::default();
+                        let mut grpc = tonic::server::Grpc::new(codec)
+                            .apply_compression_config(
+                                accept_compression_encodings,
+                                send_compression_encodings,
+                            )
+                            .apply_max_message_size_config(
+                                max_decoding_message_size,
+                                max_encoding_message_size,
+                            );
+                        let res = grpc.unary(method, req).await;
+                        Ok(res)
+                    };
+                    Box::pin(fut)
+                }
+                "/rockbox.v1alpha1.PlaybackService/PlayAlbum" => {
+                    #[allow(non_camel_case_types)]
+                    struct PlayAlbumSvc<T: PlaybackService>(pub Arc<T>);
+                    impl<
+                        T: PlaybackService,
+                    > tonic::server::UnaryService<super::PlayAlbumRequest>
+                    for PlayAlbumSvc<T> {
+                        type Response = super::PlayAlbumResponse;
+                        type Future = BoxFuture<
+                            tonic::Response<Self::Response>,
+                            tonic::Status,
+                        >;
+                        fn call(
+                            &mut self,
+                            request: tonic::Request<super::PlayAlbumRequest>,
+                        ) -> Self::Future {
+                            let inner = Arc::clone(&self.0);
+                            let fut = async move {
+                                <T as PlaybackService>::play_album(&inner, request).await
+                            };
+                            Box::pin(fut)
+                        }
+                    }
+                    let accept_compression_encodings = self.accept_compression_encodings;
+                    let send_compression_encodings = self.send_compression_encodings;
+                    let max_decoding_message_size = self.max_decoding_message_size;
+                    let max_encoding_message_size = self.max_encoding_message_size;
+                    let inner = self.inner.clone();
+                    let fut = async move {
+                        let method = PlayAlbumSvc(inner);
+                        let codec = tonic::codec::ProstCodec::default();
+                        let mut grpc = tonic::server::Grpc::new(codec)
+                            .apply_compression_config(
+                                accept_compression_encodings,
+                                send_compression_encodings,
+                            )
+                            .apply_max_message_size_config(
+                                max_decoding_message_size,
+                                max_encoding_message_size,
+                            );
+                        let res = grpc.unary(method, req).await;
+                        Ok(res)
+                    };
+                    Box::pin(fut)
+                }
+                "/rockbox.v1alpha1.PlaybackService/PlayArtistTracks" => {
+                    #[allow(non_camel_case_types)]
+                    struct PlayArtistTracksSvc<T: PlaybackService>(pub Arc<T>);
+                    impl<
+                        T: PlaybackService,
+                    > tonic::server::UnaryService<super::PlayArtistTracksRequest>
+                    for PlayArtistTracksSvc<T> {
+                        type Response = super::PlayArtistTracksResponse;
+                        type Future = BoxFuture<
+                            tonic::Response<Self::Response>,
+                            tonic::Status,
+                        >;
+                        fn call(
+                            &mut self,
+                            request: tonic::Request<super::PlayArtistTracksRequest>,
+                        ) -> Self::Future {
+                            let inner = Arc::clone(&self.0);
+                            let fut = async move {
+                                <T as PlaybackService>::play_artist_tracks(&inner, request)
+                                    .await
+                            };
+                            Box::pin(fut)
+                        }
+                    }
+                    let accept_compression_encodings = self.accept_compression_encodings;
+                    let send_compression_encodings = self.send_compression_encodings;
+                    let max_decoding_message_size = self.max_decoding_message_size;
+                    let max_encoding_message_size = self.max_encoding_message_size;
+                    let inner = self.inner.clone();
+                    let fut = async move {
+                        let method = PlayArtistTracksSvc(inner);
+                        let codec = tonic::codec::ProstCodec::default();
+                        let mut grpc = tonic::server::Grpc::new(codec)
+                            .apply_compression_config(
+                                accept_compression_encodings,
+                                send_compression_encodings,
+                            )
+                            .apply_max_message_size_config(
+                                max_decoding_message_size,
+                                max_encoding_message_size,
+                            );
+                        let res = grpc.unary(method, req).await;
+                        Ok(res)
+                    };
+                    Box::pin(fut)
+                }
+                "/rockbox.v1alpha1.PlaybackService/PlayPlaylist" => {
+                    #[allow(non_camel_case_types)]
+                    struct PlayPlaylistSvc<T: PlaybackService>(pub Arc<T>);
+                    impl<
+                        T: PlaybackService,
+                    > tonic::server::UnaryService<super::PlayPlaylistRequest>
+                    for PlayPlaylistSvc<T> {
+                        type Response = super::PlayPlaylistResponse;
+                        type Future = BoxFuture<
+                            tonic::Response<Self::Response>,
+                            tonic::Status,
+                        >;
+                        fn call(
+                            &mut self,
+                            request: tonic::Request<super::PlayPlaylistRequest>,
+                        ) -> Self::Future {
+                            let inner = Arc::clone(&self.0);
+                            let fut = async move {
+                                <T as PlaybackService>::play_playlist(&inner, request).await
+                            };
+                            Box::pin(fut)
+                        }
+                    }
+                    let accept_compression_encodings = self.accept_compression_encodings;
+                    let send_compression_encodings = self.send_compression_encodings;
+                    let max_decoding_message_size = self.max_decoding_message_size;
+                    let max_encoding_message_size = self.max_encoding_message_size;
+                    let inner = self.inner.clone();
+                    let fut = async move {
+                        let method = PlayPlaylistSvc(inner);
+                        let codec = tonic::codec::ProstCodec::default();
+                        let mut grpc = tonic::server::Grpc::new(codec)
+                            .apply_compression_config(
+                                accept_compression_encodings,
+                                send_compression_encodings,
+                            )
+                            .apply_max_message_size_config(
+                                max_decoding_message_size,
+                                max_encoding_message_size,
+                            );
+                        let res = grpc.unary(method, req).await;
+                        Ok(res)
+                    };
+                    Box::pin(fut)
+                }
+                "/rockbox.v1alpha1.PlaybackService/PlayDirectory" => {
+                    #[allow(non_camel_case_types)]
+                    struct PlayDirectorySvc<T: PlaybackService>(pub Arc<T>);
+                    impl<
+                        T: PlaybackService,
+                    > tonic::server::UnaryService<super::PlayDirectoryRequest>
+                    for PlayDirectorySvc<T> {
+                        type Response = super::PlayDirectoryResponse;
+                        type Future = BoxFuture<
+                            tonic::Response<Self::Response>,
+                            tonic::Status,
+                        >;
+                        fn call(
+                            &mut self,
+                            request: tonic::Request<super::PlayDirectoryRequest>,
+                        ) -> Self::Future {
+                            let inner = Arc::clone(&self.0);
+                            let fut = async move {
+                                <T as PlaybackService>::play_directory(&inner, request)
+                                    .await
+                            };
+                            Box::pin(fut)
+                        }
+                    }
+                    let accept_compression_encodings = self.accept_compression_encodings;
+                    let send_compression_encodings = self.send_compression_encodings;
+                    let max_decoding_message_size = self.max_decoding_message_size;
+                    let max_encoding_message_size = self.max_encoding_message_size;
+                    let inner = self.inner.clone();
+                    let fut = async move {
+                        let method = PlayDirectorySvc(inner);
+                        let codec = tonic::codec::ProstCodec::default();
+                        let mut grpc = tonic::server::Grpc::new(codec)
+                            .apply_compression_config(
+                                accept_compression_encodings,
+                                send_compression_encodings,
+                            )
+                            .apply_max_message_size_config(
+                                max_decoding_message_size,
+                                max_encoding_message_size,
+                            );
+                        let res = grpc.unary(method, req).await;
+                        Ok(res)
+                    };
+                    Box::pin(fut)
+                }
+                "/rockbox.v1alpha1.PlaybackService/PlayTrack" => {
+                    #[allow(non_camel_case_types)]
+                    struct PlayTrackSvc<T: PlaybackService>(pub Arc<T>);
+                    impl<
+                        T: PlaybackService,
+                    > tonic::server::UnaryService<super::PlayTrackRequest>
+                    for PlayTrackSvc<T> {
+                        type Response = super::PlayTrackResponse;
+                        type Future = BoxFuture<
+                            tonic::Response<Self::Response>,
+                            tonic::Status,
+                        >;
+                        fn call(
+                            &mut self,
+                            request: tonic::Request<super::PlayTrackRequest>,
+                        ) -> Self::Future {
+                            let inner = Arc::clone(&self.0);
+                            let fut = async move {
+                                <T as PlaybackService>::play_track(&inner, request).await
+                            };
+                            Box::pin(fut)
+                        }
+                    }
+                    let accept_compression_encodings = self.accept_compression_encodings;
+                    let send_compression_encodings = self.send_compression_encodings;
+                    let max_decoding_message_size = self.max_decoding_message_size;
+                    let max_encoding_message_size = self.max_encoding_message_size;
+                    let inner = self.inner.clone();
+                    let fut = async move {
+                        let method = PlayTrackSvc(inner);
+                        let codec = tonic::codec::ProstCodec::default();
+                        let mut grpc = tonic::server::Grpc::new(codec)
+                            .apply_compression_config(
+                                accept_compression_encodings,
+                                send_compression_encodings,
+                            )
+                            .apply_max_message_size_config(
+                                max_decoding_message_size,
+                                max_encoding_message_size,
+                            );
+                        let res = grpc.unary(method, req).await;
+                        Ok(res)
+                    };
+                    Box::pin(fut)
+                }
+                "/rockbox.v1alpha1.PlaybackService/PlayLikedTracks" => {
+                    #[allow(non_camel_case_types)]
+                    struct PlayLikedTracksSvc<T: PlaybackService>(pub Arc<T>);
+                    impl<
+                        T: PlaybackService,
+                    > tonic::server::UnaryService<super::PlayLikedTracksRequest>
+                    for PlayLikedTracksSvc<T> {
+                        type Response = super::PlayLikedTracksResponse;
+                        type Future = BoxFuture<
+                            tonic::Response<Self::Response>,
+                            tonic::Status,
+                        >;
+                        fn call(
+                            &mut self,
+                            request: tonic::Request<super::PlayLikedTracksRequest>,
+                        ) -> Self::Future {
+                            let inner = Arc::clone(&self.0);
+                            let fut = async move {
+                                <T as PlaybackService>::play_liked_tracks(&inner, request)
+                                    .await
+                            };
+                            Box::pin(fut)
+                        }
+                    }
+                    let accept_compression_encodings = self.accept_compression_encodings;
+                    let send_compression_encodings = self.send_compression_encodings;
+                    let max_decoding_message_size = self.max_decoding_message_size;
+                    let max_encoding_message_size = self.max_encoding_message_size;
+                    let inner = self.inner.clone();
+                    let fut = async move {
+                        let method = PlayLikedTracksSvc(inner);
+                        let codec = tonic::codec::ProstCodec::default();
+                        let mut grpc = tonic::server::Grpc::new(codec)
+                            .apply_compression_config(
+                                accept_compression_encodings,
+                                send_compression_encodings,
+                            )
+                            .apply_max_message_size_config(
+                                max_decoding_message_size,
+                                max_encoding_message_size,
+                            );
+                        let res = grpc.unary(method, req).await;
+                        Ok(res)
+                    };
+                    Box::pin(fut)
+                }
+                "/rockbox.v1alpha1.PlaybackService/PlayAllTracks" => {
+                    #[allow(non_camel_case_types)]
+                    struct PlayAllTracksSvc<T: PlaybackService>(pub Arc<T>);
+                    impl<
+                        T: PlaybackService,
+                    > tonic::server::UnaryService<super::PlayAllTracksRequest>
+                    for PlayAllTracksSvc<T> {
+                        type Response = super::PlayAllTracksResponse;
+                        type Future = BoxFuture<
+                            tonic::Response<Self::Response>,
+                            tonic::Status,
+                        >;
+                        fn call(
+                            &mut self,
+                            request: tonic::Request<super::PlayAllTracksRequest>,
+                        ) -> Self::Future {
+                            let inner = Arc::clone(&self.0);
+                            let fut = async move {
+                                <T as PlaybackService>::play_all_tracks(&inner, request)
+                                    .await
+                            };
+                            Box::pin(fut)
+                        }
+                    }
+                    let accept_compression_encodings = self.accept_compression_encodings;
+                    let send_compression_encodings = self.send_compression_encodings;
+                    let max_decoding_message_size = self.max_decoding_message_size;
+                    let max_encoding_message_size = self.max_encoding_message_size;
+                    let inner = self.inner.clone();
+                    let fut = async move {
+                        let method = PlayAllTracksSvc(inner);
+                        let codec = tonic::codec::ProstCodec::default();
+                        let mut grpc = tonic::server::Grpc::new(codec)
+                            .apply_compression_config(
+                                accept_compression_encodings,
+                                send_compression_encodings,
+                            )
+                            .apply_max_message_size_config(
+                                max_decoding_message_size,
+                                max_encoding_message_size,
+                            );
+                        let res = grpc.unary(method, req).await;
+                        Ok(res)
+                    };
+                    Box::pin(fut)
+                }
+                "/rockbox.v1alpha1.PlaybackService/StreamCurrentTrack" => {
+                    #[allow(non_camel_case_types)]
+                    struct StreamCurrentTrackSvc<T: PlaybackService>(pub Arc<T>);
+                    impl<
+                        T: PlaybackService,
+                    > tonic::server::ServerStreamingService<
+                        super::StreamCurrentTrackRequest,
+                    > for StreamCurrentTrackSvc<T> {
+                        type Response = super::CurrentTrackResponse;
+                        type ResponseStream = T::StreamCurrentTrackStream;
+                        type Future = BoxFuture<
+                            tonic::Response<Self::ResponseStream>,
+                            tonic::Status,
+                        >;
+                        fn call(
+                            &mut self,
+                            request: tonic::Request<super::StreamCurrentTrackRequest>,
+                        ) -> Self::Future {
+                            let inner = Arc::clone(&self.0);
+                            let fut = async move {
+                                <T as PlaybackService>::stream_current_track(
+                                        &inner,
+                                        request,
+                                    )
+                                    .await
+                            };
+                            Box::pin(fut)
+                        }
+                    }
+                    let accept_compression_encodings = self.accept_compression_encodings;
+                    let send_compression_encodings = self.send_compression_encodings;
+                    let max_decoding_message_size = self.max_decoding_message_size;
+                    let max_encoding_message_size = self.max_encoding_message_size;
+                    let inner = self.inner.clone();
+                    let fut = async move {
+                        let method = StreamCurrentTrackSvc(inner);
+                        let codec = tonic::codec::ProstCodec::default();
+                        let mut grpc = tonic::server::Grpc::new(codec)
+                            .apply_compression_config(
+                                accept_compression_encodings,
+                                send_compression_encodings,
+                            )
+                            .apply_max_message_size_config(
+                                max_decoding_message_size,
+                                max_encoding_message_size,
+                            );
+                        let res = grpc.server_streaming(method, req).await;
+                        Ok(res)
+                    };
+                    Box::pin(fut)
+                }
+                "/rockbox.v1alpha1.PlaybackService/StreamStatus" => {
+                    #[allow(non_camel_case_types)]
+                    struct StreamStatusSvc<T: PlaybackService>(pub Arc<T>);
+                    impl<
+                        T: PlaybackService,
+                    > tonic::server::ServerStreamingService<super::StreamStatusRequest>
+                    for StreamStatusSvc<T> {
+                        type Response = super::StatusResponse;
+                        type ResponseStream = T::StreamStatusStream;
+                        type Future = BoxFuture<
+                            tonic::Response<Self::ResponseStream>,
+                            tonic::Status,
+                        >;
+                        fn call(
+                            &mut self,
+                            request: tonic::Request<super::StreamStatusRequest>,
+                        ) -> Self::Future {
+                            let inner = Arc::clone(&self.0);
+                            let fut = async move {
+                                <T as PlaybackService>::stream_status(&inner, request).await
+                            };
+                            Box::pin(fut)
+                        }
+                    }
+                    let accept_compression_encodings = self.accept_compression_encodings;
+                    let send_compression_encodings = self.send_compression_encodings;
+                    let max_decoding_message_size = self.max_decoding_message_size;
+                    let max_encoding_message_size = self.max_encoding_message_size;
+                    let inner = self.inner.clone();
+                    let fut = async move {
+                        let method = StreamStatusSvc(inner);
+                        let codec = tonic::codec::ProstCodec::default();
+                        let mut grpc = tonic::server::Grpc::new(codec)
+                            .apply_compression_config(
+                                accept_compression_encodings,
+                                send_compression_encodings,
+                            )
+                            .apply_max_message_size_config(
+                                max_decoding_message_size,
+                                max_encoding_message_size,
+                            );
+                        let res = grpc.server_streaming(method, req).await;
+                        Ok(res)
+                    };
+                    Box::pin(fut)
+                }
+                "/rockbox.v1alpha1.PlaybackService/StreamPlaylist" => {
+                    #[allow(non_camel_case_types)]
+                    struct StreamPlaylistSvc<T: PlaybackService>(pub Arc<T>);
+                    impl<
+                        T: PlaybackService,
+                    > tonic::server::ServerStreamingService<super::StreamPlaylistRequest>
+                    for StreamPlaylistSvc<T> {
+                        type Response = super::PlaylistResponse;
+                        type ResponseStream = T::StreamPlaylistStream;
+                        type Future = BoxFuture<
+                            tonic::Response<Self::ResponseStream>,
+                            tonic::Status,
+                        >;
+                        fn call(
+                            &mut self,
+                            request: tonic::Request<super::StreamPlaylistRequest>,
+                        ) -> Self::Future {
+                            let inner = Arc::clone(&self.0);
+                            let fut = async move {
+                                <T as PlaybackService>::stream_playlist(&inner, request)
+                                    .await
+                            };
+                            Box::pin(fut)
+                        }
+                    }
+                    let accept_compression_encodings = self.accept_compression_encodings;
+                    let send_compression_encodings = self.send_compression_encodings;
+                    let max_decoding_message_size = self.max_decoding_message_size;
+                    let max_encoding_message_size = self.max_encoding_message_size;
+                    let inner = self.inner.clone();
+                    let fut = async move {
+                        let method = StreamPlaylistSvc(inner);
+                        let codec = tonic::codec::ProstCodec::default();
+                        let mut grpc = tonic::server::Grpc::new(codec)
+                            .apply_compression_config(
+                                accept_compression_encodings,
+                                send_compression_encodings,
+                            )
+                            .apply_max_message_size_config(
+                                max_decoding_message_size,
+                                max_encoding_message_size,
+                            );
+                        let res = grpc.server_streaming(method, req).await;
+                        Ok(res)
+                    };
+                    Box::pin(fut)
+                }
+                _ => {
+                    Box::pin(async move {
+                        let mut response = http::Response::new(empty_body());
+                        let headers = response.headers_mut();
+                        headers
+                            .insert(
+                                tonic::Status::GRPC_STATUS,
+                                (tonic::Code::Unimplemented as i32).into(),
+                            );
+                        headers
+                            .insert(
+                                http::header::CONTENT_TYPE,
+                                tonic::metadata::GRPC_CONTENT_TYPE,
+                            );
+                        Ok(response)
+                    })
+                }
+            }
+        }
+    }
+    impl<T> Clone for PlaybackServiceServer<T> {
+        fn clone(&self) -> Self {
+            let inner = self.inner.clone();
+            Self {
+                inner,
+                accept_compression_encodings: self.accept_compression_encodings,
+                send_compression_encodings: self.send_compression_encodings,
+                max_decoding_message_size: self.max_decoding_message_size,
+                max_encoding_message_size: self.max_encoding_message_size,
+            }
+        }
+    }
+    /// Generated gRPC service name
+    pub const SERVICE_NAME: &str = "rockbox.v1alpha1.PlaybackService";
+    impl<T> tonic::server::NamedService for PlaybackServiceServer<T> {
+        const NAME: &'static str = SERVICE_NAME;
+    }
+}
+#[derive(Clone, Copy, PartialEq, ::prost::Message)]
+pub struct GetCurrentRequest {}
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct GetCurrentResponse {
+    #[prost(int32, tag = "1")]
+    pub index: i32,
+    #[prost(int32, tag = "2")]
+    pub amount: i32,
+    #[prost(int32, tag = "3")]
+    pub max_playlist_size: i32,
+    #[prost(int32, tag = "4")]
+    pub first_index: i32,
+    #[prost(int32, tag = "5")]
+    pub last_insert_pos: i32,
+    #[prost(int32, tag = "6")]
+    pub seed: i32,
+    #[prost(int32, tag = "7")]
+    pub last_shuffled_start: i32,
+    #[prost(message, repeated, tag = "8")]
+    pub tracks: ::prost::alloc::vec::Vec<CurrentTrackResponse>,
+}
+#[derive(Clone, Copy, PartialEq, ::prost::Message)]
+pub struct GetResumeInfoRequest {}
+#[derive(Clone, Copy, PartialEq, ::prost::Message)]
+pub struct GetResumeInfoResponse {}
+#[derive(Clone, Copy, PartialEq, ::prost::Message)]
+pub struct GetTrackInfoRequest {}
+#[derive(Clone, Copy, PartialEq, ::prost::Message)]
+pub struct GetTrackInfoResponse {}
+#[derive(Clone, Copy, PartialEq, ::prost::Message)]
+pub struct GetFirstIndexRequest {}
+#[derive(Clone, Copy, PartialEq, ::prost::Message)]
+pub struct GetFirstIndexResponse {}
+#[derive(Clone, Copy, PartialEq, ::prost::Message)]
+pub struct GetDisplayIndexRequest {}
+#[derive(Clone, Copy, PartialEq, ::prost::Message)]
+pub struct GetDisplayIndexResponse {}
+#[derive(Clone, Copy, PartialEq, ::prost::Message)]
+pub struct AmountRequest {}
+#[derive(Clone, Copy, PartialEq, ::prost::Message)]
+pub struct AmountResponse {
+    #[prost(int32, tag = "1")]
+    pub amount: i32,
+}
+#[derive(Clone, Copy, PartialEq, ::prost::Message)]
+pub struct PlaylistResumeRequest {}
+#[derive(Clone, Copy, PartialEq, ::prost::Message)]
+pub struct PlaylistResumeResponse {
+    #[prost(int32, tag = "1")]
+    pub code: i32,
+}
+#[derive(Clone, Copy, PartialEq, ::prost::Message)]
+pub struct ResumeTrackRequest {
+    #[prost(int32, tag = "1")]
+    pub start_index: i32,
+    #[prost(uint32, tag = "2")]
+    pub crc: u32,
+    #[prost(uint64, tag = "3")]
+    pub elapsed: u64,
+    #[prost(uint64, tag = "4")]
+    pub offset: u64,
+}
+#[derive(Clone, Copy, PartialEq, ::prost::Message)]
+pub struct ResumeTrackResponse {}
+#[derive(Clone, Copy, PartialEq, ::prost::Message)]
+pub struct SetModifiedRequest {}
+#[derive(Clone, Copy, PartialEq, ::prost::Message)]
+pub struct SetModifiedResponse {}
+#[derive(Clone, Copy, PartialEq, ::prost::Message)]
+pub struct StartRequest {
+    #[prost(int32, optional, tag = "1")]
+    pub start_index: ::core::option::Option<i32>,
+    #[prost(int32, optional, tag = "2")]
+    pub elapsed: ::core::option::Option<i32>,
+    #[prost(int32, optional, tag = "3")]
+    pub offset: ::core::option::Option<i32>,
+}
+#[derive(Clone, Copy, PartialEq, ::prost::Message)]
+pub struct StartResponse {}
+#[derive(Clone, Copy, PartialEq, ::prost::Message)]
+pub struct SyncRequest {}
+#[derive(Clone, Copy, PartialEq, ::prost::Message)]
+pub struct SyncResponse {}
+#[derive(Clone, Copy, PartialEq, ::prost::Message)]
+pub struct RemoveAllTracksRequest {}
+#[derive(Clone, Copy, PartialEq, ::prost::Message)]
+pub struct RemoveAllTracksResponse {}
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct RemoveTracksRequest {
+    #[prost(int32, repeated, tag = "1")]
+    pub positions: ::prost::alloc::vec::Vec<i32>,
+}
+#[derive(Clone, Copy, PartialEq, ::prost::Message)]
+pub struct RemoveTracksResponse {}
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct CreatePlaylistRequest {
+    #[prost(string, tag = "1")]
+    pub name: ::prost::alloc::string::String,
+    #[prost(string, repeated, tag = "2")]
+    pub tracks: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
+    #[prost(string, optional, tag = "3")]
+    pub folder_id: ::core::option::Option<::prost::alloc::string::String>,
+}
+#[derive(Clone, Copy, PartialEq, ::prost::Message)]
+pub struct CreatePlaylistResponse {
+    #[prost(int32, tag = "1")]
+    pub start_index: i32,
+}
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct InsertTracksRequest {
+    #[prost(string, optional, tag = "1")]
+    pub playlist_id: ::core::option::Option<::prost::alloc::string::String>,
+    #[prost(int32, tag = "2")]
+    pub position: i32,
+    #[prost(string, repeated, tag = "3")]
+    pub tracks: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
+    #[prost(bool, optional, tag = "4")]
+    pub shuffle: ::core::option::Option<bool>,
+}
+#[derive(Clone, Copy, PartialEq, ::prost::Message)]
+pub struct InsertTracksResponse {}
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct InsertDirectoryRequest {
+    #[prost(string, optional, tag = "1")]
+    pub playlist_id: ::core::option::Option<::prost::alloc::string::String>,
+    #[prost(int32, tag = "2")]
+    pub position: i32,
+    #[prost(string, tag = "3")]
+    pub directory: ::prost::alloc::string::String,
+    #[prost(bool, optional, tag = "4")]
+    pub recurse: ::core::option::Option<bool>,
+    #[prost(bool, optional, tag = "5")]
+    pub shuffle: ::core::option::Option<bool>,
+}
+#[derive(Clone, Copy, PartialEq, ::prost::Message)]
+pub struct InsertDirectoryResponse {}
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct InsertPlaylistRequest {
+    #[prost(int32, tag = "1")]
+    pub position: i32,
+    #[prost(string, tag = "2")]
+    pub target_playlist_id: ::prost::alloc::string::String,
+    #[prost(string, tag = "3")]
+    pub playlist_id: ::prost::alloc::string::String,
+    #[prost(bool, optional, tag = "4")]
+    pub shuffle: ::core::option::Option<bool>,
+}
+#[derive(Clone, Copy, PartialEq, ::prost::Message)]
+pub struct InsertPlaylistResponse {}
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct InsertAlbumRequest {
+    #[prost(int32, tag = "1")]
+    pub position: i32,
+    #[prost(string, tag = "2")]
+    pub album_id: ::prost::alloc::string::String,
+    #[prost(bool, optional, tag = "3")]
+    pub shuffle: ::core::option::Option<bool>,
+}
+#[derive(Clone, Copy, PartialEq, ::prost::Message)]
+pub struct InsertAlbumResponse {}
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct InsertArtistTracksRequest {
+    #[prost(int32, tag = "1")]
+    pub position: i32,
+    #[prost(string, tag = "2")]
+    pub artist_id: ::prost::alloc::string::String,
+    #[prost(bool, optional, tag = "3")]
+    pub shuffle: ::core::option::Option<bool>,
+}
+#[derive(Clone, Copy, PartialEq, ::prost::Message)]
+pub struct InsertArtistTracksResponse {}
+#[derive(Clone, Copy, PartialEq, ::prost::Message)]
+pub struct ShufflePlaylistRequest {
+    #[prost(int32, tag = "1")]
+    pub start_index: i32,
+}
+#[derive(Clone, Copy, PartialEq, ::prost::Message)]
+pub struct ShufflePlaylistResponse {}
+/// Generated client implementations.
+pub mod playlist_service_client {
+    #![allow(
+        unused_variables,
+        dead_code,
+        missing_docs,
+        clippy::wildcard_imports,
+        clippy::let_unit_value,
+    )]
+    use tonic::codegen::*;
+    use tonic::codegen::http::Uri;
+    #[derive(Debug, Clone)]
+    pub struct PlaylistServiceClient<T> {
+        inner: tonic::client::Grpc<T>,
+    }
+    impl PlaylistServiceClient<tonic::transport::Channel> {
+        /// Attempt to create a new client by connecting to a given endpoint.
+        pub async fn connect<D>(dst: D) -> Result<Self, tonic::transport::Error>
+        where
+            D: TryInto<tonic::transport::Endpoint>,
+            D::Error: Into<StdError>,
+        {
+            let conn = tonic::transport::Endpoint::new(dst)?.connect().await?;
+            Ok(Self::new(conn))
+        }
+    }
+    impl<T> PlaylistServiceClient<T>
+    where
+        T: tonic::client::GrpcService<tonic::body::BoxBody>,
+        T::Error: Into<StdError>,
+        T::ResponseBody: Body<Data = Bytes> + std::marker::Send + 'static,
+        <T::ResponseBody as Body>::Error: Into<StdError> + std::marker::Send,
+    {
+        pub fn new(inner: T) -> Self {
+            let inner = tonic::client::Grpc::new(inner);
+            Self { inner }
+        }
+        pub fn with_origin(inner: T, origin: Uri) -> Self {
+            let inner = tonic::client::Grpc::with_origin(inner, origin);
+            Self { inner }
+        }
+        pub fn with_interceptor<F>(
+            inner: T,
+            interceptor: F,
+        ) -> PlaylistServiceClient<InterceptedService<T, F>>
+        where
+            F: tonic::service::Interceptor,
+            T::ResponseBody: Default,
+            T: tonic::codegen::Service<
+                http::Request<tonic::body::BoxBody>,
+                Response = http::Response<
+                    <T as tonic::client::GrpcService<tonic::body::BoxBody>>::ResponseBody,
+                >,
+            >,
+            <T as tonic::codegen::Service<
+                http::Request<tonic::body::BoxBody>,
+            >>::Error: Into<StdError> + std::marker::Send + std::marker::Sync,
+        {
+            PlaylistServiceClient::new(InterceptedService::new(inner, interceptor))
+        }
+        /// Compress requests with the given encoding.
+        ///
+        /// This requires the server to support it otherwise it might respond with an
+        /// error.
+        #[must_use]
+        pub fn send_compressed(mut self, encoding: CompressionEncoding) -> Self {
+            self.inner = self.inner.send_compressed(encoding);
+            self
+        }
+        /// Enable decompressing responses.
+        #[must_use]
+        pub fn accept_compressed(mut self, encoding: CompressionEncoding) -> Self {
+            self.inner = self.inner.accept_compressed(encoding);
+            self
+        }
+        /// Limits the maximum size of a decoded message.
+        ///
+        /// Default: `4MB`
+        #[must_use]
+        pub fn max_decoding_message_size(mut self, limit: usize) -> Self {
+            self.inner = self.inner.max_decoding_message_size(limit);
+            self
+        }
+        /// Limits the maximum size of an encoded message.
+        ///
+        /// Default: `usize::MAX`
+        #[must_use]
+        pub fn max_encoding_message_size(mut self, limit: usize) -> Self {
+            self.inner = self.inner.max_encoding_message_size(limit);
+            self
+        }
+        pub async fn get_current(
+            &mut self,
+            request: impl tonic::IntoRequest<super::GetCurrentRequest>,
+        ) -> std::result::Result<
+            tonic::Response<super::GetCurrentResponse>,
+            tonic::Status,
+        > {
+            self.inner
+                .ready()
+                .await
+                .map_err(|e| {
+                    tonic::Status::unknown(
+                        format!("Service was not ready: {}", e.into()),
+                    )
+                })?;
+            let codec = tonic::codec::ProstCodec::default();
+            let path = http::uri::PathAndQuery::from_static(
+                "/rockbox.v1alpha1.PlaylistService/GetCurrent",
+            );
+            let mut req = request.into_request();
+            req.extensions_mut()
+                .insert(
+                    GrpcMethod::new("rockbox.v1alpha1.PlaylistService", "GetCurrent"),
+                );
+            self.inner.unary(req, path, codec).await
+        }
+        pub async fn get_resume_info(
+            &mut self,
+            request: impl tonic::IntoRequest<super::GetResumeInfoRequest>,
+        ) -> std::result::Result<
+            tonic::Response<super::GetResumeInfoResponse>,
+            tonic::Status,
+        > {
+            self.inner
+                .ready()
+                .await
+                .map_err(|e| {
+                    tonic::Status::unknown(
+                        format!("Service was not ready: {}", e.into()),
+                    )
+                })?;
+            let codec = tonic::codec::ProstCodec::default();
+            let path = http::uri::PathAndQuery::from_static(
+                "/rockbox.v1alpha1.PlaylistService/GetResumeInfo",
+            );
+            let mut req = request.into_request();
+            req.extensions_mut()
+                .insert(
+                    GrpcMethod::new("rockbox.v1alpha1.PlaylistService", "GetResumeInfo"),
+                );
+            self.inner.unary(req, path, codec).await
+        }
+        pub async fn get_track_info(
+            &mut self,
+            request: impl tonic::IntoRequest<super::GetTrackInfoRequest>,
+        ) -> std::result::Result<
+            tonic::Response<super::GetTrackInfoResponse>,
+            tonic::Status,
+        > {
+            self.inner
+                .ready()
+                .await
+                .map_err(|e| {
+                    tonic::Status::unknown(
+                        format!("Service was not ready: {}", e.into()),
+                    )
+                })?;
+            let codec = tonic::codec::ProstCodec::default();
+            let path = http::uri::PathAndQuery::from_static(
+                "/rockbox.v1alpha1.PlaylistService/GetTrackInfo",
+            );
+            let mut req = request.into_request();
+            req.extensions_mut()
+                .insert(
+                    GrpcMethod::new("rockbox.v1alpha1.PlaylistService", "GetTrackInfo"),
+                );
+            self.inner.unary(req, path, codec).await
+        }
+        pub async fn get_first_index(
+            &mut self,
+            request: impl tonic::IntoRequest<super::GetFirstIndexRequest>,
+        ) -> std::result::Result<
+            tonic::Response<super::GetFirstIndexResponse>,
+            tonic::Status,
+        > {
+            self.inner
+                .ready()
+                .await
+                .map_err(|e| {
+                    tonic::Status::unknown(
+                        format!("Service was not ready: {}", e.into()),
+                    )
+                })?;
+            let codec = tonic::codec::ProstCodec::default();
+            let path = http::uri::PathAndQuery::from_static(
+                "/rockbox.v1alpha1.PlaylistService/GetFirstIndex",
+            );
+            let mut req = request.into_request();
+            req.extensions_mut()
+                .insert(
+                    GrpcMethod::new("rockbox.v1alpha1.PlaylistService", "GetFirstIndex"),
+                );
+            self.inner.unary(req, path, codec).await
+        }
+        pub async fn get_display_index(
+            &mut self,
+            request: impl tonic::IntoRequest<super::GetDisplayIndexRequest>,
+        ) -> std::result::Result<
+            tonic::Response<super::GetDisplayIndexResponse>,
+            tonic::Status,
+        > {
+            self.inner
+                .ready()
+                .await
+                .map_err(|e| {
+                    tonic::Status::unknown(
+                        format!("Service was not ready: {}", e.into()),
+                    )
+                })?;
+            let codec = tonic::codec::ProstCodec::default();
+            let path = http::uri::PathAndQuery::from_static(
+                "/rockbox.v1alpha1.PlaylistService/GetDisplayIndex",
+            );
+            let mut req = request.into_request();
+            req.extensions_mut()
+                .insert(
+                    GrpcMethod::new(
+                        "rockbox.v1alpha1.PlaylistService",
+                        "GetDisplayIndex",
+                    ),
+                );
+            self.inner.unary(req, path, codec).await
+        }
+        pub async fn amount(
+            &mut self,
+            request: impl tonic::IntoRequest<super::AmountRequest>,
+        ) -> std::result::Result<tonic::Response<super::AmountResponse>, tonic::Status> {
+            self.inner
+                .ready()
+                .await
+                .map_err(|e| {
+                    tonic::Status::unknown(
+                        format!("Service was not ready: {}", e.into()),
+                    )
+                })?;
+            let codec = tonic::codec::ProstCodec::default();
+            let path = http::uri::PathAndQuery::from_static(
+                "/rockbox.v1alpha1.PlaylistService/Amount",
+            );
+            let mut req = request.into_request();
+            req.extensions_mut()
+                .insert(GrpcMethod::new("rockbox.v1alpha1.PlaylistService", "Amount"));
+            self.inner.unary(req, path, codec).await
+        }
+        pub async fn playlist_resume(
+            &mut self,
+            request: impl tonic::IntoRequest<super::PlaylistResumeRequest>,
+        ) -> std::result::Result<
+            tonic::Response<super::PlaylistResumeResponse>,
+            tonic::Status,
+        > {
+            self.inner
+                .ready()
+                .await
+                .map_err(|e| {
+                    tonic::Status::unknown(
+                        format!("Service was not ready: {}", e.into()),
+                    )
+                })?;
+            let codec = tonic::codec::ProstCodec::default();
+            let path = http::uri::PathAndQuery::from_static(
+                "/rockbox.v1alpha1.PlaylistService/PlaylistResume",
+            );
+            let mut req = request.into_request();
+            req.extensions_mut()
+                .insert(
+                    GrpcMethod::new("rockbox.v1alpha1.PlaylistService", "PlaylistResume"),
+                );
+            self.inner.unary(req, path, codec).await
+        }
+        pub async fn resume_track(
+            &mut self,
+            request: impl tonic::IntoRequest<super::ResumeTrackRequest>,
+        ) -> std::result::Result<
+            tonic::Response<super::ResumeTrackResponse>,
+            tonic::Status,
+        > {
+            self.inner
+                .ready()
+                .await
+                .map_err(|e| {
+                    tonic::Status::unknown(
+                        format!("Service was not ready: {}", e.into()),
+                    )
+                })?;
+            let codec = tonic::codec::ProstCodec::default();
+            let path = http::uri::PathAndQuery::from_static(
+                "/rockbox.v1alpha1.PlaylistService/ResumeTrack",
+            );
+            let mut req = request.into_request();
+            req.extensions_mut()
+                .insert(
+                    GrpcMethod::new("rockbox.v1alpha1.PlaylistService", "ResumeTrack"),
+                );
+            self.inner.unary(req, path, codec).await
+        }
+        pub async fn set_modified(
+            &mut self,
+            request: impl tonic::IntoRequest<super::SetModifiedRequest>,
+        ) -> std::result::Result<
+            tonic::Response<super::SetModifiedResponse>,
+            tonic::Status,
+        > {
+            self.inner
+                .ready()
+                .await
+                .map_err(|e| {
+                    tonic::Status::unknown(
+                        format!("Service was not ready: {}", e.into()),
+                    )
+                })?;
+            let codec = tonic::codec::ProstCodec::default();
+            let path = http::uri::PathAndQuery::from_static(
+                "/rockbox.v1alpha1.PlaylistService/SetModified",
+            );
+            let mut req = request.into_request();
+            req.extensions_mut()
+                .insert(
+                    GrpcMethod::new("rockbox.v1alpha1.PlaylistService", "SetModified"),
+                );
+            self.inner.unary(req, path, codec).await
+        }
+        pub async fn start(
+            &mut self,
+            request: impl tonic::IntoRequest<super::StartRequest>,
+        ) -> std::result::Result<tonic::Response<super::StartResponse>, tonic::Status> {
+            self.inner
+                .ready()
+                .await
+                .map_err(|e| {
+                    tonic::Status::unknown(
+                        format!("Service was not ready: {}", e.into()),
+                    )
+                })?;
+            let codec = tonic::codec::ProstCodec::default();
+            let path = http::uri::PathAndQuery::from_static(
+                "/rockbox.v1alpha1.PlaylistService/Start",
+            );
+            let mut req = request.into_request();
+            req.extensions_mut()
+                .insert(GrpcMethod::new("rockbox.v1alpha1.PlaylistService", "Start"));
+            self.inner.unary(req, path, codec).await
+        }
+        pub async fn sync(
+            &mut self,
+            request: impl tonic::IntoRequest<super::SyncRequest>,
+        ) -> std::result::Result<tonic::Response<super::SyncResponse>, tonic::Status> {
+            self.inner
+                .ready()
+                .await
+                .map_err(|e| {
+                    tonic::Status::unknown(
+                        format!("Service was not ready: {}", e.into()),
+                    )
+                })?;
+            let codec = tonic::codec::ProstCodec::default();
+            let path = http::uri::PathAndQuery::from_static(
+                "/rockbox.v1alpha1.PlaylistService/Sync",
+            );
+            let mut req = request.into_request();
+            req.extensions_mut()
+                .insert(GrpcMethod::new("rockbox.v1alpha1.PlaylistService", "Sync"));
+            self.inner.unary(req, path, codec).await
+        }
+        pub async fn remove_all_tracks(
+            &mut self,
+            request: impl tonic::IntoRequest<super::RemoveAllTracksRequest>,
+        ) -> std::result::Result<
+            tonic::Response<super::RemoveAllTracksResponse>,
+            tonic::Status,
+        > {
+            self.inner
+                .ready()
+                .await
+                .map_err(|e| {
+                    tonic::Status::unknown(
+                        format!("Service was not ready: {}", e.into()),
+                    )
+                })?;
+            let codec = tonic::codec::ProstCodec::default();
+            let path = http::uri::PathAndQuery::from_static(
+                "/rockbox.v1alpha1.PlaylistService/RemoveAllTracks",
+            );
+            let mut req = request.into_request();
+            req.extensions_mut()
+                .insert(
+                    GrpcMethod::new(
+                        "rockbox.v1alpha1.PlaylistService",
+                        "RemoveAllTracks",
+                    ),
+                );
+            self.inner.unary(req, path, codec).await
+        }
+        pub async fn remove_tracks(
+            &mut self,
+            request: impl tonic::IntoRequest<super::RemoveTracksRequest>,
+        ) -> std::result::Result<
+            tonic::Response<super::RemoveTracksResponse>,
+            tonic::Status,
+        > {
+            self.inner
+                .ready()
+                .await
+                .map_err(|e| {
+                    tonic::Status::unknown(
+                        format!("Service was not ready: {}", e.into()),
+                    )
+                })?;
+            let codec = tonic::codec::ProstCodec::default();
+            let path = http::uri::PathAndQuery::from_static(
+                "/rockbox.v1alpha1.PlaylistService/RemoveTracks",
+            );
+            let mut req = request.into_request();
+            req.extensions_mut()
+                .insert(
+                    GrpcMethod::new("rockbox.v1alpha1.PlaylistService", "RemoveTracks"),
+                );
+            self.inner.unary(req, path, codec).await
+        }
+        pub async fn create_playlist(
+            &mut self,
+            request: impl tonic::IntoRequest<super::CreatePlaylistRequest>,
+        ) -> std::result::Result<
+            tonic::Response<super::CreatePlaylistResponse>,
+            tonic::Status,
+        > {
+            self.inner
+                .ready()
+                .await
+                .map_err(|e| {
+                    tonic::Status::unknown(
+                        format!("Service was not ready: {}", e.into()),
+                    )
+                })?;
+            let codec = tonic::codec::ProstCodec::default();
+            let path = http::uri::PathAndQuery::from_static(
+                "/rockbox.v1alpha1.PlaylistService/CreatePlaylist",
+            );
+            let mut req = request.into_request();
+            req.extensions_mut()
+                .insert(
+                    GrpcMethod::new("rockbox.v1alpha1.PlaylistService", "CreatePlaylist"),
+                );
+            self.inner.unary(req, path, codec).await
+        }
+        pub async fn insert_tracks(
+            &mut self,
+            request: impl tonic::IntoRequest<super::InsertTracksRequest>,
+        ) -> std::result::Result<
+            tonic::Response<super::InsertTracksResponse>,
+            tonic::Status,
+        > {
+            self.inner
+                .ready()
+                .await
+                .map_err(|e| {
+                    tonic::Status::unknown(
+                        format!("Service was not ready: {}", e.into()),
+                    )
+                })?;
+            let codec = tonic::codec::ProstCodec::default();
+            let path = http::uri::PathAndQuery::from_static(
+                "/rockbox.v1alpha1.PlaylistService/InsertTracks",
+            );
+            let mut req = request.into_request();
+            req.extensions_mut()
+                .insert(
+                    GrpcMethod::new("rockbox.v1alpha1.PlaylistService", "InsertTracks"),
+                );
+            self.inner.unary(req, path, codec).await
+        }
+        pub async fn insert_directory(
+            &mut self,
+            request: impl tonic::IntoRequest<super::InsertDirectoryRequest>,
+        ) -> std::result::Result<
+            tonic::Response<super::InsertDirectoryResponse>,
+            tonic::Status,
+        > {
+            self.inner
+                .ready()
+                .await
+                .map_err(|e| {
+                    tonic::Status::unknown(
+                        format!("Service was not ready: {}", e.into()),
+                    )
+                })?;
+            let codec = tonic::codec::ProstCodec::default();
+            let path = http::uri::PathAndQuery::from_static(
+                "/rockbox.v1alpha1.PlaylistService/InsertDirectory",
+            );
+            let mut req = request.into_request();
+            req.extensions_mut()
+                .insert(
+                    GrpcMethod::new(
+                        "rockbox.v1alpha1.PlaylistService",
+                        "InsertDirectory",
+                    ),
+                );
+            self.inner.unary(req, path, codec).await
+        }
+        pub async fn insert_playlist(
+            &mut self,
+            request: impl tonic::IntoRequest<super::InsertPlaylistRequest>,
+        ) -> std::result::Result<
+            tonic::Response<super::InsertPlaylistResponse>,
+            tonic::Status,
+        > {
+            self.inner
+                .ready()
+                .await
+                .map_err(|e| {
+                    tonic::Status::unknown(
+                        format!("Service was not ready: {}", e.into()),
+                    )
+                })?;
+            let codec = tonic::codec::ProstCodec::default();
+            let path = http::uri::PathAndQuery::from_static(
+                "/rockbox.v1alpha1.PlaylistService/InsertPlaylist",
+            );
+            let mut req = request.into_request();
+            req.extensions_mut()
+                .insert(
+                    GrpcMethod::new("rockbox.v1alpha1.PlaylistService", "InsertPlaylist"),
+                );
+            self.inner.unary(req, path, codec).await
+        }
+        pub async fn insert_album(
+            &mut self,
+            request: impl tonic::IntoRequest<super::InsertAlbumRequest>,
+        ) -> std::result::Result<
+            tonic::Response<super::InsertAlbumResponse>,
+            tonic::Status,
+        > {
+            self.inner
+                .ready()
+                .await
+                .map_err(|e| {
+                    tonic::Status::unknown(
+                        format!("Service was not ready: {}", e.into()),
+                    )
+                })?;
+            let codec = tonic::codec::ProstCodec::default();
+            let path = http::uri::PathAndQuery::from_static(
+                "/rockbox.v1alpha1.PlaylistService/InsertAlbum",
+            );
+            let mut req = request.into_request();
+            req.extensions_mut()
+                .insert(
+                    GrpcMethod::new("rockbox.v1alpha1.PlaylistService", "InsertAlbum"),
+                );
+            self.inner.unary(req, path, codec).await
+        }
+        pub async fn insert_artist_tracks(
+            &mut self,
+            request: impl tonic::IntoRequest<super::InsertArtistTracksRequest>,
+        ) -> std::result::Result<
+            tonic::Response<super::InsertArtistTracksResponse>,
+            tonic::Status,
+        > {
+            self.inner
+                .ready()
+                .await
+                .map_err(|e| {
+                    tonic::Status::unknown(
+                        format!("Service was not ready: {}", e.into()),
+                    )
+                })?;
+            let codec = tonic::codec::ProstCodec::default();
+            let path = http::uri::PathAndQuery::from_static(
+                "/rockbox.v1alpha1.PlaylistService/InsertArtistTracks",
+            );
+            let mut req = request.into_request();
+            req.extensions_mut()
+                .insert(
+                    GrpcMethod::new(
+                        "rockbox.v1alpha1.PlaylistService",
+                        "InsertArtistTracks",
+                    ),
+                );
+            self.inner.unary(req, path, codec).await
+        }
+        pub async fn shuffle_playlist(
+            &mut self,
+            request: impl tonic::IntoRequest<super::ShufflePlaylistRequest>,
+        ) -> std::result::Result<
+            tonic::Response<super::ShufflePlaylistResponse>,
+            tonic::Status,
+        > {
+            self.inner
+                .ready()
+                .await
+                .map_err(|e| {
+                    tonic::Status::unknown(
+                        format!("Service was not ready: {}", e.into()),
+                    )
+                })?;
+            let codec = tonic::codec::ProstCodec::default();
+            let path = http::uri::PathAndQuery::from_static(
+                "/rockbox.v1alpha1.PlaylistService/ShufflePlaylist",
+            );
+            let mut req = request.into_request();
+            req.extensions_mut()
+                .insert(
+                    GrpcMethod::new(
+                        "rockbox.v1alpha1.PlaylistService",
+                        "ShufflePlaylist",
+                    ),
+                );
+            self.inner.unary(req, path, codec).await
+        }
+    }
+}
+/// Generated server implementations.
+pub mod playlist_service_server {
+    #![allow(
+        unused_variables,
+        dead_code,
+        missing_docs,
+        clippy::wildcard_imports,
+        clippy::let_unit_value,
+    )]
+    use tonic::codegen::*;
+    /// Generated trait containing gRPC methods that should be implemented for use with PlaylistServiceServer.
+    #[async_trait]
+    pub trait PlaylistService: std::marker::Send + std::marker::Sync + 'static {
+        async fn get_current(
+            &self,
+            request: tonic::Request<super::GetCurrentRequest>,
+        ) -> std::result::Result<
+            tonic::Response<super::GetCurrentResponse>,
+            tonic::Status,
+        >;
+        async fn get_resume_info(
+            &self,
+            request: tonic::Request<super::GetResumeInfoRequest>,
+        ) -> std::result::Result<
+            tonic::Response<super::GetResumeInfoResponse>,
+            tonic::Status,
+        >;
+        async fn get_track_info(
+            &self,
+            request: tonic::Request<super::GetTrackInfoRequest>,
+        ) -> std::result::Result<
+            tonic::Response<super::GetTrackInfoResponse>,
+            tonic::Status,
+        >;
+        async fn get_first_index(
+            &self,
+            request: tonic::Request<super::GetFirstIndexRequest>,
+        ) -> std::result::Result<
+            tonic::Response<super::GetFirstIndexResponse>,
+            tonic::Status,
+        >;
+        async fn get_display_index(
+            &self,
+            request: tonic::Request<super::GetDisplayIndexRequest>,
+        ) -> std::result::Result<
+            tonic::Response<super::GetDisplayIndexResponse>,
+            tonic::Status,
+        >;
+        async fn amount(
+            &self,
+            request: tonic::Request<super::AmountRequest>,
+        ) -> std::result::Result<tonic::Response<super::AmountResponse>, tonic::Status>;
+        async fn playlist_resume(
+            &self,
+            request: tonic::Request<super::PlaylistResumeRequest>,
+        ) -> std::result::Result<
+            tonic::Response<super::PlaylistResumeResponse>,
+            tonic::Status,
+        >;
+        async fn resume_track(
+            &self,
+            request: tonic::Request<super::ResumeTrackRequest>,
+        ) -> std::result::Result<
+            tonic::Response<super::ResumeTrackResponse>,
+            tonic::Status,
+        >;
+        async fn set_modified(
+            &self,
+            request: tonic::Request<super::SetModifiedRequest>,
+        ) -> std::result::Result<
+            tonic::Response<super::SetModifiedResponse>,
+            tonic::Status,
+        >;
+        async fn start(
+            &self,
+            request: tonic::Request<super::StartRequest>,
+        ) -> std::result::Result<tonic::Response<super::StartResponse>, tonic::Status>;
+        async fn sync(
+            &self,
+            request: tonic::Request<super::SyncRequest>,
+        ) -> std::result::Result<tonic::Response<super::SyncResponse>, tonic::Status>;
+        async fn remove_all_tracks(
+            &self,
+            request: tonic::Request<super::RemoveAllTracksRequest>,
+        ) -> std::result::Result<
+            tonic::Response<super::RemoveAllTracksResponse>,
+            tonic::Status,
+        >;
+        async fn remove_tracks(
+            &self,
+            request: tonic::Request<super::RemoveTracksRequest>,
+        ) -> std::result::Result<
+            tonic::Response<super::RemoveTracksResponse>,
+            tonic::Status,
+        >;
+        async fn create_playlist(
+            &self,
+            request: tonic::Request<super::CreatePlaylistRequest>,
+        ) -> std::result::Result<
+            tonic::Response<super::CreatePlaylistResponse>,
+            tonic::Status,
+        >;
+        async fn insert_tracks(
+            &self,
+            request: tonic::Request<super::InsertTracksRequest>,
+        ) -> std::result::Result<
+            tonic::Response<super::InsertTracksResponse>,
+            tonic::Status,
+        >;
+        async fn insert_directory(
+            &self,
+            request: tonic::Request<super::InsertDirectoryRequest>,
+        ) -> std::result::Result<
+            tonic::Response<super::InsertDirectoryResponse>,
+            tonic::Status,
+        >;
+        async fn insert_playlist(
+            &self,
+            request: tonic::Request<super::InsertPlaylistRequest>,
+        ) -> std::result::Result<
+            tonic::Response<super::InsertPlaylistResponse>,
+            tonic::Status,
+        >;
+        async fn insert_album(
+            &self,
+            request: tonic::Request<super::InsertAlbumRequest>,
+        ) -> std::result::Result<
+            tonic::Response<super::InsertAlbumResponse>,
+            tonic::Status,
+        >;
+        async fn insert_artist_tracks(
+            &self,
+            request: tonic::Request<super::InsertArtistTracksRequest>,
+        ) -> std::result::Result<
+            tonic::Response<super::InsertArtistTracksResponse>,
+            tonic::Status,
+        >;
+        async fn shuffle_playlist(
+            &self,
+            request: tonic::Request<super::ShufflePlaylistRequest>,
+        ) -> std::result::Result<
+            tonic::Response<super::ShufflePlaylistResponse>,
+            tonic::Status,
+        >;
+    }
+    #[derive(Debug)]
+    pub struct PlaylistServiceServer<T> {
+        inner: Arc<T>,
+        accept_compression_encodings: EnabledCompressionEncodings,
+        send_compression_encodings: EnabledCompressionEncodings,
+        max_decoding_message_size: Option<usize>,
+        max_encoding_message_size: Option<usize>,
+    }
+    impl<T> PlaylistServiceServer<T> {
+        pub fn new(inner: T) -> Self {
+            Self::from_arc(Arc::new(inner))
+        }
+        pub fn from_arc(inner: Arc<T>) -> Self {
+            Self {
+                inner,
+                accept_compression_encodings: Default::default(),
+                send_compression_encodings: Default::default(),
+                max_decoding_message_size: None,
+                max_encoding_message_size: None,
+            }
+        }
+        pub fn with_interceptor<F>(
+            inner: T,
+            interceptor: F,
+        ) -> InterceptedService<Self, F>
+        where
+            F: tonic::service::Interceptor,
+        {
+            InterceptedService::new(Self::new(inner), interceptor)
+        }
+        /// Enable decompressing requests with the given encoding.
+        #[must_use]
+        pub fn accept_compressed(mut self, encoding: CompressionEncoding) -> Self {
+            self.accept_compression_encodings.enable(encoding);
+            self
+        }
+        /// Compress responses with the given encoding, if the client supports it.
+        #[must_use]
+        pub fn send_compressed(mut self, encoding: CompressionEncoding) -> Self {
+            self.send_compression_encodings.enable(encoding);
+            self
+        }
+        /// Limits the maximum size of a decoded message.
+        ///
+        /// Default: `4MB`
+        #[must_use]
+        pub fn max_decoding_message_size(mut self, limit: usize) -> Self {
+            self.max_decoding_message_size = Some(limit);
+            self
+        }
+        /// Limits the maximum size of an encoded message.
+        ///
+        /// Default: `usize::MAX`
+        #[must_use]
+        pub fn max_encoding_message_size(mut self, limit: usize) -> Self {
+            self.max_encoding_message_size = Some(limit);
+            self
+        }
+    }
+    impl<T, B> tonic::codegen::Service<http::Request<B>> for PlaylistServiceServer<T>
+    where
+        T: PlaylistService,
+        B: Body + std::marker::Send + 'static,
+        B::Error: Into<StdError> + std::marker::Send + 'static,
+    {
+        type Response = http::Response<tonic::body::BoxBody>;
+        type Error = std::convert::Infallible;
+        type Future = BoxFuture<Self::Response, Self::Error>;
+        fn poll_ready(
+            &mut self,
+            _cx: &mut Context<'_>,
+        ) -> Poll<std::result::Result<(), Self::Error>> {
+            Poll::Ready(Ok(()))
+        }
+        fn call(&mut self, req: http::Request<B>) -> Self::Future {
+            match req.uri().path() {
+                "/rockbox.v1alpha1.PlaylistService/GetCurrent" => {
+                    #[allow(non_camel_case_types)]
+                    struct GetCurrentSvc<T: PlaylistService>(pub Arc<T>);
+                    impl<
+                        T: PlaylistService,
+                    > tonic::server::UnaryService<super::GetCurrentRequest>
+                    for GetCurrentSvc<T> {
+                        type Response = super::GetCurrentResponse;
+                        type Future = BoxFuture<
+                            tonic::Response<Self::Response>,
+                            tonic::Status,
+                        >;
+                        fn call(
+                            &mut self,
+                            request: tonic::Request<super::GetCurrentRequest>,
+                        ) -> Self::Future {
+                            let inner = Arc::clone(&self.0);
+                            let fut = async move {
+                                <T as PlaylistService>::get_current(&inner, request).await
+                            };
+                            Box::pin(fut)
+                        }
+                    }
+                    let accept_compression_encodings = self.accept_compression_encodings;
+                    let send_compression_encodings = self.send_compression_encodings;
+                    let max_decoding_message_size = self.max_decoding_message_size;
+                    let max_encoding_message_size = self.max_encoding_message_size;
+                    let inner = self.inner.clone();
+                    let fut = async move {
+                        let method = GetCurrentSvc(inner);
+                        let codec = tonic::codec::ProstCodec::default();
+                        let mut grpc = tonic::server::Grpc::new(codec)
+                            .apply_compression_config(
+                                accept_compression_encodings,
+                                send_compression_encodings,
+                            )
+                            .apply_max_message_size_config(
+                                max_decoding_message_size,
+                                max_encoding_message_size,
+                            );
+                        let res = grpc.unary(method, req).await;
+                        Ok(res)
+                    };
+                    Box::pin(fut)
+                }
+                "/rockbox.v1alpha1.PlaylistService/GetResumeInfo" => {
+                    #[allow(non_camel_case_types)]
+                    struct GetResumeInfoSvc<T: PlaylistService>(pub Arc<T>);
+                    impl<
+                        T: PlaylistService,
+                    > tonic::server::UnaryService<super::GetResumeInfoRequest>
+                    for GetResumeInfoSvc<T> {
+                        type Response = super::GetResumeInfoResponse;
+                        type Future = BoxFuture<
+                            tonic::Response<Self::Response>,
+                            tonic::Status,
+                        >;
+                        fn call(
+                            &mut self,
+                            request: tonic::Request<super::GetResumeInfoRequest>,
+                        ) -> Self::Future {
+                            let inner = Arc::clone(&self.0);
+                            let fut = async move {
+                                <T as PlaylistService>::get_resume_info(&inner, request)
+                                    .await
+                            };
+                            Box::pin(fut)
+                        }
+                    }
+                    let accept_compression_encodings = self.accept_compression_encodings;
+                    let send_compression_encodings = self.send_compression_encodings;
+                    let max_decoding_message_size = self.max_decoding_message_size;
+                    let max_encoding_message_size = self.max_encoding_message_size;
+                    let inner = self.inner.clone();
+                    let fut = async move {
+                        let method = GetResumeInfoSvc(inner);
+                        let codec = tonic::codec::ProstCodec::default();
+                        let mut grpc = tonic::server::Grpc::new(codec)
+                            .apply_compression_config(
+                                accept_compression_encodings,
+                                send_compression_encodings,
+                            )
+                            .apply_max_message_size_config(
+                                max_decoding_message_size,
+                                max_encoding_message_size,
+                            );
+                        let res = grpc.unary(method, req).await;
+                        Ok(res)
+                    };
+                    Box::pin(fut)
+                }
+                "/rockbox.v1alpha1.PlaylistService/GetTrackInfo" => {
+                    #[allow(non_camel_case_types)]
+                    struct GetTrackInfoSvc<T: PlaylistService>(pub Arc<T>);
+                    impl<
+                        T: PlaylistService,
+                    > tonic::server::UnaryService<super::GetTrackInfoRequest>
+                    for GetTrackInfoSvc<T> {
+                        type Response = super::GetTrackInfoResponse;
+                        type Future = BoxFuture<
+                            tonic::Response<Self::Response>,
+                            tonic::Status,
+                        >;
+                        fn call(
+                            &mut self,
+                            request: tonic::Request<super::GetTrackInfoRequest>,
+                        ) -> Self::Future {
+                            let inner = Arc::clone(&self.0);
+                            let fut = async move {
+                                <T as PlaylistService>::get_track_info(&inner, request)
+                                    .await
+                            };
+                            Box::pin(fut)
+                        }
+                    }
+                    let accept_compression_encodings = self.accept_compression_encodings;
+                    let send_compression_encodings = self.send_compression_encodings;
+                    let max_decoding_message_size = self.max_decoding_message_size;
+                    let max_encoding_message_size = self.max_encoding_message_size;
+                    let inner = self.inner.clone();
+                    let fut = async move {
+                        let method = GetTrackInfoSvc(inner);
+                        let codec = tonic::codec::ProstCodec::default();
+                        let mut grpc = tonic::server::Grpc::new(codec)
+                            .apply_compression_config(
+                                accept_compression_encodings,
+                                send_compression_encodings,
+                            )
+                            .apply_max_message_size_config(
+                                max_decoding_message_size,
+                                max_encoding_message_size,
+                            );
+                        let res = grpc.unary(method, req).await;
+                        Ok(res)
+                    };
+                    Box::pin(fut)
+                }
+                "/rockbox.v1alpha1.PlaylistService/GetFirstIndex" => {
+                    #[allow(non_camel_case_types)]
+                    struct GetFirstIndexSvc<T: PlaylistService>(pub Arc<T>);
+                    impl<
+                        T: PlaylistService,
+                    > tonic::server::UnaryService<super::GetFirstIndexRequest>
+                    for GetFirstIndexSvc<T> {
+                        type Response = super::GetFirstIndexResponse;
+                        type Future = BoxFuture<
+                            tonic::Response<Self::Response>,
+                            tonic::Status,
+                        >;
+                        fn call(
+                            &mut self,
+                            request: tonic::Request<super::GetFirstIndexRequest>,
+                        ) -> Self::Future {
+                            let inner = Arc::clone(&self.0);
+                            let fut = async move {
+                                <T as PlaylistService>::get_first_index(&inner, request)
+                                    .await
+                            };
+                            Box::pin(fut)
+                        }
+                    }
+                    let accept_compression_encodings = self.accept_compression_encodings;
+                    let send_compression_encodings = self.send_compression_encodings;
+                    let max_decoding_message_size = self.max_decoding_message_size;
+                    let max_encoding_message_size = self.max_encoding_message_size;
+                    let inner = self.inner.clone();
+                    let fut = async move {
+                        let method = GetFirstIndexSvc(inner);
+                        let codec = tonic::codec::ProstCodec::default();
+                        let mut grpc = tonic::server::Grpc::new(codec)
+                            .apply_compression_config(
+                                accept_compression_encodings,
+                                send_compression_encodings,
+                            )
+                            .apply_max_message_size_config(
+                                max_decoding_message_size,
+                                max_encoding_message_size,
+                            );
+                        let res = grpc.unary(method, req).await;
+                        Ok(res)
+                    };
+                    Box::pin(fut)
+                }
+                "/rockbox.v1alpha1.PlaylistService/GetDisplayIndex" => {
+                    #[allow(non_camel_case_types)]
+                    struct GetDisplayIndexSvc<T: PlaylistService>(pub Arc<T>);
+                    impl<
+                        T: PlaylistService,
+                    > tonic::server::UnaryService<super::GetDisplayIndexRequest>
+                    for GetDisplayIndexSvc<T> {
+                        type Response = super::GetDisplayIndexResponse;
+                        type Future = BoxFuture<
+                            tonic::Response<Self::Response>,
+                            tonic::Status,
+                        >;
+                        fn call(
+                            &mut self,
+                            request: tonic::Request<super::GetDisplayIndexRequest>,
+                        ) -> Self::Future {
+                            let inner = Arc::clone(&self.0);
+                            let fut = async move {
+                                <T as PlaylistService>::get_display_index(&inner, request)
+                                    .await
+                            };
+                            Box::pin(fut)
+                        }
+                    }
+                    let accept_compression_encodings = self.accept_compression_encodings;
+                    let send_compression_encodings = self.send_compression_encodings;
+                    let max_decoding_message_size = self.max_decoding_message_size;
+                    let max_encoding_message_size = self.max_encoding_message_size;
+                    let inner = self.inner.clone();
+                    let fut = async move {
+                        let method = GetDisplayIndexSvc(inner);
+                        let codec = tonic::codec::ProstCodec::default();
+                        let mut grpc = tonic::server::Grpc::new(codec)
+                            .apply_compression_config(
+                                accept_compression_encodings,
+                                send_compression_encodings,
+                            )
+                            .apply_max_message_size_config(
+                                max_decoding_message_size,
+                                max_encoding_message_size,
+                            );
+                        let res = grpc.unary(method, req).await;
+                        Ok(res)
+                    };
+                    Box::pin(fut)
+                }
+                "/rockbox.v1alpha1.PlaylistService/Amount" => {
+                    #[allow(non_camel_case_types)]
+                    struct AmountSvc<T: PlaylistService>(pub Arc<T>);
+                    impl<
+                        T: PlaylistService,
+                    > tonic::server::UnaryService<super::AmountRequest>
+                    for AmountSvc<T> {
+                        type Response = super::AmountResponse;
+                        type Future = BoxFuture<
+                            tonic::Response<Self::Response>,
+                            tonic::Status,
+                        >;
+                        fn call(
+                            &mut self,
+                            request: tonic::Request<super::AmountRequest>,
+                        ) -> Self::Future {
+                            let inner = Arc::clone(&self.0);
+                            let fut = async move {
+                                <T as PlaylistService>::amount(&inner, request).await
+                            };
+                            Box::pin(fut)
+                        }
+                    }
+                    let accept_compression_encodings = self.accept_compression_encodings;
+                    let send_compression_encodings = self.send_compression_encodings;
+                    let max_decoding_message_size = self.max_decoding_message_size;
+                    let max_encoding_message_size = self.max_encoding_message_size;
+                    let inner = self.inner.clone();
+                    let fut = async move {
+                        let method = AmountSvc(inner);
+                        let codec = tonic::codec::ProstCodec::default();
+                        let mut grpc = tonic::server::Grpc::new(codec)
+                            .apply_compression_config(
+                                accept_compression_encodings,
+                                send_compression_encodings,
+                            )
+                            .apply_max_message_size_config(
+                                max_decoding_message_size,
+                                max_encoding_message_size,
+                            );
+                        let res = grpc.unary(method, req).await;
+                        Ok(res)
+                    };
+                    Box::pin(fut)
+                }
+                "/rockbox.v1alpha1.PlaylistService/PlaylistResume" => {
+                    #[allow(non_camel_case_types)]
+                    struct PlaylistResumeSvc<T: PlaylistService>(pub Arc<T>);
+                    impl<
+                        T: PlaylistService,
+                    > tonic::server::UnaryService<super::PlaylistResumeRequest>
+                    for PlaylistResumeSvc<T> {
+                        type Response = super::PlaylistResumeResponse;
+                        type Future = BoxFuture<
+                            tonic::Response<Self::Response>,
+                            tonic::Status,
+                        >;
+                        fn call(
+                            &mut self,
+                            request: tonic::Request<super::PlaylistResumeRequest>,
+                        ) -> Self::Future {
+                            let inner = Arc::clone(&self.0);
+                            let fut = async move {
+                                <T as PlaylistService>::playlist_resume(&inner, request)
+                                    .await
+                            };
+                            Box::pin(fut)
+                        }
+                    }
+                    let accept_compression_encodings = self.accept_compression_encodings;
+                    let send_compression_encodings = self.send_compression_encodings;
+                    let max_decoding_message_size = self.max_decoding_message_size;
+                    let max_encoding_message_size = self.max_encoding_message_size;
+                    let inner = self.inner.clone();
+                    let fut = async move {
+                        let method = PlaylistResumeSvc(inner);
+                        let codec = tonic::codec::ProstCodec::default();
+                        let mut grpc = tonic::server::Grpc::new(codec)
+                            .apply_compression_config(
+                                accept_compression_encodings,
+                                send_compression_encodings,
+                            )
+                            .apply_max_message_size_config(
+                                max_decoding_message_size,
+                                max_encoding_message_size,
+                            );
+                        let res = grpc.unary(method, req).await;
+                        Ok(res)
+                    };
+                    Box::pin(fut)
+                }
+                "/rockbox.v1alpha1.PlaylistService/ResumeTrack" => {
+                    #[allow(non_camel_case_types)]
+                    struct ResumeTrackSvc<T: PlaylistService>(pub Arc<T>);
+                    impl<
+                        T: PlaylistService,
+                    > tonic::server::UnaryService<super::ResumeTrackRequest>
+                    for ResumeTrackSvc<T> {
+                        type Response = super::ResumeTrackResponse;
+                        type Future = BoxFuture<
+                            tonic::Response<Self::Response>,
+                            tonic::Status,
+                        >;
+                        fn call(
+                            &mut self,
+                            request: tonic::Request<super::ResumeTrackRequest>,
+                        ) -> Self::Future {
+                            let inner = Arc::clone(&self.0);
+                            let fut = async move {
+                                <T as PlaylistService>::resume_track(&inner, request).await
+                            };
+                            Box::pin(fut)
+                        }
+                    }
+                    let accept_compression_encodings = self.accept_compression_encodings;
+                    let send_compression_encodings = self.send_compression_encodings;
+                    let max_decoding_message_size = self.max_decoding_message_size;
+                    let max_encoding_message_size = self.max_encoding_message_size;
+                    let inner = self.inner.clone();
+                    let fut = async move {
+                        let method = ResumeTrackSvc(inner);
+                        let codec = tonic::codec::ProstCodec::default();
+                        let mut grpc = tonic::server::Grpc::new(codec)
+                            .apply_compression_config(
+                                accept_compression_encodings,
+                                send_compression_encodings,
+                            )
+                            .apply_max_message_size_config(
+                                max_decoding_message_size,
+                                max_encoding_message_size,
+                            );
+                        let res = grpc.unary(method, req).await;
+                        Ok(res)
+                    };
+                    Box::pin(fut)
+                }
+                "/rockbox.v1alpha1.PlaylistService/SetModified" => {
+                    #[allow(non_camel_case_types)]
+                    struct SetModifiedSvc<T: PlaylistService>(pub Arc<T>);
+                    impl<
+                        T: PlaylistService,
+                    > tonic::server::UnaryService<super::SetModifiedRequest>
+                    for SetModifiedSvc<T> {
+                        type Response = super::SetModifiedResponse;
+                        type Future = BoxFuture<
+                            tonic::Response<Self::Response>,
+                            tonic::Status,
+                        >;
+                        fn call(
+                            &mut self,
+                            request: tonic::Request<super::SetModifiedRequest>,
+                        ) -> Self::Future {
+                            let inner = Arc::clone(&self.0);
+                            let fut = async move {
+                                <T as PlaylistService>::set_modified(&inner, request).await
+                            };
+                            Box::pin(fut)
+                        }
+                    }
+                    let accept_compression_encodings = self.accept_compression_encodings;
+                    let send_compression_encodings = self.send_compression_encodings;
+                    let max_decoding_message_size = self.max_decoding_message_size;
+                    let max_encoding_message_size = self.max_encoding_message_size;
+                    let inner = self.inner.clone();
+                    let fut = async move {
+                        let method = SetModifiedSvc(inner);
+                        let codec = tonic::codec::ProstCodec::default();
+                        let mut grpc = tonic::server::Grpc::new(codec)
+                            .apply_compression_config(
+                                accept_compression_encodings,
+                                send_compression_encodings,
+                            )
+                            .apply_max_message_size_config(
+                                max_decoding_message_size,
+                                max_encoding_message_size,
+                            );
+                        let res = grpc.unary(method, req).await;
+                        Ok(res)
+                    };
+                    Box::pin(fut)
+                }
+                "/rockbox.v1alpha1.PlaylistService/Start" => {
+                    #[allow(non_camel_case_types)]
+                    struct StartSvc<T: PlaylistService>(pub Arc<T>);
+                    impl<
+                        T: PlaylistService,
+                    > tonic::server::UnaryService<super::StartRequest> for StartSvc<T> {
+                        type Response = super::StartResponse;
+                        type Future = BoxFuture<
+                            tonic::Response<Self::Response>,
+                            tonic::Status,
+                        >;
+                        fn call(
+                            &mut self,
+                            request: tonic::Request<super::StartRequest>,
+                        ) -> Self::Future {
+                            let inner = Arc::clone(&self.0);
+                            let fut = async move {
+                                <T as PlaylistService>::start(&inner, request).await
+                            };
+                            Box::pin(fut)
+                        }
+                    }
+                    let accept_compression_encodings = self.accept_compression_encodings;
+                    let send_compression_encodings = self.send_compression_encodings;
+                    let max_decoding_message_size = self.max_decoding_message_size;
+                    let max_encoding_message_size = self.max_encoding_message_size;
+                    let inner = self.inner.clone();
+                    let fut = async move {
+                        let method = StartSvc(inner);
+                        let codec = tonic::codec::ProstCodec::default();
+                        let mut grpc = tonic::server::Grpc::new(codec)
+                            .apply_compression_config(
+                                accept_compression_encodings,
+                                send_compression_encodings,
+                            )
+                            .apply_max_message_size_config(
+                                max_decoding_message_size,
+                                max_encoding_message_size,
+                            );
+                        let res = grpc.unary(method, req).await;
+                        Ok(res)
+                    };
+                    Box::pin(fut)
+                }
+                "/rockbox.v1alpha1.PlaylistService/Sync" => {
+                    #[allow(non_camel_case_types)]
+                    struct SyncSvc<T: PlaylistService>(pub Arc<T>);
+                    impl<
+                        T: PlaylistService,
+                    > tonic::server::UnaryService<super::SyncRequest> for SyncSvc<T> {
+                        type Response = super::SyncResponse;
+                        type Future = BoxFuture<
+                            tonic::Response<Self::Response>,
+                            tonic::Status,
+                        >;
+                        fn call(
+                            &mut self,
+                            request: tonic::Request<super::SyncRequest>,
+                        ) -> Self::Future {
+                            let inner = Arc::clone(&self.0);
+                            let fut = async move {
+                                <T as PlaylistService>::sync(&inner, request).await
+                            };
+                            Box::pin(fut)
+                        }
+                    }
+                    let accept_compression_encodings = self.accept_compression_encodings;
+                    let send_compression_encodings = self.send_compression_encodings;
+                    let max_decoding_message_size = self.max_decoding_message_size;
+                    let max_encoding_message_size = self.max_encoding_message_size;
+                    let inner = self.inner.clone();
+                    let fut = async move {
+                        let method = SyncSvc(inner);
+                        let codec = tonic::codec::ProstCodec::default();
+                        let mut grpc = tonic::server::Grpc::new(codec)
+                            .apply_compression_config(
+                                accept_compression_encodings,
+                                send_compression_encodings,
+                            )
+                            .apply_max_message_size_config(
+                                max_decoding_message_size,
+                                max_encoding_message_size,
+                            );
+                        let res = grpc.unary(method, req).await;
+                        Ok(res)
+                    };
+                    Box::pin(fut)
+                }
+                "/rockbox.v1alpha1.PlaylistService/RemoveAllTracks" => {
+                    #[allow(non_camel_case_types)]
+                    struct RemoveAllTracksSvc<T: PlaylistService>(pub Arc<T>);
+                    impl<
+                        T: PlaylistService,
+                    > tonic::server::UnaryService<super::RemoveAllTracksRequest>
+                    for RemoveAllTracksSvc<T> {
+                        type Response = super::RemoveAllTracksResponse;
+                        type Future = BoxFuture<
+                            tonic::Response<Self::Response>,
+                            tonic::Status,
+                        >;
+                        fn call(
+                            &mut self,
+                            request: tonic::Request<super::RemoveAllTracksRequest>,
+                        ) -> Self::Future {
+                            let inner = Arc::clone(&self.0);
+                            let fut = async move {
+                                <T as PlaylistService>::remove_all_tracks(&inner, request)
+                                    .await
+                            };
+                            Box::pin(fut)
+                        }
+                    }
+                    let accept_compression_encodings = self.accept_compression_encodings;
+                    let send_compression_encodings = self.send_compression_encodings;
+                    let max_decoding_message_size = self.max_decoding_message_size;
+                    let max_encoding_message_size = self.max_encoding_message_size;
+                    let inner = self.inner.clone();
+                    let fut = async move {
+                        let method = RemoveAllTracksSvc(inner);
+                        let codec = tonic::codec::ProstCodec::default();
+                        let mut grpc = tonic::server::Grpc::new(codec)
+                            .apply_compression_config(
+                                accept_compression_encodings,
+                                send_compression_encodings,
+                            )
+                            .apply_max_message_size_config(
+                                max_decoding_message_size,
+                                max_encoding_message_size,
+                            );
+                        let res = grpc.unary(method, req).await;
+                        Ok(res)
+                    };
+                    Box::pin(fut)
+                }
+                "/rockbox.v1alpha1.PlaylistService/RemoveTracks" => {
+                    #[allow(non_camel_case_types)]
+                    struct RemoveTracksSvc<T: PlaylistService>(pub Arc<T>);
+                    impl<
+                        T: PlaylistService,
+                    > tonic::server::UnaryService<super::RemoveTracksRequest>
+                    for RemoveTracksSvc<T> {
+                        type Response = super::RemoveTracksResponse;
+                        type Future = BoxFuture<
+                            tonic::Response<Self::Response>,
+                            tonic::Status,
+                        >;
+                        fn call(
+                            &mut self,
+                            request: tonic::Request<super::RemoveTracksRequest>,
+                        ) -> Self::Future {
+                            let inner = Arc::clone(&self.0);
+                            let fut = async move {
+                                <T as PlaylistService>::remove_tracks(&inner, request).await
+                            };
+                            Box::pin(fut)
+                        }
+                    }
+                    let accept_compression_encodings = self.accept_compression_encodings;
+                    let send_compression_encodings = self.send_compression_encodings;
+                    let max_decoding_message_size = self.max_decoding_message_size;
+                    let max_encoding_message_size = self.max_encoding_message_size;
+                    let inner = self.inner.clone();
+                    let fut = async move {
+                        let method = RemoveTracksSvc(inner);
+                        let codec = tonic::codec::ProstCodec::default();
+                        let mut grpc = tonic::server::Grpc::new(codec)
+                            .apply_compression_config(
+                                accept_compression_encodings,
+                                send_compression_encodings,
+                            )
+                            .apply_max_message_size_config(
+                                max_decoding_message_size,
+                                max_encoding_message_size,
+                            );
+                        let res = grpc.unary(method, req).await;
+                        Ok(res)
+                    };
+                    Box::pin(fut)
+                }
+                "/rockbox.v1alpha1.PlaylistService/CreatePlaylist" => {
+                    #[allow(non_camel_case_types)]
+                    struct CreatePlaylistSvc<T: PlaylistService>(pub Arc<T>);
+                    impl<
+                        T: PlaylistService,
+                    > tonic::server::UnaryService<super::CreatePlaylistRequest>
+                    for CreatePlaylistSvc<T> {
+                        type Response = super::CreatePlaylistResponse;
+                        type Future = BoxFuture<
+                            tonic::Response<Self::Response>,
+                            tonic::Status,
+                        >;
+                        fn call(
+                            &mut self,
+                            request: tonic::Request<super::CreatePlaylistRequest>,
+                        ) -> Self::Future {
+                            let inner = Arc::clone(&self.0);
+                            let fut = async move {
+                                <T as PlaylistService>::create_playlist(&inner, request)
+                                    .await
+                            };
+                            Box::pin(fut)
+                        }
+                    }
+                    let accept_compression_encodings = self.accept_compression_encodings;
+                    let send_compression_encodings = self.send_compression_encodings;
+                    let max_decoding_message_size = self.max_decoding_message_size;
+                    let max_encoding_message_size = self.max_encoding_message_size;
+                    let inner = self.inner.clone();
+                    let fut = async move {
+                        let method = CreatePlaylistSvc(inner);
+                        let codec = tonic::codec::ProstCodec::default();
+                        let mut grpc = tonic::server::Grpc::new(codec)
+                            .apply_compression_config(
+                                accept_compression_encodings,
+                                send_compression_encodings,
+                            )
+                            .apply_max_message_size_config(
+                                max_decoding_message_size,
+                                max_encoding_message_size,
+                            );
+                        let res = grpc.unary(method, req).await;
+                        Ok(res)
+                    };
+                    Box::pin(fut)
+                }
+                "/rockbox.v1alpha1.PlaylistService/InsertTracks" => {
+                    #[allow(non_camel_case_types)]
+                    struct InsertTracksSvc<T: PlaylistService>(pub Arc<T>);
+                    impl<
+                        T: PlaylistService,
+                    > tonic::server::UnaryService<super::InsertTracksRequest>
+                    for InsertTracksSvc<T> {
+                        type Response = super::InsertTracksResponse;
+                        type Future = BoxFuture<
+                            tonic::Response<Self::Response>,
+                            tonic::Status,
+                        >;
+                        fn call(
+                            &mut self,
+                            request: tonic::Request<super::InsertTracksRequest>,
+                        ) -> Self::Future {
+                            let inner = Arc::clone(&self.0);
+                            let fut = async move {
+                                <T as PlaylistService>::insert_tracks(&inner, request).await
+                            };
+                            Box::pin(fut)
+                        }
+                    }
+                    let accept_compression_encodings = self.accept_compression_encodings;
+                    let send_compression_encodings = self.send_compression_encodings;
+                    let max_decoding_message_size = self.max_decoding_message_size;
+                    let max_encoding_message_size = self.max_encoding_message_size;
+                    let inner = self.inner.clone();
+                    let fut = async move {
+                        let method = InsertTracksSvc(inner);
+                        let codec = tonic::codec::ProstCodec::default();
+                        let mut grpc = tonic::server::Grpc::new(codec)
+                            .apply_compression_config(
+                                accept_compression_encodings,
+                                send_compression_encodings,
+                            )
+                            .apply_max_message_size_config(
+                                max_decoding_message_size,
+                                max_encoding_message_size,
+                            );
+                        let res = grpc.unary(method, req).await;
+                        Ok(res)
+                    };
+                    Box::pin(fut)
+                }
+                "/rockbox.v1alpha1.PlaylistService/InsertDirectory" => {
+                    #[allow(non_camel_case_types)]
+                    struct InsertDirectorySvc<T: PlaylistService>(pub Arc<T>);
+                    impl<
+                        T: PlaylistService,
+                    > tonic::server::UnaryService<super::InsertDirectoryRequest>
+                    for InsertDirectorySvc<T> {
+                        type Response = super::InsertDirectoryResponse;
+                        type Future = BoxFuture<
+                            tonic::Response<Self::Response>,
+                            tonic::Status,
+                        >;
+                        fn call(
+                            &mut self,
+                            request: tonic::Request<super::InsertDirectoryRequest>,
+                        ) -> Self::Future {
+                            let inner = Arc::clone(&self.0);
+                            let fut = async move {
+                                <T as PlaylistService>::insert_directory(&inner, request)
+                                    .await
+                            };
+                            Box::pin(fut)
+                        }
+                    }
+                    let accept_compression_encodings = self.accept_compression_encodings;
+                    let send_compression_encodings = self.send_compression_encodings;
+                    let max_decoding_message_size = self.max_decoding_message_size;
+                    let max_encoding_message_size = self.max_encoding_message_size;
+                    let inner = self.inner.clone();
+                    let fut = async move {
+                        let method = InsertDirectorySvc(inner);
+                        let codec = tonic::codec::ProstCodec::default();
+                        let mut grpc = tonic::server::Grpc::new(codec)
+                            .apply_compression_config(
+                                accept_compression_encodings,
+                                send_compression_encodings,
+                            )
+                            .apply_max_message_size_config(
+                                max_decoding_message_size,
+                                max_encoding_message_size,
+                            );
+                        let res = grpc.unary(method, req).await;
+                        Ok(res)
+                    };
+                    Box::pin(fut)
+                }
+                "/rockbox.v1alpha1.PlaylistService/InsertPlaylist" => {
+                    #[allow(non_camel_case_types)]
+                    struct InsertPlaylistSvc<T: PlaylistService>(pub Arc<T>);
+                    impl<
+                        T: PlaylistService,
+                    > tonic::server::UnaryService<super::InsertPlaylistRequest>
+                    for InsertPlaylistSvc<T> {
+                        type Response = super::InsertPlaylistResponse;
+                        type Future = BoxFuture<
+                            tonic::Response<Self::Response>,
+                            tonic::Status,
+                        >;
+                        fn call(
+                            &mut self,
+                            request: tonic::Request<super::InsertPlaylistRequest>,
+                        ) -> Self::Future {
+                            let inner = Arc::clone(&self.0);
+                            let fut = async move {
+                                <T as PlaylistService>::insert_playlist(&inner, request)
+                                    .await
+                            };
+                            Box::pin(fut)
+                        }
+                    }
+                    let accept_compression_encodings = self.accept_compression_encodings;
+                    let send_compression_encodings = self.send_compression_encodings;
+                    let max_decoding_message_size = self.max_decoding_message_size;
+                    let max_encoding_message_size = self.max_encoding_message_size;
+                    let inner = self.inner.clone();
+                    let fut = async move {
+                        let method = InsertPlaylistSvc(inner);
+                        let codec = tonic::codec::ProstCodec::default();
+                        let mut grpc = tonic::server::Grpc::new(codec)
+                            .apply_compression_config(
+                                accept_compression_encodings,
+                                send_compression_encodings,
+                            )
+                            .apply_max_message_size_config(
+                                max_decoding_message_size,
+                                max_encoding_message_size,
+                            );
+                        let res = grpc.unary(method, req).await;
+                        Ok(res)
+                    };
+                    Box::pin(fut)
+                }
+                "/rockbox.v1alpha1.PlaylistService/InsertAlbum" => {
+                    #[allow(non_camel_case_types)]
+                    struct InsertAlbumSvc<T: PlaylistService>(pub Arc<T>);
+                    impl<
+                        T: PlaylistService,
+                    > tonic::server::UnaryService<super::InsertAlbumRequest>
+                    for InsertAlbumSvc<T> {
+                        type Response = super::InsertAlbumResponse;
+                        type Future = BoxFuture<
+                            tonic::Response<Self::Response>,
+                            tonic::Status,
+                        >;
+                        fn call(
+                            &mut self,
+                            request: tonic::Request<super::InsertAlbumRequest>,
+                        ) -> Self::Future {
+                            let inner = Arc::clone(&self.0);
+                            let fut = async move {
+                                <T as PlaylistService>::insert_album(&inner, request).await
+                            };
+                            Box::pin(fut)
+                        }
+                    }
+                    let accept_compression_encodings = self.accept_compression_encodings;
+                    let send_compression_encodings = self.send_compression_encodings;
+                    let max_decoding_message_size = self.max_decoding_message_size;
+                    let max_encoding_message_size = self.max_encoding_message_size;
+                    let inner = self.inner.clone();
+                    let fut = async move {
+                        let method = InsertAlbumSvc(inner);
+                        let codec = tonic::codec::ProstCodec::default();
+                        let mut grpc = tonic::server::Grpc::new(codec)
+                            .apply_compression_config(
+                                accept_compression_encodings,
+                                send_compression_encodings,
+                            )
+                            .apply_max_message_size_config(
+                                max_decoding_message_size,
+                                max_encoding_message_size,
+                            );
+                        let res = grpc.unary(method, req).await;
+                        Ok(res)
+                    };
+                    Box::pin(fut)
+                }
+                "/rockbox.v1alpha1.PlaylistService/InsertArtistTracks" => {
+                    #[allow(non_camel_case_types)]
+                    struct InsertArtistTracksSvc<T: PlaylistService>(pub Arc<T>);
+                    impl<
+                        T: PlaylistService,
+                    > tonic::server::UnaryService<super::InsertArtistTracksRequest>
+                    for InsertArtistTracksSvc<T> {
+                        type Response = super::InsertArtistTracksResponse;
+                        type Future = BoxFuture<
+                            tonic::Response<Self::Response>,
+                            tonic::Status,
+                        >;
+                        fn call(
+                            &mut self,
+                            request: tonic::Request<super::InsertArtistTracksRequest>,
+                        ) -> Self::Future {
+                            let inner = Arc::clone(&self.0);
+                            let fut = async move {
+                                <T as PlaylistService>::insert_artist_tracks(
+                                        &inner,
+                                        request,
+                                    )
+                                    .await
+                            };
+                            Box::pin(fut)
+                        }
+                    }
+                    let accept_compression_encodings = self.accept_compression_encodings;
+                    let send_compression_encodings = self.send_compression_encodings;
+                    let max_decoding_message_size = self.max_decoding_message_size;
+                    let max_encoding_message_size = self.max_encoding_message_size;
+                    let inner = self.inner.clone();
+                    let fut = async move {
+                        let method = InsertArtistTracksSvc(inner);
+                        let codec = tonic::codec::ProstCodec::default();
+                        let mut grpc = tonic::server::Grpc::new(codec)
+                            .apply_compression_config(
+                                accept_compression_encodings,
+                                send_compression_encodings,
+                            )
+                            .apply_max_message_size_config(
+                                max_decoding_message_size,
+                                max_encoding_message_size,
+                            );
+                        let res = grpc.unary(method, req).await;
+                        Ok(res)
+                    };
+                    Box::pin(fut)
+                }
+                "/rockbox.v1alpha1.PlaylistService/ShufflePlaylist" => {
+                    #[allow(non_camel_case_types)]
+                    struct ShufflePlaylistSvc<T: PlaylistService>(pub Arc<T>);
+                    impl<
+                        T: PlaylistService,
+                    > tonic::server::UnaryService<super::ShufflePlaylistRequest>
+                    for ShufflePlaylistSvc<T> {
+                        type Response = super::ShufflePlaylistResponse;
+                        type Future = BoxFuture<
+                            tonic::Response<Self::Response>,
+                            tonic::Status,
+                        >;
+                        fn call(
+                            &mut self,
+                            request: tonic::Request<super::ShufflePlaylistRequest>,
+                        ) -> Self::Future {
+                            let inner = Arc::clone(&self.0);
+                            let fut = async move {
+                                <T as PlaylistService>::shuffle_playlist(&inner, request)
+                                    .await
+                            };
+                            Box::pin(fut)
+                        }
+                    }
+                    let accept_compression_encodings = self.accept_compression_encodings;
+                    let send_compression_encodings = self.send_compression_encodings;
+                    let max_decoding_message_size = self.max_decoding_message_size;
+                    let max_encoding_message_size = self.max_encoding_message_size;
+                    let inner = self.inner.clone();
+                    let fut = async move {
+                        let method = ShufflePlaylistSvc(inner);
+                        let codec = tonic::codec::ProstCodec::default();
+                        let mut grpc = tonic::server::Grpc::new(codec)
+                            .apply_compression_config(
+                                accept_compression_encodings,
+                                send_compression_encodings,
+                            )
+                            .apply_max_message_size_config(
+                                max_decoding_message_size,
+                                max_encoding_message_size,
+                            );
+                        let res = grpc.unary(method, req).await;
+                        Ok(res)
+                    };
+                    Box::pin(fut)
+                }
+                _ => {
+                    Box::pin(async move {
+                        let mut response = http::Response::new(empty_body());
+                        let headers = response.headers_mut();
+                        headers
+                            .insert(
+                                tonic::Status::GRPC_STATUS,
+                                (tonic::Code::Unimplemented as i32).into(),
+                            );
+                        headers
+                            .insert(
+                                http::header::CONTENT_TYPE,
+                                tonic::metadata::GRPC_CONTENT_TYPE,
+                            );
+                        Ok(response)
+                    })
+                }
+            }
+        }
+    }
+    impl<T> Clone for PlaylistServiceServer<T> {
+        fn clone(&self) -> Self {
+            let inner = self.inner.clone();
+            Self {
+                inner,
+                accept_compression_encodings: self.accept_compression_encodings,
+                send_compression_encodings: self.send_compression_encodings,
+                max_decoding_message_size: self.max_decoding_message_size,
+                max_encoding_message_size: self.max_encoding_message_size,
+            }
+        }
+    }
+    /// Generated gRPC service name
+    pub const SERVICE_NAME: &str = "rockbox.v1alpha1.PlaylistService";
+    impl<T> tonic::server::NamedService for PlaylistServiceServer<T> {
+        const NAME: &'static str = SERVICE_NAME;
+    }
+}
+#[derive(Clone, Copy, PartialEq, ::prost::Message)]
+pub struct GetSettingsListRequest {
+    #[prost(int32, tag = "1")]
+    pub count: i32,
+}
+#[derive(Clone, Copy, PartialEq, ::prost::Message)]
+pub struct GetSettingsListResponse {}
+#[derive(Clone, Copy, PartialEq, ::prost::Message)]
+pub struct GetGlobalSettingsRequest {}
+#[derive(Clone, Copy, PartialEq, ::prost::Message)]
+pub struct ReplaygainSettings {
+    #[prost(bool, tag = "1")]
+    pub noclip: bool,
+    #[prost(int32, tag = "2")]
+    pub r#type: i32,
+    #[prost(int32, tag = "3")]
+    pub preamp: i32,
+}
+#[derive(Clone, Copy, PartialEq, ::prost::Message)]
+pub struct EqBandSetting {
+    #[prost(int32, tag = "1")]
+    pub cutoff: i32,
+    #[prost(int32, tag = "2")]
+    pub q: i32,
+    #[prost(int32, tag = "3")]
+    pub gain: i32,
+}
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct SettingsList {
+    #[prost(uint32, tag = "1")]
+    pub flags: u32,
+    #[prost(int32, tag = "2")]
+    pub lang_id: i32,
+    #[prost(string, tag = "3")]
+    pub cfg_name: ::prost::alloc::string::String,
+    #[prost(string, tag = "4")]
+    pub cfg_vals: ::prost::alloc::string::String,
+}
+#[derive(Clone, Copy, PartialEq, ::prost::Message)]
+pub struct CompressorSettings {
+    #[prost(int32, tag = "1")]
+    pub threshold: i32,
+    #[prost(int32, tag = "2")]
+    pub makeup_gain: i32,
+    #[prost(int32, tag = "3")]
+    pub ratio: i32,
+    #[prost(int32, tag = "4")]
+    pub knee: i32,
+    #[prost(int32, tag = "5")]
+    pub release_time: i32,
+    #[prost(int32, tag = "6")]
+    pub attack_time: i32,
+}
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct GetGlobalSettingsResponse {
+    #[prost(int32, tag = "1")]
+    pub volume: i32,
+    #[prost(int32, tag = "2")]
+    pub balance: i32,
+    #[prost(int32, tag = "3")]
+    pub bass: i32,
+    #[prost(int32, tag = "4")]
+    pub treble: i32,
+    #[prost(int32, tag = "5")]
+    pub channel_config: i32,
+    #[prost(int32, tag = "6")]
+    pub stereo_width: i32,
+    #[prost(int32, tag = "7")]
+    pub bass_cutoff: i32,
+    #[prost(int32, tag = "8")]
+    pub treble_cutoff: i32,
+    #[prost(int32, tag = "9")]
+    pub crossfade: i32,
+    #[prost(int32, tag = "10")]
+    pub crossfade_fade_in_delay: i32,
+    #[prost(int32, tag = "11")]
+    pub crossfade_fade_out_delay: i32,
+    #[prost(int32, tag = "12")]
+    pub crossfade_fade_in_duration: i32,
+    #[prost(int32, tag = "13")]
+    pub crossfade_fade_out_duration: i32,
+    #[prost(int32, tag = "14")]
+    pub crossfade_fade_out_mixmode: i32,
+    #[prost(message, optional, tag = "15")]
+    pub replaygain_settings: ::core::option::Option<ReplaygainSettings>,
+    #[prost(int32, tag = "16")]
+    pub crossfeed: i32,
+    #[prost(uint32, tag = "17")]
+    pub crossfeed_direct_gain: u32,
+    #[prost(uint32, tag = "18")]
+    pub crossfeed_cross_gain: u32,
+    #[prost(uint32, tag = "19")]
+    pub crossfeed_hf_attenuation: u32,
+    #[prost(uint32, tag = "20")]
+    pub crossfeed_hf_cutoff: u32,
+    #[prost(bool, tag = "21")]
+    pub eq_enabled: bool,
+    #[prost(uint32, tag = "22")]
+    pub eq_precut: u32,
+    #[prost(message, repeated, tag = "23")]
+    pub eq_band_settings: ::prost::alloc::vec::Vec<EqBandSetting>,
+    #[prost(int32, tag = "24")]
+    pub beep: i32,
+    #[prost(int32, tag = "25")]
+    pub keyclick: i32,
+    #[prost(int32, tag = "26")]
+    pub keyclick_repeats: i32,
+    #[prost(bool, tag = "27")]
+    pub dithering_enabled: bool,
+    #[prost(bool, tag = "28")]
+    pub timestretch_enabled: bool,
+    #[prost(int32, tag = "29")]
+    pub list_accel_start_delay: i32,
+    #[prost(int32, tag = "30")]
+    pub list_accel_wait: i32,
+    #[prost(int32, tag = "31")]
+    pub touchpad_sensitivity: i32,
+    #[prost(int32, tag = "32")]
+    pub touchpad_deadzone: i32,
+    #[prost(int32, tag = "33")]
+    pub pause_rewind: i32,
+    #[prost(int32, tag = "34")]
+    pub unplug_mode: i32,
+    #[prost(bool, tag = "35")]
+    pub unplug_autoresume: bool,
+    #[prost(int32, tag = "37")]
+    pub timeformat: i32,
+    #[prost(int32, tag = "38")]
+    pub disk_spindown: i32,
+    #[prost(int32, tag = "39")]
+    pub buffer_margin: i32,
+    #[prost(int32, tag = "40")]
+    pub dirfilter: i32,
+    #[prost(int32, tag = "41")]
+    pub show_filename_ext: i32,
+    #[prost(int32, tag = "42")]
+    pub default_codepage: i32,
+    #[prost(bool, tag = "43")]
+    pub hold_lr_for_scroll_in_list: bool,
+    #[prost(bool, tag = "44")]
+    pub play_selected: bool,
+    #[prost(int32, tag = "45")]
+    pub single_mode: i32,
+    #[prost(bool, tag = "46")]
+    pub party_mode: bool,
+    #[prost(bool, tag = "48")]
+    pub car_adapter_mode: bool,
+    #[prost(int32, tag = "49")]
+    pub car_adapter_mode_delay: i32,
+    #[prost(int32, tag = "50")]
+    pub start_in_screen: i32,
+    #[prost(int32, tag = "51")]
+    pub ff_rewind_min_step: i32,
+    #[prost(int32, tag = "52")]
+    pub ff_rewind_accel: i32,
+    #[prost(int32, tag = "53")]
+    pub peak_meter_release: i32,
+    #[prost(int32, tag = "54")]
+    pub peak_meter_hold: i32,
+    #[prost(int32, tag = "55")]
+    pub peak_meter_clip_hold: i32,
+    #[prost(bool, tag = "56")]
+    pub peak_meter_dbfs: bool,
+    #[prost(int32, tag = "57")]
+    pub peak_meter_min: i32,
+    #[prost(int32, tag = "58")]
+    pub peak_meter_max: i32,
+    #[prost(string, tag = "59")]
+    pub wps_file: ::prost::alloc::string::String,
+    #[prost(string, tag = "60")]
+    pub sbs_file: ::prost::alloc::string::String,
+    #[prost(string, tag = "61")]
+    pub lang_file: ::prost::alloc::string::String,
+    #[prost(string, tag = "62")]
+    pub playlist_catalog_dir: ::prost::alloc::string::String,
+    #[prost(int32, tag = "63")]
+    pub skip_length: i32,
+    #[prost(int32, tag = "64")]
+    pub max_files_in_dir: i32,
+    #[prost(int32, tag = "65")]
+    pub max_files_in_playlist: i32,
+    #[prost(int32, tag = "66")]
+    pub volume_type: i32,
+    #[prost(int32, tag = "67")]
+    pub battery_display: i32,
+    #[prost(bool, tag = "68")]
+    pub show_icons: bool,
+    #[prost(int32, tag = "69")]
+    pub statusbar: i32,
+    #[prost(int32, tag = "70")]
+    pub scrollbar: i32,
+    #[prost(int32, tag = "71")]
+    pub scrollbar_width: i32,
+    #[prost(int32, tag = "72")]
+    pub list_line_padding: i32,
+    #[prost(int32, tag = "73")]
+    pub list_separator_color: i32,
+    #[prost(bool, tag = "74")]
+    pub browse_current: bool,
+    #[prost(bool, tag = "75")]
+    pub scroll_paginated: bool,
+    #[prost(bool, tag = "76")]
+    pub list_wraparound: bool,
+    #[prost(int32, tag = "77")]
+    pub list_order: i32,
+    #[prost(int32, tag = "78")]
+    pub scroll_speed: i32,
+    #[prost(int32, tag = "79")]
+    pub bidir_limit: i32,
+    #[prost(int32, tag = "80")]
+    pub scroll_delay: i32,
+    #[prost(int32, tag = "81")]
+    pub scroll_step: i32,
+    #[prost(int32, tag = "82")]
+    pub autoloadbookmark: i32,
+    #[prost(int32, tag = "83")]
+    pub autocreatebookmark: i32,
+    #[prost(bool, tag = "84")]
+    pub autoupdatebookmark: bool,
+    #[prost(int32, tag = "85")]
+    pub usemrb: i32,
+    #[prost(bool, tag = "86")]
+    pub dircache: bool,
+    #[prost(int32, tag = "87")]
+    pub tagcache_ram: i32,
+    #[prost(bool, tag = "88")]
+    pub tagcache_autoupdate: bool,
+    #[prost(bool, tag = "89")]
+    pub autoresume_enable: bool,
+    #[prost(int32, tag = "90")]
+    pub autoresume_automatic: i32,
+    #[prost(string, tag = "91")]
+    pub autoresume_paths: ::prost::alloc::string::String,
+    #[prost(bool, tag = "92")]
+    pub runtimedb: bool,
+    #[prost(string, tag = "93")]
+    pub tagcache_scan_paths: ::prost::alloc::string::String,
+    #[prost(string, tag = "94")]
+    pub tagcache_db_path: ::prost::alloc::string::String,
+    #[prost(string, tag = "95")]
+    pub backdrop_file: ::prost::alloc::string::String,
+    #[prost(int32, tag = "96")]
+    pub bg_color: i32,
+    #[prost(int32, tag = "97")]
+    pub fg_color: i32,
+    #[prost(int32, tag = "98")]
+    pub lss_color: i32,
+    #[prost(int32, tag = "99")]
+    pub lse_color: i32,
+    #[prost(int32, tag = "100")]
+    pub lst_color: i32,
+    #[prost(string, tag = "101")]
+    pub colors_file: ::prost::alloc::string::String,
+    #[prost(int32, tag = "102")]
+    pub browser_default: i32,
+    #[prost(int32, tag = "103")]
+    pub repeat_mode: i32,
+    #[prost(int32, tag = "104")]
+    pub next_folder: i32,
+    #[prost(bool, tag = "105")]
+    pub constrain_next_folder: bool,
+    #[prost(int32, tag = "106")]
+    pub recursive_dir_insert: i32,
+    #[prost(bool, tag = "107")]
+    pub fade_on_stop: bool,
+    #[prost(bool, tag = "108")]
+    pub playlist_shuffle: bool,
+    #[prost(bool, tag = "109")]
+    pub warnon_erase_dynplaylist: bool,
+    #[prost(bool, tag = "110")]
+    pub keep_current_track_on_replace_playlist: bool,
+    #[prost(bool, tag = "111")]
+    pub show_shuffled_adding_options: bool,
+    #[prost(int32, tag = "112")]
+    pub show_queue_options: i32,
+    #[prost(int32, tag = "113")]
+    pub album_art: i32,
+    #[prost(bool, tag = "114")]
+    pub rewind_across_tracks: bool,
+    #[prost(bool, tag = "115")]
+    pub playlist_viewer_icons: bool,
+    #[prost(bool, tag = "116")]
+    pub playlist_viewer_indices: bool,
+    #[prost(int32, tag = "117")]
+    pub playlist_viewer_track_display: i32,
+    #[prost(bool, tag = "118")]
+    pub sort_case: bool,
+    #[prost(int32, tag = "119")]
+    pub sort_dir: i32,
+    #[prost(int32, tag = "120")]
+    pub sort_file: i32,
+    #[prost(int32, tag = "121")]
+    pub interpret_numbers: i32,
+    #[prost(int32, tag = "122")]
+    pub poweroff: i32,
+    #[prost(bool, tag = "123")]
+    pub spdif_enable: bool,
+    #[prost(int32, tag = "124")]
+    pub contrast: i32,
+    #[prost(bool, tag = "125")]
+    pub invert: bool,
+    #[prost(bool, tag = "126")]
+    pub flip_display: bool,
+    #[prost(int32, tag = "127")]
+    pub cursor_style: i32,
+    #[prost(int32, tag = "128")]
+    pub screen_scroll_step: i32,
+    #[prost(int32, tag = "129")]
+    pub show_path_in_browser: i32,
+    #[prost(bool, tag = "130")]
+    pub offset_out_of_view: bool,
+    #[prost(bool, tag = "131")]
+    pub disable_mainmenu_scrolling: bool,
+    #[prost(string, tag = "132")]
+    pub icon_file: ::prost::alloc::string::String,
+    #[prost(string, tag = "133")]
+    pub viewers_icon_file: ::prost::alloc::string::String,
+    #[prost(string, tag = "134")]
+    pub font_file: ::prost::alloc::string::String,
+    #[prost(int32, tag = "135")]
+    pub glyphs_to_cache: i32,
+    #[prost(string, tag = "136")]
+    pub kbd_file: ::prost::alloc::string::String,
+    #[prost(int32, tag = "137")]
+    pub backlight_timeout: i32,
+    #[prost(bool, tag = "138")]
+    pub caption_backlight: bool,
+    #[prost(bool, tag = "139")]
+    pub bl_filter_first_keypress: bool,
+    #[prost(int32, tag = "140")]
+    pub backlight_timeout_plugged: i32,
+    #[prost(bool, tag = "141")]
+    pub bt_selective_softlock_actions: bool,
+    #[prost(int32, tag = "142")]
+    pub bt_selective_softlock_actions_mask: i32,
+    #[prost(bool, tag = "143")]
+    pub bl_selective_actions: bool,
+    #[prost(int32, tag = "144")]
+    pub bl_selective_actions_mask: i32,
+    #[prost(int32, tag = "145")]
+    pub backlight_on_button_hold: i32,
+    #[prost(int32, tag = "146")]
+    pub lcd_sleep_after_backlight_off: i32,
+    #[prost(int32, tag = "147")]
+    pub brightness: i32,
+    #[prost(int32, tag = "148")]
+    pub speaker_mode: i32,
+    #[prost(bool, tag = "149")]
+    pub prevent_skip: bool,
+    #[prost(int32, tag = "150")]
+    pub touch_mode: i32,
+    #[prost(bool, tag = "151")]
+    pub pitch_mode_semitone: bool,
+    #[prost(bool, tag = "152")]
+    pub pitch_mode_timestretch: bool,
+    #[prost(string, tag = "153")]
+    pub player_name: ::prost::alloc::string::String,
+    #[prost(message, optional, tag = "154")]
+    pub compressor_settings: ::core::option::Option<CompressorSettings>,
+    #[prost(int32, tag = "155")]
+    pub sleeptimer_duration: i32,
+    #[prost(bool, tag = "156")]
+    pub sleeptimer_on_startup: bool,
+    #[prost(bool, tag = "157")]
+    pub keypress_restarts_sleeptimer: bool,
+    #[prost(bool, tag = "158")]
+    pub show_shutdown_message: bool,
+    #[prost(int32, tag = "159")]
+    pub hotkey_wps: i32,
+    #[prost(int32, tag = "160")]
+    pub hotkey_tree: i32,
+    #[prost(int32, tag = "161")]
+    pub resume_rewind: i32,
+    #[prost(int32, tag = "162")]
+    pub depth_3d: i32,
+    #[prost(int32, tag = "163")]
+    pub roll_off: i32,
+    #[prost(int32, tag = "164")]
+    pub power_mode: i32,
+    #[prost(bool, tag = "165")]
+    pub keyclick_hardware: bool,
+    #[prost(string, tag = "166")]
+    pub start_directory: ::prost::alloc::string::String,
+    #[prost(bool, tag = "167")]
+    pub root_menu_customized: bool,
+    #[prost(bool, tag = "168")]
+    pub shortcuts_replaces_qs: bool,
+    #[prost(int32, tag = "169")]
+    pub play_frequency: i32,
+    #[prost(int32, tag = "170")]
+    pub volume_limit: i32,
+    #[prost(int32, tag = "171")]
+    pub volume_adjust_mode: i32,
+    #[prost(int32, tag = "172")]
+    pub volume_adjust_norm_steps: i32,
+    #[prost(int32, tag = "173")]
+    pub surround_enabled: i32,
+    #[prost(int32, tag = "174")]
+    pub surround_balance: i32,
+    #[prost(int32, tag = "175")]
+    pub surround_fx1: i32,
+    #[prost(int32, tag = "176")]
+    pub surround_fx2: i32,
+    #[prost(bool, tag = "177")]
+    pub surround_method2: bool,
+    #[prost(int32, tag = "178")]
+    pub surround_mix: i32,
+    #[prost(int32, tag = "179")]
+    pub pbe: i32,
+    #[prost(int32, tag = "180")]
+    pub pbe_precut: i32,
+    #[prost(int32, tag = "181")]
+    pub afr_enabled: i32,
+    #[prost(int32, tag = "182")]
+    pub governor: i32,
+    #[prost(int32, tag = "183")]
+    pub stereosw_mode: i32,
+    #[prost(string, tag = "184")]
+    pub music_dir: ::prost::alloc::string::String,
+}
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct SaveSettingsRequest {
+    #[prost(string, optional, tag = "1")]
+    pub music_dir: ::core::option::Option<::prost::alloc::string::String>,
+    #[prost(bool, optional, tag = "2")]
+    pub playlist_shuffle: ::core::option::Option<bool>,
+    #[prost(int32, optional, tag = "3")]
+    pub repeat_mode: ::core::option::Option<i32>,
+    #[prost(int32, optional, tag = "4")]
+    pub bass: ::core::option::Option<i32>,
+    #[prost(int32, optional, tag = "5")]
+    pub treble: ::core::option::Option<i32>,
+    #[prost(int32, optional, tag = "6")]
+    pub bass_cutoff: ::core::option::Option<i32>,
+    #[prost(int32, optional, tag = "7")]
+    pub treble_cutoff: ::core::option::Option<i32>,
+    #[prost(int32, optional, tag = "8")]
+    pub crossfade: ::core::option::Option<i32>,
+    #[prost(bool, optional, tag = "9")]
+    pub fade_on_stop: ::core::option::Option<bool>,
+    #[prost(int32, optional, tag = "10")]
+    pub fade_in_delay: ::core::option::Option<i32>,
+    #[prost(int32, optional, tag = "11")]
+    pub fade_in_duration: ::core::option::Option<i32>,
+    #[prost(int32, optional, tag = "12")]
+    pub fade_out_delay: ::core::option::Option<i32>,
+    #[prost(int32, optional, tag = "13")]
+    pub fade_out_duration: ::core::option::Option<i32>,
+    #[prost(int32, optional, tag = "14")]
+    pub fade_out_mixmode: ::core::option::Option<i32>,
+    #[prost(int32, optional, tag = "15")]
+    pub balance: ::core::option::Option<i32>,
+    #[prost(int32, optional, tag = "16")]
+    pub stereo_width: ::core::option::Option<i32>,
+    #[prost(int32, optional, tag = "17")]
+    pub stereosw_mode: ::core::option::Option<i32>,
+    #[prost(int32, optional, tag = "18")]
+    pub surround_enabled: ::core::option::Option<i32>,
+    #[prost(int32, optional, tag = "19")]
+    pub surround_balance: ::core::option::Option<i32>,
+    #[prost(int32, optional, tag = "20")]
+    pub surround_fx1: ::core::option::Option<i32>,
+    #[prost(int32, optional, tag = "21")]
+    pub surround_fx2: ::core::option::Option<i32>,
+    #[prost(bool, optional, tag = "22")]
+    pub party_mode: ::core::option::Option<bool>,
+    #[prost(int32, optional, tag = "23")]
+    pub channel_config: ::core::option::Option<i32>,
+    #[prost(string, optional, tag = "24")]
+    pub player_name: ::core::option::Option<::prost::alloc::string::String>,
+    #[prost(bool, optional, tag = "25")]
+    pub eq_enabled: ::core::option::Option<bool>,
+    #[prost(message, repeated, tag = "26")]
+    pub eq_band_settings: ::prost::alloc::vec::Vec<EqBandSetting>,
+    #[prost(message, optional, tag = "27")]
+    pub replaygain_settings: ::core::option::Option<ReplaygainSettings>,
+}
+#[derive(Clone, Copy, PartialEq, ::prost::Message)]
+pub struct SaveSettingsResponse {}
+/// Generated client implementations.
+pub mod settings_service_client {
+    #![allow(
+        unused_variables,
+        dead_code,
+        missing_docs,
+        clippy::wildcard_imports,
+        clippy::let_unit_value,
+    )]
+    use tonic::codegen::*;
+    use tonic::codegen::http::Uri;
+    #[derive(Debug, Clone)]
+    pub struct SettingsServiceClient<T> {
+        inner: tonic::client::Grpc<T>,
+    }
+    impl SettingsServiceClient<tonic::transport::Channel> {
+        /// Attempt to create a new client by connecting to a given endpoint.
+        pub async fn connect<D>(dst: D) -> Result<Self, tonic::transport::Error>
+        where
+            D: TryInto<tonic::transport::Endpoint>,
+            D::Error: Into<StdError>,
+        {
+            let conn = tonic::transport::Endpoint::new(dst)?.connect().await?;
+            Ok(Self::new(conn))
+        }
+    }
+    impl<T> SettingsServiceClient<T>
+    where
+        T: tonic::client::GrpcService<tonic::body::BoxBody>,
+        T::Error: Into<StdError>,
+        T::ResponseBody: Body<Data = Bytes> + std::marker::Send + 'static,
+        <T::ResponseBody as Body>::Error: Into<StdError> + std::marker::Send,
+    {
+        pub fn new(inner: T) -> Self {
+            let inner = tonic::client::Grpc::new(inner);
+            Self { inner }
+        }
+        pub fn with_origin(inner: T, origin: Uri) -> Self {
+            let inner = tonic::client::Grpc::with_origin(inner, origin);
+            Self { inner }
+        }
+        pub fn with_interceptor<F>(
+            inner: T,
+            interceptor: F,
+        ) -> SettingsServiceClient<InterceptedService<T, F>>
+        where
+            F: tonic::service::Interceptor,
+            T::ResponseBody: Default,
+            T: tonic::codegen::Service<
+                http::Request<tonic::body::BoxBody>,
+                Response = http::Response<
+                    <T as tonic::client::GrpcService<tonic::body::BoxBody>>::ResponseBody,
+                >,
+            >,
+            <T as tonic::codegen::Service<
+                http::Request<tonic::body::BoxBody>,
+            >>::Error: Into<StdError> + std::marker::Send + std::marker::Sync,
+        {
+            SettingsServiceClient::new(InterceptedService::new(inner, interceptor))
+        }
+        /// Compress requests with the given encoding.
+        ///
+        /// This requires the server to support it otherwise it might respond with an
+        /// error.
+        #[must_use]
+        pub fn send_compressed(mut self, encoding: CompressionEncoding) -> Self {
+            self.inner = self.inner.send_compressed(encoding);
+            self
+        }
+        /// Enable decompressing responses.
+        #[must_use]
+        pub fn accept_compressed(mut self, encoding: CompressionEncoding) -> Self {
+            self.inner = self.inner.accept_compressed(encoding);
+            self
+        }
+        /// Limits the maximum size of a decoded message.
+        ///
+        /// Default: `4MB`
+        #[must_use]
+        pub fn max_decoding_message_size(mut self, limit: usize) -> Self {
+            self.inner = self.inner.max_decoding_message_size(limit);
+            self
+        }
+        /// Limits the maximum size of an encoded message.
+        ///
+        /// Default: `usize::MAX`
+        #[must_use]
+        pub fn max_encoding_message_size(mut self, limit: usize) -> Self {
+            self.inner = self.inner.max_encoding_message_size(limit);
+            self
+        }
+        pub async fn get_settings_list(
+            &mut self,
+            request: impl tonic::IntoRequest<super::GetSettingsListRequest>,
+        ) -> std::result::Result<
+            tonic::Response<super::GetSettingsListResponse>,
+            tonic::Status,
+        > {
+            self.inner
+                .ready()
+                .await
+                .map_err(|e| {
+                    tonic::Status::unknown(
+                        format!("Service was not ready: {}", e.into()),
+                    )
+                })?;
+            let codec = tonic::codec::ProstCodec::default();
+            let path = http::uri::PathAndQuery::from_static(
+                "/rockbox.v1alpha1.SettingsService/GetSettingsList",
+            );
+            let mut req = request.into_request();
+            req.extensions_mut()
+                .insert(
+                    GrpcMethod::new(
+                        "rockbox.v1alpha1.SettingsService",
+                        "GetSettingsList",
+                    ),
+                );
+            self.inner.unary(req, path, codec).await
+        }
+        pub async fn get_global_settings(
+            &mut self,
+            request: impl tonic::IntoRequest<super::GetGlobalSettingsRequest>,
+        ) -> std::result::Result<
+            tonic::Response<super::GetGlobalSettingsResponse>,
+            tonic::Status,
+        > {
+            self.inner
+                .ready()
+                .await
+                .map_err(|e| {
+                    tonic::Status::unknown(
+                        format!("Service was not ready: {}", e.into()),
+                    )
+                })?;
+            let codec = tonic::codec::ProstCodec::default();
+            let path = http::uri::PathAndQuery::from_static(
+                "/rockbox.v1alpha1.SettingsService/GetGlobalSettings",
+            );
+            let mut req = request.into_request();
+            req.extensions_mut()
+                .insert(
+                    GrpcMethod::new(
+                        "rockbox.v1alpha1.SettingsService",
+                        "GetGlobalSettings",
+                    ),
+                );
+            self.inner.unary(req, path, codec).await
+        }
+        pub async fn save_settings(
+            &mut self,
+            request: impl tonic::IntoRequest<super::SaveSettingsRequest>,
+        ) -> std::result::Result<
+            tonic::Response<super::SaveSettingsResponse>,
+            tonic::Status,
+        > {
+            self.inner
+                .ready()
+                .await
+                .map_err(|e| {
+                    tonic::Status::unknown(
+                        format!("Service was not ready: {}", e.into()),
+                    )
+                })?;
+            let codec = tonic::codec::ProstCodec::default();
+            let path = http::uri::PathAndQuery::from_static(
+                "/rockbox.v1alpha1.SettingsService/SaveSettings",
+            );
+            let mut req = request.into_request();
+            req.extensions_mut()
+                .insert(
+                    GrpcMethod::new("rockbox.v1alpha1.SettingsService", "SaveSettings"),
+                );
+            self.inner.unary(req, path, codec).await
+        }
+    }
+}
+/// Generated server implementations.
+pub mod settings_service_server {
+    #![allow(
+        unused_variables,
+        dead_code,
+        missing_docs,
+        clippy::wildcard_imports,
+        clippy::let_unit_value,
+    )]
+    use tonic::codegen::*;
+    /// Generated trait containing gRPC methods that should be implemented for use with SettingsServiceServer.
+    #[async_trait]
+    pub trait SettingsService: std::marker::Send + std::marker::Sync + 'static {
+        async fn get_settings_list(
+            &self,
+            request: tonic::Request<super::GetSettingsListRequest>,
+        ) -> std::result::Result<
+            tonic::Response<super::GetSettingsListResponse>,
+            tonic::Status,
+        >;
+        async fn get_global_settings(
+            &self,
+            request: tonic::Request<super::GetGlobalSettingsRequest>,
+        ) -> std::result::Result<
+            tonic::Response<super::GetGlobalSettingsResponse>,
+            tonic::Status,
+        >;
+        async fn save_settings(
+            &self,
+            request: tonic::Request<super::SaveSettingsRequest>,
+        ) -> std::result::Result<
+            tonic::Response<super::SaveSettingsResponse>,
+            tonic::Status,
+        >;
+    }
+    #[derive(Debug)]
+    pub struct SettingsServiceServer<T> {
+        inner: Arc<T>,
+        accept_compression_encodings: EnabledCompressionEncodings,
+        send_compression_encodings: EnabledCompressionEncodings,
+        max_decoding_message_size: Option<usize>,
+        max_encoding_message_size: Option<usize>,
+    }
+    impl<T> SettingsServiceServer<T> {
+        pub fn new(inner: T) -> Self {
+            Self::from_arc(Arc::new(inner))
+        }
+        pub fn from_arc(inner: Arc<T>) -> Self {
+            Self {
+                inner,
+                accept_compression_encodings: Default::default(),
+                send_compression_encodings: Default::default(),
+                max_decoding_message_size: None,
+                max_encoding_message_size: None,
+            }
+        }
+        pub fn with_interceptor<F>(
+            inner: T,
+            interceptor: F,
+        ) -> InterceptedService<Self, F>
+        where
+            F: tonic::service::Interceptor,
+        {
+            InterceptedService::new(Self::new(inner), interceptor)
+        }
+        /// Enable decompressing requests with the given encoding.
+        #[must_use]
+        pub fn accept_compressed(mut self, encoding: CompressionEncoding) -> Self {
+            self.accept_compression_encodings.enable(encoding);
+            self
+        }
+        /// Compress responses with the given encoding, if the client supports it.
+        #[must_use]
+        pub fn send_compressed(mut self, encoding: CompressionEncoding) -> Self {
+            self.send_compression_encodings.enable(encoding);
+            self
+        }
+        /// Limits the maximum size of a decoded message.
+        ///
+        /// Default: `4MB`
+        #[must_use]
+        pub fn max_decoding_message_size(mut self, limit: usize) -> Self {
+            self.max_decoding_message_size = Some(limit);
+            self
+        }
+        /// Limits the maximum size of an encoded message.
+        ///
+        /// Default: `usize::MAX`
+        #[must_use]
+        pub fn max_encoding_message_size(mut self, limit: usize) -> Self {
+            self.max_encoding_message_size = Some(limit);
+            self
+        }
+    }
+    impl<T, B> tonic::codegen::Service<http::Request<B>> for SettingsServiceServer<T>
+    where
+        T: SettingsService,
+        B: Body + std::marker::Send + 'static,
+        B::Error: Into<StdError> + std::marker::Send + 'static,
+    {
+        type Response = http::Response<tonic::body::BoxBody>;
+        type Error = std::convert::Infallible;
+        type Future = BoxFuture<Self::Response, Self::Error>;
+        fn poll_ready(
+            &mut self,
+            _cx: &mut Context<'_>,
+        ) -> Poll<std::result::Result<(), Self::Error>> {
+            Poll::Ready(Ok(()))
+        }
+        fn call(&mut self, req: http::Request<B>) -> Self::Future {
+            match req.uri().path() {
+                "/rockbox.v1alpha1.SettingsService/GetSettingsList" => {
+                    #[allow(non_camel_case_types)]
+                    struct GetSettingsListSvc<T: SettingsService>(pub Arc<T>);
+                    impl<
+                        T: SettingsService,
+                    > tonic::server::UnaryService<super::GetSettingsListRequest>
+                    for GetSettingsListSvc<T> {
+                        type Response = super::GetSettingsListResponse;
+                        type Future = BoxFuture<
+                            tonic::Response<Self::Response>,
+                            tonic::Status,
+                        >;
+                        fn call(
+                            &mut self,
+                            request: tonic::Request<super::GetSettingsListRequest>,
+                        ) -> Self::Future {
+                            let inner = Arc::clone(&self.0);
+                            let fut = async move {
+                                <T as SettingsService>::get_settings_list(&inner, request)
+                                    .await
+                            };
+                            Box::pin(fut)
+                        }
+                    }
+                    let accept_compression_encodings = self.accept_compression_encodings;
+                    let send_compression_encodings = self.send_compression_encodings;
+                    let max_decoding_message_size = self.max_decoding_message_size;
+                    let max_encoding_message_size = self.max_encoding_message_size;
+                    let inner = self.inner.clone();
+                    let fut = async move {
+                        let method = GetSettingsListSvc(inner);
+                        let codec = tonic::codec::ProstCodec::default();
+                        let mut grpc = tonic::server::Grpc::new(codec)
+                            .apply_compression_config(
+                                accept_compression_encodings,
+                                send_compression_encodings,
+                            )
+                            .apply_max_message_size_config(
+                                max_decoding_message_size,
+                                max_encoding_message_size,
+                            );
+                        let res = grpc.unary(method, req).await;
+                        Ok(res)
+                    };
+                    Box::pin(fut)
+                }
+                "/rockbox.v1alpha1.SettingsService/GetGlobalSettings" => {
+                    #[allow(non_camel_case_types)]
+                    struct GetGlobalSettingsSvc<T: SettingsService>(pub Arc<T>);
+                    impl<
+                        T: SettingsService,
+                    > tonic::server::UnaryService<super::GetGlobalSettingsRequest>
+                    for GetGlobalSettingsSvc<T> {
+                        type Response = super::GetGlobalSettingsResponse;
+                        type Future = BoxFuture<
+                            tonic::Response<Self::Response>,
+                            tonic::Status,
+                        >;
+                        fn call(
+                            &mut self,
+                            request: tonic::Request<super::GetGlobalSettingsRequest>,
+                        ) -> Self::Future {
+                            let inner = Arc::clone(&self.0);
+                            let fut = async move {
+                                <T as SettingsService>::get_global_settings(&inner, request)
+                                    .await
+                            };
+                            Box::pin(fut)
+                        }
+                    }
+                    let accept_compression_encodings = self.accept_compression_encodings;
+                    let send_compression_encodings = self.send_compression_encodings;
+                    let max_decoding_message_size = self.max_decoding_message_size;
+                    let max_encoding_message_size = self.max_encoding_message_size;
+                    let inner = self.inner.clone();
+                    let fut = async move {
+                        let method = GetGlobalSettingsSvc(inner);
+                        let codec = tonic::codec::ProstCodec::default();
+                        let mut grpc = tonic::server::Grpc::new(codec)
+                            .apply_compression_config(
+                                accept_compression_encodings,
+                                send_compression_encodings,
+                            )
+                            .apply_max_message_size_config(
+                                max_decoding_message_size,
+                                max_encoding_message_size,
+                            );
+                        let res = grpc.unary(method, req).await;
+                        Ok(res)
+                    };
+                    Box::pin(fut)
+                }
+                "/rockbox.v1alpha1.SettingsService/SaveSettings" => {
+                    #[allow(non_camel_case_types)]
+                    struct SaveSettingsSvc<T: SettingsService>(pub Arc<T>);
+                    impl<
+                        T: SettingsService,
+                    > tonic::server::UnaryService<super::SaveSettingsRequest>
+                    for SaveSettingsSvc<T> {
+                        type Response = super::SaveSettingsResponse;
+                        type Future = BoxFuture<
+                            tonic::Response<Self::Response>,
+                            tonic::Status,
+                        >;
+                        fn call(
+                            &mut self,
+                            request: tonic::Request<super::SaveSettingsRequest>,
+                        ) -> Self::Future {
+                            let inner = Arc::clone(&self.0);
+                            let fut = async move {
+                                <T as SettingsService>::save_settings(&inner, request).await
+                            };
+                            Box::pin(fut)
+                        }
+                    }
+                    let accept_compression_encodings = self.accept_compression_encodings;
+                    let send_compression_encodings = self.send_compression_encodings;
+                    let max_decoding_message_size = self.max_decoding_message_size;
+                    let max_encoding_message_size = self.max_encoding_message_size;
+                    let inner = self.inner.clone();
+                    let fut = async move {
+                        let method = SaveSettingsSvc(inner);
+                        let codec = tonic::codec::ProstCodec::default();
+                        let mut grpc = tonic::server::Grpc::new(codec)
+                            .apply_compression_config(
+                                accept_compression_encodings,
+                                send_compression_encodings,
+                            )
+                            .apply_max_message_size_config(
+                                max_decoding_message_size,
+                                max_encoding_message_size,
+                            );
+                        let res = grpc.unary(method, req).await;
+                        Ok(res)
+                    };
+                    Box::pin(fut)
+                }
+                _ => {
+                    Box::pin(async move {
+                        let mut response = http::Response::new(empty_body());
+                        let headers = response.headers_mut();
+                        headers
+                            .insert(
+                                tonic::Status::GRPC_STATUS,
+                                (tonic::Code::Unimplemented as i32).into(),
+                            );
+                        headers
+                            .insert(
+                                http::header::CONTENT_TYPE,
+                                tonic::metadata::GRPC_CONTENT_TYPE,
+                            );
+                        Ok(response)
+                    })
+                }
+            }
+        }
+    }
+    impl<T> Clone for SettingsServiceServer<T> {
+        fn clone(&self) -> Self {
+            let inner = self.inner.clone();
+            Self {
+                inner,
+                accept_compression_encodings: self.accept_compression_encodings,
+                send_compression_encodings: self.send_compression_encodings,
+                max_decoding_message_size: self.max_decoding_message_size,
+                max_encoding_message_size: self.max_encoding_message_size,
+            }
+        }
+    }
+    /// Generated gRPC service name
+    pub const SERVICE_NAME: &str = "rockbox.v1alpha1.SettingsService";
+    impl<T> tonic::server::NamedService for SettingsServiceServer<T> {
+        const NAME: &'static str = SERVICE_NAME;
+    }
+}
+#[derive(Clone, Copy, PartialEq, ::prost::Message)]
+pub struct AdjustVolumeRequest {
+    #[prost(int32, tag = "1")]
+    pub steps: i32,
+}
+#[derive(Clone, Copy, PartialEq, ::prost::Message)]
+pub struct AdjustVolumeResponse {}
+#[derive(Clone, Copy, PartialEq, ::prost::Message)]
+pub struct SoundSetRequest {
+    #[prost(int32, tag = "1")]
+    pub setting: i32,
+    #[prost(int32, tag = "2")]
+    pub value: i32,
+}
+#[derive(Clone, Copy, PartialEq, ::prost::Message)]
+pub struct SoundSetResponse {}
+#[derive(Clone, Copy, PartialEq, ::prost::Message)]
+pub struct SoundCurrentRequest {
+    #[prost(int32, tag = "1")]
+    pub setting: i32,
+}
+#[derive(Clone, Copy, PartialEq, ::prost::Message)]
+pub struct SoundCurrentResponse {
+    #[prost(int32, tag = "1")]
+    pub value: i32,
+}
+#[derive(Clone, Copy, PartialEq, ::prost::Message)]
+pub struct SoundDefaultRequest {
+    #[prost(int32, tag = "1")]
+    pub setting: i32,
+}
+#[derive(Clone, Copy, PartialEq, ::prost::Message)]
+pub struct SoundDefaultResponse {
+    #[prost(int32, tag = "1")]
+    pub value: i32,
+}
+#[derive(Clone, Copy, PartialEq, ::prost::Message)]
+pub struct SoundMinRequest {
+    #[prost(int32, tag = "1")]
+    pub setting: i32,
+}
+#[derive(Clone, Copy, PartialEq, ::prost::Message)]
+pub struct SoundMinResponse {
+    #[prost(int32, tag = "1")]
+    pub value: i32,
+}
+#[derive(Clone, Copy, PartialEq, ::prost::Message)]
+pub struct SoundMaxRequest {
+    #[prost(int32, tag = "1")]
+    pub setting: i32,
+}
+#[derive(Clone, Copy, PartialEq, ::prost::Message)]
+pub struct SoundMaxResponse {
+    #[prost(int32, tag = "1")]
+    pub value: i32,
+}
+#[derive(Clone, Copy, PartialEq, ::prost::Message)]
+pub struct SoundUnitRequest {}
+#[derive(Clone, Copy, PartialEq, ::prost::Message)]
+pub struct SoundUnitResponse {}
+#[derive(Clone, Copy, PartialEq, ::prost::Message)]
+pub struct SoundVal2PhysRequest {
+    #[prost(int32, tag = "1")]
+    pub setting: i32,
+    #[prost(int32, tag = "2")]
+    pub value: i32,
+}
+#[derive(Clone, Copy, PartialEq, ::prost::Message)]
+pub struct SoundVal2PhysResponse {
+    #[prost(int32, tag = "1")]
+    pub value: i32,
+}
+#[derive(Clone, Copy, PartialEq, ::prost::Message)]
+pub struct GetPitchRequest {}
+#[derive(Clone, Copy, PartialEq, ::prost::Message)]
+pub struct GetPitchResponse {
+    #[prost(int32, tag = "1")]
+    pub value: i32,
+}
+#[derive(Clone, Copy, PartialEq, ::prost::Message)]
+pub struct SetPitchRequest {
+    #[prost(int32, tag = "1")]
+    pub value: i32,
+}
+#[derive(Clone, Copy, PartialEq, ::prost::Message)]
+pub struct SetPitchResponse {}
+#[derive(Clone, Copy, PartialEq, ::prost::Message)]
+pub struct BeepPlayRequest {
+    #[prost(uint32, tag = "1")]
+    pub frequency: u32,
+    #[prost(uint32, tag = "2")]
+    pub duration: u32,
+    #[prost(uint32, tag = "3")]
+    pub amplitude: u32,
+}
+#[derive(Clone, Copy, PartialEq, ::prost::Message)]
+pub struct BeepPlayResponse {}
+#[derive(Clone, Copy, PartialEq, ::prost::Message)]
+pub struct PcmbufFadeRequest {
+    #[prost(int32, tag = "1")]
+    pub fade: i32,
+    #[prost(bool, tag = "2")]
+    pub r#in: bool,
+}
+#[derive(Clone, Copy, PartialEq, ::prost::Message)]
+pub struct PcmbufFadeResponse {}
+#[derive(Clone, Copy, PartialEq, ::prost::Message)]
+pub struct PcmbufSetLowLatencyRequest {
+    #[prost(bool, tag = "1")]
+    pub state: bool,
+}
+#[derive(Clone, Copy, PartialEq, ::prost::Message)]
+pub struct PcmbufSetLowLatencyResponse {}
+#[derive(Clone, Copy, PartialEq, ::prost::Message)]
+pub struct SystemSoundPlayRequest {
+    #[prost(uint32, tag = "1")]
+    pub sound: u32,
+}
+#[derive(Clone, Copy, PartialEq, ::prost::Message)]
+pub struct SystemSoundPlayResponse {}
+#[derive(Clone, Copy, PartialEq, ::prost::Message)]
+pub struct KeyclickClickRequest {
+    #[prost(bool, tag = "1")]
+    pub rawbutton: bool,
+    #[prost(int32, tag = "2")]
+    pub action: i32,
+}
+#[derive(Clone, Copy, PartialEq, ::prost::Message)]
+pub struct KeyclickClickResponse {}
+/// Generated client implementations.
+pub mod sound_service_client {
+    #![allow(
+        unused_variables,
+        dead_code,
+        missing_docs,
+        clippy::wildcard_imports,
+        clippy::let_unit_value,
+    )]
+    use tonic::codegen::*;
+    use tonic::codegen::http::Uri;
+    #[derive(Debug, Clone)]
+    pub struct SoundServiceClient<T> {
+        inner: tonic::client::Grpc<T>,
+    }
+    impl SoundServiceClient<tonic::transport::Channel> {
+        /// Attempt to create a new client by connecting to a given endpoint.
+        pub async fn connect<D>(dst: D) -> Result<Self, tonic::transport::Error>
+        where
+            D: TryInto<tonic::transport::Endpoint>,
+            D::Error: Into<StdError>,
+        {
+            let conn = tonic::transport::Endpoint::new(dst)?.connect().await?;
+            Ok(Self::new(conn))
+        }
+    }
+    impl<T> SoundServiceClient<T>
+    where
+        T: tonic::client::GrpcService<tonic::body::BoxBody>,
+        T::Error: Into<StdError>,
+        T::ResponseBody: Body<Data = Bytes> + std::marker::Send + 'static,
+        <T::ResponseBody as Body>::Error: Into<StdError> + std::marker::Send,
+    {
+        pub fn new(inner: T) -> Self {
+            let inner = tonic::client::Grpc::new(inner);
+            Self { inner }
+        }
+        pub fn with_origin(inner: T, origin: Uri) -> Self {
+            let inner = tonic::client::Grpc::with_origin(inner, origin);
+            Self { inner }
+        }
+        pub fn with_interceptor<F>(
+            inner: T,
+            interceptor: F,
+        ) -> SoundServiceClient<InterceptedService<T, F>>
+        where
+            F: tonic::service::Interceptor,
+            T::ResponseBody: Default,
+            T: tonic::codegen::Service<
+                http::Request<tonic::body::BoxBody>,
+                Response = http::Response<
+                    <T as tonic::client::GrpcService<tonic::body::BoxBody>>::ResponseBody,
+                >,
+            >,
+            <T as tonic::codegen::Service<
+                http::Request<tonic::body::BoxBody>,
+            >>::Error: Into<StdError> + std::marker::Send + std::marker::Sync,
+        {
+            SoundServiceClient::new(InterceptedService::new(inner, interceptor))
+        }
+        /// Compress requests with the given encoding.
+        ///
+        /// This requires the server to support it otherwise it might respond with an
+        /// error.
+        #[must_use]
+        pub fn send_compressed(mut self, encoding: CompressionEncoding) -> Self {
+            self.inner = self.inner.send_compressed(encoding);
+            self
+        }
+        /// Enable decompressing responses.
+        #[must_use]
+        pub fn accept_compressed(mut self, encoding: CompressionEncoding) -> Self {
+            self.inner = self.inner.accept_compressed(encoding);
+            self
+        }
+        /// Limits the maximum size of a decoded message.
+        ///
+        /// Default: `4MB`
+        #[must_use]
+        pub fn max_decoding_message_size(mut self, limit: usize) -> Self {
+            self.inner = self.inner.max_decoding_message_size(limit);
+            self
+        }
+        /// Limits the maximum size of an encoded message.
+        ///
+        /// Default: `usize::MAX`
+        #[must_use]
+        pub fn max_encoding_message_size(mut self, limit: usize) -> Self {
+            self.inner = self.inner.max_encoding_message_size(limit);
+            self
+        }
+        pub async fn adjust_volume(
+            &mut self,
+            request: impl tonic::IntoRequest<super::AdjustVolumeRequest>,
+        ) -> std::result::Result<
+            tonic::Response<super::AdjustVolumeResponse>,
+            tonic::Status,
+        > {
+            self.inner
+                .ready()
+                .await
+                .map_err(|e| {
+                    tonic::Status::unknown(
+                        format!("Service was not ready: {}", e.into()),
+                    )
+                })?;
+            let codec = tonic::codec::ProstCodec::default();
+            let path = http::uri::PathAndQuery::from_static(
+                "/rockbox.v1alpha1.SoundService/AdjustVolume",
+            );
+            let mut req = request.into_request();
+            req.extensions_mut()
+                .insert(
+                    GrpcMethod::new("rockbox.v1alpha1.SoundService", "AdjustVolume"),
+                );
+            self.inner.unary(req, path, codec).await
+        }
+        pub async fn sound_set(
+            &mut self,
+            request: impl tonic::IntoRequest<super::SoundSetRequest>,
+        ) -> std::result::Result<
+            tonic::Response<super::SoundSetResponse>,
+            tonic::Status,
+        > {
+            self.inner
+                .ready()
+                .await
+                .map_err(|e| {
+                    tonic::Status::unknown(
+                        format!("Service was not ready: {}", e.into()),
+                    )
+                })?;
+            let codec = tonic::codec::ProstCodec::default();
+            let path = http::uri::PathAndQuery::from_static(
+                "/rockbox.v1alpha1.SoundService/SoundSet",
+            );
+            let mut req = request.into_request();
+            req.extensions_mut()
+                .insert(GrpcMethod::new("rockbox.v1alpha1.SoundService", "SoundSet"));
+            self.inner.unary(req, path, codec).await
+        }
+        pub async fn sound_current(
+            &mut self,
+            request: impl tonic::IntoRequest<super::SoundCurrentRequest>,
+        ) -> std::result::Result<
+            tonic::Response<super::SoundCurrentResponse>,
+            tonic::Status,
+        > {
+            self.inner
+                .ready()
+                .await
+                .map_err(|e| {
+                    tonic::Status::unknown(
+                        format!("Service was not ready: {}", e.into()),
+                    )
+                })?;
+            let codec = tonic::codec::ProstCodec::default();
+            let path = http::uri::PathAndQuery::from_static(
+                "/rockbox.v1alpha1.SoundService/SoundCurrent",
+            );
+            let mut req = request.into_request();
+            req.extensions_mut()
+                .insert(
+                    GrpcMethod::new("rockbox.v1alpha1.SoundService", "SoundCurrent"),
+                );
+            self.inner.unary(req, path, codec).await
+        }
+        pub async fn sound_default(
+            &mut self,
+            request: impl tonic::IntoRequest<super::SoundDefaultRequest>,
+        ) -> std::result::Result<
+            tonic::Response<super::SoundDefaultResponse>,
+            tonic::Status,
+        > {
+            self.inner
+                .ready()
+                .await
+                .map_err(|e| {
+                    tonic::Status::unknown(
+                        format!("Service was not ready: {}", e.into()),
+                    )
+                })?;
+            let codec = tonic::codec::ProstCodec::default();
+            let path = http::uri::PathAndQuery::from_static(
+                "/rockbox.v1alpha1.SoundService/SoundDefault",
+            );
+            let mut req = request.into_request();
+            req.extensions_mut()
+                .insert(
+                    GrpcMethod::new("rockbox.v1alpha1.SoundService", "SoundDefault"),
+                );
+            self.inner.unary(req, path, codec).await
+        }
+        pub async fn sound_min(
+            &mut self,
+            request: impl tonic::IntoRequest<super::SoundMinRequest>,
+        ) -> std::result::Result<
+            tonic::Response<super::SoundMinResponse>,
+            tonic::Status,
+        > {
+            self.inner
+                .ready()
+                .await
+                .map_err(|e| {
+                    tonic::Status::unknown(
+                        format!("Service was not ready: {}", e.into()),
+                    )
+                })?;
+            let codec = tonic::codec::ProstCodec::default();
+            let path = http::uri::PathAndQuery::from_static(
+                "/rockbox.v1alpha1.SoundService/SoundMin",
+            );
+            let mut req = request.into_request();
+            req.extensions_mut()
+                .insert(GrpcMethod::new("rockbox.v1alpha1.SoundService", "SoundMin"));
+            self.inner.unary(req, path, codec).await
+        }
+        pub async fn sound_max(
+            &mut self,
+            request: impl tonic::IntoRequest<super::SoundMaxRequest>,
+        ) -> std::result::Result<
+            tonic::Response<super::SoundMaxResponse>,
+            tonic::Status,
+        > {
+            self.inner
+                .ready()
+                .await
+                .map_err(|e| {
+                    tonic::Status::unknown(
+                        format!("Service was not ready: {}", e.into()),
+                    )
+                })?;
+            let codec = tonic::codec::ProstCodec::default();
+            let path = http::uri::PathAndQuery::from_static(
+                "/rockbox.v1alpha1.SoundService/SoundMax",
+            );
+            let mut req = request.into_request();
+            req.extensions_mut()
+                .insert(GrpcMethod::new("rockbox.v1alpha1.SoundService", "SoundMax"));
+            self.inner.unary(req, path, codec).await
+        }
+        pub async fn sound_unit(
+            &mut self,
+            request: impl tonic::IntoRequest<super::SoundUnitRequest>,
+        ) -> std::result::Result<
+            tonic::Response<super::SoundUnitResponse>,
+            tonic::Status,
+        > {
+            self.inner
+                .ready()
+                .await
+                .map_err(|e| {
+                    tonic::Status::unknown(
+                        format!("Service was not ready: {}", e.into()),
+                    )
+                })?;
+            let codec = tonic::codec::ProstCodec::default();
+            let path = http::uri::PathAndQuery::from_static(
+                "/rockbox.v1alpha1.SoundService/SoundUnit",
+            );
+            let mut req = request.into_request();
+            req.extensions_mut()
+                .insert(GrpcMethod::new("rockbox.v1alpha1.SoundService", "SoundUnit"));
+            self.inner.unary(req, path, codec).await
+        }
+        pub async fn sound_val2_phys(
+            &mut self,
+            request: impl tonic::IntoRequest<super::SoundVal2PhysRequest>,
+        ) -> std::result::Result<
+            tonic::Response<super::SoundVal2PhysResponse>,
+            tonic::Status,
+        > {
+            self.inner
+                .ready()
+                .await
+                .map_err(|e| {
+                    tonic::Status::unknown(
+                        format!("Service was not ready: {}", e.into()),
+                    )
+                })?;
+            let codec = tonic::codec::ProstCodec::default();
+            let path = http::uri::PathAndQuery::from_static(
+                "/rockbox.v1alpha1.SoundService/SoundVal2Phys",
+            );
+            let mut req = request.into_request();
+            req.extensions_mut()
+                .insert(
+                    GrpcMethod::new("rockbox.v1alpha1.SoundService", "SoundVal2Phys"),
+                );
+            self.inner.unary(req, path, codec).await
+        }
+        pub async fn get_pitch(
+            &mut self,
+            request: impl tonic::IntoRequest<super::GetPitchRequest>,
+        ) -> std::result::Result<
+            tonic::Response<super::GetPitchResponse>,
+            tonic::Status,
+        > {
+            self.inner
+                .ready()
+                .await
+                .map_err(|e| {
+                    tonic::Status::unknown(
+                        format!("Service was not ready: {}", e.into()),
+                    )
+                })?;
+            let codec = tonic::codec::ProstCodec::default();
+            let path = http::uri::PathAndQuery::from_static(
+                "/rockbox.v1alpha1.SoundService/GetPitch",
+            );
+            let mut req = request.into_request();
+            req.extensions_mut()
+                .insert(GrpcMethod::new("rockbox.v1alpha1.SoundService", "GetPitch"));
+            self.inner.unary(req, path, codec).await
+        }
+        pub async fn set_pitch(
+            &mut self,
+            request: impl tonic::IntoRequest<super::SetPitchRequest>,
+        ) -> std::result::Result<
+            tonic::Response<super::SetPitchResponse>,
+            tonic::Status,
+        > {
+            self.inner
+                .ready()
+                .await
+                .map_err(|e| {
+                    tonic::Status::unknown(
+                        format!("Service was not ready: {}", e.into()),
+                    )
+                })?;
+            let codec = tonic::codec::ProstCodec::default();
+            let path = http::uri::PathAndQuery::from_static(
+                "/rockbox.v1alpha1.SoundService/SetPitch",
+            );
+            let mut req = request.into_request();
+            req.extensions_mut()
+                .insert(GrpcMethod::new("rockbox.v1alpha1.SoundService", "SetPitch"));
+            self.inner.unary(req, path, codec).await
+        }
+        pub async fn beep_play(
+            &mut self,
+            request: impl tonic::IntoRequest<super::BeepPlayRequest>,
+        ) -> std::result::Result<
+            tonic::Response<super::BeepPlayResponse>,
+            tonic::Status,
+        > {
+            self.inner
+                .ready()
+                .await
+                .map_err(|e| {
+                    tonic::Status::unknown(
+                        format!("Service was not ready: {}", e.into()),
+                    )
+                })?;
+            let codec = tonic::codec::ProstCodec::default();
+            let path = http::uri::PathAndQuery::from_static(
+                "/rockbox.v1alpha1.SoundService/BeepPlay",
+            );
+            let mut req = request.into_request();
+            req.extensions_mut()
+                .insert(GrpcMethod::new("rockbox.v1alpha1.SoundService", "BeepPlay"));
+            self.inner.unary(req, path, codec).await
+        }
+        pub async fn pcmbuf_fade(
+            &mut self,
+            request: impl tonic::IntoRequest<super::PcmbufFadeRequest>,
+        ) -> std::result::Result<
+            tonic::Response<super::PcmbufFadeResponse>,
+            tonic::Status,
+        > {
+            self.inner
+                .ready()
+                .await
+                .map_err(|e| {
+                    tonic::Status::unknown(
+                        format!("Service was not ready: {}", e.into()),
+                    )
+                })?;
+            let codec = tonic::codec::ProstCodec::default();
+            let path = http::uri::PathAndQuery::from_static(
+                "/rockbox.v1alpha1.SoundService/PcmbufFade",
+            );
+            let mut req = request.into_request();
+            req.extensions_mut()
+                .insert(GrpcMethod::new("rockbox.v1alpha1.SoundService", "PcmbufFade"));
+            self.inner.unary(req, path, codec).await
+        }
+        pub async fn pcmbuf_set_low_latency(
+            &mut self,
+            request: impl tonic::IntoRequest<super::PcmbufSetLowLatencyRequest>,
+        ) -> std::result::Result<
+            tonic::Response<super::PcmbufSetLowLatencyResponse>,
+            tonic::Status,
+        > {
+            self.inner
+                .ready()
+                .await
+                .map_err(|e| {
+                    tonic::Status::unknown(
+                        format!("Service was not ready: {}", e.into()),
+                    )
+                })?;
+            let codec = tonic::codec::ProstCodec::default();
+            let path = http::uri::PathAndQuery::from_static(
+                "/rockbox.v1alpha1.SoundService/PcmbufSetLowLatency",
+            );
+            let mut req = request.into_request();
+            req.extensions_mut()
+                .insert(
+                    GrpcMethod::new(
+                        "rockbox.v1alpha1.SoundService",
+                        "PcmbufSetLowLatency",
+                    ),
+                );
+            self.inner.unary(req, path, codec).await
+        }
+        pub async fn system_sound_play(
+            &mut self,
+            request: impl tonic::IntoRequest<super::SystemSoundPlayRequest>,
+        ) -> std::result::Result<
+            tonic::Response<super::SystemSoundPlayResponse>,
+            tonic::Status,
+        > {
+            self.inner
+                .ready()
+                .await
+                .map_err(|e| {
+                    tonic::Status::unknown(
+                        format!("Service was not ready: {}", e.into()),
+                    )
+                })?;
+            let codec = tonic::codec::ProstCodec::default();
+            let path = http::uri::PathAndQuery::from_static(
+                "/rockbox.v1alpha1.SoundService/SystemSoundPlay",
+            );
+            let mut req = request.into_request();
+            req.extensions_mut()
+                .insert(
+                    GrpcMethod::new("rockbox.v1alpha1.SoundService", "SystemSoundPlay"),
+                );
+            self.inner.unary(req, path, codec).await
+        }
+        pub async fn keyclick_click(
+            &mut self,
+            request: impl tonic::IntoRequest<super::KeyclickClickRequest>,
+        ) -> std::result::Result<
+            tonic::Response<super::KeyclickClickResponse>,
+            tonic::Status,
+        > {
+            self.inner
+                .ready()
+                .await
+                .map_err(|e| {
+                    tonic::Status::unknown(
+                        format!("Service was not ready: {}", e.into()),
+                    )
+                })?;
+            let codec = tonic::codec::ProstCodec::default();
+            let path = http::uri::PathAndQuery::from_static(
+                "/rockbox.v1alpha1.SoundService/KeyclickClick",
+            );
+            let mut req = request.into_request();
+            req.extensions_mut()
+                .insert(
+                    GrpcMethod::new("rockbox.v1alpha1.SoundService", "KeyclickClick"),
+                );
+            self.inner.unary(req, path, codec).await
+        }
+    }
+}
+/// Generated server implementations.
+pub mod sound_service_server {
+    #![allow(
+        unused_variables,
+        dead_code,
+        missing_docs,
+        clippy::wildcard_imports,
+        clippy::let_unit_value,
+    )]
+    use tonic::codegen::*;
+    /// Generated trait containing gRPC methods that should be implemented for use with SoundServiceServer.
+    #[async_trait]
+    pub trait SoundService: std::marker::Send + std::marker::Sync + 'static {
+        async fn adjust_volume(
+            &self,
+            request: tonic::Request<super::AdjustVolumeRequest>,
+        ) -> std::result::Result<
+            tonic::Response<super::AdjustVolumeResponse>,
+            tonic::Status,
+        >;
+        async fn sound_set(
+            &self,
+            request: tonic::Request<super::SoundSetRequest>,
+        ) -> std::result::Result<
+            tonic::Response<super::SoundSetResponse>,
+            tonic::Status,
+        >;
+        async fn sound_current(
+            &self,
+            request: tonic::Request<super::SoundCurrentRequest>,
+        ) -> std::result::Result<
+            tonic::Response<super::SoundCurrentResponse>,
+            tonic::Status,
+        >;
+        async fn sound_default(
+            &self,
+            request: tonic::Request<super::SoundDefaultRequest>,
+        ) -> std::result::Result<
+            tonic::Response<super::SoundDefaultResponse>,
+            tonic::Status,
+        >;
+        async fn sound_min(
+            &self,
+            request: tonic::Request<super::SoundMinRequest>,
+        ) -> std::result::Result<
+            tonic::Response<super::SoundMinResponse>,
+            tonic::Status,
+        >;
+        async fn sound_max(
+            &self,
+            request: tonic::Request<super::SoundMaxRequest>,
+        ) -> std::result::Result<
+            tonic::Response<super::SoundMaxResponse>,
+            tonic::Status,
+        >;
+        async fn sound_unit(
+            &self,
+            request: tonic::Request<super::SoundUnitRequest>,
+        ) -> std::result::Result<
+            tonic::Response<super::SoundUnitResponse>,
+            tonic::Status,
+        >;
+        async fn sound_val2_phys(
+            &self,
+            request: tonic::Request<super::SoundVal2PhysRequest>,
+        ) -> std::result::Result<
+            tonic::Response<super::SoundVal2PhysResponse>,
+            tonic::Status,
+        >;
+        async fn get_pitch(
+            &self,
+            request: tonic::Request<super::GetPitchRequest>,
+        ) -> std::result::Result<
+            tonic::Response<super::GetPitchResponse>,
+            tonic::Status,
+        >;
+        async fn set_pitch(
+            &self,
+            request: tonic::Request<super::SetPitchRequest>,
+        ) -> std::result::Result<
+            tonic::Response<super::SetPitchResponse>,
+            tonic::Status,
+        >;
+        async fn beep_play(
+            &self,
+            request: tonic::Request<super::BeepPlayRequest>,
+        ) -> std::result::Result<
+            tonic::Response<super::BeepPlayResponse>,
+            tonic::Status,
+        >;
+        async fn pcmbuf_fade(
+            &self,
+            request: tonic::Request<super::PcmbufFadeRequest>,
+        ) -> std::result::Result<
+            tonic::Response<super::PcmbufFadeResponse>,
+            tonic::Status,
+        >;
+        async fn pcmbuf_set_low_latency(
+            &self,
+            request: tonic::Request<super::PcmbufSetLowLatencyRequest>,
+        ) -> std::result::Result<
+            tonic::Response<super::PcmbufSetLowLatencyResponse>,
+            tonic::Status,
+        >;
+        async fn system_sound_play(
+            &self,
+            request: tonic::Request<super::SystemSoundPlayRequest>,
+        ) -> std::result::Result<
+            tonic::Response<super::SystemSoundPlayResponse>,
+            tonic::Status,
+        >;
+        async fn keyclick_click(
+            &self,
+            request: tonic::Request<super::KeyclickClickRequest>,
+        ) -> std::result::Result<
+            tonic::Response<super::KeyclickClickResponse>,
+            tonic::Status,
+        >;
+    }
+    #[derive(Debug)]
+    pub struct SoundServiceServer<T> {
+        inner: Arc<T>,
+        accept_compression_encodings: EnabledCompressionEncodings,
+        send_compression_encodings: EnabledCompressionEncodings,
+        max_decoding_message_size: Option<usize>,
+        max_encoding_message_size: Option<usize>,
+    }
+    impl<T> SoundServiceServer<T> {
+        pub fn new(inner: T) -> Self {
+            Self::from_arc(Arc::new(inner))
+        }
+        pub fn from_arc(inner: Arc<T>) -> Self {
+            Self {
+                inner,
+                accept_compression_encodings: Default::default(),
+                send_compression_encodings: Default::default(),
+                max_decoding_message_size: None,
+                max_encoding_message_size: None,
+            }
+        }
+        pub fn with_interceptor<F>(
+            inner: T,
+            interceptor: F,
+        ) -> InterceptedService<Self, F>
+        where
+            F: tonic::service::Interceptor,
+        {
+            InterceptedService::new(Self::new(inner), interceptor)
+        }
+        /// Enable decompressing requests with the given encoding.
+        #[must_use]
+        pub fn accept_compressed(mut self, encoding: CompressionEncoding) -> Self {
+            self.accept_compression_encodings.enable(encoding);
+            self
+        }
+        /// Compress responses with the given encoding, if the client supports it.
+        #[must_use]
+        pub fn send_compressed(mut self, encoding: CompressionEncoding) -> Self {
+            self.send_compression_encodings.enable(encoding);
+            self
+        }
+        /// Limits the maximum size of a decoded message.
+        ///
+        /// Default: `4MB`
+        #[must_use]
+        pub fn max_decoding_message_size(mut self, limit: usize) -> Self {
+            self.max_decoding_message_size = Some(limit);
+            self
+        }
+        /// Limits the maximum size of an encoded message.
+        ///
+        /// Default: `usize::MAX`
+        #[must_use]
+        pub fn max_encoding_message_size(mut self, limit: usize) -> Self {
+            self.max_encoding_message_size = Some(limit);
+            self
+        }
+    }
+    impl<T, B> tonic::codegen::Service<http::Request<B>> for SoundServiceServer<T>
+    where
+        T: SoundService,
+        B: Body + std::marker::Send + 'static,
+        B::Error: Into<StdError> + std::marker::Send + 'static,
+    {
+        type Response = http::Response<tonic::body::BoxBody>;
+        type Error = std::convert::Infallible;
+        type Future = BoxFuture<Self::Response, Self::Error>;
+        fn poll_ready(
+            &mut self,
+            _cx: &mut Context<'_>,
+        ) -> Poll<std::result::Result<(), Self::Error>> {
+            Poll::Ready(Ok(()))
+        }
+        fn call(&mut self, req: http::Request<B>) -> Self::Future {
+            match req.uri().path() {
+                "/rockbox.v1alpha1.SoundService/AdjustVolume" => {
+                    #[allow(non_camel_case_types)]
+                    struct AdjustVolumeSvc<T: SoundService>(pub Arc<T>);
+                    impl<
+                        T: SoundService,
+                    > tonic::server::UnaryService<super::AdjustVolumeRequest>
+                    for AdjustVolumeSvc<T> {
+                        type Response = super::AdjustVolumeResponse;
+                        type Future = BoxFuture<
+                            tonic::Response<Self::Response>,
+                            tonic::Status,
+                        >;
+                        fn call(
+                            &mut self,
+                            request: tonic::Request<super::AdjustVolumeRequest>,
+                        ) -> Self::Future {
+                            let inner = Arc::clone(&self.0);
+                            let fut = async move {
+                                <T as SoundService>::adjust_volume(&inner, request).await
+                            };
+                            Box::pin(fut)
+                        }
+                    }
+                    let accept_compression_encodings = self.accept_compression_encodings;
+                    let send_compression_encodings = self.send_compression_encodings;
+                    let max_decoding_message_size = self.max_decoding_message_size;
+                    let max_encoding_message_size = self.max_encoding_message_size;
+                    let inner = self.inner.clone();
+                    let fut = async move {
+                        let method = AdjustVolumeSvc(inner);
+                        let codec = tonic::codec::ProstCodec::default();
+                        let mut grpc = tonic::server::Grpc::new(codec)
+                            .apply_compression_config(
+                                accept_compression_encodings,
+                                send_compression_encodings,
+                            )
+                            .apply_max_message_size_config(
+                                max_decoding_message_size,
+                                max_encoding_message_size,
+                            );
+                        let res = grpc.unary(method, req).await;
+                        Ok(res)
+                    };
+                    Box::pin(fut)
+                }
+                "/rockbox.v1alpha1.SoundService/SoundSet" => {
+                    #[allow(non_camel_case_types)]
+                    struct SoundSetSvc<T: SoundService>(pub Arc<T>);
+                    impl<
+                        T: SoundService,
+                    > tonic::server::UnaryService<super::SoundSetRequest>
+                    for SoundSetSvc<T> {
+                        type Response = super::SoundSetResponse;
+                        type Future = BoxFuture<
+                            tonic::Response<Self::Response>,
+                            tonic::Status,
+                        >;
+                        fn call(
+                            &mut self,
+                            request: tonic::Request<super::SoundSetRequest>,
+                        ) -> Self::Future {
+                            let inner = Arc::clone(&self.0);
+                            let fut = async move {
+                                <T as SoundService>::sound_set(&inner, request).await
+                            };
+                            Box::pin(fut)
+                        }
+                    }
+                    let accept_compression_encodings = self.accept_compression_encodings;
+                    let send_compression_encodings = self.send_compression_encodings;
+                    let max_decoding_message_size = self.max_decoding_message_size;
+                    let max_encoding_message_size = self.max_encoding_message_size;
+                    let inner = self.inner.clone();
+                    let fut = async move {
+                        let method = SoundSetSvc(inner);
+                        let codec = tonic::codec::ProstCodec::default();
+                        let mut grpc = tonic::server::Grpc::new(codec)
+                            .apply_compression_config(
+                                accept_compression_encodings,
+                                send_compression_encodings,
+                            )
+                            .apply_max_message_size_config(
+                                max_decoding_message_size,
+                                max_encoding_message_size,
+                            );
+                        let res = grpc.unary(method, req).await;
+                        Ok(res)
+                    };
+                    Box::pin(fut)
+                }
+                "/rockbox.v1alpha1.SoundService/SoundCurrent" => {
+                    #[allow(non_camel_case_types)]
+                    struct SoundCurrentSvc<T: SoundService>(pub Arc<T>);
+                    impl<
+                        T: SoundService,
+                    > tonic::server::UnaryService<super::SoundCurrentRequest>
+                    for SoundCurrentSvc<T> {
+                        type Response = super::SoundCurrentResponse;
+                        type Future = BoxFuture<
+                            tonic::Response<Self::Response>,
+                            tonic::Status,
+                        >;
+                        fn call(
+                            &mut self,
+                            request: tonic::Request<super::SoundCurrentRequest>,
+                        ) -> Self::Future {
+                            let inner = Arc::clone(&self.0);
+                            let fut = async move {
+                                <T as SoundService>::sound_current(&inner, request).await
+                            };
+                            Box::pin(fut)
+                        }
+                    }
+                    let accept_compression_encodings = self.accept_compression_encodings;
+                    let send_compression_encodings = self.send_compression_encodings;
+                    let max_decoding_message_size = self.max_decoding_message_size;
+                    let max_encoding_message_size = self.max_encoding_message_size;
+                    let inner = self.inner.clone();
+                    let fut = async move {
+                        let method = SoundCurrentSvc(inner);
+                        let codec = tonic::codec::ProstCodec::default();
+                        let mut grpc = tonic::server::Grpc::new(codec)
+                            .apply_compression_config(
+                                accept_compression_encodings,
+                                send_compression_encodings,
+                            )
+                            .apply_max_message_size_config(
+                                max_decoding_message_size,
+                                max_encoding_message_size,
+                            );
+                        let res = grpc.unary(method, req).await;
+                        Ok(res)
+                    };
+                    Box::pin(fut)
+                }
+                "/rockbox.v1alpha1.SoundService/SoundDefault" => {
+                    #[allow(non_camel_case_types)]
+                    struct SoundDefaultSvc<T: SoundService>(pub Arc<T>);
+                    impl<
+                        T: SoundService,
+                    > tonic::server::UnaryService<super::SoundDefaultRequest>
+                    for SoundDefaultSvc<T> {
+                        type Response = super::SoundDefaultResponse;
+                        type Future = BoxFuture<
+                            tonic::Response<Self::Response>,
+                            tonic::Status,
+                        >;
+                        fn call(
+                            &mut self,
+                            request: tonic::Request<super::SoundDefaultRequest>,
+                        ) -> Self::Future {
+                            let inner = Arc::clone(&self.0);
+                            let fut = async move {
+                                <T as SoundService>::sound_default(&inner, request).await
+                            };
+                            Box::pin(fut)
+                        }
+                    }
+                    let accept_compression_encodings = self.accept_compression_encodings;
+                    let send_compression_encodings = self.send_compression_encodings;
+                    let max_decoding_message_size = self.max_decoding_message_size;
+                    let max_encoding_message_size = self.max_encoding_message_size;
+                    let inner = self.inner.clone();
+                    let fut = async move {
+                        let method = SoundDefaultSvc(inner);
+                        let codec = tonic::codec::ProstCodec::default();
+                        let mut grpc = tonic::server::Grpc::new(codec)
+                            .apply_compression_config(
+                                accept_compression_encodings,
+                                send_compression_encodings,
+                            )
+                            .apply_max_message_size_config(
+                                max_decoding_message_size,
+                                max_encoding_message_size,
+                            );
+                        let res = grpc.unary(method, req).await;
+                        Ok(res)
+                    };
+                    Box::pin(fut)
+                }
+                "/rockbox.v1alpha1.SoundService/SoundMin" => {
+                    #[allow(non_camel_case_types)]
+                    struct SoundMinSvc<T: SoundService>(pub Arc<T>);
+                    impl<
+                        T: SoundService,
+                    > tonic::server::UnaryService<super::SoundMinRequest>
+                    for SoundMinSvc<T> {
+                        type Response = super::SoundMinResponse;
+                        type Future = BoxFuture<
+                            tonic::Response<Self::Response>,
+                            tonic::Status,
+                        >;
+                        fn call(
+                            &mut self,
+                            request: tonic::Request<super::SoundMinRequest>,
+                        ) -> Self::Future {
+                            let inner = Arc::clone(&self.0);
+                            let fut = async move {
+                                <T as SoundService>::sound_min(&inner, request).await
+                            };
+                            Box::pin(fut)
+                        }
+                    }
+                    let accept_compression_encodings = self.accept_compression_encodings;
+                    let send_compression_encodings = self.send_compression_encodings;
+                    let max_decoding_message_size = self.max_decoding_message_size;
+                    let max_encoding_message_size = self.max_encoding_message_size;
+                    let inner = self.inner.clone();
+                    let fut = async move {
+                        let method = SoundMinSvc(inner);
+                        let codec = tonic::codec::ProstCodec::default();
+                        let mut grpc = tonic::server::Grpc::new(codec)
+                            .apply_compression_config(
+                                accept_compression_encodings,
+                                send_compression_encodings,
+                            )
+                            .apply_max_message_size_config(
+                                max_decoding_message_size,
+                                max_encoding_message_size,
+                            );
+                        let res = grpc.unary(method, req).await;
+                        Ok(res)
+                    };
+                    Box::pin(fut)
+                }
+                "/rockbox.v1alpha1.SoundService/SoundMax" => {
+                    #[allow(non_camel_case_types)]
+                    struct SoundMaxSvc<T: SoundService>(pub Arc<T>);
+                    impl<
+                        T: SoundService,
+                    > tonic::server::UnaryService<super::SoundMaxRequest>
+                    for SoundMaxSvc<T> {
+                        type Response = super::SoundMaxResponse;
+                        type Future = BoxFuture<
+                            tonic::Response<Self::Response>,
+                            tonic::Status,
+                        >;
+                        fn call(
+                            &mut self,
+                            request: tonic::Request<super::SoundMaxRequest>,
+                        ) -> Self::Future {
+                            let inner = Arc::clone(&self.0);
+                            let fut = async move {
+                                <T as SoundService>::sound_max(&inner, request).await
+                            };
+                            Box::pin(fut)
+                        }
+                    }
+                    let accept_compression_encodings = self.accept_compression_encodings;
+                    let send_compression_encodings = self.send_compression_encodings;
+                    let max_decoding_message_size = self.max_decoding_message_size;
+                    let max_encoding_message_size = self.max_encoding_message_size;
+                    let inner = self.inner.clone();
+                    let fut = async move {
+                        let method = SoundMaxSvc(inner);
+                        let codec = tonic::codec::ProstCodec::default();
+                        let mut grpc = tonic::server::Grpc::new(codec)
+                            .apply_compression_config(
+                                accept_compression_encodings,
+                                send_compression_encodings,
+                            )
+                            .apply_max_message_size_config(
+                                max_decoding_message_size,
+                                max_encoding_message_size,
+                            );
+                        let res = grpc.unary(method, req).await;
+                        Ok(res)
+                    };
+                    Box::pin(fut)
+                }
+                "/rockbox.v1alpha1.SoundService/SoundUnit" => {
+                    #[allow(non_camel_case_types)]
+                    struct SoundUnitSvc<T: SoundService>(pub Arc<T>);
+                    impl<
+                        T: SoundService,
+                    > tonic::server::UnaryService<super::SoundUnitRequest>
+                    for SoundUnitSvc<T> {
+                        type Response = super::SoundUnitResponse;
+                        type Future = BoxFuture<
+                            tonic::Response<Self::Response>,
+                            tonic::Status,
+                        >;
+                        fn call(
+                            &mut self,
+                            request: tonic::Request<super::SoundUnitRequest>,
+                        ) -> Self::Future {
+                            let inner = Arc::clone(&self.0);
+                            let fut = async move {
+                                <T as SoundService>::sound_unit(&inner, request).await
+                            };
+                            Box::pin(fut)
+                        }
+                    }
+                    let accept_compression_encodings = self.accept_compression_encodings;
+                    let send_compression_encodings = self.send_compression_encodings;
+                    let max_decoding_message_size = self.max_decoding_message_size;
+                    let max_encoding_message_size = self.max_encoding_message_size;
+                    let inner = self.inner.clone();
+                    let fut = async move {
+                        let method = SoundUnitSvc(inner);
+                        let codec = tonic::codec::ProstCodec::default();
+                        let mut grpc = tonic::server::Grpc::new(codec)
+                            .apply_compression_config(
+                                accept_compression_encodings,
+                                send_compression_encodings,
+                            )
+                            .apply_max_message_size_config(
+                                max_decoding_message_size,
+                                max_encoding_message_size,
+                            );
+                        let res = grpc.unary(method, req).await;
+                        Ok(res)
+                    };
+                    Box::pin(fut)
+                }
+                "/rockbox.v1alpha1.SoundService/SoundVal2Phys" => {
+                    #[allow(non_camel_case_types)]
+                    struct SoundVal2PhysSvc<T: SoundService>(pub Arc<T>);
+                    impl<
+                        T: SoundService,
+                    > tonic::server::UnaryService<super::SoundVal2PhysRequest>
+                    for SoundVal2PhysSvc<T> {
+                        type Response = super::SoundVal2PhysResponse;
+                        type Future = BoxFuture<
+                            tonic::Response<Self::Response>,
+                            tonic::Status,
+                        >;
+                        fn call(
+                            &mut self,
+                            request: tonic::Request<super::SoundVal2PhysRequest>,
+                        ) -> Self::Future {
+                            let inner = Arc::clone(&self.0);
+                            let fut = async move {
+                                <T as SoundService>::sound_val2_phys(&inner, request).await
+                            };
+                            Box::pin(fut)
+                        }
+                    }
+                    let accept_compression_encodings = self.accept_compression_encodings;
+                    let send_compression_encodings = self.send_compression_encodings;
+                    let max_decoding_message_size = self.max_decoding_message_size;
+                    let max_encoding_message_size = self.max_encoding_message_size;
+                    let inner = self.inner.clone();
+                    let fut = async move {
+                        let method = SoundVal2PhysSvc(inner);
+                        let codec = tonic::codec::ProstCodec::default();
+                        let mut grpc = tonic::server::Grpc::new(codec)
+                            .apply_compression_config(
+                                accept_compression_encodings,
+                                send_compression_encodings,
+                            )
+                            .apply_max_message_size_config(
+                                max_decoding_message_size,
+                                max_encoding_message_size,
+                            );
+                        let res = grpc.unary(method, req).await;
+                        Ok(res)
+                    };
+                    Box::pin(fut)
+                }
+                "/rockbox.v1alpha1.SoundService/GetPitch" => {
+                    #[allow(non_camel_case_types)]
+                    struct GetPitchSvc<T: SoundService>(pub Arc<T>);
+                    impl<
+                        T: SoundService,
+                    > tonic::server::UnaryService<super::GetPitchRequest>
+                    for GetPitchSvc<T> {
+                        type Response = super::GetPitchResponse;
+                        type Future = BoxFuture<
+                            tonic::Response<Self::Response>,
+                            tonic::Status,
+                        >;
+                        fn call(
+                            &mut self,
+                            request: tonic::Request<super::GetPitchRequest>,
+                        ) -> Self::Future {
+                            let inner = Arc::clone(&self.0);
+                            let fut = async move {
+                                <T as SoundService>::get_pitch(&inner, request).await
+                            };
+                            Box::pin(fut)
+                        }
+                    }
+                    let accept_compression_encodings = self.accept_compression_encodings;
+                    let send_compression_encodings = self.send_compression_encodings;
+                    let max_decoding_message_size = self.max_decoding_message_size;
+                    let max_encoding_message_size = self.max_encoding_message_size;
+                    let inner = self.inner.clone();
+                    let fut = async move {
+                        let method = GetPitchSvc(inner);
+                        let codec = tonic::codec::ProstCodec::default();
+                        let mut grpc = tonic::server::Grpc::new(codec)
+                            .apply_compression_config(
+                                accept_compression_encodings,
+                                send_compression_encodings,
+                            )
+                            .apply_max_message_size_config(
+                                max_decoding_message_size,
+                                max_encoding_message_size,
+                            );
+                        let res = grpc.unary(method, req).await;
+                        Ok(res)
+                    };
+                    Box::pin(fut)
+                }
+                "/rockbox.v1alpha1.SoundService/SetPitch" => {
+                    #[allow(non_camel_case_types)]
+                    struct SetPitchSvc<T: SoundService>(pub Arc<T>);
+                    impl<
+                        T: SoundService,
+                    > tonic::server::UnaryService<super::SetPitchRequest>
+                    for SetPitchSvc<T> {
+                        type Response = super::SetPitchResponse;
+                        type Future = BoxFuture<
+                            tonic::Response<Self::Response>,
+                            tonic::Status,
+                        >;
+                        fn call(
+                            &mut self,
+                            request: tonic::Request<super::SetPitchRequest>,
+                        ) -> Self::Future {
+                            let inner = Arc::clone(&self.0);
+                            let fut = async move {
+                                <T as SoundService>::set_pitch(&inner, request).await
+                            };
+                            Box::pin(fut)
+                        }
+                    }
+                    let accept_compression_encodings = self.accept_compression_encodings;
+                    let send_compression_encodings = self.send_compression_encodings;
+                    let max_decoding_message_size = self.max_decoding_message_size;
+                    let max_encoding_message_size = self.max_encoding_message_size;
+                    let inner = self.inner.clone();
+                    let fut = async move {
+                        let method = SetPitchSvc(inner);
+                        let codec = tonic::codec::ProstCodec::default();
+                        let mut grpc = tonic::server::Grpc::new(codec)
+                            .apply_compression_config(
+                                accept_compression_encodings,
+                                send_compression_encodings,
+                            )
+                            .apply_max_message_size_config(
+                                max_decoding_message_size,
+                                max_encoding_message_size,
+                            );
+                        let res = grpc.unary(method, req).await;
+                        Ok(res)
+                    };
+                    Box::pin(fut)
+                }
+                "/rockbox.v1alpha1.SoundService/BeepPlay" => {
+                    #[allow(non_camel_case_types)]
+                    struct BeepPlaySvc<T: SoundService>(pub Arc<T>);
+                    impl<
+                        T: SoundService,
+                    > tonic::server::UnaryService<super::BeepPlayRequest>
+                    for BeepPlaySvc<T> {
+                        type Response = super::BeepPlayResponse;
+                        type Future = BoxFuture<
+                            tonic::Response<Self::Response>,
+                            tonic::Status,
+                        >;
+                        fn call(
+                            &mut self,
+                            request: tonic::Request<super::BeepPlayRequest>,
+                        ) -> Self::Future {
+                            let inner = Arc::clone(&self.0);
+                            let fut = async move {
+                                <T as SoundService>::beep_play(&inner, request).await
+                            };
+                            Box::pin(fut)
+                        }
+                    }
+                    let accept_compression_encodings = self.accept_compression_encodings;
+                    let send_compression_encodings = self.send_compression_encodings;
+                    let max_decoding_message_size = self.max_decoding_message_size;
+                    let max_encoding_message_size = self.max_encoding_message_size;
+                    let inner = self.inner.clone();
+                    let fut = async move {
+                        let method = BeepPlaySvc(inner);
+                        let codec = tonic::codec::ProstCodec::default();
+                        let mut grpc = tonic::server::Grpc::new(codec)
+                            .apply_compression_config(
+                                accept_compression_encodings,
+                                send_compression_encodings,
+                            )
+                            .apply_max_message_size_config(
+                                max_decoding_message_size,
+                                max_encoding_message_size,
+                            );
+                        let res = grpc.unary(method, req).await;
+                        Ok(res)
+                    };
+                    Box::pin(fut)
+                }
+                "/rockbox.v1alpha1.SoundService/PcmbufFade" => {
+                    #[allow(non_camel_case_types)]
+                    struct PcmbufFadeSvc<T: SoundService>(pub Arc<T>);
+                    impl<
+                        T: SoundService,
+                    > tonic::server::UnaryService<super::PcmbufFadeRequest>
+                    for PcmbufFadeSvc<T> {
+                        type Response = super::PcmbufFadeResponse;
+                        type Future = BoxFuture<
+                            tonic::Response<Self::Response>,
+                            tonic::Status,
+                        >;
+                        fn call(
+                            &mut self,
+                            request: tonic::Request<super::PcmbufFadeRequest>,
+                        ) -> Self::Future {
+                            let inner = Arc::clone(&self.0);
+                            let fut = async move {
+                                <T as SoundService>::pcmbuf_fade(&inner, request).await
+                            };
+                            Box::pin(fut)
+                        }
+                    }
+                    let accept_compression_encodings = self.accept_compression_encodings;
+                    let send_compression_encodings = self.send_compression_encodings;
+                    let max_decoding_message_size = self.max_decoding_message_size;
+                    let max_encoding_message_size = self.max_encoding_message_size;
+                    let inner = self.inner.clone();
+                    let fut = async move {
+                        let method = PcmbufFadeSvc(inner);
+                        let codec = tonic::codec::ProstCodec::default();
+                        let mut grpc = tonic::server::Grpc::new(codec)
+                            .apply_compression_config(
+                                accept_compression_encodings,
+                                send_compression_encodings,
+                            )
+                            .apply_max_message_size_config(
+                                max_decoding_message_size,
+                                max_encoding_message_size,
+                            );
+                        let res = grpc.unary(method, req).await;
+                        Ok(res)
+                    };
+                    Box::pin(fut)
+                }
+                "/rockbox.v1alpha1.SoundService/PcmbufSetLowLatency" => {
+                    #[allow(non_camel_case_types)]
+                    struct PcmbufSetLowLatencySvc<T: SoundService>(pub Arc<T>);
+                    impl<
+                        T: SoundService,
+                    > tonic::server::UnaryService<super::PcmbufSetLowLatencyRequest>
+                    for PcmbufSetLowLatencySvc<T> {
+                        type Response = super::PcmbufSetLowLatencyResponse;
+                        type Future = BoxFuture<
+                            tonic::Response<Self::Response>,
+                            tonic::Status,
+                        >;
+                        fn call(
+                            &mut self,
+                            request: tonic::Request<super::PcmbufSetLowLatencyRequest>,
+                        ) -> Self::Future {
+                            let inner = Arc::clone(&self.0);
+                            let fut = async move {
+                                <T as SoundService>::pcmbuf_set_low_latency(&inner, request)
+                                    .await
+                            };
+                            Box::pin(fut)
+                        }
+                    }
+                    let accept_compression_encodings = self.accept_compression_encodings;
+                    let send_compression_encodings = self.send_compression_encodings;
+                    let max_decoding_message_size = self.max_decoding_message_size;
+                    let max_encoding_message_size = self.max_encoding_message_size;
+                    let inner = self.inner.clone();
+                    let fut = async move {
+                        let method = PcmbufSetLowLatencySvc(inner);
+                        let codec = tonic::codec::ProstCodec::default();
+                        let mut grpc = tonic::server::Grpc::new(codec)
+                            .apply_compression_config(
+                                accept_compression_encodings,
+                                send_compression_encodings,
+                            )
+                            .apply_max_message_size_config(
+                                max_decoding_message_size,
+                                max_encoding_message_size,
+                            );
+                        let res = grpc.unary(method, req).await;
+                        Ok(res)
+                    };
+                    Box::pin(fut)
+                }
+                "/rockbox.v1alpha1.SoundService/SystemSoundPlay" => {
+                    #[allow(non_camel_case_types)]
+                    struct SystemSoundPlaySvc<T: SoundService>(pub Arc<T>);
+                    impl<
+                        T: SoundService,
+                    > tonic::server::UnaryService<super::SystemSoundPlayRequest>
+                    for SystemSoundPlaySvc<T> {
+                        type Response = super::SystemSoundPlayResponse;
+                        type Future = BoxFuture<
+                            tonic::Response<Self::Response>,
+                            tonic::Status,
+                        >;
+                        fn call(
+                            &mut self,
+                            request: tonic::Request<super::SystemSoundPlayRequest>,
+                        ) -> Self::Future {
+                            let inner = Arc::clone(&self.0);
+                            let fut = async move {
+                                <T as SoundService>::system_sound_play(&inner, request)
+                                    .await
+                            };
+                            Box::pin(fut)
+                        }
+                    }
+                    let accept_compression_encodings = self.accept_compression_encodings;
+                    let send_compression_encodings = self.send_compression_encodings;
+                    let max_decoding_message_size = self.max_decoding_message_size;
+                    let max_encoding_message_size = self.max_encoding_message_size;
+                    let inner = self.inner.clone();
+                    let fut = async move {
+                        let method = SystemSoundPlaySvc(inner);
+                        let codec = tonic::codec::ProstCodec::default();
+                        let mut grpc = tonic::server::Grpc::new(codec)
+                            .apply_compression_config(
+                                accept_compression_encodings,
+                                send_compression_encodings,
+                            )
+                            .apply_max_message_size_config(
+                                max_decoding_message_size,
+                                max_encoding_message_size,
+                            );
+                        let res = grpc.unary(method, req).await;
+                        Ok(res)
+                    };
+                    Box::pin(fut)
+                }
+                "/rockbox.v1alpha1.SoundService/KeyclickClick" => {
+                    #[allow(non_camel_case_types)]
+                    struct KeyclickClickSvc<T: SoundService>(pub Arc<T>);
+                    impl<
+                        T: SoundService,
+                    > tonic::server::UnaryService<super::KeyclickClickRequest>
+                    for KeyclickClickSvc<T> {
+                        type Response = super::KeyclickClickResponse;
+                        type Future = BoxFuture<
+                            tonic::Response<Self::Response>,
+                            tonic::Status,
+                        >;
+                        fn call(
+                            &mut self,
+                            request: tonic::Request<super::KeyclickClickRequest>,
+                        ) -> Self::Future {
+                            let inner = Arc::clone(&self.0);
+                            let fut = async move {
+                                <T as SoundService>::keyclick_click(&inner, request).await
+                            };
+                            Box::pin(fut)
+                        }
+                    }
+                    let accept_compression_encodings = self.accept_compression_encodings;
+                    let send_compression_encodings = self.send_compression_encodings;
+                    let max_decoding_message_size = self.max_decoding_message_size;
+                    let max_encoding_message_size = self.max_encoding_message_size;
+                    let inner = self.inner.clone();
+                    let fut = async move {
+                        let method = KeyclickClickSvc(inner);
+                        let codec = tonic::codec::ProstCodec::default();
+                        let mut grpc = tonic::server::Grpc::new(codec)
+                            .apply_compression_config(
+                                accept_compression_encodings,
+                                send_compression_encodings,
+                            )
+                            .apply_max_message_size_config(
+                                max_decoding_message_size,
+                                max_encoding_message_size,
+                            );
+                        let res = grpc.unary(method, req).await;
+                        Ok(res)
+                    };
+                    Box::pin(fut)
+                }
+                _ => {
+                    Box::pin(async move {
+                        let mut response = http::Response::new(empty_body());
+                        let headers = response.headers_mut();
+                        headers
+                            .insert(
+                                tonic::Status::GRPC_STATUS,
+                                (tonic::Code::Unimplemented as i32).into(),
+                            );
+                        headers
+                            .insert(
+                                http::header::CONTENT_TYPE,
+                                tonic::metadata::GRPC_CONTENT_TYPE,
+                            );
+                        Ok(response)
+                    })
+                }
+            }
+        }
+    }
+    impl<T> Clone for SoundServiceServer<T> {
+        fn clone(&self) -> Self {
+            let inner = self.inner.clone();
+            Self {
+                inner,
+                accept_compression_encodings: self.accept_compression_encodings,
+                send_compression_encodings: self.send_compression_encodings,
+                max_decoding_message_size: self.max_decoding_message_size,
+                max_encoding_message_size: self.max_encoding_message_size,
+            }
+        }
+    }
+    /// Generated gRPC service name
+    pub const SERVICE_NAME: &str = "rockbox.v1alpha1.SoundService";
+    impl<T> tonic::server::NamedService for SoundServiceServer<T> {
+        const NAME: &'static str = SERVICE_NAME;
+    }
+}
+#[derive(Clone, Copy, PartialEq, ::prost::Message)]
+pub struct GetRockboxVersionRequest {}
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct GetRockboxVersionResponse {
+    #[prost(string, tag = "1")]
+    pub version: ::prost::alloc::string::String,
+}
+#[derive(Clone, Copy, PartialEq, ::prost::Message)]
+pub struct GetGlobalStatusRequest {}
+#[derive(Clone, Copy, PartialEq, ::prost::Message)]
+pub struct GetGlobalStatusResponse {
+    #[prost(int32, tag = "1")]
+    pub resume_index: i32,
+    #[prost(uint32, tag = "2")]
+    pub resume_crc32: u32,
+    #[prost(uint32, tag = "3")]
+    pub resume_elapsed: u32,
+    #[prost(uint32, tag = "4")]
+    pub resume_offset: u32,
+    #[prost(int32, tag = "5")]
+    pub runtime: i32,
+    #[prost(int32, tag = "6")]
+    pub topruntime: i32,
+    #[prost(int32, tag = "7")]
+    pub dircache_size: i32,
+    #[prost(int32, tag = "8")]
+    pub last_screen: i32,
+    #[prost(int32, tag = "9")]
+    pub viewer_icon_count: i32,
+    #[prost(int32, tag = "10")]
+    pub last_volume_change: i32,
+}
+/// Generated client implementations.
+pub mod system_service_client {
+    #![allow(
+        unused_variables,
+        dead_code,
+        missing_docs,
+        clippy::wildcard_imports,
+        clippy::let_unit_value,
+    )]
+    use tonic::codegen::*;
+    use tonic::codegen::http::Uri;
+    #[derive(Debug, Clone)]
+    pub struct SystemServiceClient<T> {
+        inner: tonic::client::Grpc<T>,
+    }
+    impl SystemServiceClient<tonic::transport::Channel> {
+        /// Attempt to create a new client by connecting to a given endpoint.
+        pub async fn connect<D>(dst: D) -> Result<Self, tonic::transport::Error>
+        where
+            D: TryInto<tonic::transport::Endpoint>,
+            D::Error: Into<StdError>,
+        {
+            let conn = tonic::transport::Endpoint::new(dst)?.connect().await?;
+            Ok(Self::new(conn))
+        }
+    }
+    impl<T> SystemServiceClient<T>
+    where
+        T: tonic::client::GrpcService<tonic::body::BoxBody>,
+        T::Error: Into<StdError>,
+        T::ResponseBody: Body<Data = Bytes> + std::marker::Send + 'static,
+        <T::ResponseBody as Body>::Error: Into<StdError> + std::marker::Send,
+    {
+        pub fn new(inner: T) -> Self {
+            let inner = tonic::client::Grpc::new(inner);
+            Self { inner }
+        }
+        pub fn with_origin(inner: T, origin: Uri) -> Self {
+            let inner = tonic::client::Grpc::with_origin(inner, origin);
+            Self { inner }
+        }
+        pub fn with_interceptor<F>(
+            inner: T,
+            interceptor: F,
+        ) -> SystemServiceClient<InterceptedService<T, F>>
+        where
+            F: tonic::service::Interceptor,
+            T::ResponseBody: Default,
+            T: tonic::codegen::Service<
+                http::Request<tonic::body::BoxBody>,
+                Response = http::Response<
+                    <T as tonic::client::GrpcService<tonic::body::BoxBody>>::ResponseBody,
+                >,
+            >,
+            <T as tonic::codegen::Service<
+                http::Request<tonic::body::BoxBody>,
+            >>::Error: Into<StdError> + std::marker::Send + std::marker::Sync,
+        {
+            SystemServiceClient::new(InterceptedService::new(inner, interceptor))
+        }
+        /// Compress requests with the given encoding.
+        ///
+        /// This requires the server to support it otherwise it might respond with an
+        /// error.
+        #[must_use]
+        pub fn send_compressed(mut self, encoding: CompressionEncoding) -> Self {
+            self.inner = self.inner.send_compressed(encoding);
+            self
+        }
+        /// Enable decompressing responses.
+        #[must_use]
+        pub fn accept_compressed(mut self, encoding: CompressionEncoding) -> Self {
+            self.inner = self.inner.accept_compressed(encoding);
+            self
+        }
+        /// Limits the maximum size of a decoded message.
+        ///
+        /// Default: `4MB`
+        #[must_use]
+        pub fn max_decoding_message_size(mut self, limit: usize) -> Self {
+            self.inner = self.inner.max_decoding_message_size(limit);
+            self
+        }
+        /// Limits the maximum size of an encoded message.
+        ///
+        /// Default: `usize::MAX`
+        #[must_use]
+        pub fn max_encoding_message_size(mut self, limit: usize) -> Self {
+            self.inner = self.inner.max_encoding_message_size(limit);
+            self
+        }
+        pub async fn get_rockbox_version(
+            &mut self,
+            request: impl tonic::IntoRequest<super::GetRockboxVersionRequest>,
+        ) -> std::result::Result<
+            tonic::Response<super::GetRockboxVersionResponse>,
+            tonic::Status,
+        > {
+            self.inner
+                .ready()
+                .await
+                .map_err(|e| {
+                    tonic::Status::unknown(
+                        format!("Service was not ready: {}", e.into()),
+                    )
+                })?;
+            let codec = tonic::codec::ProstCodec::default();
+            let path = http::uri::PathAndQuery::from_static(
+                "/rockbox.v1alpha1.SystemService/GetRockboxVersion",
+            );
+            let mut req = request.into_request();
+            req.extensions_mut()
+                .insert(
+                    GrpcMethod::new(
+                        "rockbox.v1alpha1.SystemService",
+                        "GetRockboxVersion",
+                    ),
+                );
+            self.inner.unary(req, path, codec).await
+        }
+        pub async fn get_global_status(
+            &mut self,
+            request: impl tonic::IntoRequest<super::GetGlobalStatusRequest>,
+        ) -> std::result::Result<
+            tonic::Response<super::GetGlobalStatusResponse>,
+            tonic::Status,
+        > {
+            self.inner
+                .ready()
+                .await
+                .map_err(|e| {
+                    tonic::Status::unknown(
+                        format!("Service was not ready: {}", e.into()),
+                    )
+                })?;
+            let codec = tonic::codec::ProstCodec::default();
+            let path = http::uri::PathAndQuery::from_static(
+                "/rockbox.v1alpha1.SystemService/GetGlobalStatus",
+            );
+            let mut req = request.into_request();
+            req.extensions_mut()
+                .insert(
+                    GrpcMethod::new("rockbox.v1alpha1.SystemService", "GetGlobalStatus"),
+                );
+            self.inner.unary(req, path, codec).await
+        }
+    }
+}
+/// Generated server implementations.
+pub mod system_service_server {
+    #![allow(
+        unused_variables,
+        dead_code,
+        missing_docs,
+        clippy::wildcard_imports,
+        clippy::let_unit_value,
+    )]
+    use tonic::codegen::*;
+    /// Generated trait containing gRPC methods that should be implemented for use with SystemServiceServer.
+    #[async_trait]
+    pub trait SystemService: std::marker::Send + std::marker::Sync + 'static {
+        async fn get_rockbox_version(
+            &self,
+            request: tonic::Request<super::GetRockboxVersionRequest>,
+        ) -> std::result::Result<
+            tonic::Response<super::GetRockboxVersionResponse>,
+            tonic::Status,
+        >;
+        async fn get_global_status(
+            &self,
+            request: tonic::Request<super::GetGlobalStatusRequest>,
+        ) -> std::result::Result<
+            tonic::Response<super::GetGlobalStatusResponse>,
+            tonic::Status,
+        >;
+    }
+    #[derive(Debug)]
+    pub struct SystemServiceServer<T> {
+        inner: Arc<T>,
+        accept_compression_encodings: EnabledCompressionEncodings,
+        send_compression_encodings: EnabledCompressionEncodings,
+        max_decoding_message_size: Option<usize>,
+        max_encoding_message_size: Option<usize>,
+    }
+    impl<T> SystemServiceServer<T> {
+        pub fn new(inner: T) -> Self {
+            Self::from_arc(Arc::new(inner))
+        }
+        pub fn from_arc(inner: Arc<T>) -> Self {
+            Self {
+                inner,
+                accept_compression_encodings: Default::default(),
+                send_compression_encodings: Default::default(),
+                max_decoding_message_size: None,
+                max_encoding_message_size: None,
+            }
+        }
+        pub fn with_interceptor<F>(
+            inner: T,
+            interceptor: F,
+        ) -> InterceptedService<Self, F>
+        where
+            F: tonic::service::Interceptor,
+        {
+            InterceptedService::new(Self::new(inner), interceptor)
+        }
+        /// Enable decompressing requests with the given encoding.
+        #[must_use]
+        pub fn accept_compressed(mut self, encoding: CompressionEncoding) -> Self {
+            self.accept_compression_encodings.enable(encoding);
+            self
+        }
+        /// Compress responses with the given encoding, if the client supports it.
+        #[must_use]
+        pub fn send_compressed(mut self, encoding: CompressionEncoding) -> Self {
+            self.send_compression_encodings.enable(encoding);
+            self
+        }
+        /// Limits the maximum size of a decoded message.
+        ///
+        /// Default: `4MB`
+        #[must_use]
+        pub fn max_decoding_message_size(mut self, limit: usize) -> Self {
+            self.max_decoding_message_size = Some(limit);
+            self
+        }
+        /// Limits the maximum size of an encoded message.
+        ///
+        /// Default: `usize::MAX`
+        #[must_use]
+        pub fn max_encoding_message_size(mut self, limit: usize) -> Self {
+            self.max_encoding_message_size = Some(limit);
+            self
+        }
+    }
+    impl<T, B> tonic::codegen::Service<http::Request<B>> for SystemServiceServer<T>
+    where
+        T: SystemService,
+        B: Body + std::marker::Send + 'static,
+        B::Error: Into<StdError> + std::marker::Send + 'static,
+    {
+        type Response = http::Response<tonic::body::BoxBody>;
+        type Error = std::convert::Infallible;
+        type Future = BoxFuture<Self::Response, Self::Error>;
+        fn poll_ready(
+            &mut self,
+            _cx: &mut Context<'_>,
+        ) -> Poll<std::result::Result<(), Self::Error>> {
+            Poll::Ready(Ok(()))
+        }
+        fn call(&mut self, req: http::Request<B>) -> Self::Future {
+            match req.uri().path() {
+                "/rockbox.v1alpha1.SystemService/GetRockboxVersion" => {
+                    #[allow(non_camel_case_types)]
+                    struct GetRockboxVersionSvc<T: SystemService>(pub Arc<T>);
+                    impl<
+                        T: SystemService,
+                    > tonic::server::UnaryService<super::GetRockboxVersionRequest>
+                    for GetRockboxVersionSvc<T> {
+                        type Response = super::GetRockboxVersionResponse;
+                        type Future = BoxFuture<
+                            tonic::Response<Self::Response>,
+                            tonic::Status,
+                        >;
+                        fn call(
+                            &mut self,
+                            request: tonic::Request<super::GetRockboxVersionRequest>,
+                        ) -> Self::Future {
+                            let inner = Arc::clone(&self.0);
+                            let fut = async move {
+                                <T as SystemService>::get_rockbox_version(&inner, request)
+                                    .await
+                            };
+                            Box::pin(fut)
+                        }
+                    }
+                    let accept_compression_encodings = self.accept_compression_encodings;
+                    let send_compression_encodings = self.send_compression_encodings;
+                    let max_decoding_message_size = self.max_decoding_message_size;
+                    let max_encoding_message_size = self.max_encoding_message_size;
+                    let inner = self.inner.clone();
+                    let fut = async move {
+                        let method = GetRockboxVersionSvc(inner);
+                        let codec = tonic::codec::ProstCodec::default();
+                        let mut grpc = tonic::server::Grpc::new(codec)
+                            .apply_compression_config(
+                                accept_compression_encodings,
+                                send_compression_encodings,
+                            )
+                            .apply_max_message_size_config(
+                                max_decoding_message_size,
+                                max_encoding_message_size,
+                            );
+                        let res = grpc.unary(method, req).await;
+                        Ok(res)
+                    };
+                    Box::pin(fut)
+                }
+                "/rockbox.v1alpha1.SystemService/GetGlobalStatus" => {
+                    #[allow(non_camel_case_types)]
+                    struct GetGlobalStatusSvc<T: SystemService>(pub Arc<T>);
+                    impl<
+                        T: SystemService,
+                    > tonic::server::UnaryService<super::GetGlobalStatusRequest>
+                    for GetGlobalStatusSvc<T> {
+                        type Response = super::GetGlobalStatusResponse;
+                        type Future = BoxFuture<
+                            tonic::Response<Self::Response>,
+                            tonic::Status,
+                        >;
+                        fn call(
+                            &mut self,
+                            request: tonic::Request<super::GetGlobalStatusRequest>,
+                        ) -> Self::Future {
+                            let inner = Arc::clone(&self.0);
+                            let fut = async move {
+                                <T as SystemService>::get_global_status(&inner, request)
+                                    .await
+                            };
+                            Box::pin(fut)
+                        }
+                    }
+                    let accept_compression_encodings = self.accept_compression_encodings;
+                    let send_compression_encodings = self.send_compression_encodings;
+                    let max_decoding_message_size = self.max_decoding_message_size;
+                    let max_encoding_message_size = self.max_encoding_message_size;
+                    let inner = self.inner.clone();
+                    let fut = async move {
+                        let method = GetGlobalStatusSvc(inner);
+                        let codec = tonic::codec::ProstCodec::default();
+                        let mut grpc = tonic::server::Grpc::new(codec)
+                            .apply_compression_config(
+                                accept_compression_encodings,
+                                send_compression_encodings,
+                            )
+                            .apply_max_message_size_config(
+                                max_decoding_message_size,
+                                max_encoding_message_size,
+                            );
+                        let res = grpc.unary(method, req).await;
+                        Ok(res)
+                    };
+                    Box::pin(fut)
+                }
+                _ => {
+                    Box::pin(async move {
+                        let mut response = http::Response::new(empty_body());
+                        let headers = response.headers_mut();
+                        headers
+                            .insert(
+                                tonic::Status::GRPC_STATUS,
+                                (tonic::Code::Unimplemented as i32).into(),
+                            );
+                        headers
+                            .insert(
+                                http::header::CONTENT_TYPE,
+                                tonic::metadata::GRPC_CONTENT_TYPE,
+                            );
+                        Ok(response)
+                    })
+                }
+            }
+        }
+    }
+    impl<T> Clone for SystemServiceServer<T> {
+        fn clone(&self) -> Self {
+            let inner = self.inner.clone();
+            Self {
+                inner,
+                accept_compression_encodings: self.accept_compression_encodings,
+                send_compression_encodings: self.send_compression_encodings,
+                max_decoding_message_size: self.max_decoding_message_size,
+                max_encoding_message_size: self.max_encoding_message_size,
+            }
+        }
+    }
+    /// Generated gRPC service name
+    pub const SERVICE_NAME: &str = "rockbox.v1alpha1.SystemService";
+    impl<T> tonic::server::NamedService for SystemServiceServer<T> {
+        const NAME: &'static str = SERVICE_NAME;
+    }
+}

crates/rocksky/src/lib.rs

···
 use anyhow::Error;
+use api::rockbox::v1alpha1::playback_service_client::PlaybackServiceClient;
+use api::rockbox::v1alpha1::NextRequest;
+use api::rockbox::v1alpha1::PauseRequest;
+use api::rockbox::v1alpha1::PlayRequest;
+use api::rockbox::v1alpha1::PreviousRequest;
+use api::rockbox::v1alpha1::ResumeRequest;
+use api::rockbox::v1alpha1::StreamCurrentTrackRequest;
+use api::rockbox::v1alpha1::StreamStatusRequest;
+use futures_util::SinkExt;
+use futures_util::StreamExt;
 use lofty::file::TaggedFileExt;
 use reqwest::multipart;
 use reqwest::Client;
 use rockbox_library::entity::album::Album;
 use rockbox_library::entity::track::Track;
+use serde_json::json;
+use serde_json::Value;
+use std::env;
 use std::fs::File;
 use std::io::Read;
+use std::sync::Arc;
+use std::thread;
+use tokio::sync::Mutex;
+use tokio_tungstenite::connect_async;
 
 const AUDIO_EXTENSIONS: [&str; 18] = [
     "mp3", "ogg", "flac", "m4a", "aac", "mp4", "alac", "wav", "wv", "mpc", "aiff", "aif", "ac3",
     "opus", "spx", "sid", "ape", "wma",
 ];
+
+// const ROCKSKY_WS: &str = "ws://localhost:8000/ws";
+
+pub mod api {
+    #[path = ""]
+    pub mod rockbox {
+
+        #[path = "rockbox.v1alpha1.rs"]
+        pub mod v1alpha1;
+    }
+}
+
+pub fn register_rockbox() -> Result<(), Error> {
+    let home = dirs::home_dir().unwrap();
+    let token_file = home.join(".config").join("rockbox.org").join("token");
+
+    if !token_file.exists() {
+        return Ok(());
+    }
+
+    let token = std::fs::read_to_string(token_file)?;
+
+    thread::spawn(move || {
+        let rt = tokio::runtime::Runtime::new().unwrap();
+        rt.block_on(async {
+            let device_id = Arc::new(Mutex::new(String::new()));
+            let rocksky_ws =
+                env::var("ROCKSKY_WS").unwrap_or_else(|_| "wss://api.rocksky.app/ws".to_string());
+            let (ws_stream, _) = connect_async(rocksky_ws).await?;
+            println!("Handshake successful");
+            let (mut write, mut read) = ws_stream.split();
+            write
+                .send(
+                    json!({
+                        "type": "register",
+                        "clientName": "Rockbox",
+                        "token": token,
+                    })
+                    .to_string()
+                    .into(),
+                )
+                .await?;
+
+            let (tx, mut rx) = tokio::sync::mpsc::channel::<String>(32);
+
+            let tx_clone = tx.clone();
+            thread::spawn(move || {
+                let rt = tokio::runtime::Runtime::new().unwrap();
+                rt.block_on(async {
+                    let host = env::var("ROCKBOX_HOST").unwrap_or_else(|_| "localhost".to_string());
+                    let port = env::var("ROCKBOX_PORT").unwrap_or_else(|_| "6061".to_string());
+
+                    let url = format!("tcp://{}:{}", host, port);
+                    let mut client = PlaybackServiceClient::connect(url).await?;
+                    let request = tonic::Request::new(StreamCurrentTrackRequest {});
+
+                    let mut stream = client.stream_current_track(request).await?.into_inner();
+                    while let Some(Ok(track)) = stream.next().await {
+                        tx_clone
+                            .send(
+                                json!(
+                                    {
+                                        "type": "track",
+                                        "title": track.title,
+                                        "artist": track.artist,
+                                        "album_artist": track.album_artist,
+                                        "album": track.album,
+                                        "length": track.length,
+                                        "elapsed": track.elapsed,
+                                        "track_number": track.tracknum,
+                                        "disc_number": track.discnum,
+                                        "composer": track.composer,
+                                        "album_art": track.album_art,
+                                    }
+                                )
+                                .to_string(),
+                            )
+                            .await?;
+                    }
+
+                    Ok::<(), Error>(())
+                })?;
+
+                Ok::<(), Error>(())
+            });
+
+            thread::spawn(move || {
+                let rt = tokio::runtime::Runtime::new().unwrap();
+                rt.block_on(async {
+                    let host = env::var("ROCKBOX_HOST").unwrap_or_else(|_| "localhost".to_string());
+                    let port = env::var("ROCKBOX_PORT").unwrap_or_else(|_| "6061".to_string());
+
+                    let url = format!("tcp://{}:{}", host, port);
+                    let mut client = PlaybackServiceClient::connect(url).await?;
+                    let request = tonic::Request::new(StreamStatusRequest {});
+
+                    let mut stream = client.stream_status(request).await?.into_inner();
+                    while let Some(Ok(response)) = stream.next().await {
+                        tx.send(
+                            json!(
+                                {
+                                    "type": "status",
+                                    "status": response.status,
+                                }
+                            )
+                            .to_string(),
+                        )
+                        .await?;
+                    }
+
+                    Ok::<(), Error>(())
+                })?;
+
+                Ok::<(), Error>(())
+            });
+
+            let device_id_clone = device_id.clone();
+            thread::spawn(move || {
+                let rt = tokio::runtime::Runtime::new().unwrap();
+                rt.block_on(async {
+                    while let Some(msg) = rx.recv().await {
+                        let device_id = device_id_clone.lock().await;
+                        match write
+                            .send(
+                                json!({
+                                    "type": "message",
+                                    "data": serde_json::from_str::<Value>(&msg).unwrap(),
+                                    "device_id": *device_id,
+                                    "token": token,
+                                })
+                                .to_string()
+                                .into(),
+                            )
+                            .await
+                        {
+                            Ok(_) => {}
+                            Err(e) => {
+                                eprintln!("Failed to send message: {}", e);
+                            }
+                        }
+                    }
+                })
+            });
+
+            let host = env::var("ROCKBOX_HOST").unwrap_or_else(|_| "localhost".to_string());
+            let port = env::var("ROCKBOX_PORT").unwrap_or_else(|_| "6061".to_string());
+            let url = format!("tcp://{}:{}", host, port);
+            let mut client = PlaybackServiceClient::connect(url).await?;
+
+            while let Some(Ok(msg)) = read.next().await {
+                let msg = msg.to_string();
+                let msg = serde_json::from_str::<Value>(&msg)?;
+                if msg["deviceId"].is_string() {
+                    let mut device_id = device_id.lock().await;
+                    *device_id = msg["deviceId"].as_str().unwrap().to_string();
+                }
+
+                if msg["type"].is_string() {
+                    if msg["type"].as_str().unwrap() == "command" {
+                        let command = msg["action"].as_str().unwrap();
+                        match command {
+                            "play" => {
+                                let request = tonic::Request::new(ResumeRequest {});
+                                client.resume(request).await?;
+                            }
+                            "pause" => {
+                                let request = tonic::Request::new(PauseRequest {
+                                    ..Default::default()
+                                });
+                                client.pause(request).await?;
+                            }
+                            "next" => {
+                                let request = tonic::Request::new(NextRequest {
+                                    ..Default::default()
+                                });
+                                client.next(request).await?;
+                            }
+                            "previous" => {
+                                let request = tonic::Request::new(PreviousRequest {
+                                    ..Default::default()
+                                });
+                                client.previous(request).await?;
+                            }
+                            "seek" => {
+                                let position = msg["args"]["position"].as_i64().unwrap();
+                                let request = tonic::Request::new(PlayRequest {
+                                    offset: 0,
+                                    elapsed: position,
+                                });
+                                client.play(request).await?;
+                            }
+                            _ => {
+                                println!("Unknown command: {}", command);
+                            }
+                        }
+                    }
+                }
+            }
+
+            Ok::<(), Error>(())
+        })?;
+        Ok::<(), Error>(())
+    });
+
+    Ok(())
+}
 
 pub async fn upload_album_cover(name: &str) -> Result<(), Error> {
     let home = dirs::home_dir().unwrap();

crates/rocksky/src/main.rs

···
-use std::{thread, time::Duration};
-
 use anyhow::Error;
-use rockbox_library::repo;
-use rockbox_rocksky::save_track;
 
 #[tokio::main]
 async fn main() -> Result<(), Error> {
-    let pool = rockbox_library::create_connection_pool().await?;
-    let tracks = repo::track::all(pool.clone()).await?;
-    println!("Tracks {}", tracks.len());
-
-    for (i, track) in tracks.iter().enumerate() {
-        print!("{}/{} ", i + 1, tracks.len());
-        let album = repo::album::find(pool.clone(), &track.album_id).await?;
-        let track_clone = track.clone();
-        let album = album.unwrap();
-        let album_clone = album.clone();
-        thread::spawn(move || {
-            let rt = tokio::runtime::Runtime::new().unwrap();
-            rt.block_on(save_track(track_clone, album_clone)).unwrap();
-        });
-        thread::sleep(Duration::from_millis(500));
+    rockbox_rocksky::register_rockbox()?;
+    loop {
+        tokio::time::sleep(tokio::time::Duration::from_secs(1)).await;
     }
-
-    Ok(())
 }