cli: split into rockbox cli and rockbox daemon

Cargo.lock

···
 ]
 
 [[package]]
+name = "bstr"
+version = "1.10.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "40723b8fb387abc38f4f4a37c09073622e41dd12327033091ef8950659e6dc0c"
+dependencies = [
+ "memchr",
+ "regex-automata",
+ "serde",
+]
+
+[[package]]
 name = "bumpalo"
 version = "3.16.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
···
 
 [[package]]
 name = "clap"
-version = "4.5.17"
+version = "4.5.20"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3e5a21b8495e732f1b3c364c9949b201ca7bae518c502c80256c96ad79eaf6ac"
+checksum = "b97f376d85a664d5837dbae44bf546e6477a679ff6610010f17276f686d867e8"
 dependencies = [
  "clap_builder",
 ]
 
 [[package]]
 name = "clap_builder"
-version = "4.5.17"
+version = "4.5.20"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8cf2dd12af7a047ad9d6da2b6b249759a22a7abc0f474c1dae1777afa4b21a73"
+checksum = "19bc80abd44e4bed93ca373a0704ccbd1b710dc5749406201bb018272808dc54"
 dependencies = [
  "anstream",
  "anstyle",
···
 version = "0.3.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "41b319d1b62ffbd002e057f36bebd1f42b9f97927c9577461d855f3513c4289f"
+
+[[package]]
+name = "dbus"
+version = "0.9.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1bb21987b9fb1613058ba3843121dd18b163b254d8a6e797e144cbac14d96d1b"
+dependencies = [
+ "libc",
+ "libdbus-sys",
+ "winapi",
+]
 
 [[package]]
 name = "debugid"
···
 checksum = "d8adc4bb1803a324070e64a98ae98f38934d91957a99cfb3a43dcbc01bc56439"
 
 [[package]]
+name = "libdbus-sys"
+version = "0.2.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "06085512b750d640299b79be4bad3d2fa90a9c00b1fd9e1b46364f66f0485c72"
+dependencies = [
+ "cc",
+ "pkg-config",
+]
+
+[[package]]
 name = "libffi"
 version = "3.2.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
···
 ]
 
 [[package]]
+name = "normpath"
+version = "1.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c8911957c4b1549ac0dc74e30db9c8b0e66ddcd6d7acc33098f4c63a64a6d7ed"
+dependencies = [
+ "windows-sys 0.59.0",
+]
+
+[[package]]
 name = "notify"
 version = "6.1.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
···
 version = "0.3.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "c08d65885ee38876c4f86fa503fb49d7b507c2b62552df7c70b2fce627e06381"
+
+[[package]]
+name = "opener"
+version = "0.7.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d0812e5e4df08da354c851a3376fead46db31c2214f849d3de356d774d057681"
+dependencies = [
+ "bstr",
+ "dbus",
+ "normpath",
+ "windows-sys 0.59.0",
+]
 
 [[package]]
 name = "openssl-probe"
···
 checksum = "bd124222d17ad93a644ed9d011a40f4fb64aa54275c08cc216524a9ea82fb09f"
 dependencies = [
  "digest",
+]
+
+[[package]]
+name = "rockbox"
+version = "0.1.0"
+dependencies = [
+ "anyhow",
+ "clap",
+ "opener",
+ "owo-colors 4.1.0",
+ "prost 0.13.2",
+ "tokio",
+ "tonic",
+ "tonic-build",
+ "tonic-reflection",
+ "tonic-web",
 ]
 
 [[package]]

Cargo.toml

···
 [workspace]
 default-members = ["crates/*"]
 members = [
-  "crates/*", "webui",
+  "cli",
+  "crates/*",
+  "webui",
 ]
 resolver = "2"
 

Dockerfile

···
 
 COPY --from=builder /root/.local /root/.local
 
-COPY --from=builder /root/.local/bin/rockbox /usr/bin/rockbox
+COPY --from=builder /root/.local/bin/rockboxd /usr/bin/rockboxd
 
 ENV SDL_VIDEODRIVER=dummy
 
···
 EXPOSE 6062
 EXPOSE 6063
 
-CMD ["rockbox"]
+CMD ["rockboxd"]

build.zig

···
     b.installArtifact(lib);
 
     const exe = b.addExecutable(.{
-        .name = "rockbox",
+        .name = "rockboxd",
         .root_source_file = b.path("src/main.zig"),
         .target = target,
         .optimize = optimize,

cli/Cargo.toml

···
+[package]
+edition = "2021"
+name = "rockbox"
+version = "0.1.0"
+
+[dependencies]
+anyhow = "1.0.91"
+clap = "4.5.20"
+opener = "0.7.2"
+owo-colors = "4.1.0"
+prost = "0.13.2"
+tokio = {version = "1.36.0", features = ["full"]}
+tonic = "0.12.2"
+tonic-reflection = "0.12.2"
+tonic-web = "0.12.2"
+
+[build-dependencies]
+tonic-build = "0.12.2"

cli/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(
+            &[
+                "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(())
+}

cli/proto

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

cli/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::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::new(
+                        tonic::Code::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::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 {
+                        Ok(
+                            http::Response::builder()
+                                .status(200)
+                                .header("grpc-status", tonic::Code::Unimplemented as i32)
+                                .header(
+                                    http::header::CONTENT_TYPE,
+                                    tonic::metadata::GRPC_CONTENT_TYPE,
+                                )
+                                .body(empty_body())
+                                .unwrap(),
+                        )
+                    })
+                }
+            }
+        }
+    }
+    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::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::new(
+                        tonic::Code::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::new(
+                        tonic::Code::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::new(
+                        tonic::Code::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::new(
+                        tonic::Code::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::new(
+                        tonic::Code::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::new(
+                        tonic::Code::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::new(
+                        tonic::Code::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::new(
+                        tonic::Code::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::new(
+                        tonic::Code::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::new(
+                        tonic::Code::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::new(
+                        tonic::Code::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::new(
+                        tonic::Code::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::new(
+                        tonic::Code::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::new(
+                        tonic::Code::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::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 {
+                        Ok(
+                            http::Response::builder()
+                                .status(200)
+                                .header("grpc-status", tonic::Code::Unimplemented as i32)
+                                .header(
+                                    http::header::CONTENT_TYPE,
+                                    tonic::metadata::GRPC_CONTENT_TYPE,
+                                )
+                                .body(empty_body())
+                                .unwrap(),
+                        )
+                    })
+                }
+            }
+        }
+    }
+    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::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::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 {
+                        Ok(
+                            http::Response::builder()
+                                .status(200)
+                                .header("grpc-status", tonic::Code::Unimplemented as i32)
+                                .header(
+                                    http::header::CONTENT_TYPE,
+                                    tonic::metadata::GRPC_CONTENT_TYPE,
+                                )
+                                .body(empty_body())
+                                .unwrap(),
+                        )
+                    })
+                }
+            }
+        }
+    }
+    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 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 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,
+}
+#[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(bool, optional, tag = "4")]
+    pub position: ::core::option::Option<bool>,
+}
+#[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 {}
+/// Generated client implementations.
+pub mod playback_service_client {
+    #![allow(unused_variables, dead_code, missing_docs, 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::new(
+                        tonic::Code::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::new(
+                        tonic::Code::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 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::new(
+                        tonic::Code::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::new(
+                        tonic::Code::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::new(
+                        tonic::Code::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::new(
+                        tonic::Code::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::new(
+                        tonic::Code::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::new(
+                        tonic::Code::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::new(
+                        tonic::Code::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::new(
+                        tonic::Code::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::new(
+                        tonic::Code::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::new(
+                        tonic::Code::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::new(
+                        tonic::Code::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::new(
+                        tonic::Code::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::new(
+                        tonic::Code::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::new(
+                        tonic::Code::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::new(
+                        tonic::Code::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::new(
+                        tonic::Code::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::new(
+                        tonic::Code::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
+        }
+    }
+}
+/// Generated server implementations.
+pub mod playback_service_server {
+    #![allow(unused_variables, dead_code, missing_docs, 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 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,
+        >;
+    }
+    #[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/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)
+                }
+                _ => {
+                    Box::pin(async move {
+                        Ok(
+                            http::Response::builder()
+                                .status(200)
+                                .header("grpc-status", tonic::Code::Unimplemented as i32)
+                                .header(
+                                    http::header::CONTENT_TYPE,
+                                    tonic::metadata::GRPC_CONTENT_TYPE,
+                                )
+                                .body(empty_body())
+                                .unwrap(),
+                        )
+                    })
+                }
+            }
+        }
+    }
+    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, PartialEq, ::prost::Message)]
+pub struct RemoveAllTracksRequest {
+    #[prost(int32, repeated, tag = "1")]
+    pub positions: ::prost::alloc::vec::Vec<i32>,
+}
+#[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>,
+}
+#[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, 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::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::new(
+                        tonic::Code::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::new(
+                        tonic::Code::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::new(
+                        tonic::Code::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::new(
+                        tonic::Code::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::new(
+                        tonic::Code::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::new(
+                        tonic::Code::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::new(
+                        tonic::Code::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::new(
+                        tonic::Code::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::new(
+                        tonic::Code::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::new(
+                        tonic::Code::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::new(
+                        tonic::Code::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::new(
+                        tonic::Code::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::new(
+                        tonic::Code::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::new(
+                        tonic::Code::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::new(
+                        tonic::Code::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::new(
+                        tonic::Code::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::new(
+                        tonic::Code::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::new(
+                        tonic::Code::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 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::new(
+                        tonic::Code::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::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 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/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 {
+                        Ok(
+                            http::Response::builder()
+                                .status(200)
+                                .header("grpc-status", tonic::Code::Unimplemented as i32)
+                                .header(
+                                    http::header::CONTENT_TYPE,
+                                    tonic::metadata::GRPC_CONTENT_TYPE,
+                                )
+                                .body(empty_body())
+                                .unwrap(),
+                        )
+                    })
+                }
+            }
+        }
+    }
+    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::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::new(
+                        tonic::Code::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::new(
+                        tonic::Code::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::new(
+                        tonic::Code::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::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 {
+                        Ok(
+                            http::Response::builder()
+                                .status(200)
+                                .header("grpc-status", tonic::Code::Unimplemented as i32)
+                                .header(
+                                    http::header::CONTENT_TYPE,
+                                    tonic::metadata::GRPC_CONTENT_TYPE,
+                                )
+                                .body(empty_body())
+                                .unwrap(),
+                        )
+                    })
+                }
+            }
+        }
+    }
+    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::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::new(
+                        tonic::Code::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::new(
+                        tonic::Code::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::new(
+                        tonic::Code::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::new(
+                        tonic::Code::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::new(
+                        tonic::Code::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::new(
+                        tonic::Code::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::new(
+                        tonic::Code::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::new(
+                        tonic::Code::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::new(
+                        tonic::Code::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::new(
+                        tonic::Code::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::new(
+                        tonic::Code::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::new(
+                        tonic::Code::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::new(
+                        tonic::Code::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::new(
+                        tonic::Code::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::new(
+                        tonic::Code::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::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 {
+                        Ok(
+                            http::Response::builder()
+                                .status(200)
+                                .header("grpc-status", tonic::Code::Unimplemented as i32)
+                                .header(
+                                    http::header::CONTENT_TYPE,
+                                    tonic::metadata::GRPC_CONTENT_TYPE,
+                                )
+                                .body(empty_body())
+                                .unwrap(),
+                        )
+                    })
+                }
+            }
+        }
+    }
+    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::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::new(
+                        tonic::Code::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::new(
+                        tonic::Code::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::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 {
+                        Ok(
+                            http::Response::builder()
+                                .status(200)
+                                .header("grpc-status", tonic::Code::Unimplemented as i32)
+                                .header(
+                                    http::header::CONTENT_TYPE,
+                                    tonic::metadata::GRPC_CONTENT_TYPE,
+                                )
+                                .body(empty_body())
+                                .unwrap(),
+                        )
+                    })
+                }
+            }
+        }
+    }
+    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;
+    }
+}

cli/src/cmd/community.rs

···
+use opener::open;
+use owo_colors::OwoColorize;
+
+pub fn community() {
+    match open("https://discord.gg/tXPrgcPKSt") {
+        Ok(_) => {}
+        Err(_) => println!(
+            "Open this link in your browser {}",
+            "https://discord.gg/tXPrgcPKSt".purple()
+        ),
+    };
+}

cli/src/cmd/mod.rs

···
+pub mod community;
+pub mod scan;

cli/src/cmd/scan.rs

···
+use std::env;
+
+use anyhow::Error;
+use rockbox::api::rockbox::v1alpha1::{
+    library_service_client::LibraryServiceClient, ScanLibraryRequest,
+};
+
+pub async fn scan(path: Option<String>) -> Result<(), Error> {
+    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 = LibraryServiceClient::connect(url).await?;
+    let request = tonic::Request::new(ScanLibraryRequest { path });
+    client.scan_library(request).await?;
+    println!("Scan request sent to Rockbox server");
+    Ok(())
+}

cli/src/lib.rs

···
+pub mod api {
+    #[path = ""]
+    pub mod rockbox {
+
+        #[path = "rockbox.v1alpha1.rs"]
+        pub mod v1alpha1;
+    }
+}

cli/src/main.rs

···
+use anyhow::Error;
+use clap::{arg, Command};
+use owo_colors::OwoColorize;
+
+use cmd::{community::*, scan::*};
+
+pub mod cmd;
+
+fn cli() -> Command {
+    let banner = format!(
+        "{}\nA fork of the original Rockbox project, with a focus on modernization and more features.",
+        r#"
+              __________               __   ___.
+    Open      \______   \ ____   ____ |  | _\_ |__   _______  ___
+    Source     |       _//  _ \_/ ___\|  |/ /| __ \ /  _ \  \/  /
+    Jukebox    |    |   (  <_> )  \___|    < | \_\ (  <_> > <  <
+    Firmware   |____|_  /\____/ \___  >__|_ \|___  /\____/__/\_ \
+                      \/            \/     \/    \/            \/
+    "#
+        .yellow()
+    );
+    const VERSION: &str = env!("CARGO_PKG_VERSION");
+    Command::new("rockbox")
+        .version(VERSION)
+        .about(&banner)
+        .subcommand(
+            Command::new("scan")
+                .arg(arg!(--directory -d [PATH] "path to your music library").required(false))
+                .about("Scan your music library for new media files"),
+        )
+        .subcommand(
+            Command::new("community").about("Join our community on Discord to chat with us!"),
+        )
+}
+
+#[tokio::main]
+async fn main() -> Result<(), Error> {
+    let matches = cli().get_matches();
+
+    match matches.subcommand() {
+        Some(("scan", args)) => {
+            let directory = args.get_one::<String>("directory").map(|d| d.to_string());
+            scan(directory).await?;
+        }
+        Some(("community", _)) => {
+            community();
+        }
+        _ => cli().print_help()?,
+    }
+    Ok(())
+}

crates/cli/src/lib.rs

···
     "#
         .yellow()
     );
-    let cli = Command::new("rockbox").version(VERSION).about(&banner);
+    let cli = Command::new("rockboxd").version(VERSION).about(&banner);
 
     cli.get_matches_from(args);
 

crates/rpc/proto/rockbox/v1alpha1/library.proto

···
   repeated Album albums = 1;
 }
 
-message ScanLibraryRequest {}
+message ScanLibraryRequest {
+  optional string path = 1;
+}
 
 message ScanLibraryResponse {}
 

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

···
     #[prost(message, repeated, tag = "1")]
     pub albums: ::prost::alloc::vec::Vec<Album>,
 }
-#[derive(Clone, Copy, PartialEq, ::prost::Message)]
-pub struct ScanLibraryRequest {}
+#[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)]

crates/rpc/src/library.rs

···
 
     async fn scan_library(
         &self,
-        _request: tonic::Request<ScanLibraryRequest>,
+        request: tonic::Request<ScanLibraryRequest>,
     ) -> Result<tonic::Response<ScanLibraryResponse>, tonic::Status> {
-        let url = format!("{}/scan-library", rockbox_url());
+        let request = request.into_inner();
+        let params = match request.path {
+            Some(path) => format!("?path={}", path),
+            None => "".to_string(),
+        };
+        let url = format!("{}/scan-library{}", rockbox_url(), params);
         self.client
             .put(&url)
             .send()
···
             &self.indexes.tracks,
             &term,
             &rockbox_search::track::Track::default(),
-        )
-        .map_err(|e| tonic::Status::internal(e.to_string()))?;
-        let files = search_entities(
-            &self.indexes.files,
-            &term,
-            &rockbox_search::file::File::default(),
-        )
-        .map_err(|e| tonic::Status::internal(e.to_string()))?;
-        let liked_tracks = search_entities(
-            &self.indexes.liked_tracks,
-            &term,
-            &rockbox_search::liked_track::LikedTrack::default(),
-        )
-        .map_err(|e| tonic::Status::internal(e.to_string()))?;
-        let liked_albums = search_entities(
-            &self.indexes.liked_albums,
-            &term,
-            &rockbox_search::liked_album::LikedAlbum::default(),
         )
         .map_err(|e| tonic::Status::internal(e.to_string()))?;
 

crates/server/src/handlers/system.rs

···
     Ok(())
 }
 
-pub async fn scan_library(ctx: &Context, _req: &Request, res: &mut Response) -> Result<(), Error> {
+pub async fn scan_library(ctx: &Context, req: &Request, res: &mut Response) -> Result<(), Error> {
     let home = env::var("HOME")?;
-    let path = rockbox_settings::get_music_dir().unwrap_or(format!("{}/Music", home));
+    let music_library = format!("{}/Music", home);
+
+    let path = match req.query_params.get("path") {
+        Some(path) => path.as_str().unwrap_or(&music_library),
+        None => &music_library,
+    };
+
     scan_audio_files(ctx.pool.clone(), path.into()).await?;
+
+    if path != music_library {
+        res.text("0");
+        return Ok(());
+    }
+
     let tracks = repo::track::all(ctx.pool.clone()).await?;
     let albums = repo::album::all(ctx.pool.clone()).await?;
     let artists = repo::artist::all(ctx.pool.clone()).await?;

tools/root.make

···
 	cd .. \
 	&& zig build install-rockbox \
 	&& mkdir -p $(RBPREFIX)/bin $(RBPREFIX)/share/rockbox \
-	&& cp zig-out/bin/rockbox $(RBPREFIX)/bin \
+	&& cp zig-out/bin/rockboxd $(RBPREFIX)/bin \
 	&& cp -r assets/* $(RBPREFIX)/share/rockbox
 
 symlinkinstall: simext1
···
 	cd .. \
 	&& cargo build -p rockbox-cli --release \
 	&& cargo build -p rockbox-server --release \
+	&& cargo build -p rockbox --release \
 	&& zig build all
 help:
 	@echo "A few helpful make targets"