Add macOS DMG build and startup error alert

.github/workflows/macos-build.yml

···
           sudo cp zig/zig-out/bin/rockboxd /usr/local/bin/
       - name: Generate Package Installer
         run: ./packaging/macos/build-pkg.sh
+      - name: Build DMG
+        run: |
+          xcodebuild -scheme Rockbox -configuration Release archive -archivePath ./build/Rockbox.xcarchive
+          xcodebuild -exportArchive -archivePath ./build/Rockbox.xcarchive -exportPath ./build -exportOptionsPlist ExportOptions.plist
+          mkdir dmg_temp
+          cp -r build/Rockbox.app dmg_temp
+          hdiutil create -volname "Rockbox" -srcfolder dmg_temp -ov -format UDZO Rockbox-${{ steps.vars.outputs.version }}-${{ steps.vars.outputs.arch }}.dmg
+        working-directory: macos
       - name: Show artifacts
         run: |
           ls rockbox-*.pkg
···
             rockbox-assets-${{ steps.vars.outputs.version }}-${{ steps.vars.outputs.arch }}-darwin.tar.gz
             rockbox-assets-${{ steps.vars.outputs.version }}-${{ steps.vars.outputs.arch }}-darwin.tar.gz.sha256
             rockbox-${{ steps.vars.outputs.version }}-${{ steps.vars.outputs.arch }}.pkg
+            Rockbox-${{ steps.vars.outputs.version }}-${{ steps.vars.outputs.arch }}.dmg
           tag_name: ${{ steps.vars.outputs.version }}
         env:
           GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}

cli/src/api/rockbox.v1alpha1.rs

···
         dead_code,
         missing_docs,
         clippy::wildcard_imports,
-        clippy::let_unit_value,
+        clippy::let_unit_value
     )]
-    use tonic::codegen::*;
     use tonic::codegen::http::Uri;
+    use tonic::codegen::*;
     #[derive(Debug, Clone)]
     pub struct BrowseServiceClient<T> {
         inner: tonic::client::Grpc<T>,
···
                     <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,
+            <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))
         }
···
         pub async fn tree_get_entries(
             &mut self,
             request: impl tonic::IntoRequest<super::TreeGetEntriesRequest>,
-        ) -> std::result::Result<
-            tonic::Response<super::TreeGetEntriesResponse>,
-            tonic::Status,
-        > {
-            self.inner
-                .ready()
-                .await
-                .map_err(|e| {
-                    tonic::Status::unknown(
-                        format!("Service was not ready: {}", e.into()),
-                    )
-                })?;
+        ) -> std::result::Result<tonic::Response<super::TreeGetEntriesResponse>, tonic::Status>
+        {
+            self.inner.ready().await.map_err(|e| {
+                tonic::Status::unknown(format!("Service was not ready: {}", e.into()))
+            })?;
             let codec = tonic::codec::ProstCodec::default();
             let path = http::uri::PathAndQuery::from_static(
                 "/rockbox.v1alpha1.BrowseService/TreeGetEntries",
             );
             let mut req = request.into_request();
-            req.extensions_mut()
-                .insert(
-                    GrpcMethod::new("rockbox.v1alpha1.BrowseService", "TreeGetEntries"),
-                );
+            req.extensions_mut().insert(GrpcMethod::new(
+                "rockbox.v1alpha1.BrowseService",
+                "TreeGetEntries",
+            ));
             self.inner.unary(req, path, codec).await
         }
     }
···
         dead_code,
         missing_docs,
         clippy::wildcard_imports,
-        clippy::let_unit_value,
+        clippy::let_unit_value
     )]
     use tonic::codegen::*;
     /// Generated trait containing gRPC methods that should be implemented for use with BrowseServiceServer.
···
         async fn tree_get_entries(
             &self,
             request: tonic::Request<super::TreeGetEntriesRequest>,
-        ) -> std::result::Result<
-            tonic::Response<super::TreeGetEntriesResponse>,
-            tonic::Status,
-        >;
+        ) -> std::result::Result<tonic::Response<super::TreeGetEntriesResponse>, tonic::Status>;
     }
     #[derive(Debug)]
     pub struct BrowseServiceServer<T> {
···
                 max_encoding_message_size: None,
             }
         }
-        pub fn with_interceptor<F>(
-            inner: T,
-            interceptor: F,
-        ) -> InterceptedService<Self, F>
+        pub fn with_interceptor<F>(inner: T, interceptor: F) -> InterceptedService<Self, F>
         where
             F: tonic::service::Interceptor,
         {
···
                 "/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> {
+                    impl<T: BrowseService> tonic::server::UnaryService<super::TreeGetEntriesRequest>
+                        for TreeGetEntriesSvc<T>
+                    {
                         type Response = super::TreeGetEntriesResponse;
-                        type Future = BoxFuture<
-                            tonic::Response<Self::Response>,
-                            tonic::Status,
-                        >;
+                        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
+                                <T as BrowseService>::tree_get_entries(&inner, request).await
                             };
                             Box::pin(fut)
                         }
···
                     };
                     Box::pin(fut)
                 }
-                _ => {
-                    Box::pin(async move {
-                        let mut response = http::Response::new(empty_body());
-                        let headers = response.headers_mut();
-                        headers
-                            .insert(
-                                tonic::Status::GRPC_STATUS,
-                                (tonic::Code::Unimplemented as i32).into(),
-                            );
-                        headers
-                            .insert(
-                                http::header::CONTENT_TYPE,
-                                tonic::metadata::GRPC_CONTENT_TYPE,
-                            );
-                        Ok(response)
-                    })
-                }
+                _ => Box::pin(async move {
+                    let mut response = http::Response::new(empty_body());
+                    let headers = response.headers_mut();
+                    headers.insert(
+                        tonic::Status::GRPC_STATUS,
+                        (tonic::Code::Unimplemented as i32).into(),
+                    );
+                    headers.insert(
+                        http::header::CONTENT_TYPE,
+                        tonic::metadata::GRPC_CONTENT_TYPE,
+                    );
+                    Ok(response)
+                }),
             }
         }
     }
···
         dead_code,
         missing_docs,
         clippy::wildcard_imports,
-        clippy::let_unit_value,
+        clippy::let_unit_value
     )]
-    use tonic::codegen::*;
     use tonic::codegen::http::Uri;
+    use tonic::codegen::*;
     #[derive(Debug, Clone)]
     pub struct LibraryServiceClient<T> {
         inner: tonic::client::Grpc<T>,
···
                     <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,
+            <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))
         }
···
         pub async fn get_albums(
             &mut self,
             request: impl tonic::IntoRequest<super::GetAlbumsRequest>,
-        ) -> std::result::Result<
-            tonic::Response<super::GetAlbumsResponse>,
-            tonic::Status,
-        > {
-            self.inner
-                .ready()
-                .await
-                .map_err(|e| {
-                    tonic::Status::unknown(
-                        format!("Service was not ready: {}", e.into()),
-                    )
-                })?;
+        ) -> std::result::Result<tonic::Response<super::GetAlbumsResponse>, tonic::Status> {
+            self.inner.ready().await.map_err(|e| {
+                tonic::Status::unknown(format!("Service was not ready: {}", e.into()))
+            })?;
             let codec = tonic::codec::ProstCodec::default();
-            let path = http::uri::PathAndQuery::from_static(
-                "/rockbox.v1alpha1.LibraryService/GetAlbums",
-            );
+            let 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"));
+            req.extensions_mut().insert(GrpcMethod::new(
+                "rockbox.v1alpha1.LibraryService",
+                "GetAlbums",
+            ));
             self.inner.unary(req, path, codec).await
         }
         pub async fn get_artists(
             &mut self,
             request: impl tonic::IntoRequest<super::GetArtistsRequest>,
-        ) -> std::result::Result<
-            tonic::Response<super::GetArtistsResponse>,
-            tonic::Status,
-        > {
-            self.inner
-                .ready()
-                .await
-                .map_err(|e| {
-                    tonic::Status::unknown(
-                        format!("Service was not ready: {}", e.into()),
-                    )
-                })?;
+        ) -> std::result::Result<tonic::Response<super::GetArtistsResponse>, tonic::Status>
+        {
+            self.inner.ready().await.map_err(|e| {
+                tonic::Status::unknown(format!("Service was not ready: {}", e.into()))
+            })?;
             let codec = tonic::codec::ProstCodec::default();
-            let path = http::uri::PathAndQuery::from_static(
-                "/rockbox.v1alpha1.LibraryService/GetArtists",
-            );
+            let 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"),
-                );
+            req.extensions_mut().insert(GrpcMethod::new(
+                "rockbox.v1alpha1.LibraryService",
+                "GetArtists",
+            ));
             self.inner.unary(req, path, codec).await
         }
         pub async fn get_tracks(
             &mut self,
             request: impl tonic::IntoRequest<super::GetTracksRequest>,
-        ) -> std::result::Result<
-            tonic::Response<super::GetTracksResponse>,
-            tonic::Status,
-        > {
-            self.inner
-                .ready()
-                .await
-                .map_err(|e| {
-                    tonic::Status::unknown(
-                        format!("Service was not ready: {}", e.into()),
-                    )
-                })?;
+        ) -> std::result::Result<tonic::Response<super::GetTracksResponse>, tonic::Status> {
+            self.inner.ready().await.map_err(|e| {
+                tonic::Status::unknown(format!("Service was not ready: {}", e.into()))
+            })?;
             let codec = tonic::codec::ProstCodec::default();
-            let path = http::uri::PathAndQuery::from_static(
-                "/rockbox.v1alpha1.LibraryService/GetTracks",
-            );
+            let 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"));
+            req.extensions_mut().insert(GrpcMethod::new(
+                "rockbox.v1alpha1.LibraryService",
+                "GetTracks",
+            ));
             self.inner.unary(req, path, codec).await
         }
         pub async fn get_album(
             &mut self,
             request: impl tonic::IntoRequest<super::GetAlbumRequest>,
-        ) -> std::result::Result<
-            tonic::Response<super::GetAlbumResponse>,
-            tonic::Status,
-        > {
-            self.inner
-                .ready()
-                .await
-                .map_err(|e| {
-                    tonic::Status::unknown(
-                        format!("Service was not ready: {}", e.into()),
-                    )
-                })?;
+        ) -> std::result::Result<tonic::Response<super::GetAlbumResponse>, tonic::Status> {
+            self.inner.ready().await.map_err(|e| {
+                tonic::Status::unknown(format!("Service was not ready: {}", e.into()))
+            })?;
             let codec = tonic::codec::ProstCodec::default();
-            let path = http::uri::PathAndQuery::from_static(
-                "/rockbox.v1alpha1.LibraryService/GetAlbum",
-            );
+            let 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"));
+            req.extensions_mut().insert(GrpcMethod::new(
+                "rockbox.v1alpha1.LibraryService",
+                "GetAlbum",
+            ));
             self.inner.unary(req, path, codec).await
         }
         pub async fn get_artist(
             &mut self,
             request: impl tonic::IntoRequest<super::GetArtistRequest>,
-        ) -> std::result::Result<
-            tonic::Response<super::GetArtistResponse>,
-            tonic::Status,
-        > {
-            self.inner
-                .ready()
-                .await
-                .map_err(|e| {
-                    tonic::Status::unknown(
-                        format!("Service was not ready: {}", e.into()),
-                    )
-                })?;
+        ) -> std::result::Result<tonic::Response<super::GetArtistResponse>, tonic::Status> {
+            self.inner.ready().await.map_err(|e| {
+                tonic::Status::unknown(format!("Service was not ready: {}", e.into()))
+            })?;
             let codec = tonic::codec::ProstCodec::default();
-            let path = http::uri::PathAndQuery::from_static(
-                "/rockbox.v1alpha1.LibraryService/GetArtist",
-            );
+            let 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"));
+            req.extensions_mut().insert(GrpcMethod::new(
+                "rockbox.v1alpha1.LibraryService",
+                "GetArtist",
+            ));
             self.inner.unary(req, path, codec).await
         }
         pub async fn get_track(
             &mut self,
             request: impl tonic::IntoRequest<super::GetTrackRequest>,
-        ) -> std::result::Result<
-            tonic::Response<super::GetTrackResponse>,
-            tonic::Status,
-        > {
-            self.inner
-                .ready()
-                .await
-                .map_err(|e| {
-                    tonic::Status::unknown(
-                        format!("Service was not ready: {}", e.into()),
-                    )
-                })?;
+        ) -> std::result::Result<tonic::Response<super::GetTrackResponse>, tonic::Status> {
+            self.inner.ready().await.map_err(|e| {
+                tonic::Status::unknown(format!("Service was not ready: {}", e.into()))
+            })?;
             let codec = tonic::codec::ProstCodec::default();
-            let path = http::uri::PathAndQuery::from_static(
-                "/rockbox.v1alpha1.LibraryService/GetTrack",
-            );
+            let 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"));
+            req.extensions_mut().insert(GrpcMethod::new(
+                "rockbox.v1alpha1.LibraryService",
+                "GetTrack",
+            ));
             self.inner.unary(req, path, codec).await
         }
         pub async fn like_track(
             &mut self,
             request: impl tonic::IntoRequest<super::LikeTrackRequest>,
-        ) -> std::result::Result<
-            tonic::Response<super::LikeTrackResponse>,
-            tonic::Status,
-        > {
-            self.inner
-                .ready()
-                .await
-                .map_err(|e| {
-                    tonic::Status::unknown(
-                        format!("Service was not ready: {}", e.into()),
-                    )
-                })?;
+        ) -> std::result::Result<tonic::Response<super::LikeTrackResponse>, tonic::Status> {
+            self.inner.ready().await.map_err(|e| {
+                tonic::Status::unknown(format!("Service was not ready: {}", e.into()))
+            })?;
             let codec = tonic::codec::ProstCodec::default();
-            let path = http::uri::PathAndQuery::from_static(
-                "/rockbox.v1alpha1.LibraryService/LikeTrack",
-            );
+            let 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"));
+            req.extensions_mut().insert(GrpcMethod::new(
+                "rockbox.v1alpha1.LibraryService",
+                "LikeTrack",
+            ));
             self.inner.unary(req, path, codec).await
         }
         pub async fn unlike_track(
             &mut self,
             request: impl tonic::IntoRequest<super::UnlikeTrackRequest>,
-        ) -> std::result::Result<
-            tonic::Response<super::UnlikeTrackResponse>,
-            tonic::Status,
-        > {
-            self.inner
-                .ready()
-                .await
-                .map_err(|e| {
-                    tonic::Status::unknown(
-                        format!("Service was not ready: {}", e.into()),
-                    )
-                })?;
+        ) -> std::result::Result<tonic::Response<super::UnlikeTrackResponse>, tonic::Status>
+        {
+            self.inner.ready().await.map_err(|e| {
+                tonic::Status::unknown(format!("Service was not ready: {}", e.into()))
+            })?;
             let codec = tonic::codec::ProstCodec::default();
             let path = http::uri::PathAndQuery::from_static(
                 "/rockbox.v1alpha1.LibraryService/UnlikeTrack",
             );
             let mut req = request.into_request();
-            req.extensions_mut()
-                .insert(
-                    GrpcMethod::new("rockbox.v1alpha1.LibraryService", "UnlikeTrack"),
-                );
+            req.extensions_mut().insert(GrpcMethod::new(
+                "rockbox.v1alpha1.LibraryService",
+                "UnlikeTrack",
+            ));
             self.inner.unary(req, path, codec).await
         }
         pub async fn like_album(
             &mut self,
             request: impl tonic::IntoRequest<super::LikeAlbumRequest>,
-        ) -> std::result::Result<
-            tonic::Response<super::LikeAlbumResponse>,
-            tonic::Status,
-        > {
-            self.inner
-                .ready()
-                .await
-                .map_err(|e| {
-                    tonic::Status::unknown(
-                        format!("Service was not ready: {}", e.into()),
-                    )
-                })?;
+        ) -> std::result::Result<tonic::Response<super::LikeAlbumResponse>, tonic::Status> {
+            self.inner.ready().await.map_err(|e| {
+                tonic::Status::unknown(format!("Service was not ready: {}", e.into()))
+            })?;
             let codec = tonic::codec::ProstCodec::default();
-            let path = http::uri::PathAndQuery::from_static(
-                "/rockbox.v1alpha1.LibraryService/LikeAlbum",
-            );
+            let 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"));
+            req.extensions_mut().insert(GrpcMethod::new(
+                "rockbox.v1alpha1.LibraryService",
+                "LikeAlbum",
+            ));
             self.inner.unary(req, path, codec).await
         }
         pub async fn unlike_album(
             &mut self,
             request: impl tonic::IntoRequest<super::UnlikeAlbumRequest>,
-        ) -> std::result::Result<
-            tonic::Response<super::UnlikeAlbumResponse>,
-            tonic::Status,
-        > {
-            self.inner
-                .ready()
-                .await
-                .map_err(|e| {
-                    tonic::Status::unknown(
-                        format!("Service was not ready: {}", e.into()),
-                    )
-                })?;
+        ) -> std::result::Result<tonic::Response<super::UnlikeAlbumResponse>, tonic::Status>
+        {
+            self.inner.ready().await.map_err(|e| {
+                tonic::Status::unknown(format!("Service was not ready: {}", e.into()))
+            })?;
             let codec = tonic::codec::ProstCodec::default();
             let path = http::uri::PathAndQuery::from_static(
                 "/rockbox.v1alpha1.LibraryService/UnlikeAlbum",
             );
             let mut req = request.into_request();
-            req.extensions_mut()
-                .insert(
-                    GrpcMethod::new("rockbox.v1alpha1.LibraryService", "UnlikeAlbum"),
-                );
+            req.extensions_mut().insert(GrpcMethod::new(
+                "rockbox.v1alpha1.LibraryService",
+                "UnlikeAlbum",
+            ));
             self.inner.unary(req, path, codec).await
         }
         pub async fn get_liked_tracks(
             &mut self,
             request: impl tonic::IntoRequest<super::GetLikedTracksRequest>,
-        ) -> std::result::Result<
-            tonic::Response<super::GetLikedTracksResponse>,
-            tonic::Status,
-        > {
-            self.inner
-                .ready()
-                .await
-                .map_err(|e| {
-                    tonic::Status::unknown(
-                        format!("Service was not ready: {}", e.into()),
-                    )
-                })?;
+        ) -> std::result::Result<tonic::Response<super::GetLikedTracksResponse>, tonic::Status>
+        {
+            self.inner.ready().await.map_err(|e| {
+                tonic::Status::unknown(format!("Service was not ready: {}", e.into()))
+            })?;
             let codec = tonic::codec::ProstCodec::default();
             let path = http::uri::PathAndQuery::from_static(
                 "/rockbox.v1alpha1.LibraryService/GetLikedTracks",
             );
             let mut req = request.into_request();
-            req.extensions_mut()
-                .insert(
-                    GrpcMethod::new("rockbox.v1alpha1.LibraryService", "GetLikedTracks"),
-                );
+            req.extensions_mut().insert(GrpcMethod::new(
+                "rockbox.v1alpha1.LibraryService",
+                "GetLikedTracks",
+            ));
             self.inner.unary(req, path, codec).await
         }
         pub async fn get_liked_albums(
             &mut self,
             request: impl tonic::IntoRequest<super::GetLikedAlbumsRequest>,
-        ) -> std::result::Result<
-            tonic::Response<super::GetLikedAlbumsResponse>,
-            tonic::Status,
-        > {
-            self.inner
-                .ready()
-                .await
-                .map_err(|e| {
-                    tonic::Status::unknown(
-                        format!("Service was not ready: {}", e.into()),
-                    )
-                })?;
+        ) -> std::result::Result<tonic::Response<super::GetLikedAlbumsResponse>, tonic::Status>
+        {
+            self.inner.ready().await.map_err(|e| {
+                tonic::Status::unknown(format!("Service was not ready: {}", e.into()))
+            })?;
             let codec = tonic::codec::ProstCodec::default();
             let path = http::uri::PathAndQuery::from_static(
                 "/rockbox.v1alpha1.LibraryService/GetLikedAlbums",
             );
             let mut req = request.into_request();
-            req.extensions_mut()
-                .insert(
-                    GrpcMethod::new("rockbox.v1alpha1.LibraryService", "GetLikedAlbums"),
-                );
+            req.extensions_mut().insert(GrpcMethod::new(
+                "rockbox.v1alpha1.LibraryService",
+                "GetLikedAlbums",
+            ));
             self.inner.unary(req, path, codec).await
         }
         pub async fn scan_library(
             &mut self,
             request: impl tonic::IntoRequest<super::ScanLibraryRequest>,
-        ) -> std::result::Result<
-            tonic::Response<super::ScanLibraryResponse>,
-            tonic::Status,
-        > {
-            self.inner
-                .ready()
-                .await
-                .map_err(|e| {
-                    tonic::Status::unknown(
-                        format!("Service was not ready: {}", e.into()),
-                    )
-                })?;
+        ) -> std::result::Result<tonic::Response<super::ScanLibraryResponse>, tonic::Status>
+        {
+            self.inner.ready().await.map_err(|e| {
+                tonic::Status::unknown(format!("Service was not ready: {}", e.into()))
+            })?;
             let codec = tonic::codec::ProstCodec::default();
             let path = http::uri::PathAndQuery::from_static(
                 "/rockbox.v1alpha1.LibraryService/ScanLibrary",
             );
             let mut req = request.into_request();
-            req.extensions_mut()
-                .insert(
-                    GrpcMethod::new("rockbox.v1alpha1.LibraryService", "ScanLibrary"),
-                );
+            req.extensions_mut().insert(GrpcMethod::new(
+                "rockbox.v1alpha1.LibraryService",
+                "ScanLibrary",
+            ));
             self.inner.unary(req, path, codec).await
         }
         pub async fn search(
             &mut self,
             request: impl tonic::IntoRequest<super::SearchRequest>,
         ) -> std::result::Result<tonic::Response<super::SearchResponse>, tonic::Status> {
-            self.inner
-                .ready()
-                .await
-                .map_err(|e| {
-                    tonic::Status::unknown(
-                        format!("Service was not ready: {}", e.into()),
-                    )
-                })?;
+            self.inner.ready().await.map_err(|e| {
+                tonic::Status::unknown(format!("Service was not ready: {}", e.into()))
+            })?;
             let codec = tonic::codec::ProstCodec::default();
-            let path = http::uri::PathAndQuery::from_static(
-                "/rockbox.v1alpha1.LibraryService/Search",
-            );
+            let 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"));
···
         dead_code,
         missing_docs,
         clippy::wildcard_imports,
-        clippy::let_unit_value,
+        clippy::let_unit_value
     )]
     use tonic::codegen::*;
     /// Generated trait containing gRPC methods that should be implemented for use with LibraryServiceServer.
···
         async fn get_albums(
             &self,
             request: tonic::Request<super::GetAlbumsRequest>,
-        ) -> std::result::Result<
-            tonic::Response<super::GetAlbumsResponse>,
-            tonic::Status,
-        >;
+        ) -> 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,
-        >;
+        ) -> 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,
-        >;
+        ) -> 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,
-        >;
+        ) -> 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,
-        >;
+        ) -> 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,
-        >;
+        ) -> 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,
-        >;
+        ) -> 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,
-        >;
+        ) -> 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,
-        >;
+        ) -> 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,
-        >;
+        ) -> 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,
-        >;
+        ) -> 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,
-        >;
+        ) -> 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,
-        >;
+        ) -> std::result::Result<tonic::Response<super::ScanLibraryResponse>, tonic::Status>;
         async fn search(
             &self,
             request: tonic::Request<super::SearchRequest>,
···
                 max_encoding_message_size: None,
             }
         }
-        pub fn with_interceptor<F>(
-            inner: T,
-            interceptor: F,
-        ) -> InterceptedService<Self, F>
+        pub fn with_interceptor<F>(inner: T, interceptor: F) -> InterceptedService<Self, F>
         where
             F: tonic::service::Interceptor,
         {
···
                 "/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> {
+                    impl<T: LibraryService> tonic::server::UnaryService<super::GetAlbumsRequest> for GetAlbumsSvc<T> {
                         type Response = super::GetAlbumsResponse;
-                        type Future = BoxFuture<
-                            tonic::Response<Self::Response>,
-                            tonic::Status,
-                        >;
+                        type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
                         fn call(
                             &mut self,
                             request: tonic::Request<super::GetAlbumsRequest>,
···
                 "/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> {
+                    impl<T: LibraryService> tonic::server::UnaryService<super::GetArtistsRequest> for GetArtistsSvc<T> {
                         type Response = super::GetArtistsResponse;
-                        type Future = BoxFuture<
-                            tonic::Response<Self::Response>,
-                            tonic::Status,
-                        >;
+                        type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
                         fn call(
                             &mut self,
                             request: tonic::Request<super::GetArtistsRequest>,
···
                 "/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> {
+                    impl<T: LibraryService> tonic::server::UnaryService<super::GetTracksRequest> for GetTracksSvc<T> {
                         type Response = super::GetTracksResponse;
-                        type Future = BoxFuture<
-                            tonic::Response<Self::Response>,
-                            tonic::Status,
-                        >;
+                        type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
                         fn call(
                             &mut self,
                             request: tonic::Request<super::GetTracksRequest>,
···
                 "/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> {
+                    impl<T: LibraryService> tonic::server::UnaryService<super::GetAlbumRequest> for GetAlbumSvc<T> {
                         type Response = super::GetAlbumResponse;
-                        type Future = BoxFuture<
-                            tonic::Response<Self::Response>,
-                            tonic::Status,
-                        >;
+                        type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
                         fn call(
                             &mut self,
                             request: tonic::Request<super::GetAlbumRequest>,
···
                 "/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> {
+                    impl<T: LibraryService> tonic::server::UnaryService<super::GetArtistRequest> for GetArtistSvc<T> {
                         type Response = super::GetArtistResponse;
-                        type Future = BoxFuture<
-                            tonic::Response<Self::Response>,
-                            tonic::Status,
-                        >;
+                        type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
                         fn call(
                             &mut self,
                             request: tonic::Request<super::GetArtistRequest>,
···
                 "/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> {
+                    impl<T: LibraryService> tonic::server::UnaryService<super::GetTrackRequest> for GetTrackSvc<T> {
                         type Response = super::GetTrackResponse;
-                        type Future = BoxFuture<
-                            tonic::Response<Self::Response>,
-                            tonic::Status,
-                        >;
+                        type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
                         fn call(
                             &mut self,
                             request: tonic::Request<super::GetTrackRequest>,
···
                 "/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> {
+                    impl<T: LibraryService> tonic::server::UnaryService<super::LikeTrackRequest> for LikeTrackSvc<T> {
                         type Response = super::LikeTrackResponse;
-                        type Future = BoxFuture<
-                            tonic::Response<Self::Response>,
-                            tonic::Status,
-                        >;
+                        type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
                         fn call(
                             &mut self,
                             request: tonic::Request<super::LikeTrackRequest>,
···
                 "/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> {
+                    impl<T: LibraryService> tonic::server::UnaryService<super::UnlikeTrackRequest>
+                        for UnlikeTrackSvc<T>
+                    {
                         type Response = super::UnlikeTrackResponse;
-                        type Future = BoxFuture<
-                            tonic::Response<Self::Response>,
-                            tonic::Status,
-                        >;
+                        type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
                         fn call(
                             &mut self,
                             request: tonic::Request<super::UnlikeTrackRequest>,
···
                 "/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> {
+                    impl<T: LibraryService> tonic::server::UnaryService<super::LikeAlbumRequest> for LikeAlbumSvc<T> {
                         type Response = super::LikeAlbumResponse;
-                        type Future = BoxFuture<
-                            tonic::Response<Self::Response>,
-                            tonic::Status,
-                        >;
+                        type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
                         fn call(
                             &mut self,
                             request: tonic::Request<super::LikeAlbumRequest>,
···
                 "/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> {
+                    impl<T: LibraryService> tonic::server::UnaryService<super::UnlikeAlbumRequest>
+                        for UnlikeAlbumSvc<T>
+                    {
                         type Response = super::UnlikeAlbumResponse;
-                        type Future = BoxFuture<
-                            tonic::Response<Self::Response>,
-                            tonic::Status,
-                        >;
+                        type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
                         fn call(
                             &mut self,
                             request: tonic::Request<super::UnlikeAlbumRequest>,
···
                 "/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> {
+                    impl<T: LibraryService>
+                        tonic::server::UnaryService<super::GetLikedTracksRequest>
+                        for GetLikedTracksSvc<T>
+                    {
                         type Response = super::GetLikedTracksResponse;
-                        type Future = BoxFuture<
-                            tonic::Response<Self::Response>,
-                            tonic::Status,
-                        >;
+                        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
+                                <T as LibraryService>::get_liked_tracks(&inner, request).await
                             };
                             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> {
+                    impl<T: LibraryService>
+                        tonic::server::UnaryService<super::GetLikedAlbumsRequest>
+                        for GetLikedAlbumsSvc<T>
+                    {
                         type Response = super::GetLikedAlbumsResponse;
-                        type Future = BoxFuture<
-                            tonic::Response<Self::Response>,
-                            tonic::Status,
-                        >;
+                        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
+                                <T as LibraryService>::get_liked_albums(&inner, request).await
                             };
                             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> {
+                    impl<T: LibraryService> tonic::server::UnaryService<super::ScanLibraryRequest>
+                        for ScanLibrarySvc<T>
+                    {
                         type Response = super::ScanLibraryResponse;
-                        type Future = BoxFuture<
-                            tonic::Response<Self::Response>,
-                            tonic::Status,
-                        >;
+                        type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
                         fn call(
                             &mut self,
                             request: tonic::Request<super::ScanLibraryRequest>,
···
                 "/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> {
+                    impl<T: LibraryService> tonic::server::UnaryService<super::SearchRequest> for SearchSvc<T> {
                         type Response = super::SearchResponse;
-                        type Future = BoxFuture<
-                            tonic::Response<Self::Response>,
-                            tonic::Status,
-                        >;
+                        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
-                            };
+                            let fut =
+                                async move { <T as LibraryService>::search(&inner, request).await };
                             Box::pin(fut)
                         }
                     }
···
                     };
                     Box::pin(fut)
                 }
-                _ => {
-                    Box::pin(async move {
-                        let mut response = http::Response::new(empty_body());
-                        let headers = response.headers_mut();
-                        headers
-                            .insert(
-                                tonic::Status::GRPC_STATUS,
-                                (tonic::Code::Unimplemented as i32).into(),
-                            );
-                        headers
-                            .insert(
-                                http::header::CONTENT_TYPE,
-                                tonic::metadata::GRPC_CONTENT_TYPE,
-                            );
-                        Ok(response)
-                    })
-                }
+                _ => Box::pin(async move {
+                    let mut response = http::Response::new(empty_body());
+                    let headers = response.headers_mut();
+                    headers.insert(
+                        tonic::Status::GRPC_STATUS,
+                        (tonic::Code::Unimplemented as i32).into(),
+                    );
+                    headers.insert(
+                        http::header::CONTENT_TYPE,
+                        tonic::metadata::GRPC_CONTENT_TYPE,
+                    );
+                    Ok(response)
+                }),
             }
         }
     }
···
         dead_code,
         missing_docs,
         clippy::wildcard_imports,
-        clippy::let_unit_value,
+        clippy::let_unit_value
     )]
-    use tonic::codegen::*;
     use tonic::codegen::http::Uri;
+    use tonic::codegen::*;
     #[derive(Debug, Clone)]
     pub struct MetadataServiceClient<T> {
         inner: tonic::client::Grpc<T>,
···
                     <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,
+            <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))
         }
···
         dead_code,
         missing_docs,
         clippy::wildcard_imports,
-        clippy::let_unit_value,
+        clippy::let_unit_value
     )]
     use tonic::codegen::*;
     /// Generated trait containing gRPC methods that should be implemented for use with MetadataServiceServer.
···
                 max_encoding_message_size: None,
             }
         }
-        pub fn with_interceptor<F>(
-            inner: T,
-            interceptor: F,
-        ) -> InterceptedService<Self, F>
+        pub fn with_interceptor<F>(inner: T, interceptor: F) -> InterceptedService<Self, F>
         where
             F: tonic::service::Interceptor,
         {
···
         }
         fn call(&mut self, req: http::Request<B>) -> Self::Future {
             match req.uri().path() {
-                _ => {
-                    Box::pin(async move {
-                        let mut response = http::Response::new(empty_body());
-                        let headers = response.headers_mut();
-                        headers
-                            .insert(
-                                tonic::Status::GRPC_STATUS,
-                                (tonic::Code::Unimplemented as i32).into(),
-                            );
-                        headers
-                            .insert(
-                                http::header::CONTENT_TYPE,
-                                tonic::metadata::GRPC_CONTENT_TYPE,
-                            );
-                        Ok(response)
-                    })
-                }
+                _ => Box::pin(async move {
+                    let mut response = http::Response::new(empty_body());
+                    let headers = response.headers_mut();
+                    headers.insert(
+                        tonic::Status::GRPC_STATUS,
+                        (tonic::Code::Unimplemented as i32).into(),
+                    );
+                    headers.insert(
+                        http::header::CONTENT_TYPE,
+                        tonic::metadata::GRPC_CONTENT_TYPE,
+                    );
+                    Ok(response)
+                }),
             }
         }
     }
···
         dead_code,
         missing_docs,
         clippy::wildcard_imports,
-        clippy::let_unit_value,
+        clippy::let_unit_value
     )]
-    use tonic::codegen::*;
     use tonic::codegen::http::Uri;
+    use tonic::codegen::*;
     #[derive(Debug, Clone)]
     pub struct PlaybackServiceClient<T> {
         inner: tonic::client::Grpc<T>,
···
                     <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,
+            <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))
         }
···
             &mut self,
             request: impl tonic::IntoRequest<super::PlayRequest>,
         ) -> std::result::Result<tonic::Response<super::PlayResponse>, tonic::Status> {
-            self.inner
-                .ready()
-                .await
-                .map_err(|e| {
-                    tonic::Status::unknown(
-                        format!("Service was not ready: {}", e.into()),
-                    )
-                })?;
+            self.inner.ready().await.map_err(|e| {
+                tonic::Status::unknown(format!("Service was not ready: {}", e.into()))
+            })?;
             let codec = tonic::codec::ProstCodec::default();
-            let path = http::uri::PathAndQuery::from_static(
-                "/rockbox.v1alpha1.PlaybackService/Play",
-            );
+            let 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"));
···
             &mut self,
             request: impl tonic::IntoRequest<super::PauseRequest>,
         ) -> std::result::Result<tonic::Response<super::PauseResponse>, tonic::Status> {
-            self.inner
-                .ready()
-                .await
-                .map_err(|e| {
-                    tonic::Status::unknown(
-                        format!("Service was not ready: {}", e.into()),
-                    )
-                })?;
+            self.inner.ready().await.map_err(|e| {
+                tonic::Status::unknown(format!("Service was not ready: {}", e.into()))
+            })?;
             let codec = tonic::codec::ProstCodec::default();
-            let path = http::uri::PathAndQuery::from_static(
-                "/rockbox.v1alpha1.PlaybackService/Pause",
-            );
+            let 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"));
···
         pub async fn play_or_pause(
             &mut self,
             request: impl tonic::IntoRequest<super::PlayOrPauseRequest>,
-        ) -> std::result::Result<
-            tonic::Response<super::PlayOrPauseResponse>,
-            tonic::Status,
-        > {
-            self.inner
-                .ready()
-                .await
-                .map_err(|e| {
-                    tonic::Status::unknown(
-                        format!("Service was not ready: {}", e.into()),
-                    )
-                })?;
+        ) -> std::result::Result<tonic::Response<super::PlayOrPauseResponse>, tonic::Status>
+        {
+            self.inner.ready().await.map_err(|e| {
+                tonic::Status::unknown(format!("Service was not ready: {}", e.into()))
+            })?;
             let codec = tonic::codec::ProstCodec::default();
             let path = http::uri::PathAndQuery::from_static(
                 "/rockbox.v1alpha1.PlaybackService/PlayOrPause",
             );
             let mut req = request.into_request();
-            req.extensions_mut()
-                .insert(
-                    GrpcMethod::new("rockbox.v1alpha1.PlaybackService", "PlayOrPause"),
-                );
+            req.extensions_mut().insert(GrpcMethod::new(
+                "rockbox.v1alpha1.PlaybackService",
+                "PlayOrPause",
+            ));
             self.inner.unary(req, path, codec).await
         }
         pub async fn resume(
             &mut self,
             request: impl tonic::IntoRequest<super::ResumeRequest>,
         ) -> std::result::Result<tonic::Response<super::ResumeResponse>, tonic::Status> {
-            self.inner
-                .ready()
-                .await
-                .map_err(|e| {
-                    tonic::Status::unknown(
-                        format!("Service was not ready: {}", e.into()),
-                    )
-                })?;
+            self.inner.ready().await.map_err(|e| {
+                tonic::Status::unknown(format!("Service was not ready: {}", e.into()))
+            })?;
             let codec = tonic::codec::ProstCodec::default();
-            let path = http::uri::PathAndQuery::from_static(
-                "/rockbox.v1alpha1.PlaybackService/Resume",
-            );
+            let 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"));
+            req.extensions_mut().insert(GrpcMethod::new(
+                "rockbox.v1alpha1.PlaybackService",
+                "Resume",
+            ));
             self.inner.unary(req, path, codec).await
         }
         pub async fn next(
             &mut self,
             request: impl tonic::IntoRequest<super::NextRequest>,
         ) -> std::result::Result<tonic::Response<super::NextResponse>, tonic::Status> {
-            self.inner
-                .ready()
-                .await
-                .map_err(|e| {
-                    tonic::Status::unknown(
-                        format!("Service was not ready: {}", e.into()),
-                    )
-                })?;
+            self.inner.ready().await.map_err(|e| {
+                tonic::Status::unknown(format!("Service was not ready: {}", e.into()))
+            })?;
             let codec = tonic::codec::ProstCodec::default();
-            let path = http::uri::PathAndQuery::from_static(
-                "/rockbox.v1alpha1.PlaybackService/Next",
-            );
+            let 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"));
···
         pub async fn previous(
             &mut self,
             request: impl tonic::IntoRequest<super::PreviousRequest>,
-        ) -> std::result::Result<
-            tonic::Response<super::PreviousResponse>,
-            tonic::Status,
-        > {
-            self.inner
-                .ready()
-                .await
-                .map_err(|e| {
-                    tonic::Status::unknown(
-                        format!("Service was not ready: {}", e.into()),
-                    )
-                })?;
+        ) -> std::result::Result<tonic::Response<super::PreviousResponse>, tonic::Status> {
+            self.inner.ready().await.map_err(|e| {
+                tonic::Status::unknown(format!("Service was not ready: {}", e.into()))
+            })?;
             let codec = tonic::codec::ProstCodec::default();
-            let path = http::uri::PathAndQuery::from_static(
-                "/rockbox.v1alpha1.PlaybackService/Previous",
-            );
+            let 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"));
+            req.extensions_mut().insert(GrpcMethod::new(
+                "rockbox.v1alpha1.PlaybackService",
+                "Previous",
+            ));
             self.inner.unary(req, path, codec).await
         }
         pub async fn fast_forward_rewind(
             &mut self,
             request: impl tonic::IntoRequest<super::FastForwardRewindRequest>,
-        ) -> std::result::Result<
-            tonic::Response<super::FastForwardRewindResponse>,
-            tonic::Status,
-        > {
-            self.inner
-                .ready()
-                .await
-                .map_err(|e| {
-                    tonic::Status::unknown(
-                        format!("Service was not ready: {}", e.into()),
-                    )
-                })?;
+        ) -> std::result::Result<tonic::Response<super::FastForwardRewindResponse>, tonic::Status>
+        {
+            self.inner.ready().await.map_err(|e| {
+                tonic::Status::unknown(format!("Service was not ready: {}", e.into()))
+            })?;
             let codec = tonic::codec::ProstCodec::default();
             let path = http::uri::PathAndQuery::from_static(
                 "/rockbox.v1alpha1.PlaybackService/FastForwardRewind",
             );
             let mut req = request.into_request();
-            req.extensions_mut()
-                .insert(
-                    GrpcMethod::new(
-                        "rockbox.v1alpha1.PlaybackService",
-                        "FastForwardRewind",
-                    ),
-                );
+            req.extensions_mut().insert(GrpcMethod::new(
+                "rockbox.v1alpha1.PlaybackService",
+                "FastForwardRewind",
+            ));
             self.inner.unary(req, path, codec).await
         }
         pub async fn status(
             &mut self,
             request: impl tonic::IntoRequest<super::StatusRequest>,
         ) -> std::result::Result<tonic::Response<super::StatusResponse>, tonic::Status> {
-            self.inner
-                .ready()
-                .await
-                .map_err(|e| {
-                    tonic::Status::unknown(
-                        format!("Service was not ready: {}", e.into()),
-                    )
-                })?;
+            self.inner.ready().await.map_err(|e| {
+                tonic::Status::unknown(format!("Service was not ready: {}", e.into()))
+            })?;
             let codec = tonic::codec::ProstCodec::default();
-            let path = http::uri::PathAndQuery::from_static(
-                "/rockbox.v1alpha1.PlaybackService/Status",
-            );
+            let 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"));
+            req.extensions_mut().insert(GrpcMethod::new(
+                "rockbox.v1alpha1.PlaybackService",
+                "Status",
+            ));
             self.inner.unary(req, path, codec).await
         }
         pub async fn current_track(
             &mut self,
             request: impl tonic::IntoRequest<super::CurrentTrackRequest>,
-        ) -> std::result::Result<
-            tonic::Response<super::CurrentTrackResponse>,
-            tonic::Status,
-        > {
-            self.inner
-                .ready()
-                .await
-                .map_err(|e| {
-                    tonic::Status::unknown(
-                        format!("Service was not ready: {}", e.into()),
-                    )
-                })?;
+        ) -> std::result::Result<tonic::Response<super::CurrentTrackResponse>, tonic::Status>
+        {
+            self.inner.ready().await.map_err(|e| {
+                tonic::Status::unknown(format!("Service was not ready: {}", e.into()))
+            })?;
             let codec = tonic::codec::ProstCodec::default();
             let path = http::uri::PathAndQuery::from_static(
                 "/rockbox.v1alpha1.PlaybackService/CurrentTrack",
             );
             let mut req = request.into_request();
-            req.extensions_mut()
-                .insert(
-                    GrpcMethod::new("rockbox.v1alpha1.PlaybackService", "CurrentTrack"),
-                );
+            req.extensions_mut().insert(GrpcMethod::new(
+                "rockbox.v1alpha1.PlaybackService",
+                "CurrentTrack",
+            ));
             self.inner.unary(req, path, codec).await
         }
         pub async fn next_track(
             &mut self,
             request: impl tonic::IntoRequest<super::NextTrackRequest>,
-        ) -> std::result::Result<
-            tonic::Response<super::NextTrackResponse>,
-            tonic::Status,
-        > {
-            self.inner
-                .ready()
-                .await
-                .map_err(|e| {
-                    tonic::Status::unknown(
-                        format!("Service was not ready: {}", e.into()),
-                    )
-                })?;
+        ) -> std::result::Result<tonic::Response<super::NextTrackResponse>, tonic::Status> {
+            self.inner.ready().await.map_err(|e| {
+                tonic::Status::unknown(format!("Service was not ready: {}", e.into()))
+            })?;
             let codec = tonic::codec::ProstCodec::default();
-            let path = http::uri::PathAndQuery::from_static(
-                "/rockbox.v1alpha1.PlaybackService/NextTrack",
-            );
+            let 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"),
-                );
+            req.extensions_mut().insert(GrpcMethod::new(
+                "rockbox.v1alpha1.PlaybackService",
+                "NextTrack",
+            ));
             self.inner.unary(req, path, codec).await
         }
         pub async fn flush_and_reload_tracks(
             &mut self,
             request: impl tonic::IntoRequest<super::FlushAndReloadTracksRequest>,
-        ) -> std::result::Result<
-            tonic::Response<super::FlushAndReloadTracksResponse>,
-            tonic::Status,
-        > {
-            self.inner
-                .ready()
-                .await
-                .map_err(|e| {
-                    tonic::Status::unknown(
-                        format!("Service was not ready: {}", e.into()),
-                    )
-                })?;
+        ) -> std::result::Result<tonic::Response<super::FlushAndReloadTracksResponse>, tonic::Status>
+        {
+            self.inner.ready().await.map_err(|e| {
+                tonic::Status::unknown(format!("Service was not ready: {}", e.into()))
+            })?;
             let codec = tonic::codec::ProstCodec::default();
             let path = http::uri::PathAndQuery::from_static(
                 "/rockbox.v1alpha1.PlaybackService/FlushAndReloadTracks",
             );
             let mut req = request.into_request();
-            req.extensions_mut()
-                .insert(
-                    GrpcMethod::new(
-                        "rockbox.v1alpha1.PlaybackService",
-                        "FlushAndReloadTracks",
-                    ),
-                );
+            req.extensions_mut().insert(GrpcMethod::new(
+                "rockbox.v1alpha1.PlaybackService",
+                "FlushAndReloadTracks",
+            ));
             self.inner.unary(req, path, codec).await
         }
         pub async fn get_file_position(
             &mut self,
             request: impl tonic::IntoRequest<super::GetFilePositionRequest>,
-        ) -> std::result::Result<
-            tonic::Response<super::GetFilePositionResponse>,
-            tonic::Status,
-        > {
-            self.inner
-                .ready()
-                .await
-                .map_err(|e| {
-                    tonic::Status::unknown(
-                        format!("Service was not ready: {}", e.into()),
-                    )
-                })?;
+        ) -> std::result::Result<tonic::Response<super::GetFilePositionResponse>, tonic::Status>
+        {
+            self.inner.ready().await.map_err(|e| {
+                tonic::Status::unknown(format!("Service was not ready: {}", e.into()))
+            })?;
             let codec = tonic::codec::ProstCodec::default();
             let path = http::uri::PathAndQuery::from_static(
                 "/rockbox.v1alpha1.PlaybackService/GetFilePosition",
             );
             let mut req = request.into_request();
-            req.extensions_mut()
-                .insert(
-                    GrpcMethod::new(
-                        "rockbox.v1alpha1.PlaybackService",
-                        "GetFilePosition",
-                    ),
-                );
+            req.extensions_mut().insert(GrpcMethod::new(
+                "rockbox.v1alpha1.PlaybackService",
+                "GetFilePosition",
+            ));
             self.inner.unary(req, path, codec).await
         }
         pub async fn hard_stop(
             &mut self,
             request: impl tonic::IntoRequest<super::HardStopRequest>,
-        ) -> std::result::Result<
-            tonic::Response<super::HardStopResponse>,
-            tonic::Status,
-        > {
-            self.inner
-                .ready()
-                .await
-                .map_err(|e| {
-                    tonic::Status::unknown(
-                        format!("Service was not ready: {}", e.into()),
-                    )
-                })?;
+        ) -> std::result::Result<tonic::Response<super::HardStopResponse>, tonic::Status> {
+            self.inner.ready().await.map_err(|e| {
+                tonic::Status::unknown(format!("Service was not ready: {}", e.into()))
+            })?;
             let codec = tonic::codec::ProstCodec::default();
-            let path = http::uri::PathAndQuery::from_static(
-                "/rockbox.v1alpha1.PlaybackService/HardStop",
-            );
+            let 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"));
+            req.extensions_mut().insert(GrpcMethod::new(
+                "rockbox.v1alpha1.PlaybackService",
+                "HardStop",
+            ));
             self.inner.unary(req, path, codec).await
         }
         pub async fn play_album(
             &mut self,
             request: impl tonic::IntoRequest<super::PlayAlbumRequest>,
-        ) -> std::result::Result<
-            tonic::Response<super::PlayAlbumResponse>,
-            tonic::Status,
-        > {
-            self.inner
-                .ready()
-                .await
-                .map_err(|e| {
-                    tonic::Status::unknown(
-                        format!("Service was not ready: {}", e.into()),
-                    )
-                })?;
+        ) -> std::result::Result<tonic::Response<super::PlayAlbumResponse>, tonic::Status> {
+            self.inner.ready().await.map_err(|e| {
+                tonic::Status::unknown(format!("Service was not ready: {}", e.into()))
+            })?;
             let codec = tonic::codec::ProstCodec::default();
-            let path = http::uri::PathAndQuery::from_static(
-                "/rockbox.v1alpha1.PlaybackService/PlayAlbum",
-            );
+            let 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"),
-                );
+            req.extensions_mut().insert(GrpcMethod::new(
+                "rockbox.v1alpha1.PlaybackService",
+                "PlayAlbum",
+            ));
             self.inner.unary(req, path, codec).await
         }
         pub async fn play_artist_tracks(
             &mut self,
             request: impl tonic::IntoRequest<super::PlayArtistTracksRequest>,
-        ) -> std::result::Result<
-            tonic::Response<super::PlayArtistTracksResponse>,
-            tonic::Status,
-        > {
-            self.inner
-                .ready()
-                .await
-                .map_err(|e| {
-                    tonic::Status::unknown(
-                        format!("Service was not ready: {}", e.into()),
-                    )
-                })?;
+        ) -> std::result::Result<tonic::Response<super::PlayArtistTracksResponse>, tonic::Status>
+        {
+            self.inner.ready().await.map_err(|e| {
+                tonic::Status::unknown(format!("Service was not ready: {}", e.into()))
+            })?;
             let codec = tonic::codec::ProstCodec::default();
             let path = http::uri::PathAndQuery::from_static(
                 "/rockbox.v1alpha1.PlaybackService/PlayArtistTracks",
             );
             let mut req = request.into_request();
-            req.extensions_mut()
-                .insert(
-                    GrpcMethod::new(
-                        "rockbox.v1alpha1.PlaybackService",
-                        "PlayArtistTracks",
-                    ),
-                );
+            req.extensions_mut().insert(GrpcMethod::new(
+                "rockbox.v1alpha1.PlaybackService",
+                "PlayArtistTracks",
+            ));
             self.inner.unary(req, path, codec).await
         }
         pub async fn play_playlist(
             &mut self,
             request: impl tonic::IntoRequest<super::PlayPlaylistRequest>,
-        ) -> std::result::Result<
-            tonic::Response<super::PlayPlaylistResponse>,
-            tonic::Status,
-        > {
-            self.inner
-                .ready()
-                .await
-                .map_err(|e| {
-                    tonic::Status::unknown(
-                        format!("Service was not ready: {}", e.into()),
-                    )
-                })?;
+        ) -> std::result::Result<tonic::Response<super::PlayPlaylistResponse>, tonic::Status>
+        {
+            self.inner.ready().await.map_err(|e| {
+                tonic::Status::unknown(format!("Service was not ready: {}", e.into()))
+            })?;
             let codec = tonic::codec::ProstCodec::default();
             let path = http::uri::PathAndQuery::from_static(
                 "/rockbox.v1alpha1.PlaybackService/PlayPlaylist",
             );
             let mut req = request.into_request();
-            req.extensions_mut()
-                .insert(
-                    GrpcMethod::new("rockbox.v1alpha1.PlaybackService", "PlayPlaylist"),
-                );
+            req.extensions_mut().insert(GrpcMethod::new(
+                "rockbox.v1alpha1.PlaybackService",
+                "PlayPlaylist",
+            ));
             self.inner.unary(req, path, codec).await
         }
         pub async fn play_directory(
             &mut self,
             request: impl tonic::IntoRequest<super::PlayDirectoryRequest>,
-        ) -> std::result::Result<
-            tonic::Response<super::PlayDirectoryResponse>,
-            tonic::Status,
-        > {
-            self.inner
-                .ready()
-                .await
-                .map_err(|e| {
-                    tonic::Status::unknown(
-                        format!("Service was not ready: {}", e.into()),
-                    )
-                })?;
+        ) -> std::result::Result<tonic::Response<super::PlayDirectoryResponse>, tonic::Status>
+        {
+            self.inner.ready().await.map_err(|e| {
+                tonic::Status::unknown(format!("Service was not ready: {}", e.into()))
+            })?;
             let codec = tonic::codec::ProstCodec::default();
             let path = http::uri::PathAndQuery::from_static(
                 "/rockbox.v1alpha1.PlaybackService/PlayDirectory",
             );
             let mut req = request.into_request();
-            req.extensions_mut()
-                .insert(
-                    GrpcMethod::new("rockbox.v1alpha1.PlaybackService", "PlayDirectory"),
-                );
+            req.extensions_mut().insert(GrpcMethod::new(
+                "rockbox.v1alpha1.PlaybackService",
+                "PlayDirectory",
+            ));
             self.inner.unary(req, path, codec).await
         }
         pub async fn play_music_directory(
             &mut self,
             request: impl tonic::IntoRequest<super::PlayMusicDirectoryRequest>,
-        ) -> std::result::Result<
-            tonic::Response<super::PlayMusicDirectoryResponse>,
-            tonic::Status,
-        > {
-            self.inner
-                .ready()
-                .await
-                .map_err(|e| {
-                    tonic::Status::unknown(
-                        format!("Service was not ready: {}", e.into()),
-                    )
-                })?;
+        ) -> std::result::Result<tonic::Response<super::PlayMusicDirectoryResponse>, tonic::Status>
+        {
+            self.inner.ready().await.map_err(|e| {
+                tonic::Status::unknown(format!("Service was not ready: {}", e.into()))
+            })?;
             let codec = tonic::codec::ProstCodec::default();
             let path = http::uri::PathAndQuery::from_static(
                 "/rockbox.v1alpha1.PlaybackService/PlayMusicDirectory",
             );
             let mut req = request.into_request();
-            req.extensions_mut()
-                .insert(
-                    GrpcMethod::new(
-                        "rockbox.v1alpha1.PlaybackService",
-                        "PlayMusicDirectory",
-                    ),
-                );
+            req.extensions_mut().insert(GrpcMethod::new(
+                "rockbox.v1alpha1.PlaybackService",
+                "PlayMusicDirectory",
+            ));
             self.inner.unary(req, path, codec).await
         }
         pub async fn play_track(
             &mut self,
             request: impl tonic::IntoRequest<super::PlayTrackRequest>,
-        ) -> std::result::Result<
-            tonic::Response<super::PlayTrackResponse>,
-            tonic::Status,
-        > {
-            self.inner
-                .ready()
-                .await
-                .map_err(|e| {
-                    tonic::Status::unknown(
-                        format!("Service was not ready: {}", e.into()),
-                    )
-                })?;
+        ) -> std::result::Result<tonic::Response<super::PlayTrackResponse>, tonic::Status> {
+            self.inner.ready().await.map_err(|e| {
+                tonic::Status::unknown(format!("Service was not ready: {}", e.into()))
+            })?;
             let codec = tonic::codec::ProstCodec::default();
-            let path = http::uri::PathAndQuery::from_static(
-                "/rockbox.v1alpha1.PlaybackService/PlayTrack",
-            );
+            let 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"),
-                );
+            req.extensions_mut().insert(GrpcMethod::new(
+                "rockbox.v1alpha1.PlaybackService",
+                "PlayTrack",
+            ));
             self.inner.unary(req, path, codec).await
         }
         pub async fn play_liked_tracks(
             &mut self,
             request: impl tonic::IntoRequest<super::PlayLikedTracksRequest>,
-        ) -> std::result::Result<
-            tonic::Response<super::PlayLikedTracksResponse>,
-            tonic::Status,
-        > {
-            self.inner
-                .ready()
-                .await
-                .map_err(|e| {
-                    tonic::Status::unknown(
-                        format!("Service was not ready: {}", e.into()),
-                    )
-                })?;
+        ) -> std::result::Result<tonic::Response<super::PlayLikedTracksResponse>, tonic::Status>
+        {
+            self.inner.ready().await.map_err(|e| {
+                tonic::Status::unknown(format!("Service was not ready: {}", e.into()))
+            })?;
             let codec = tonic::codec::ProstCodec::default();
             let path = http::uri::PathAndQuery::from_static(
                 "/rockbox.v1alpha1.PlaybackService/PlayLikedTracks",
             );
             let mut req = request.into_request();
-            req.extensions_mut()
-                .insert(
-                    GrpcMethod::new(
-                        "rockbox.v1alpha1.PlaybackService",
-                        "PlayLikedTracks",
-                    ),
-                );
+            req.extensions_mut().insert(GrpcMethod::new(
+                "rockbox.v1alpha1.PlaybackService",
+                "PlayLikedTracks",
+            ));
             self.inner.unary(req, path, codec).await
         }
         pub async fn play_all_tracks(
             &mut self,
             request: impl tonic::IntoRequest<super::PlayAllTracksRequest>,
-        ) -> std::result::Result<
-            tonic::Response<super::PlayAllTracksResponse>,
-            tonic::Status,
-        > {
-            self.inner
-                .ready()
-                .await
-                .map_err(|e| {
-                    tonic::Status::unknown(
-                        format!("Service was not ready: {}", e.into()),
-                    )
-                })?;
+        ) -> std::result::Result<tonic::Response<super::PlayAllTracksResponse>, tonic::Status>
+        {
+            self.inner.ready().await.map_err(|e| {
+                tonic::Status::unknown(format!("Service was not ready: {}", e.into()))
+            })?;
             let codec = tonic::codec::ProstCodec::default();
             let path = http::uri::PathAndQuery::from_static(
                 "/rockbox.v1alpha1.PlaybackService/PlayAllTracks",
             );
             let mut req = request.into_request();
-            req.extensions_mut()
-                .insert(
-                    GrpcMethod::new("rockbox.v1alpha1.PlaybackService", "PlayAllTracks"),
-                );
+            req.extensions_mut().insert(GrpcMethod::new(
+                "rockbox.v1alpha1.PlaybackService",
+                "PlayAllTracks",
+            ));
             self.inner.unary(req, path, codec).await
         }
         pub async fn stream_current_track(
···
             tonic::Response<tonic::codec::Streaming<super::CurrentTrackResponse>>,
             tonic::Status,
         > {
-            self.inner
-                .ready()
-                .await
-                .map_err(|e| {
-                    tonic::Status::unknown(
-                        format!("Service was not ready: {}", e.into()),
-                    )
-                })?;
+            self.inner.ready().await.map_err(|e| {
+                tonic::Status::unknown(format!("Service was not ready: {}", e.into()))
+            })?;
             let codec = tonic::codec::ProstCodec::default();
             let path = http::uri::PathAndQuery::from_static(
                 "/rockbox.v1alpha1.PlaybackService/StreamCurrentTrack",
             );
             let mut req = request.into_request();
-            req.extensions_mut()
-                .insert(
-                    GrpcMethod::new(
-                        "rockbox.v1alpha1.PlaybackService",
-                        "StreamCurrentTrack",
-                    ),
-                );
+            req.extensions_mut().insert(GrpcMethod::new(
+                "rockbox.v1alpha1.PlaybackService",
+                "StreamCurrentTrack",
+            ));
             self.inner.server_streaming(req, path, codec).await
         }
         pub async fn stream_status(
···
             tonic::Response<tonic::codec::Streaming<super::StatusResponse>>,
             tonic::Status,
         > {
-            self.inner
-                .ready()
-                .await
-                .map_err(|e| {
-                    tonic::Status::unknown(
-                        format!("Service was not ready: {}", e.into()),
-                    )
-                })?;
+            self.inner.ready().await.map_err(|e| {
+                tonic::Status::unknown(format!("Service was not ready: {}", e.into()))
+            })?;
             let codec = tonic::codec::ProstCodec::default();
             let path = http::uri::PathAndQuery::from_static(
                 "/rockbox.v1alpha1.PlaybackService/StreamStatus",
             );
             let mut req = request.into_request();
-            req.extensions_mut()
-                .insert(
-                    GrpcMethod::new("rockbox.v1alpha1.PlaybackService", "StreamStatus"),
-                );
+            req.extensions_mut().insert(GrpcMethod::new(
+                "rockbox.v1alpha1.PlaybackService",
+                "StreamStatus",
+            ));
             self.inner.server_streaming(req, path, codec).await
         }
         pub async fn stream_playlist(
···
             tonic::Response<tonic::codec::Streaming<super::PlaylistResponse>>,
             tonic::Status,
         > {
-            self.inner
-                .ready()
-                .await
-                .map_err(|e| {
-                    tonic::Status::unknown(
-                        format!("Service was not ready: {}", e.into()),
-                    )
-                })?;
+            self.inner.ready().await.map_err(|e| {
+                tonic::Status::unknown(format!("Service was not ready: {}", e.into()))
+            })?;
             let codec = tonic::codec::ProstCodec::default();
             let path = http::uri::PathAndQuery::from_static(
                 "/rockbox.v1alpha1.PlaybackService/StreamPlaylist",
             );
             let mut req = request.into_request();
-            req.extensions_mut()
-                .insert(
-                    GrpcMethod::new("rockbox.v1alpha1.PlaybackService", "StreamPlaylist"),
-                );
+            req.extensions_mut().insert(GrpcMethod::new(
+                "rockbox.v1alpha1.PlaybackService",
+                "StreamPlaylist",
+            ));
             self.inner.server_streaming(req, path, codec).await
         }
     }
···
         dead_code,
         missing_docs,
         clippy::wildcard_imports,
-        clippy::let_unit_value,
+        clippy::let_unit_value
     )]
     use tonic::codegen::*;
     /// Generated trait containing gRPC methods that should be implemented for use with PlaybackServiceServer.
···
         async fn play_or_pause(
             &self,
             request: tonic::Request<super::PlayOrPauseRequest>,
-        ) -> std::result::Result<
-            tonic::Response<super::PlayOrPauseResponse>,
-            tonic::Status,
-        >;
+        ) -> std::result::Result<tonic::Response<super::PlayOrPauseResponse>, tonic::Status>;
         async fn resume(
             &self,
             request: tonic::Request<super::ResumeRequest>,
···
         async fn previous(
             &self,
             request: tonic::Request<super::PreviousRequest>,
-        ) -> std::result::Result<
-            tonic::Response<super::PreviousResponse>,
-            tonic::Status,
-        >;
+        ) -> 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,
-        >;
+        ) -> std::result::Result<tonic::Response<super::FastForwardRewindResponse>, tonic::Status>;
         async fn status(
             &self,
             request: tonic::Request<super::StatusRequest>,
···
         async fn current_track(
             &self,
             request: tonic::Request<super::CurrentTrackRequest>,
-        ) -> std::result::Result<
-            tonic::Response<super::CurrentTrackResponse>,
-            tonic::Status,
-        >;
+        ) -> 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,
-        >;
+        ) -> 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,
-        >;
+        ) -> 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,
-        >;
+        ) -> 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,
-        >;
+        ) -> 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,
-        >;
+        ) -> 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,
-        >;
+        ) -> 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,
-        >;
+        ) -> 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,
-        >;
+        ) -> std::result::Result<tonic::Response<super::PlayDirectoryResponse>, tonic::Status>;
         async fn play_music_directory(
             &self,
             request: tonic::Request<super::PlayMusicDirectoryRequest>,
-        ) -> std::result::Result<
-            tonic::Response<super::PlayMusicDirectoryResponse>,
-            tonic::Status,
-        >;
+        ) -> std::result::Result<tonic::Response<super::PlayMusicDirectoryResponse>, tonic::Status>;
         async fn play_track(
             &self,
             request: tonic::Request<super::PlayTrackRequest>,
-        ) -> std::result::Result<
-            tonic::Response<super::PlayTrackResponse>,
-            tonic::Status,
-        >;
+        ) -> 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,
-        >;
+        ) -> 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,
-        >;
+        ) -> std::result::Result<tonic::Response<super::PlayAllTracksResponse>, tonic::Status>;
         /// Server streaming response type for the StreamCurrentTrack method.
         type StreamCurrentTrackStream: tonic::codegen::tokio_stream::Stream<
                 Item = std::result::Result<super::CurrentTrackResponse, tonic::Status>,
-            >
-            + std::marker::Send
+            > + std::marker::Send
             + 'static;
         async fn stream_current_track(
             &self,
             request: tonic::Request<super::StreamCurrentTrackRequest>,
-        ) -> std::result::Result<
-            tonic::Response<Self::StreamCurrentTrackStream>,
-            tonic::Status,
-        >;
+        ) -> std::result::Result<tonic::Response<Self::StreamCurrentTrackStream>, tonic::Status>;
         /// Server streaming response type for the StreamStatus method.
         type StreamStatusStream: tonic::codegen::tokio_stream::Stream<
                 Item = std::result::Result<super::StatusResponse, tonic::Status>,
-            >
-            + std::marker::Send
+            > + std::marker::Send
             + 'static;
         async fn stream_status(
             &self,
             request: tonic::Request<super::StreamStatusRequest>,
-        ) -> std::result::Result<
-            tonic::Response<Self::StreamStatusStream>,
-            tonic::Status,
-        >;
+        ) -> std::result::Result<tonic::Response<Self::StreamStatusStream>, tonic::Status>;
         /// Server streaming response type for the StreamPlaylist method.
         type StreamPlaylistStream: tonic::codegen::tokio_stream::Stream<
                 Item = std::result::Result<super::PlaylistResponse, tonic::Status>,
-            >
-            + std::marker::Send
+            > + std::marker::Send
             + 'static;
         async fn stream_playlist(
             &self,
             request: tonic::Request<super::StreamPlaylistRequest>,
-        ) -> std::result::Result<
-            tonic::Response<Self::StreamPlaylistStream>,
-            tonic::Status,
-        >;
+        ) -> std::result::Result<tonic::Response<Self::StreamPlaylistStream>, tonic::Status>;
     }
     #[derive(Debug)]
     pub struct PlaybackServiceServer<T> {
···
                 max_encoding_message_size: None,
             }
         }
-        pub fn with_interceptor<F>(
-            inner: T,
-            interceptor: F,
-        ) -> InterceptedService<Self, F>
+        pub fn with_interceptor<F>(inner: T, interceptor: F) -> InterceptedService<Self, F>
         where
             F: tonic::service::Interceptor,
         {
···
                 "/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> {
+                    impl<T: PlaybackService> tonic::server::UnaryService<super::PlayRequest> for PlaySvc<T> {
                         type Response = super::PlayResponse;
-                        type Future = BoxFuture<
-                            tonic::Response<Self::Response>,
-                            tonic::Status,
-                        >;
+                        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
-                            };
+                            let fut =
+                                async move { <T as PlaybackService>::play(&inner, request).await };
                             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> {
+                    impl<T: PlaybackService> tonic::server::UnaryService<super::PauseRequest> for PauseSvc<T> {
                         type Response = super::PauseResponse;
-                        type Future = BoxFuture<
-                            tonic::Response<Self::Response>,
-                            tonic::Status,
-                        >;
+                        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
-                            };
+                            let fut =
+                                async move { <T as PlaybackService>::pause(&inner, request).await };
                             Box::pin(fut)
                         }
                     }
···
                 "/rockbox.v1alpha1.PlaybackService/PlayOrPause" => {
                     #[allow(non_camel_case_types)]
                     struct PlayOrPauseSvc<T: PlaybackService>(pub Arc<T>);
-                    impl<
-                        T: PlaybackService,
-                    > tonic::server::UnaryService<super::PlayOrPauseRequest>
-                    for PlayOrPauseSvc<T> {
+                    impl<T: PlaybackService> tonic::server::UnaryService<super::PlayOrPauseRequest>
+                        for PlayOrPauseSvc<T>
+                    {
                         type Response = super::PlayOrPauseResponse;
-                        type Future = BoxFuture<
-                            tonic::Response<Self::Response>,
-                            tonic::Status,
-                        >;
+                        type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
                         fn call(
                             &mut self,
                             request: tonic::Request<super::PlayOrPauseRequest>,
···
                 "/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> {
+                    impl<T: PlaybackService> tonic::server::UnaryService<super::ResumeRequest> for ResumeSvc<T> {
                         type Response = super::ResumeResponse;
-                        type Future = BoxFuture<
-                            tonic::Response<Self::Response>,
-                            tonic::Status,
-                        >;
+                        type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
                         fn call(
                             &mut self,
                             request: tonic::Request<super::ResumeRequest>,
···
                 "/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> {
+                    impl<T: PlaybackService> tonic::server::UnaryService<super::NextRequest> for NextSvc<T> {
                         type Response = super::NextResponse;
-                        type Future = BoxFuture<
-                            tonic::Response<Self::Response>,
-                            tonic::Status,
-                        >;
+                        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
-                            };
+                            let fut =
+                                async move { <T as PlaybackService>::next(&inner, request).await };
                             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> {
+                    impl<T: PlaybackService> tonic::server::UnaryService<super::PreviousRequest> for PreviousSvc<T> {
                         type Response = super::PreviousResponse;
-                        type Future = BoxFuture<
-                            tonic::Response<Self::Response>,
-                            tonic::Status,
-                        >;
+                        type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
                         fn call(
                             &mut self,
                             request: tonic::Request<super::PreviousRequest>,
···
                 "/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> {
+                    impl<T: PlaybackService>
+                        tonic::server::UnaryService<super::FastForwardRewindRequest>
+                        for FastForwardRewindSvc<T>
+                    {
                         type Response = super::FastForwardRewindResponse;
-                        type Future = BoxFuture<
-                            tonic::Response<Self::Response>,
-                            tonic::Status,
-                        >;
+                        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
+                                <T as PlaybackService>::fast_forward_rewind(&inner, request).await
                             };
                             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> {
+                    impl<T: PlaybackService> tonic::server::UnaryService<super::StatusRequest> for StatusSvc<T> {
                         type Response = super::StatusResponse;
-                        type Future = BoxFuture<
-                            tonic::Response<Self::Response>,
-                            tonic::Status,
-                        >;
+                        type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
                         fn call(
                             &mut self,
                             request: tonic::Request<super::StatusRequest>,
···
                 "/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> {
+                    impl<T: PlaybackService> tonic::server::UnaryService<super::CurrentTrackRequest>
+                        for CurrentTrackSvc<T>
+                    {
                         type Response = super::CurrentTrackResponse;
-                        type Future = BoxFuture<
-                            tonic::Response<Self::Response>,
-                            tonic::Status,
-                        >;
+                        type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
                         fn call(
                             &mut self,
                             request: tonic::Request<super::CurrentTrackRequest>,
···
                 "/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> {
+                    impl<T: PlaybackService> tonic::server::UnaryService<super::NextTrackRequest> for NextTrackSvc<T> {
                         type Response = super::NextTrackResponse;
-                        type Future = BoxFuture<
-                            tonic::Response<Self::Response>,
-                            tonic::Status,
-                        >;
+                        type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
                         fn call(
                             &mut self,
                             request: tonic::Request<super::NextTrackRequest>,
···
                 "/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> {
+                    impl<T: PlaybackService>
+                        tonic::server::UnaryService<super::FlushAndReloadTracksRequest>
+                        for FlushAndReloadTracksSvc<T>
+                    {
                         type Response = super::FlushAndReloadTracksResponse;
-                        type Future = BoxFuture<
-                            tonic::Response<Self::Response>,
-                            tonic::Status,
-                        >;
+                        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,
-                                    )
+                                <T as PlaybackService>::flush_and_reload_tracks(&inner, request)
                                     .await
                             };
                             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> {
+                    impl<T: PlaybackService>
+                        tonic::server::UnaryService<super::GetFilePositionRequest>
+                        for GetFilePositionSvc<T>
+                    {
                         type Response = super::GetFilePositionResponse;
-                        type Future = BoxFuture<
-                            tonic::Response<Self::Response>,
-                            tonic::Status,
-                        >;
+                        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
+                                <T as PlaybackService>::get_file_position(&inner, request).await
                             };
                             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> {
+                    impl<T: PlaybackService> tonic::server::UnaryService<super::HardStopRequest> for HardStopSvc<T> {
                         type Response = super::HardStopResponse;
-                        type Future = BoxFuture<
-                            tonic::Response<Self::Response>,
-                            tonic::Status,
-                        >;
+                        type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
                         fn call(
                             &mut self,
                             request: tonic::Request<super::HardStopRequest>,
···
                 "/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> {
+                    impl<T: PlaybackService> tonic::server::UnaryService<super::PlayAlbumRequest> for PlayAlbumSvc<T> {
                         type Response = super::PlayAlbumResponse;
-                        type Future = BoxFuture<
-                            tonic::Response<Self::Response>,
-                            tonic::Status,
-                        >;
+                        type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
                         fn call(
                             &mut self,
                             request: tonic::Request<super::PlayAlbumRequest>,
···
                 "/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> {
+                    impl<T: PlaybackService>
+                        tonic::server::UnaryService<super::PlayArtistTracksRequest>
+                        for PlayArtistTracksSvc<T>
+                    {
                         type Response = super::PlayArtistTracksResponse;
-                        type Future = BoxFuture<
-                            tonic::Response<Self::Response>,
-                            tonic::Status,
-                        >;
+                        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
+                                <T as PlaybackService>::play_artist_tracks(&inner, request).await
                             };
                             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> {
+                    impl<T: PlaybackService> tonic::server::UnaryService<super::PlayPlaylistRequest>
+                        for PlayPlaylistSvc<T>
+                    {
                         type Response = super::PlayPlaylistResponse;
-                        type Future = BoxFuture<
-                            tonic::Response<Self::Response>,
-                            tonic::Status,
-                        >;
+                        type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
                         fn call(
                             &mut self,
                             request: tonic::Request<super::PlayPlaylistRequest>,
···
                 "/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> {
+                    impl<T: PlaybackService>
+                        tonic::server::UnaryService<super::PlayDirectoryRequest>
+                        for PlayDirectorySvc<T>
+                    {
                         type Response = super::PlayDirectoryResponse;
-                        type Future = BoxFuture<
-                            tonic::Response<Self::Response>,
-                            tonic::Status,
-                        >;
+                        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
+                                <T as PlaybackService>::play_directory(&inner, request).await
                             };
                             Box::pin(fut)
                         }
···
                 "/rockbox.v1alpha1.PlaybackService/PlayMusicDirectory" => {
                     #[allow(non_camel_case_types)]
                     struct PlayMusicDirectorySvc<T: PlaybackService>(pub Arc<T>);
-                    impl<
-                        T: PlaybackService,
-                    > tonic::server::UnaryService<super::PlayMusicDirectoryRequest>
-                    for PlayMusicDirectorySvc<T> {
+                    impl<T: PlaybackService>
+                        tonic::server::UnaryService<super::PlayMusicDirectoryRequest>
+                        for PlayMusicDirectorySvc<T>
+                    {
                         type Response = super::PlayMusicDirectoryResponse;
-                        type Future = BoxFuture<
-                            tonic::Response<Self::Response>,
-                            tonic::Status,
-                        >;
+                        type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
                         fn call(
                             &mut self,
                             request: tonic::Request<super::PlayMusicDirectoryRequest>,
                         ) -> Self::Future {
                             let inner = Arc::clone(&self.0);
                             let fut = async move {
-                                <T as PlaybackService>::play_music_directory(
-                                        &inner,
-                                        request,
-                                    )
-                                    .await
+                                <T as PlaybackService>::play_music_directory(&inner, request).await
                             };
                             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> {
+                    impl<T: PlaybackService> tonic::server::UnaryService<super::PlayTrackRequest> for PlayTrackSvc<T> {
                         type Response = super::PlayTrackResponse;
-                        type Future = BoxFuture<
-                            tonic::Response<Self::Response>,
-                            tonic::Status,
-                        >;
+                        type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
                         fn call(
                             &mut self,
                             request: tonic::Request<super::PlayTrackRequest>,
···
                 "/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> {
+                    impl<T: PlaybackService>
+                        tonic::server::UnaryService<super::PlayLikedTracksRequest>
+                        for PlayLikedTracksSvc<T>
+                    {
                         type Response = super::PlayLikedTracksResponse;
-                        type Future = BoxFuture<
-                            tonic::Response<Self::Response>,
-                            tonic::Status,
-                        >;
+                        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
+                                <T as PlaybackService>::play_liked_tracks(&inner, request).await
                             };
                             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> {
+                    impl<T: PlaybackService>
+                        tonic::server::UnaryService<super::PlayAllTracksRequest>
+                        for PlayAllTracksSvc<T>
+                    {
                         type Response = super::PlayAllTracksResponse;
-                        type Future = BoxFuture<
-                            tonic::Response<Self::Response>,
-                            tonic::Status,
-                        >;
+                        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
+                                <T as PlaybackService>::play_all_tracks(&inner, request).await
                             };
                             Box::pin(fut)
                         }
···
                 "/rockbox.v1alpha1.PlaybackService/StreamCurrentTrack" => {
                     #[allow(non_camel_case_types)]
                     struct StreamCurrentTrackSvc<T: PlaybackService>(pub Arc<T>);
-                    impl<
-                        T: PlaybackService,
-                    > tonic::server::ServerStreamingService<
-                        super::StreamCurrentTrackRequest,
-                    > for StreamCurrentTrackSvc<T> {
+                    impl<T: PlaybackService>
+                        tonic::server::ServerStreamingService<super::StreamCurrentTrackRequest>
+                        for StreamCurrentTrackSvc<T>
+                    {
                         type Response = super::CurrentTrackResponse;
                         type ResponseStream = T::StreamCurrentTrackStream;
-                        type Future = BoxFuture<
-                            tonic::Response<Self::ResponseStream>,
-                            tonic::Status,
-                        >;
+                        type Future =
+                            BoxFuture<tonic::Response<Self::ResponseStream>, tonic::Status>;
                         fn call(
                             &mut self,
                             request: tonic::Request<super::StreamCurrentTrackRequest>,
                         ) -> Self::Future {
                             let inner = Arc::clone(&self.0);
                             let fut = async move {
-                                <T as PlaybackService>::stream_current_track(
-                                        &inner,
-                                        request,
-                                    )
-                                    .await
+                                <T as PlaybackService>::stream_current_track(&inner, request).await
                             };
                             Box::pin(fut)
                         }
···
                 "/rockbox.v1alpha1.PlaybackService/StreamStatus" => {
                     #[allow(non_camel_case_types)]
                     struct StreamStatusSvc<T: PlaybackService>(pub Arc<T>);
-                    impl<
-                        T: PlaybackService,
-                    > tonic::server::ServerStreamingService<super::StreamStatusRequest>
-                    for StreamStatusSvc<T> {
+                    impl<T: PlaybackService>
+                        tonic::server::ServerStreamingService<super::StreamStatusRequest>
+                        for StreamStatusSvc<T>
+                    {
                         type Response = super::StatusResponse;
                         type ResponseStream = T::StreamStatusStream;
-                        type Future = BoxFuture<
-                            tonic::Response<Self::ResponseStream>,
-                            tonic::Status,
-                        >;
+                        type Future =
+                            BoxFuture<tonic::Response<Self::ResponseStream>, tonic::Status>;
                         fn call(
                             &mut self,
                             request: tonic::Request<super::StreamStatusRequest>,
···
                 "/rockbox.v1alpha1.PlaybackService/StreamPlaylist" => {
                     #[allow(non_camel_case_types)]
                     struct StreamPlaylistSvc<T: PlaybackService>(pub Arc<T>);
-                    impl<
-                        T: PlaybackService,
-                    > tonic::server::ServerStreamingService<super::StreamPlaylistRequest>
-                    for StreamPlaylistSvc<T> {
+                    impl<T: PlaybackService>
+                        tonic::server::ServerStreamingService<super::StreamPlaylistRequest>
+                        for StreamPlaylistSvc<T>
+                    {
                         type Response = super::PlaylistResponse;
                         type ResponseStream = T::StreamPlaylistStream;
-                        type Future = BoxFuture<
-                            tonic::Response<Self::ResponseStream>,
-                            tonic::Status,
-                        >;
+                        type Future =
+                            BoxFuture<tonic::Response<Self::ResponseStream>, tonic::Status>;
                         fn call(
                             &mut self,
                             request: tonic::Request<super::StreamPlaylistRequest>,
                         ) -> Self::Future {
                             let inner = Arc::clone(&self.0);
                             let fut = async move {
-                                <T as PlaybackService>::stream_playlist(&inner, request)
-                                    .await
+                                <T as PlaybackService>::stream_playlist(&inner, request).await
                             };
                             Box::pin(fut)
                         }
···
                     };
                     Box::pin(fut)
                 }
-                _ => {
-                    Box::pin(async move {
-                        let mut response = http::Response::new(empty_body());
-                        let headers = response.headers_mut();
-                        headers
-                            .insert(
-                                tonic::Status::GRPC_STATUS,
-                                (tonic::Code::Unimplemented as i32).into(),
-                            );
-                        headers
-                            .insert(
-                                http::header::CONTENT_TYPE,
-                                tonic::metadata::GRPC_CONTENT_TYPE,
-                            );
-                        Ok(response)
-                    })
-                }
+                _ => Box::pin(async move {
+                    let mut response = http::Response::new(empty_body());
+                    let headers = response.headers_mut();
+                    headers.insert(
+                        tonic::Status::GRPC_STATUS,
+                        (tonic::Code::Unimplemented as i32).into(),
+                    );
+                    headers.insert(
+                        http::header::CONTENT_TYPE,
+                        tonic::metadata::GRPC_CONTENT_TYPE,
+                    );
+                    Ok(response)
+                }),
             }
         }
     }
···
         dead_code,
         missing_docs,
         clippy::wildcard_imports,
-        clippy::let_unit_value,
+        clippy::let_unit_value
     )]
-    use tonic::codegen::*;
     use tonic::codegen::http::Uri;
+    use tonic::codegen::*;
     #[derive(Debug, Clone)]
     pub struct PlaylistServiceClient<T> {
         inner: tonic::client::Grpc<T>,
···
                     <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,
+            <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))
         }
···
         pub async fn get_current(
             &mut self,
             request: impl tonic::IntoRequest<super::GetCurrentRequest>,
-        ) -> std::result::Result<
-            tonic::Response<super::GetCurrentResponse>,
-            tonic::Status,
-        > {
-            self.inner
-                .ready()
-                .await
-                .map_err(|e| {
-                    tonic::Status::unknown(
-                        format!("Service was not ready: {}", e.into()),
-                    )
-                })?;
+        ) -> std::result::Result<tonic::Response<super::GetCurrentResponse>, tonic::Status>
+        {
+            self.inner.ready().await.map_err(|e| {
+                tonic::Status::unknown(format!("Service was not ready: {}", e.into()))
+            })?;
             let codec = tonic::codec::ProstCodec::default();
             let path = http::uri::PathAndQuery::from_static(
                 "/rockbox.v1alpha1.PlaylistService/GetCurrent",
             );
             let mut req = request.into_request();
-            req.extensions_mut()
-                .insert(
-                    GrpcMethod::new("rockbox.v1alpha1.PlaylistService", "GetCurrent"),
-                );
+            req.extensions_mut().insert(GrpcMethod::new(
+                "rockbox.v1alpha1.PlaylistService",
+                "GetCurrent",
+            ));
             self.inner.unary(req, path, codec).await
         }
         pub async fn get_resume_info(
             &mut self,
             request: impl tonic::IntoRequest<super::GetResumeInfoRequest>,
-        ) -> std::result::Result<
-            tonic::Response<super::GetResumeInfoResponse>,
-            tonic::Status,
-        > {
-            self.inner
-                .ready()
-                .await
-                .map_err(|e| {
-                    tonic::Status::unknown(
-                        format!("Service was not ready: {}", e.into()),
-                    )
-                })?;
+        ) -> std::result::Result<tonic::Response<super::GetResumeInfoResponse>, tonic::Status>
+        {
+            self.inner.ready().await.map_err(|e| {
+                tonic::Status::unknown(format!("Service was not ready: {}", e.into()))
+            })?;
             let codec = tonic::codec::ProstCodec::default();
             let path = http::uri::PathAndQuery::from_static(
                 "/rockbox.v1alpha1.PlaylistService/GetResumeInfo",
             );
             let mut req = request.into_request();
-            req.extensions_mut()
-                .insert(
-                    GrpcMethod::new("rockbox.v1alpha1.PlaylistService", "GetResumeInfo"),
-                );
+            req.extensions_mut().insert(GrpcMethod::new(
+                "rockbox.v1alpha1.PlaylistService",
+                "GetResumeInfo",
+            ));
             self.inner.unary(req, path, codec).await
         }
         pub async fn get_track_info(
             &mut self,
             request: impl tonic::IntoRequest<super::GetTrackInfoRequest>,
-        ) -> std::result::Result<
-            tonic::Response<super::GetTrackInfoResponse>,
-            tonic::Status,
-        > {
-            self.inner
-                .ready()
-                .await
-                .map_err(|e| {
-                    tonic::Status::unknown(
-                        format!("Service was not ready: {}", e.into()),
-                    )
-                })?;
+        ) -> std::result::Result<tonic::Response<super::GetTrackInfoResponse>, tonic::Status>
+        {
+            self.inner.ready().await.map_err(|e| {
+                tonic::Status::unknown(format!("Service was not ready: {}", e.into()))
+            })?;
             let codec = tonic::codec::ProstCodec::default();
             let path = http::uri::PathAndQuery::from_static(
                 "/rockbox.v1alpha1.PlaylistService/GetTrackInfo",
             );
             let mut req = request.into_request();
-            req.extensions_mut()
-                .insert(
-                    GrpcMethod::new("rockbox.v1alpha1.PlaylistService", "GetTrackInfo"),
-                );
+            req.extensions_mut().insert(GrpcMethod::new(
+                "rockbox.v1alpha1.PlaylistService",
+                "GetTrackInfo",
+            ));
             self.inner.unary(req, path, codec).await
         }
         pub async fn get_first_index(
             &mut self,
             request: impl tonic::IntoRequest<super::GetFirstIndexRequest>,
-        ) -> std::result::Result<
-            tonic::Response<super::GetFirstIndexResponse>,
-            tonic::Status,
-        > {
-            self.inner
-                .ready()
-                .await
-                .map_err(|e| {
-                    tonic::Status::unknown(
-                        format!("Service was not ready: {}", e.into()),
-                    )
-                })?;
+        ) -> std::result::Result<tonic::Response<super::GetFirstIndexResponse>, tonic::Status>
+        {
+            self.inner.ready().await.map_err(|e| {
+                tonic::Status::unknown(format!("Service was not ready: {}", e.into()))
+            })?;
             let codec = tonic::codec::ProstCodec::default();
             let path = http::uri::PathAndQuery::from_static(
                 "/rockbox.v1alpha1.PlaylistService/GetFirstIndex",
             );
             let mut req = request.into_request();
-            req.extensions_mut()
-                .insert(
-                    GrpcMethod::new("rockbox.v1alpha1.PlaylistService", "GetFirstIndex"),
-                );
+            req.extensions_mut().insert(GrpcMethod::new(
+                "rockbox.v1alpha1.PlaylistService",
+                "GetFirstIndex",
+            ));
             self.inner.unary(req, path, codec).await
         }
         pub async fn get_display_index(
             &mut self,
             request: impl tonic::IntoRequest<super::GetDisplayIndexRequest>,
-        ) -> std::result::Result<
-            tonic::Response<super::GetDisplayIndexResponse>,
-            tonic::Status,
-        > {
-            self.inner
-                .ready()
-                .await
-                .map_err(|e| {
-                    tonic::Status::unknown(
-                        format!("Service was not ready: {}", e.into()),
-                    )
-                })?;
+        ) -> std::result::Result<tonic::Response<super::GetDisplayIndexResponse>, tonic::Status>
+        {
+            self.inner.ready().await.map_err(|e| {
+                tonic::Status::unknown(format!("Service was not ready: {}", e.into()))
+            })?;
             let codec = tonic::codec::ProstCodec::default();
             let path = http::uri::PathAndQuery::from_static(
                 "/rockbox.v1alpha1.PlaylistService/GetDisplayIndex",
             );
             let mut req = request.into_request();
-            req.extensions_mut()
-                .insert(
-                    GrpcMethod::new(
-                        "rockbox.v1alpha1.PlaylistService",
-                        "GetDisplayIndex",
-                    ),
-                );
+            req.extensions_mut().insert(GrpcMethod::new(
+                "rockbox.v1alpha1.PlaylistService",
+                "GetDisplayIndex",
+            ));
             self.inner.unary(req, path, codec).await
         }
         pub async fn amount(
             &mut self,
             request: impl tonic::IntoRequest<super::AmountRequest>,
         ) -> std::result::Result<tonic::Response<super::AmountResponse>, tonic::Status> {
-            self.inner
-                .ready()
-                .await
-                .map_err(|e| {
-                    tonic::Status::unknown(
-                        format!("Service was not ready: {}", e.into()),
-                    )
-                })?;
+            self.inner.ready().await.map_err(|e| {
+                tonic::Status::unknown(format!("Service was not ready: {}", e.into()))
+            })?;
             let codec = tonic::codec::ProstCodec::default();
-            let path = http::uri::PathAndQuery::from_static(
-                "/rockbox.v1alpha1.PlaylistService/Amount",
-            );
+            let 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"));
+            req.extensions_mut().insert(GrpcMethod::new(
+                "rockbox.v1alpha1.PlaylistService",
+                "Amount",
+            ));
             self.inner.unary(req, path, codec).await
         }
         pub async fn playlist_resume(
             &mut self,
             request: impl tonic::IntoRequest<super::PlaylistResumeRequest>,
-        ) -> std::result::Result<
-            tonic::Response<super::PlaylistResumeResponse>,
-            tonic::Status,
-        > {
-            self.inner
-                .ready()
-                .await
-                .map_err(|e| {
-                    tonic::Status::unknown(
-                        format!("Service was not ready: {}", e.into()),
-                    )
-                })?;
+        ) -> std::result::Result<tonic::Response<super::PlaylistResumeResponse>, tonic::Status>
+        {
+            self.inner.ready().await.map_err(|e| {
+                tonic::Status::unknown(format!("Service was not ready: {}", e.into()))
+            })?;
             let codec = tonic::codec::ProstCodec::default();
             let path = http::uri::PathAndQuery::from_static(
                 "/rockbox.v1alpha1.PlaylistService/PlaylistResume",
             );
             let mut req = request.into_request();
-            req.extensions_mut()
-                .insert(
-                    GrpcMethod::new("rockbox.v1alpha1.PlaylistService", "PlaylistResume"),
-                );
+            req.extensions_mut().insert(GrpcMethod::new(
+                "rockbox.v1alpha1.PlaylistService",
+                "PlaylistResume",
+            ));
             self.inner.unary(req, path, codec).await
         }
         pub async fn resume_track(
             &mut self,
             request: impl tonic::IntoRequest<super::ResumeTrackRequest>,
-        ) -> std::result::Result<
-            tonic::Response<super::ResumeTrackResponse>,
-            tonic::Status,
-        > {
-            self.inner
-                .ready()
-                .await
-                .map_err(|e| {
-                    tonic::Status::unknown(
-                        format!("Service was not ready: {}", e.into()),
-                    )
-                })?;
+        ) -> std::result::Result<tonic::Response<super::ResumeTrackResponse>, tonic::Status>
+        {
+            self.inner.ready().await.map_err(|e| {
+                tonic::Status::unknown(format!("Service was not ready: {}", e.into()))
+            })?;
             let codec = tonic::codec::ProstCodec::default();
             let path = http::uri::PathAndQuery::from_static(
                 "/rockbox.v1alpha1.PlaylistService/ResumeTrack",
             );
             let mut req = request.into_request();
-            req.extensions_mut()
-                .insert(
-                    GrpcMethod::new("rockbox.v1alpha1.PlaylistService", "ResumeTrack"),
-                );
+            req.extensions_mut().insert(GrpcMethod::new(
+                "rockbox.v1alpha1.PlaylistService",
+                "ResumeTrack",
+            ));
             self.inner.unary(req, path, codec).await
         }
         pub async fn set_modified(
             &mut self,
             request: impl tonic::IntoRequest<super::SetModifiedRequest>,
-        ) -> std::result::Result<
-            tonic::Response<super::SetModifiedResponse>,
-            tonic::Status,
-        > {
-            self.inner
-                .ready()
-                .await
-                .map_err(|e| {
-                    tonic::Status::unknown(
-                        format!("Service was not ready: {}", e.into()),
-                    )
-                })?;
+        ) -> std::result::Result<tonic::Response<super::SetModifiedResponse>, tonic::Status>
+        {
+            self.inner.ready().await.map_err(|e| {
+                tonic::Status::unknown(format!("Service was not ready: {}", e.into()))
+            })?;
             let codec = tonic::codec::ProstCodec::default();
             let path = http::uri::PathAndQuery::from_static(
                 "/rockbox.v1alpha1.PlaylistService/SetModified",
             );
             let mut req = request.into_request();
-            req.extensions_mut()
-                .insert(
-                    GrpcMethod::new("rockbox.v1alpha1.PlaylistService", "SetModified"),
-                );
+            req.extensions_mut().insert(GrpcMethod::new(
+                "rockbox.v1alpha1.PlaylistService",
+                "SetModified",
+            ));
             self.inner.unary(req, path, codec).await
         }
         pub async fn start(
             &mut self,
             request: impl tonic::IntoRequest<super::StartRequest>,
         ) -> std::result::Result<tonic::Response<super::StartResponse>, tonic::Status> {
-            self.inner
-                .ready()
-                .await
-                .map_err(|e| {
-                    tonic::Status::unknown(
-                        format!("Service was not ready: {}", e.into()),
-                    )
-                })?;
+            self.inner.ready().await.map_err(|e| {
+                tonic::Status::unknown(format!("Service was not ready: {}", e.into()))
+            })?;
             let codec = tonic::codec::ProstCodec::default();
-            let path = http::uri::PathAndQuery::from_static(
-                "/rockbox.v1alpha1.PlaylistService/Start",
-            );
+            let 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"));
···
             &mut self,
             request: impl tonic::IntoRequest<super::SyncRequest>,
         ) -> std::result::Result<tonic::Response<super::SyncResponse>, tonic::Status> {
-            self.inner
-                .ready()
-                .await
-                .map_err(|e| {
-                    tonic::Status::unknown(
-                        format!("Service was not ready: {}", e.into()),
-                    )
-                })?;
+            self.inner.ready().await.map_err(|e| {
+                tonic::Status::unknown(format!("Service was not ready: {}", e.into()))
+            })?;
             let codec = tonic::codec::ProstCodec::default();
-            let path = http::uri::PathAndQuery::from_static(
-                "/rockbox.v1alpha1.PlaylistService/Sync",
-            );
+            let 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"));
···
         pub async fn remove_all_tracks(
             &mut self,
             request: impl tonic::IntoRequest<super::RemoveAllTracksRequest>,
-        ) -> std::result::Result<
-            tonic::Response<super::RemoveAllTracksResponse>,
-            tonic::Status,
-        > {
-            self.inner
-                .ready()
-                .await
-                .map_err(|e| {
-                    tonic::Status::unknown(
-                        format!("Service was not ready: {}", e.into()),
-                    )
-                })?;
+        ) -> std::result::Result<tonic::Response<super::RemoveAllTracksResponse>, tonic::Status>
+        {
+            self.inner.ready().await.map_err(|e| {
+                tonic::Status::unknown(format!("Service was not ready: {}", e.into()))
+            })?;
             let codec = tonic::codec::ProstCodec::default();
             let path = http::uri::PathAndQuery::from_static(
                 "/rockbox.v1alpha1.PlaylistService/RemoveAllTracks",
             );
             let mut req = request.into_request();
-            req.extensions_mut()
-                .insert(
-                    GrpcMethod::new(
-                        "rockbox.v1alpha1.PlaylistService",
-                        "RemoveAllTracks",
-                    ),
-                );
+            req.extensions_mut().insert(GrpcMethod::new(
+                "rockbox.v1alpha1.PlaylistService",
+                "RemoveAllTracks",
+            ));
             self.inner.unary(req, path, codec).await
         }
         pub async fn remove_tracks(
             &mut self,
             request: impl tonic::IntoRequest<super::RemoveTracksRequest>,
-        ) -> std::result::Result<
-            tonic::Response<super::RemoveTracksResponse>,
-            tonic::Status,
-        > {
-            self.inner
-                .ready()
-                .await
-                .map_err(|e| {
-                    tonic::Status::unknown(
-                        format!("Service was not ready: {}", e.into()),
-                    )
-                })?;
+        ) -> std::result::Result<tonic::Response<super::RemoveTracksResponse>, tonic::Status>
+        {
+            self.inner.ready().await.map_err(|e| {
+                tonic::Status::unknown(format!("Service was not ready: {}", e.into()))
+            })?;
             let codec = tonic::codec::ProstCodec::default();
             let path = http::uri::PathAndQuery::from_static(
                 "/rockbox.v1alpha1.PlaylistService/RemoveTracks",
             );
             let mut req = request.into_request();
-            req.extensions_mut()
-                .insert(
-                    GrpcMethod::new("rockbox.v1alpha1.PlaylistService", "RemoveTracks"),
-                );
+            req.extensions_mut().insert(GrpcMethod::new(
+                "rockbox.v1alpha1.PlaylistService",
+                "RemoveTracks",
+            ));
             self.inner.unary(req, path, codec).await
         }
         pub async fn create_playlist(
             &mut self,
             request: impl tonic::IntoRequest<super::CreatePlaylistRequest>,
-        ) -> std::result::Result<
-            tonic::Response<super::CreatePlaylistResponse>,
-            tonic::Status,
-        > {
-            self.inner
-                .ready()
-                .await
-                .map_err(|e| {
-                    tonic::Status::unknown(
-                        format!("Service was not ready: {}", e.into()),
-                    )
-                })?;
+        ) -> std::result::Result<tonic::Response<super::CreatePlaylistResponse>, tonic::Status>
+        {
+            self.inner.ready().await.map_err(|e| {
+                tonic::Status::unknown(format!("Service was not ready: {}", e.into()))
+            })?;
             let codec = tonic::codec::ProstCodec::default();
             let path = http::uri::PathAndQuery::from_static(
                 "/rockbox.v1alpha1.PlaylistService/CreatePlaylist",
             );
             let mut req = request.into_request();
-            req.extensions_mut()
-                .insert(
-                    GrpcMethod::new("rockbox.v1alpha1.PlaylistService", "CreatePlaylist"),
-                );
+            req.extensions_mut().insert(GrpcMethod::new(
+                "rockbox.v1alpha1.PlaylistService",
+                "CreatePlaylist",
+            ));
             self.inner.unary(req, path, codec).await
         }
         pub async fn insert_tracks(
             &mut self,
             request: impl tonic::IntoRequest<super::InsertTracksRequest>,
-        ) -> std::result::Result<
-            tonic::Response<super::InsertTracksResponse>,
-            tonic::Status,
-        > {
-            self.inner
-                .ready()
-                .await
-                .map_err(|e| {
-                    tonic::Status::unknown(
-                        format!("Service was not ready: {}", e.into()),
-                    )
-                })?;
+        ) -> std::result::Result<tonic::Response<super::InsertTracksResponse>, tonic::Status>
+        {
+            self.inner.ready().await.map_err(|e| {
+                tonic::Status::unknown(format!("Service was not ready: {}", e.into()))
+            })?;
             let codec = tonic::codec::ProstCodec::default();
             let path = http::uri::PathAndQuery::from_static(
                 "/rockbox.v1alpha1.PlaylistService/InsertTracks",
             );
             let mut req = request.into_request();
-            req.extensions_mut()
-                .insert(
-                    GrpcMethod::new("rockbox.v1alpha1.PlaylistService", "InsertTracks"),
-                );
+            req.extensions_mut().insert(GrpcMethod::new(
+                "rockbox.v1alpha1.PlaylistService",
+                "InsertTracks",
+            ));
             self.inner.unary(req, path, codec).await
         }
         pub async fn insert_directory(
             &mut self,
             request: impl tonic::IntoRequest<super::InsertDirectoryRequest>,
-        ) -> std::result::Result<
-            tonic::Response<super::InsertDirectoryResponse>,
-            tonic::Status,
-        > {
-            self.inner
-                .ready()
-                .await
-                .map_err(|e| {
-                    tonic::Status::unknown(
-                        format!("Service was not ready: {}", e.into()),
-                    )
-                })?;
+        ) -> std::result::Result<tonic::Response<super::InsertDirectoryResponse>, tonic::Status>
+        {
+            self.inner.ready().await.map_err(|e| {
+                tonic::Status::unknown(format!("Service was not ready: {}", e.into()))
+            })?;
             let codec = tonic::codec::ProstCodec::default();
             let path = http::uri::PathAndQuery::from_static(
                 "/rockbox.v1alpha1.PlaylistService/InsertDirectory",
             );
             let mut req = request.into_request();
-            req.extensions_mut()
-                .insert(
-                    GrpcMethod::new(
-                        "rockbox.v1alpha1.PlaylistService",
-                        "InsertDirectory",
-                    ),
-                );
+            req.extensions_mut().insert(GrpcMethod::new(
+                "rockbox.v1alpha1.PlaylistService",
+                "InsertDirectory",
+            ));
             self.inner.unary(req, path, codec).await
         }
         pub async fn insert_playlist(
             &mut self,
             request: impl tonic::IntoRequest<super::InsertPlaylistRequest>,
-        ) -> std::result::Result<
-            tonic::Response<super::InsertPlaylistResponse>,
-            tonic::Status,
-        > {
-            self.inner
-                .ready()
-                .await
-                .map_err(|e| {
-                    tonic::Status::unknown(
-                        format!("Service was not ready: {}", e.into()),
-                    )
-                })?;
+        ) -> std::result::Result<tonic::Response<super::InsertPlaylistResponse>, tonic::Status>
+        {
+            self.inner.ready().await.map_err(|e| {
+                tonic::Status::unknown(format!("Service was not ready: {}", e.into()))
+            })?;
             let codec = tonic::codec::ProstCodec::default();
             let path = http::uri::PathAndQuery::from_static(
                 "/rockbox.v1alpha1.PlaylistService/InsertPlaylist",
             );
             let mut req = request.into_request();
-            req.extensions_mut()
-                .insert(
-                    GrpcMethod::new("rockbox.v1alpha1.PlaylistService", "InsertPlaylist"),
-                );
+            req.extensions_mut().insert(GrpcMethod::new(
+                "rockbox.v1alpha1.PlaylistService",
+                "InsertPlaylist",
+            ));
             self.inner.unary(req, path, codec).await
         }
         pub async fn insert_album(
             &mut self,
             request: impl tonic::IntoRequest<super::InsertAlbumRequest>,
-        ) -> std::result::Result<
-            tonic::Response<super::InsertAlbumResponse>,
-            tonic::Status,
-        > {
-            self.inner
-                .ready()
-                .await
-                .map_err(|e| {
-                    tonic::Status::unknown(
-                        format!("Service was not ready: {}", e.into()),
-                    )
-                })?;
+        ) -> std::result::Result<tonic::Response<super::InsertAlbumResponse>, tonic::Status>
+        {
+            self.inner.ready().await.map_err(|e| {
+                tonic::Status::unknown(format!("Service was not ready: {}", e.into()))
+            })?;
             let codec = tonic::codec::ProstCodec::default();
             let path = http::uri::PathAndQuery::from_static(
                 "/rockbox.v1alpha1.PlaylistService/InsertAlbum",
             );
             let mut req = request.into_request();
-            req.extensions_mut()
-                .insert(
-                    GrpcMethod::new("rockbox.v1alpha1.PlaylistService", "InsertAlbum"),
-                );
+            req.extensions_mut().insert(GrpcMethod::new(
+                "rockbox.v1alpha1.PlaylistService",
+                "InsertAlbum",
+            ));
             self.inner.unary(req, path, codec).await
         }
         pub async fn insert_artist_tracks(
             &mut self,
             request: impl tonic::IntoRequest<super::InsertArtistTracksRequest>,
-        ) -> std::result::Result<
-            tonic::Response<super::InsertArtistTracksResponse>,
-            tonic::Status,
-        > {
-            self.inner
-                .ready()
-                .await
-                .map_err(|e| {
-                    tonic::Status::unknown(
-                        format!("Service was not ready: {}", e.into()),
-                    )
-                })?;
+        ) -> std::result::Result<tonic::Response<super::InsertArtistTracksResponse>, tonic::Status>
+        {
+            self.inner.ready().await.map_err(|e| {
+                tonic::Status::unknown(format!("Service was not ready: {}", e.into()))
+            })?;
             let codec = tonic::codec::ProstCodec::default();
             let path = http::uri::PathAndQuery::from_static(
                 "/rockbox.v1alpha1.PlaylistService/InsertArtistTracks",
             );
             let mut req = request.into_request();
-            req.extensions_mut()
-                .insert(
-                    GrpcMethod::new(
-                        "rockbox.v1alpha1.PlaylistService",
-                        "InsertArtistTracks",
-                    ),
-                );
+            req.extensions_mut().insert(GrpcMethod::new(
+                "rockbox.v1alpha1.PlaylistService",
+                "InsertArtistTracks",
+            ));
             self.inner.unary(req, path, codec).await
         }
         pub async fn shuffle_playlist(
             &mut self,
             request: impl tonic::IntoRequest<super::ShufflePlaylistRequest>,
-        ) -> std::result::Result<
-            tonic::Response<super::ShufflePlaylistResponse>,
-            tonic::Status,
-        > {
-            self.inner
-                .ready()
-                .await
-                .map_err(|e| {
-                    tonic::Status::unknown(
-                        format!("Service was not ready: {}", e.into()),
-                    )
-                })?;
+        ) -> std::result::Result<tonic::Response<super::ShufflePlaylistResponse>, tonic::Status>
+        {
+            self.inner.ready().await.map_err(|e| {
+                tonic::Status::unknown(format!("Service was not ready: {}", e.into()))
+            })?;
             let codec = tonic::codec::ProstCodec::default();
             let path = http::uri::PathAndQuery::from_static(
                 "/rockbox.v1alpha1.PlaylistService/ShufflePlaylist",
             );
             let mut req = request.into_request();
-            req.extensions_mut()
-                .insert(
-                    GrpcMethod::new(
-                        "rockbox.v1alpha1.PlaylistService",
-                        "ShufflePlaylist",
-                    ),
-                );
+            req.extensions_mut().insert(GrpcMethod::new(
+                "rockbox.v1alpha1.PlaylistService",
+                "ShufflePlaylist",
+            ));
             self.inner.unary(req, path, codec).await
         }
     }
···
         dead_code,
         missing_docs,
         clippy::wildcard_imports,
-        clippy::let_unit_value,
+        clippy::let_unit_value
     )]
     use tonic::codegen::*;
     /// Generated trait containing gRPC methods that should be implemented for use with PlaylistServiceServer.
···
         async fn get_current(
             &self,
             request: tonic::Request<super::GetCurrentRequest>,
-        ) -> std::result::Result<
-            tonic::Response<super::GetCurrentResponse>,
-            tonic::Status,
-        >;
+        ) -> 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,
-        >;
+        ) -> 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,
-        >;
+        ) -> 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,
-        >;
+        ) -> 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,
-        >;
+        ) -> std::result::Result<tonic::Response<super::GetDisplayIndexResponse>, tonic::Status>;
         async fn amount(
             &self,
             request: tonic::Request<super::AmountRequest>,
···
         async fn playlist_resume(
             &self,
             request: tonic::Request<super::PlaylistResumeRequest>,
-        ) -> std::result::Result<
-            tonic::Response<super::PlaylistResumeResponse>,
-            tonic::Status,
-        >;
+        ) -> 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,
-        >;
+        ) -> 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,
-        >;
+        ) -> std::result::Result<tonic::Response<super::SetModifiedResponse>, tonic::Status>;
         async fn start(
             &self,
             request: tonic::Request<super::StartRequest>,
···
         async fn remove_all_tracks(
             &self,
             request: tonic::Request<super::RemoveAllTracksRequest>,
-        ) -> std::result::Result<
-            tonic::Response<super::RemoveAllTracksResponse>,
-            tonic::Status,
-        >;
+        ) -> 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,
-        >;
+        ) -> 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,
-        >;
+        ) -> 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,
-        >;
+        ) -> 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,
-        >;
+        ) -> 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,
-        >;
+        ) -> 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,
-        >;
+        ) -> std::result::Result<tonic::Response<super::InsertAlbumResponse>, tonic::Status>;
         async fn insert_artist_tracks(
             &self,
             request: tonic::Request<super::InsertArtistTracksRequest>,
-        ) -> std::result::Result<
-            tonic::Response<super::InsertArtistTracksResponse>,
-            tonic::Status,
-        >;
+        ) -> std::result::Result<tonic::Response<super::InsertArtistTracksResponse>, tonic::Status>;
         async fn shuffle_playlist(
             &self,
             request: tonic::Request<super::ShufflePlaylistRequest>,
-        ) -> std::result::Result<
-            tonic::Response<super::ShufflePlaylistResponse>,
-            tonic::Status,
-        >;
+        ) -> std::result::Result<tonic::Response<super::ShufflePlaylistResponse>, tonic::Status>;
     }
     #[derive(Debug)]
     pub struct PlaylistServiceServer<T> {
···
                 max_encoding_message_size: None,
             }
         }
-        pub fn with_interceptor<F>(
-            inner: T,
-            interceptor: F,
-        ) -> InterceptedService<Self, F>
+        pub fn with_interceptor<F>(inner: T, interceptor: F) -> InterceptedService<Self, F>
         where
             F: tonic::service::Interceptor,
         {
···
                 "/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> {
+                    impl<T: PlaylistService> tonic::server::UnaryService<super::GetCurrentRequest>
+                        for GetCurrentSvc<T>
+                    {
                         type Response = super::GetCurrentResponse;
-                        type Future = BoxFuture<
-                            tonic::Response<Self::Response>,
-                            tonic::Status,
-                        >;
+                        type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
                         fn call(
                             &mut self,
                             request: tonic::Request<super::GetCurrentRequest>,
···
                 "/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> {
+                    impl<T: PlaylistService>
+                        tonic::server::UnaryService<super::GetResumeInfoRequest>
+                        for GetResumeInfoSvc<T>
+                    {
                         type Response = super::GetResumeInfoResponse;
-                        type Future = BoxFuture<
-                            tonic::Response<Self::Response>,
-                            tonic::Status,
-                        >;
+                        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
+                                <T as PlaylistService>::get_resume_info(&inner, request).await
                             };
                             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> {
+                    impl<T: PlaylistService> tonic::server::UnaryService<super::GetTrackInfoRequest>
+                        for GetTrackInfoSvc<T>
+                    {
                         type Response = super::GetTrackInfoResponse;
-                        type Future = BoxFuture<
-                            tonic::Response<Self::Response>,
-                            tonic::Status,
-                        >;
+                        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
+                                <T as PlaylistService>::get_track_info(&inner, request).await
                             };
                             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> {
+                    impl<T: PlaylistService>
+                        tonic::server::UnaryService<super::GetFirstIndexRequest>
+                        for GetFirstIndexSvc<T>
+                    {
                         type Response = super::GetFirstIndexResponse;
-                        type Future = BoxFuture<
-                            tonic::Response<Self::Response>,
-                            tonic::Status,
-                        >;
+                        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
+                                <T as PlaylistService>::get_first_index(&inner, request).await
                             };
                             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> {
+                    impl<T: PlaylistService>
+                        tonic::server::UnaryService<super::GetDisplayIndexRequest>
+                        for GetDisplayIndexSvc<T>
+                    {
                         type Response = super::GetDisplayIndexResponse;
-                        type Future = BoxFuture<
-                            tonic::Response<Self::Response>,
-                            tonic::Status,
-                        >;
+                        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
+                                <T as PlaylistService>::get_display_index(&inner, request).await
                             };
                             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> {
+                    impl<T: PlaylistService> tonic::server::UnaryService<super::AmountRequest> for AmountSvc<T> {
                         type Response = super::AmountResponse;
-                        type Future = BoxFuture<
-                            tonic::Response<Self::Response>,
-                            tonic::Status,
-                        >;
+                        type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
                         fn call(
                             &mut self,
                             request: tonic::Request<super::AmountRequest>,
···
                 "/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> {
+                    impl<T: PlaylistService>
+                        tonic::server::UnaryService<super::PlaylistResumeRequest>
+                        for PlaylistResumeSvc<T>
+                    {
                         type Response = super::PlaylistResumeResponse;
-                        type Future = BoxFuture<
-                            tonic::Response<Self::Response>,
-                            tonic::Status,
-                        >;
+                        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
+                                <T as PlaylistService>::playlist_resume(&inner, request).await
                             };
                             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> {
+                    impl<T: PlaylistService> tonic::server::UnaryService<super::ResumeTrackRequest>
+                        for ResumeTrackSvc<T>
+                    {
                         type Response = super::ResumeTrackResponse;
-                        type Future = BoxFuture<
-                            tonic::Response<Self::Response>,
-                            tonic::Status,
-                        >;
+                        type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
                         fn call(
                             &mut self,
                             request: tonic::Request<super::ResumeTrackRequest>,
···
                 "/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> {
+                    impl<T: PlaylistService> tonic::server::UnaryService<super::SetModifiedRequest>
+                        for SetModifiedSvc<T>
+                    {
                         type Response = super::SetModifiedResponse;
-                        type Future = BoxFuture<
-                            tonic::Response<Self::Response>,
-                            tonic::Status,
-                        >;
+                        type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
                         fn call(
                             &mut self,
                             request: tonic::Request<super::SetModifiedRequest>,
···
                 "/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> {
+                    impl<T: PlaylistService> tonic::server::UnaryService<super::StartRequest> for StartSvc<T> {
                         type Response = super::StartResponse;
-                        type Future = BoxFuture<
-                            tonic::Response<Self::Response>,
-                            tonic::Status,
-                        >;
+                        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
-                            };
+                            let fut =
+                                async move { <T as PlaylistService>::start(&inner, request).await };
                             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> {
+                    impl<T: PlaylistService> tonic::server::UnaryService<super::SyncRequest> for SyncSvc<T> {
                         type Response = super::SyncResponse;
-                        type Future = BoxFuture<
-                            tonic::Response<Self::Response>,
-                            tonic::Status,
-                        >;
+                        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
-                            };
+                            let fut =
+                                async move { <T as PlaylistService>::sync(&inner, request).await };
                             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> {
+                    impl<T: PlaylistService>
+                        tonic::server::UnaryService<super::RemoveAllTracksRequest>
+                        for RemoveAllTracksSvc<T>
+                    {
                         type Response = super::RemoveAllTracksResponse;
-                        type Future = BoxFuture<
-                            tonic::Response<Self::Response>,
-                            tonic::Status,
-                        >;
+                        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
+                                <T as PlaylistService>::remove_all_tracks(&inner, request).await
                             };
                             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> {
+                    impl<T: PlaylistService> tonic::server::UnaryService<super::RemoveTracksRequest>
+                        for RemoveTracksSvc<T>
+                    {
                         type Response = super::RemoveTracksResponse;
-                        type Future = BoxFuture<
-                            tonic::Response<Self::Response>,
-                            tonic::Status,
-                        >;
+                        type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
                         fn call(
                             &mut self,
                             request: tonic::Request<super::RemoveTracksRequest>,
···
                 "/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> {
+                    impl<T: PlaylistService>
+                        tonic::server::UnaryService<super::CreatePlaylistRequest>
+                        for CreatePlaylistSvc<T>
+                    {
                         type Response = super::CreatePlaylistResponse;
-                        type Future = BoxFuture<
-                            tonic::Response<Self::Response>,
-                            tonic::Status,
-                        >;
+                        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
+                                <T as PlaylistService>::create_playlist(&inner, request).await
                             };
                             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> {
+                    impl<T: PlaylistService> tonic::server::UnaryService<super::InsertTracksRequest>
+                        for InsertTracksSvc<T>
+                    {
                         type Response = super::InsertTracksResponse;
-                        type Future = BoxFuture<
-                            tonic::Response<Self::Response>,
-                            tonic::Status,
-                        >;
+                        type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
                         fn call(
                             &mut self,
                             request: tonic::Request<super::InsertTracksRequest>,
···
                 "/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> {
+                    impl<T: PlaylistService>
+                        tonic::server::UnaryService<super::InsertDirectoryRequest>
+                        for InsertDirectorySvc<T>
+                    {
                         type Response = super::InsertDirectoryResponse;
-                        type Future = BoxFuture<
-                            tonic::Response<Self::Response>,
-                            tonic::Status,
-                        >;
+                        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
+                                <T as PlaylistService>::insert_directory(&inner, request).await
                             };
                             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> {
+                    impl<T: PlaylistService>
+                        tonic::server::UnaryService<super::InsertPlaylistRequest>
+                        for InsertPlaylistSvc<T>
+                    {
                         type Response = super::InsertPlaylistResponse;
-                        type Future = BoxFuture<
-                            tonic::Response<Self::Response>,
-                            tonic::Status,
-                        >;
+                        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
+                                <T as PlaylistService>::insert_playlist(&inner, request).await
                             };
                             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> {
+                    impl<T: PlaylistService> tonic::server::UnaryService<super::InsertAlbumRequest>
+                        for InsertAlbumSvc<T>
+                    {
                         type Response = super::InsertAlbumResponse;
-                        type Future = BoxFuture<
-                            tonic::Response<Self::Response>,
-                            tonic::Status,
-                        >;
+                        type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
                         fn call(
                             &mut self,
                             request: tonic::Request<super::InsertAlbumRequest>,
···
                 "/rockbox.v1alpha1.PlaylistService/InsertArtistTracks" => {
                     #[allow(non_camel_case_types)]
                     struct InsertArtistTracksSvc<T: PlaylistService>(pub Arc<T>);
-                    impl<
-                        T: PlaylistService,
-                    > tonic::server::UnaryService<super::InsertArtistTracksRequest>
-                    for InsertArtistTracksSvc<T> {
+                    impl<T: PlaylistService>
+                        tonic::server::UnaryService<super::InsertArtistTracksRequest>
+                        for InsertArtistTracksSvc<T>
+                    {
                         type Response = super::InsertArtistTracksResponse;
-                        type Future = BoxFuture<
-                            tonic::Response<Self::Response>,
-                            tonic::Status,
-                        >;
+                        type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
                         fn call(
                             &mut self,
                             request: tonic::Request<super::InsertArtistTracksRequest>,
                         ) -> Self::Future {
                             let inner = Arc::clone(&self.0);
                             let fut = async move {
-                                <T as PlaylistService>::insert_artist_tracks(
-                                        &inner,
-                                        request,
-                                    )
-                                    .await
+                                <T as PlaylistService>::insert_artist_tracks(&inner, request).await
                             };
                             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> {
+                    impl<T: PlaylistService>
+                        tonic::server::UnaryService<super::ShufflePlaylistRequest>
+                        for ShufflePlaylistSvc<T>
+                    {
                         type Response = super::ShufflePlaylistResponse;
-                        type Future = BoxFuture<
-                            tonic::Response<Self::Response>,
-                            tonic::Status,
-                        >;
+                        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
+                                <T as PlaylistService>::shuffle_playlist(&inner, request).await
                             };
                             Box::pin(fut)
                         }
···
                     };
                     Box::pin(fut)
                 }
-                _ => {
-                    Box::pin(async move {
-                        let mut response = http::Response::new(empty_body());
-                        let headers = response.headers_mut();
-                        headers
-                            .insert(
-                                tonic::Status::GRPC_STATUS,
-                                (tonic::Code::Unimplemented as i32).into(),
-                            );
-                        headers
-                            .insert(
-                                http::header::CONTENT_TYPE,
-                                tonic::metadata::GRPC_CONTENT_TYPE,
-                            );
-                        Ok(response)
-                    })
-                }
+                _ => Box::pin(async move {
+                    let mut response = http::Response::new(empty_body());
+                    let headers = response.headers_mut();
+                    headers.insert(
+                        tonic::Status::GRPC_STATUS,
+                        (tonic::Code::Unimplemented as i32).into(),
+                    );
+                    headers.insert(
+                        http::header::CONTENT_TYPE,
+                        tonic::metadata::GRPC_CONTENT_TYPE,
+                    );
+                    Ok(response)
+                }),
             }
         }
     }
···
         dead_code,
         missing_docs,
         clippy::wildcard_imports,
-        clippy::let_unit_value,
+        clippy::let_unit_value
     )]
-    use tonic::codegen::*;
     use tonic::codegen::http::Uri;
+    use tonic::codegen::*;
     #[derive(Debug, Clone)]
     pub struct SettingsServiceClient<T> {
         inner: tonic::client::Grpc<T>,
···
                     <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,
+            <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))
         }
···
         pub async fn get_settings_list(
             &mut self,
             request: impl tonic::IntoRequest<super::GetSettingsListRequest>,
-        ) -> std::result::Result<
-            tonic::Response<super::GetSettingsListResponse>,
-            tonic::Status,
-        > {
-            self.inner
-                .ready()
-                .await
-                .map_err(|e| {
-                    tonic::Status::unknown(
-                        format!("Service was not ready: {}", e.into()),
-                    )
-                })?;
+        ) -> std::result::Result<tonic::Response<super::GetSettingsListResponse>, tonic::Status>
+        {
+            self.inner.ready().await.map_err(|e| {
+                tonic::Status::unknown(format!("Service was not ready: {}", e.into()))
+            })?;
             let codec = tonic::codec::ProstCodec::default();
             let path = http::uri::PathAndQuery::from_static(
                 "/rockbox.v1alpha1.SettingsService/GetSettingsList",
             );
             let mut req = request.into_request();
-            req.extensions_mut()
-                .insert(
-                    GrpcMethod::new(
-                        "rockbox.v1alpha1.SettingsService",
-                        "GetSettingsList",
-                    ),
-                );
+            req.extensions_mut().insert(GrpcMethod::new(
+                "rockbox.v1alpha1.SettingsService",
+                "GetSettingsList",
+            ));
             self.inner.unary(req, path, codec).await
         }
         pub async fn get_global_settings(
             &mut self,
             request: impl tonic::IntoRequest<super::GetGlobalSettingsRequest>,
-        ) -> std::result::Result<
-            tonic::Response<super::GetGlobalSettingsResponse>,
-            tonic::Status,
-        > {
-            self.inner
-                .ready()
-                .await
-                .map_err(|e| {
-                    tonic::Status::unknown(
-                        format!("Service was not ready: {}", e.into()),
-                    )
-                })?;
+        ) -> std::result::Result<tonic::Response<super::GetGlobalSettingsResponse>, tonic::Status>
+        {
+            self.inner.ready().await.map_err(|e| {
+                tonic::Status::unknown(format!("Service was not ready: {}", e.into()))
+            })?;
             let codec = tonic::codec::ProstCodec::default();
             let path = http::uri::PathAndQuery::from_static(
                 "/rockbox.v1alpha1.SettingsService/GetGlobalSettings",
             );
             let mut req = request.into_request();
-            req.extensions_mut()
-                .insert(
-                    GrpcMethod::new(
-                        "rockbox.v1alpha1.SettingsService",
-                        "GetGlobalSettings",
-                    ),
-                );
+            req.extensions_mut().insert(GrpcMethod::new(
+                "rockbox.v1alpha1.SettingsService",
+                "GetGlobalSettings",
+            ));
             self.inner.unary(req, path, codec).await
         }
         pub async fn save_settings(
             &mut self,
             request: impl tonic::IntoRequest<super::SaveSettingsRequest>,
-        ) -> std::result::Result<
-            tonic::Response<super::SaveSettingsResponse>,
-            tonic::Status,
-        > {
-            self.inner
-                .ready()
-                .await
-                .map_err(|e| {
-                    tonic::Status::unknown(
-                        format!("Service was not ready: {}", e.into()),
-                    )
-                })?;
+        ) -> std::result::Result<tonic::Response<super::SaveSettingsResponse>, tonic::Status>
+        {
+            self.inner.ready().await.map_err(|e| {
+                tonic::Status::unknown(format!("Service was not ready: {}", e.into()))
+            })?;
             let codec = tonic::codec::ProstCodec::default();
             let path = http::uri::PathAndQuery::from_static(
                 "/rockbox.v1alpha1.SettingsService/SaveSettings",
             );
             let mut req = request.into_request();
-            req.extensions_mut()
-                .insert(
-                    GrpcMethod::new("rockbox.v1alpha1.SettingsService", "SaveSettings"),
-                );
+            req.extensions_mut().insert(GrpcMethod::new(
+                "rockbox.v1alpha1.SettingsService",
+                "SaveSettings",
+            ));
             self.inner.unary(req, path, codec).await
         }
     }
···
         dead_code,
         missing_docs,
         clippy::wildcard_imports,
-        clippy::let_unit_value,
+        clippy::let_unit_value
     )]
     use tonic::codegen::*;
     /// Generated trait containing gRPC methods that should be implemented for use with SettingsServiceServer.
···
         async fn get_settings_list(
             &self,
             request: tonic::Request<super::GetSettingsListRequest>,
-        ) -> std::result::Result<
-            tonic::Response<super::GetSettingsListResponse>,
-            tonic::Status,
-        >;
+        ) -> 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,
-        >;
+        ) -> 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,
-        >;
+        ) -> std::result::Result<tonic::Response<super::SaveSettingsResponse>, tonic::Status>;
     }
     #[derive(Debug)]
     pub struct SettingsServiceServer<T> {
···
                 max_encoding_message_size: None,
             }
         }
-        pub fn with_interceptor<F>(
-            inner: T,
-            interceptor: F,
-        ) -> InterceptedService<Self, F>
+        pub fn with_interceptor<F>(inner: T, interceptor: F) -> InterceptedService<Self, F>
         where
             F: tonic::service::Interceptor,
         {
···
                 "/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> {
+                    impl<T: SettingsService>
+                        tonic::server::UnaryService<super::GetSettingsListRequest>
+                        for GetSettingsListSvc<T>
+                    {
                         type Response = super::GetSettingsListResponse;
-                        type Future = BoxFuture<
-                            tonic::Response<Self::Response>,
-                            tonic::Status,
-                        >;
+                        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
+                                <T as SettingsService>::get_settings_list(&inner, request).await
                             };
                             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> {
+                    impl<T: SettingsService>
+                        tonic::server::UnaryService<super::GetGlobalSettingsRequest>
+                        for GetGlobalSettingsSvc<T>
+                    {
                         type Response = super::GetGlobalSettingsResponse;
-                        type Future = BoxFuture<
-                            tonic::Response<Self::Response>,
-                            tonic::Status,
-                        >;
+                        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
+                                <T as SettingsService>::get_global_settings(&inner, request).await
                             };
                             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> {
+                    impl<T: SettingsService> tonic::server::UnaryService<super::SaveSettingsRequest>
+                        for SaveSettingsSvc<T>
+                    {
                         type Response = super::SaveSettingsResponse;
-                        type Future = BoxFuture<
-                            tonic::Response<Self::Response>,
-                            tonic::Status,
-                        >;
+                        type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
                         fn call(
                             &mut self,
                             request: tonic::Request<super::SaveSettingsRequest>,
···
                     };
                     Box::pin(fut)
                 }
-                _ => {
-                    Box::pin(async move {
-                        let mut response = http::Response::new(empty_body());
-                        let headers = response.headers_mut();
-                        headers
-                            .insert(
-                                tonic::Status::GRPC_STATUS,
-                                (tonic::Code::Unimplemented as i32).into(),
-                            );
-                        headers
-                            .insert(
-                                http::header::CONTENT_TYPE,
-                                tonic::metadata::GRPC_CONTENT_TYPE,
-                            );
-                        Ok(response)
-                    })
-                }
+                _ => Box::pin(async move {
+                    let mut response = http::Response::new(empty_body());
+                    let headers = response.headers_mut();
+                    headers.insert(
+                        tonic::Status::GRPC_STATUS,
+                        (tonic::Code::Unimplemented as i32).into(),
+                    );
+                    headers.insert(
+                        http::header::CONTENT_TYPE,
+                        tonic::metadata::GRPC_CONTENT_TYPE,
+                    );
+                    Ok(response)
+                }),
             }
         }
     }
···
         dead_code,
         missing_docs,
         clippy::wildcard_imports,
-        clippy::let_unit_value,
+        clippy::let_unit_value
     )]
-    use tonic::codegen::*;
     use tonic::codegen::http::Uri;
+    use tonic::codegen::*;
     #[derive(Debug, Clone)]
     pub struct SoundServiceClient<T> {
         inner: tonic::client::Grpc<T>,
···
                     <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,
+            <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))
         }
···
         pub async fn adjust_volume(
             &mut self,
             request: impl tonic::IntoRequest<super::AdjustVolumeRequest>,
-        ) -> std::result::Result<
-            tonic::Response<super::AdjustVolumeResponse>,
-            tonic::Status,
-        > {
-            self.inner
-                .ready()
-                .await
-                .map_err(|e| {
-                    tonic::Status::unknown(
-                        format!("Service was not ready: {}", e.into()),
-                    )
-                })?;
+        ) -> std::result::Result<tonic::Response<super::AdjustVolumeResponse>, tonic::Status>
+        {
+            self.inner.ready().await.map_err(|e| {
+                tonic::Status::unknown(format!("Service was not ready: {}", e.into()))
+            })?;
             let codec = tonic::codec::ProstCodec::default();
-            let path = http::uri::PathAndQuery::from_static(
-                "/rockbox.v1alpha1.SoundService/AdjustVolume",
-            );
+            let 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"),
-                );
+            req.extensions_mut().insert(GrpcMethod::new(
+                "rockbox.v1alpha1.SoundService",
+                "AdjustVolume",
+            ));
             self.inner.unary(req, path, codec).await
         }
         pub async fn sound_set(
             &mut self,
             request: impl tonic::IntoRequest<super::SoundSetRequest>,
-        ) -> std::result::Result<
-            tonic::Response<super::SoundSetResponse>,
-            tonic::Status,
-        > {
-            self.inner
-                .ready()
-                .await
-                .map_err(|e| {
-                    tonic::Status::unknown(
-                        format!("Service was not ready: {}", e.into()),
-                    )
-                })?;
+        ) -> std::result::Result<tonic::Response<super::SoundSetResponse>, tonic::Status> {
+            self.inner.ready().await.map_err(|e| {
+                tonic::Status::unknown(format!("Service was not ready: {}", e.into()))
+            })?;
             let codec = tonic::codec::ProstCodec::default();
-            let path = http::uri::PathAndQuery::from_static(
-                "/rockbox.v1alpha1.SoundService/SoundSet",
-            );
+            let 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"));
···
         pub async fn sound_current(
             &mut self,
             request: impl tonic::IntoRequest<super::SoundCurrentRequest>,
-        ) -> std::result::Result<
-            tonic::Response<super::SoundCurrentResponse>,
-            tonic::Status,
-        > {
-            self.inner
-                .ready()
-                .await
-                .map_err(|e| {
-                    tonic::Status::unknown(
-                        format!("Service was not ready: {}", e.into()),
-                    )
-                })?;
+        ) -> std::result::Result<tonic::Response<super::SoundCurrentResponse>, tonic::Status>
+        {
+            self.inner.ready().await.map_err(|e| {
+                tonic::Status::unknown(format!("Service was not ready: {}", e.into()))
+            })?;
             let codec = tonic::codec::ProstCodec::default();
-            let path = http::uri::PathAndQuery::from_static(
-                "/rockbox.v1alpha1.SoundService/SoundCurrent",
-            );
+            let 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"),
-                );
+            req.extensions_mut().insert(GrpcMethod::new(
+                "rockbox.v1alpha1.SoundService",
+                "SoundCurrent",
+            ));
             self.inner.unary(req, path, codec).await
         }
         pub async fn sound_default(
             &mut self,
             request: impl tonic::IntoRequest<super::SoundDefaultRequest>,
-        ) -> std::result::Result<
-            tonic::Response<super::SoundDefaultResponse>,
-            tonic::Status,
-        > {
-            self.inner
-                .ready()
-                .await
-                .map_err(|e| {
-                    tonic::Status::unknown(
-                        format!("Service was not ready: {}", e.into()),
-                    )
-                })?;
+        ) -> std::result::Result<tonic::Response<super::SoundDefaultResponse>, tonic::Status>
+        {
+            self.inner.ready().await.map_err(|e| {
+                tonic::Status::unknown(format!("Service was not ready: {}", e.into()))
+            })?;
             let codec = tonic::codec::ProstCodec::default();
-            let path = http::uri::PathAndQuery::from_static(
-                "/rockbox.v1alpha1.SoundService/SoundDefault",
-            );
+            let 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"),
-                );
+            req.extensions_mut().insert(GrpcMethod::new(
+                "rockbox.v1alpha1.SoundService",
+                "SoundDefault",
+            ));
             self.inner.unary(req, path, codec).await
         }
         pub async fn sound_min(
             &mut self,
             request: impl tonic::IntoRequest<super::SoundMinRequest>,
-        ) -> std::result::Result<
-            tonic::Response<super::SoundMinResponse>,
-            tonic::Status,
-        > {
-            self.inner
-                .ready()
-                .await
-                .map_err(|e| {
-                    tonic::Status::unknown(
-                        format!("Service was not ready: {}", e.into()),
-                    )
-                })?;
+        ) -> std::result::Result<tonic::Response<super::SoundMinResponse>, tonic::Status> {
+            self.inner.ready().await.map_err(|e| {
+                tonic::Status::unknown(format!("Service was not ready: {}", e.into()))
+            })?;
             let codec = tonic::codec::ProstCodec::default();
-            let path = http::uri::PathAndQuery::from_static(
-                "/rockbox.v1alpha1.SoundService/SoundMin",
-            );
+            let 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"));
···
         pub async fn sound_max(
             &mut self,
             request: impl tonic::IntoRequest<super::SoundMaxRequest>,
-        ) -> std::result::Result<
-            tonic::Response<super::SoundMaxResponse>,
-            tonic::Status,
-        > {
-            self.inner
-                .ready()
-                .await
-                .map_err(|e| {
-                    tonic::Status::unknown(
-                        format!("Service was not ready: {}", e.into()),
-                    )
-                })?;
+        ) -> std::result::Result<tonic::Response<super::SoundMaxResponse>, tonic::Status> {
+            self.inner.ready().await.map_err(|e| {
+                tonic::Status::unknown(format!("Service was not ready: {}", e.into()))
+            })?;
             let codec = tonic::codec::ProstCodec::default();
-            let path = http::uri::PathAndQuery::from_static(
-                "/rockbox.v1alpha1.SoundService/SoundMax",
-            );
+            let 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"));
···
         pub async fn sound_unit(
             &mut self,
             request: impl tonic::IntoRequest<super::SoundUnitRequest>,
-        ) -> std::result::Result<
-            tonic::Response<super::SoundUnitResponse>,
-            tonic::Status,
-        > {
-            self.inner
-                .ready()
-                .await
-                .map_err(|e| {
-                    tonic::Status::unknown(
-                        format!("Service was not ready: {}", e.into()),
-                    )
-                })?;
+        ) -> std::result::Result<tonic::Response<super::SoundUnitResponse>, tonic::Status> {
+            self.inner.ready().await.map_err(|e| {
+                tonic::Status::unknown(format!("Service was not ready: {}", e.into()))
+            })?;
             let codec = tonic::codec::ProstCodec::default();
-            let path = http::uri::PathAndQuery::from_static(
-                "/rockbox.v1alpha1.SoundService/SoundUnit",
-            );
+            let 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"));
+            req.extensions_mut().insert(GrpcMethod::new(
+                "rockbox.v1alpha1.SoundService",
+                "SoundUnit",
+            ));
             self.inner.unary(req, path, codec).await
         }
         pub async fn sound_val2_phys(
             &mut self,
             request: impl tonic::IntoRequest<super::SoundVal2PhysRequest>,
-        ) -> std::result::Result<
-            tonic::Response<super::SoundVal2PhysResponse>,
-            tonic::Status,
-        > {
-            self.inner
-                .ready()
-                .await
-                .map_err(|e| {
-                    tonic::Status::unknown(
-                        format!("Service was not ready: {}", e.into()),
-                    )
-                })?;
+        ) -> std::result::Result<tonic::Response<super::SoundVal2PhysResponse>, tonic::Status>
+        {
+            self.inner.ready().await.map_err(|e| {
+                tonic::Status::unknown(format!("Service was not ready: {}", e.into()))
+            })?;
             let codec = tonic::codec::ProstCodec::default();
             let path = http::uri::PathAndQuery::from_static(
                 "/rockbox.v1alpha1.SoundService/SoundVal2Phys",
             );
             let mut req = request.into_request();
-            req.extensions_mut()
-                .insert(
-                    GrpcMethod::new("rockbox.v1alpha1.SoundService", "SoundVal2Phys"),
-                );
+            req.extensions_mut().insert(GrpcMethod::new(
+                "rockbox.v1alpha1.SoundService",
+                "SoundVal2Phys",
+            ));
             self.inner.unary(req, path, codec).await
         }
         pub async fn get_pitch(
             &mut self,
             request: impl tonic::IntoRequest<super::GetPitchRequest>,
-        ) -> std::result::Result<
-            tonic::Response<super::GetPitchResponse>,
-            tonic::Status,
-        > {
-            self.inner
-                .ready()
-                .await
-                .map_err(|e| {
-                    tonic::Status::unknown(
-                        format!("Service was not ready: {}", e.into()),
-                    )
-                })?;
+        ) -> std::result::Result<tonic::Response<super::GetPitchResponse>, tonic::Status> {
+            self.inner.ready().await.map_err(|e| {
+                tonic::Status::unknown(format!("Service was not ready: {}", e.into()))
+            })?;
             let codec = tonic::codec::ProstCodec::default();
-            let path = http::uri::PathAndQuery::from_static(
-                "/rockbox.v1alpha1.SoundService/GetPitch",
-            );
+            let 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"));
···
         pub async fn set_pitch(
             &mut self,
             request: impl tonic::IntoRequest<super::SetPitchRequest>,
-        ) -> std::result::Result<
-            tonic::Response<super::SetPitchResponse>,
-            tonic::Status,
-        > {
-            self.inner
-                .ready()
-                .await
-                .map_err(|e| {
-                    tonic::Status::unknown(
-                        format!("Service was not ready: {}", e.into()),
-                    )
-                })?;
+        ) -> std::result::Result<tonic::Response<super::SetPitchResponse>, tonic::Status> {
+            self.inner.ready().await.map_err(|e| {
+                tonic::Status::unknown(format!("Service was not ready: {}", e.into()))
+            })?;
             let codec = tonic::codec::ProstCodec::default();
-            let path = http::uri::PathAndQuery::from_static(
-                "/rockbox.v1alpha1.SoundService/SetPitch",
-            );
+            let 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"));
···
         pub async fn beep_play(
             &mut self,
             request: impl tonic::IntoRequest<super::BeepPlayRequest>,
-        ) -> std::result::Result<
-            tonic::Response<super::BeepPlayResponse>,
-            tonic::Status,
-        > {
-            self.inner
-                .ready()
-                .await
-                .map_err(|e| {
-                    tonic::Status::unknown(
-                        format!("Service was not ready: {}", e.into()),
-                    )
-                })?;
+        ) -> std::result::Result<tonic::Response<super::BeepPlayResponse>, tonic::Status> {
+            self.inner.ready().await.map_err(|e| {
+                tonic::Status::unknown(format!("Service was not ready: {}", e.into()))
+            })?;
             let codec = tonic::codec::ProstCodec::default();
-            let path = http::uri::PathAndQuery::from_static(
-                "/rockbox.v1alpha1.SoundService/BeepPlay",
-            );
+            let 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"));
···
         pub async fn pcmbuf_fade(
             &mut self,
             request: impl tonic::IntoRequest<super::PcmbufFadeRequest>,
-        ) -> std::result::Result<
-            tonic::Response<super::PcmbufFadeResponse>,
-            tonic::Status,
-        > {
-            self.inner
-                .ready()
-                .await
-                .map_err(|e| {
-                    tonic::Status::unknown(
-                        format!("Service was not ready: {}", e.into()),
-                    )
-                })?;
+        ) -> std::result::Result<tonic::Response<super::PcmbufFadeResponse>, tonic::Status>
+        {
+            self.inner.ready().await.map_err(|e| {
+                tonic::Status::unknown(format!("Service was not ready: {}", e.into()))
+            })?;
             let codec = tonic::codec::ProstCodec::default();
-            let path = http::uri::PathAndQuery::from_static(
-                "/rockbox.v1alpha1.SoundService/PcmbufFade",
-            );
+            let 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"));
+            req.extensions_mut().insert(GrpcMethod::new(
+                "rockbox.v1alpha1.SoundService",
+                "PcmbufFade",
+            ));
             self.inner.unary(req, path, codec).await
         }
         pub async fn pcmbuf_set_low_latency(
             &mut self,
             request: impl tonic::IntoRequest<super::PcmbufSetLowLatencyRequest>,
-        ) -> std::result::Result<
-            tonic::Response<super::PcmbufSetLowLatencyResponse>,
-            tonic::Status,
-        > {
-            self.inner
-                .ready()
-                .await
-                .map_err(|e| {
-                    tonic::Status::unknown(
-                        format!("Service was not ready: {}", e.into()),
-                    )
-                })?;
+        ) -> std::result::Result<tonic::Response<super::PcmbufSetLowLatencyResponse>, tonic::Status>
+        {
+            self.inner.ready().await.map_err(|e| {
+                tonic::Status::unknown(format!("Service was not ready: {}", e.into()))
+            })?;
             let codec = tonic::codec::ProstCodec::default();
             let path = http::uri::PathAndQuery::from_static(
                 "/rockbox.v1alpha1.SoundService/PcmbufSetLowLatency",
             );
             let mut req = request.into_request();
-            req.extensions_mut()
-                .insert(
-                    GrpcMethod::new(
-                        "rockbox.v1alpha1.SoundService",
-                        "PcmbufSetLowLatency",
-                    ),
-                );
+            req.extensions_mut().insert(GrpcMethod::new(
+                "rockbox.v1alpha1.SoundService",
+                "PcmbufSetLowLatency",
+            ));
             self.inner.unary(req, path, codec).await
         }
         pub async fn system_sound_play(
             &mut self,
             request: impl tonic::IntoRequest<super::SystemSoundPlayRequest>,
-        ) -> std::result::Result<
-            tonic::Response<super::SystemSoundPlayResponse>,
-            tonic::Status,
-        > {
-            self.inner
-                .ready()
-                .await
-                .map_err(|e| {
-                    tonic::Status::unknown(
-                        format!("Service was not ready: {}", e.into()),
-                    )
-                })?;
+        ) -> std::result::Result<tonic::Response<super::SystemSoundPlayResponse>, tonic::Status>
+        {
+            self.inner.ready().await.map_err(|e| {
+                tonic::Status::unknown(format!("Service was not ready: {}", e.into()))
+            })?;
             let codec = tonic::codec::ProstCodec::default();
             let path = http::uri::PathAndQuery::from_static(
                 "/rockbox.v1alpha1.SoundService/SystemSoundPlay",
             );
             let mut req = request.into_request();
-            req.extensions_mut()
-                .insert(
-                    GrpcMethod::new("rockbox.v1alpha1.SoundService", "SystemSoundPlay"),
-                );
+            req.extensions_mut().insert(GrpcMethod::new(
+                "rockbox.v1alpha1.SoundService",
+                "SystemSoundPlay",
+            ));
             self.inner.unary(req, path, codec).await
         }
         pub async fn keyclick_click(
             &mut self,
             request: impl tonic::IntoRequest<super::KeyclickClickRequest>,
-        ) -> std::result::Result<
-            tonic::Response<super::KeyclickClickResponse>,
-            tonic::Status,
-        > {
-            self.inner
-                .ready()
-                .await
-                .map_err(|e| {
-                    tonic::Status::unknown(
-                        format!("Service was not ready: {}", e.into()),
-                    )
-                })?;
+        ) -> std::result::Result<tonic::Response<super::KeyclickClickResponse>, tonic::Status>
+        {
+            self.inner.ready().await.map_err(|e| {
+                tonic::Status::unknown(format!("Service was not ready: {}", e.into()))
+            })?;
             let codec = tonic::codec::ProstCodec::default();
             let path = http::uri::PathAndQuery::from_static(
                 "/rockbox.v1alpha1.SoundService/KeyclickClick",
             );
             let mut req = request.into_request();
-            req.extensions_mut()
-                .insert(
-                    GrpcMethod::new("rockbox.v1alpha1.SoundService", "KeyclickClick"),
-                );
+            req.extensions_mut().insert(GrpcMethod::new(
+                "rockbox.v1alpha1.SoundService",
+                "KeyclickClick",
+            ));
             self.inner.unary(req, path, codec).await
         }
     }
···
         dead_code,
         missing_docs,
         clippy::wildcard_imports,
-        clippy::let_unit_value,
+        clippy::let_unit_value
     )]
     use tonic::codegen::*;
     /// Generated trait containing gRPC methods that should be implemented for use with SoundServiceServer.
···
         async fn adjust_volume(
             &self,
             request: tonic::Request<super::AdjustVolumeRequest>,
-        ) -> std::result::Result<
-            tonic::Response<super::AdjustVolumeResponse>,
-            tonic::Status,
-        >;
+        ) -> 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,
-        >;
+        ) -> 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,
-        >;
+        ) -> 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,
-        >;
+        ) -> 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,
-        >;
+        ) -> 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,
-        >;
+        ) -> 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,
-        >;
+        ) -> 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,
-        >;
+        ) -> 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,
-        >;
+        ) -> 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,
-        >;
+        ) -> 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,
-        >;
+        ) -> 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,
-        >;
+        ) -> 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,
-        >;
+        ) -> 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,
-        >;
+        ) -> 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,
-        >;
+        ) -> std::result::Result<tonic::Response<super::KeyclickClickResponse>, tonic::Status>;
     }
     #[derive(Debug)]
     pub struct SoundServiceServer<T> {
···
                 max_encoding_message_size: None,
             }
         }
-        pub fn with_interceptor<F>(
-            inner: T,
-            interceptor: F,
-        ) -> InterceptedService<Self, F>
+        pub fn with_interceptor<F>(inner: T, interceptor: F) -> InterceptedService<Self, F>
         where
             F: tonic::service::Interceptor,
         {
···
                 "/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> {
+                    impl<T: SoundService> tonic::server::UnaryService<super::AdjustVolumeRequest>
+                        for AdjustVolumeSvc<T>
+                    {
                         type Response = super::AdjustVolumeResponse;
-                        type Future = BoxFuture<
-                            tonic::Response<Self::Response>,
-                            tonic::Status,
-                        >;
+                        type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
                         fn call(
                             &mut self,
                             request: tonic::Request<super::AdjustVolumeRequest>,
···
                 "/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> {
+                    impl<T: SoundService> tonic::server::UnaryService<super::SoundSetRequest> for SoundSetSvc<T> {
                         type Response = super::SoundSetResponse;
-                        type Future = BoxFuture<
-                            tonic::Response<Self::Response>,
-                            tonic::Status,
-                        >;
+                        type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
                         fn call(
                             &mut self,
                             request: tonic::Request<super::SoundSetRequest>,
···
                 "/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> {
+                    impl<T: SoundService> tonic::server::UnaryService<super::SoundCurrentRequest>
+                        for SoundCurrentSvc<T>
+                    {
                         type Response = super::SoundCurrentResponse;
-                        type Future = BoxFuture<
-                            tonic::Response<Self::Response>,
-                            tonic::Status,
-                        >;
+                        type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
                         fn call(
                             &mut self,
                             request: tonic::Request<super::SoundCurrentRequest>,
···
                 "/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> {
+                    impl<T: SoundService> tonic::server::UnaryService<super::SoundDefaultRequest>
+                        for SoundDefaultSvc<T>
+                    {
                         type Response = super::SoundDefaultResponse;
-                        type Future = BoxFuture<
-                            tonic::Response<Self::Response>,
-                            tonic::Status,
-                        >;
+                        type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
                         fn call(
                             &mut self,
                             request: tonic::Request<super::SoundDefaultRequest>,
···
                 "/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> {
+                    impl<T: SoundService> tonic::server::UnaryService<super::SoundMinRequest> for SoundMinSvc<T> {
                         type Response = super::SoundMinResponse;
-                        type Future = BoxFuture<
-                            tonic::Response<Self::Response>,
-                            tonic::Status,
-                        >;
+                        type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
                         fn call(
                             &mut self,
                             request: tonic::Request<super::SoundMinRequest>,
···
                 "/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> {
+                    impl<T: SoundService> tonic::server::UnaryService<super::SoundMaxRequest> for SoundMaxSvc<T> {
                         type Response = super::SoundMaxResponse;
-                        type Future = BoxFuture<
-                            tonic::Response<Self::Response>,
-                            tonic::Status,
-                        >;
+                        type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
                         fn call(
                             &mut self,
                             request: tonic::Request<super::SoundMaxRequest>,
···
                 "/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> {
+                    impl<T: SoundService> tonic::server::UnaryService<super::SoundUnitRequest> for SoundUnitSvc<T> {
                         type Response = super::SoundUnitResponse;
-                        type Future = BoxFuture<
-                            tonic::Response<Self::Response>,
-                            tonic::Status,
-                        >;
+                        type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
                         fn call(
                             &mut self,
                             request: tonic::Request<super::SoundUnitRequest>,
···
                 "/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> {
+                    impl<T: SoundService> tonic::server::UnaryService<super::SoundVal2PhysRequest>
+                        for SoundVal2PhysSvc<T>
+                    {
                         type Response = super::SoundVal2PhysResponse;
-                        type Future = BoxFuture<
-                            tonic::Response<Self::Response>,
-                            tonic::Status,
-                        >;
+                        type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
                         fn call(
                             &mut self,
                             request: tonic::Request<super::SoundVal2PhysRequest>,
···
                 "/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> {
+                    impl<T: SoundService> tonic::server::UnaryService<super::GetPitchRequest> for GetPitchSvc<T> {
                         type Response = super::GetPitchResponse;
-                        type Future = BoxFuture<
-                            tonic::Response<Self::Response>,
-                            tonic::Status,
-                        >;
+                        type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
                         fn call(
                             &mut self,
                             request: tonic::Request<super::GetPitchRequest>,
···
                 "/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> {
+                    impl<T: SoundService> tonic::server::UnaryService<super::SetPitchRequest> for SetPitchSvc<T> {
                         type Response = super::SetPitchResponse;
-                        type Future = BoxFuture<
-                            tonic::Response<Self::Response>,
-                            tonic::Status,
-                        >;
+                        type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
                         fn call(
                             &mut self,
                             request: tonic::Request<super::SetPitchRequest>,
···
                 "/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> {
+                    impl<T: SoundService> tonic::server::UnaryService<super::BeepPlayRequest> for BeepPlaySvc<T> {
                         type Response = super::BeepPlayResponse;
-                        type Future = BoxFuture<
-                            tonic::Response<Self::Response>,
-                            tonic::Status,
-                        >;
+                        type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
                         fn call(
                             &mut self,
                             request: tonic::Request<super::BeepPlayRequest>,
···
                 "/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> {
+                    impl<T: SoundService> tonic::server::UnaryService<super::PcmbufFadeRequest> for PcmbufFadeSvc<T> {
                         type Response = super::PcmbufFadeResponse;
-                        type Future = BoxFuture<
-                            tonic::Response<Self::Response>,
-                            tonic::Status,
-                        >;
+                        type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
                         fn call(
                             &mut self,
                             request: tonic::Request<super::PcmbufFadeRequest>,
···
                 "/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> {
+                    impl<T: SoundService>
+                        tonic::server::UnaryService<super::PcmbufSetLowLatencyRequest>
+                        for PcmbufSetLowLatencySvc<T>
+                    {
                         type Response = super::PcmbufSetLowLatencyResponse;
-                        type Future = BoxFuture<
-                            tonic::Response<Self::Response>,
-                            tonic::Status,
-                        >;
+                        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
+                                <T as SoundService>::pcmbuf_set_low_latency(&inner, request).await
                             };
                             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> {
+                    impl<T: SoundService> tonic::server::UnaryService<super::SystemSoundPlayRequest>
+                        for SystemSoundPlaySvc<T>
+                    {
                         type Response = super::SystemSoundPlayResponse;
-                        type Future = BoxFuture<
-                            tonic::Response<Self::Response>,
-                            tonic::Status,
-                        >;
+                        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
+                                <T as SoundService>::system_sound_play(&inner, request).await
                             };
                             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> {
+                    impl<T: SoundService> tonic::server::UnaryService<super::KeyclickClickRequest>
+                        for KeyclickClickSvc<T>
+                    {
                         type Response = super::KeyclickClickResponse;
-                        type Future = BoxFuture<
-                            tonic::Response<Self::Response>,
-                            tonic::Status,
-                        >;
+                        type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
                         fn call(
                             &mut self,
                             request: tonic::Request<super::KeyclickClickRequest>,
···
                     };
                     Box::pin(fut)
                 }
-                _ => {
-                    Box::pin(async move {
-                        let mut response = http::Response::new(empty_body());
-                        let headers = response.headers_mut();
-                        headers
-                            .insert(
-                                tonic::Status::GRPC_STATUS,
-                                (tonic::Code::Unimplemented as i32).into(),
-                            );
-                        headers
-                            .insert(
-                                http::header::CONTENT_TYPE,
-                                tonic::metadata::GRPC_CONTENT_TYPE,
-                            );
-                        Ok(response)
-                    })
-                }
+                _ => Box::pin(async move {
+                    let mut response = http::Response::new(empty_body());
+                    let headers = response.headers_mut();
+                    headers.insert(
+                        tonic::Status::GRPC_STATUS,
+                        (tonic::Code::Unimplemented as i32).into(),
+                    );
+                    headers.insert(
+                        http::header::CONTENT_TYPE,
+                        tonic::metadata::GRPC_CONTENT_TYPE,
+                    );
+                    Ok(response)
+                }),
             }
         }
     }
···
         dead_code,
         missing_docs,
         clippy::wildcard_imports,
-        clippy::let_unit_value,
+        clippy::let_unit_value
     )]
+    use tonic::codegen::http::Uri;
     use tonic::codegen::*;
-    use tonic::codegen::http::Uri;
     #[derive(Debug, Clone)]
     pub struct SystemServiceClient<T> {
         inner: tonic::client::Grpc<T>,
···
                     <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,
+            <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))
         }
···
         pub async fn get_rockbox_version(
             &mut self,
             request: impl tonic::IntoRequest<super::GetRockboxVersionRequest>,
-        ) -> std::result::Result<
-            tonic::Response<super::GetRockboxVersionResponse>,
-            tonic::Status,
-        > {
-            self.inner
-                .ready()
-                .await
-                .map_err(|e| {
-                    tonic::Status::unknown(
-                        format!("Service was not ready: {}", e.into()),
-                    )
-                })?;
+        ) -> std::result::Result<tonic::Response<super::GetRockboxVersionResponse>, tonic::Status>
+        {
+            self.inner.ready().await.map_err(|e| {
+                tonic::Status::unknown(format!("Service was not ready: {}", e.into()))
+            })?;
             let codec = tonic::codec::ProstCodec::default();
             let path = http::uri::PathAndQuery::from_static(
                 "/rockbox.v1alpha1.SystemService/GetRockboxVersion",
             );
             let mut req = request.into_request();
-            req.extensions_mut()
-                .insert(
-                    GrpcMethod::new(
-                        "rockbox.v1alpha1.SystemService",
-                        "GetRockboxVersion",
-                    ),
-                );
+            req.extensions_mut().insert(GrpcMethod::new(
+                "rockbox.v1alpha1.SystemService",
+                "GetRockboxVersion",
+            ));
             self.inner.unary(req, path, codec).await
         }
         pub async fn get_global_status(
             &mut self,
             request: impl tonic::IntoRequest<super::GetGlobalStatusRequest>,
-        ) -> std::result::Result<
-            tonic::Response<super::GetGlobalStatusResponse>,
-            tonic::Status,
-        > {
-            self.inner
-                .ready()
-                .await
-                .map_err(|e| {
-                    tonic::Status::unknown(
-                        format!("Service was not ready: {}", e.into()),
-                    )
-                })?;
+        ) -> std::result::Result<tonic::Response<super::GetGlobalStatusResponse>, tonic::Status>
+        {
+            self.inner.ready().await.map_err(|e| {
+                tonic::Status::unknown(format!("Service was not ready: {}", e.into()))
+            })?;
             let codec = tonic::codec::ProstCodec::default();
             let path = http::uri::PathAndQuery::from_static(
                 "/rockbox.v1alpha1.SystemService/GetGlobalStatus",
             );
             let mut req = request.into_request();
-            req.extensions_mut()
-                .insert(
-                    GrpcMethod::new("rockbox.v1alpha1.SystemService", "GetGlobalStatus"),
-                );
+            req.extensions_mut().insert(GrpcMethod::new(
+                "rockbox.v1alpha1.SystemService",
+                "GetGlobalStatus",
+            ));
             self.inner.unary(req, path, codec).await
         }
     }
···
         dead_code,
         missing_docs,
         clippy::wildcard_imports,
-        clippy::let_unit_value,
+        clippy::let_unit_value
     )]
     use tonic::codegen::*;
     /// Generated trait containing gRPC methods that should be implemented for use with SystemServiceServer.
···
         async fn get_rockbox_version(
             &self,
             request: tonic::Request<super::GetRockboxVersionRequest>,
-        ) -> std::result::Result<
-            tonic::Response<super::GetRockboxVersionResponse>,
-            tonic::Status,
-        >;
+        ) -> 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,
-        >;
+        ) -> std::result::Result<tonic::Response<super::GetGlobalStatusResponse>, tonic::Status>;
     }
     #[derive(Debug)]
     pub struct SystemServiceServer<T> {
···
                 max_encoding_message_size: None,
             }
         }
-        pub fn with_interceptor<F>(
-            inner: T,
-            interceptor: F,
-        ) -> InterceptedService<Self, F>
+        pub fn with_interceptor<F>(inner: T, interceptor: F) -> InterceptedService<Self, F>
         where
             F: tonic::service::Interceptor,
         {
···
                 "/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> {
+                    impl<T: SystemService>
+                        tonic::server::UnaryService<super::GetRockboxVersionRequest>
+                        for GetRockboxVersionSvc<T>
+                    {
                         type Response = super::GetRockboxVersionResponse;
-                        type Future = BoxFuture<
-                            tonic::Response<Self::Response>,
-                            tonic::Status,
-                        >;
+                        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
+                                <T as SystemService>::get_rockbox_version(&inner, request).await
                             };
                             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> {
+                    impl<T: SystemService>
+                        tonic::server::UnaryService<super::GetGlobalStatusRequest>
+                        for GetGlobalStatusSvc<T>
+                    {
                         type Response = super::GetGlobalStatusResponse;
-                        type Future = BoxFuture<
-                            tonic::Response<Self::Response>,
-                            tonic::Status,
-                        >;
+                        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
+                                <T as SystemService>::get_global_status(&inner, request).await
                             };
                             Box::pin(fut)
                         }
···
                     };
                     Box::pin(fut)
                 }
-                _ => {
-                    Box::pin(async move {
-                        let mut response = http::Response::new(empty_body());
-                        let headers = response.headers_mut();
-                        headers
-                            .insert(
-                                tonic::Status::GRPC_STATUS,
-                                (tonic::Code::Unimplemented as i32).into(),
-                            );
-                        headers
-                            .insert(
-                                http::header::CONTENT_TYPE,
-                                tonic::metadata::GRPC_CONTENT_TYPE,
-                            );
-                        Ok(response)
-                    })
-                }
+                _ => Box::pin(async move {
+                    let mut response = http::Response::new(empty_body());
+                    let headers = response.headers_mut();
+                    headers.insert(
+                        tonic::Status::GRPC_STATUS,
+                        (tonic::Code::Unimplemented as i32).into(),
+                    );
+                    headers.insert(
+                        http::header::CONTENT_TYPE,
+                        tonic::metadata::GRPC_CONTENT_TYPE,
+                    );
+                    Ok(response)
+                }),
             }
         }
     }

macos/.gitignore

···
+build
+dmg_temp
+*.dmg

macos/ExportOptions.plist

···
+<?xml version="1.0" encoding="UTF-8"?>
+   <!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+   <plist version="1.0">
+   <dict>
+       <key>method</key>
+       <string>mac-application</string>
+       <key>signingStyle</key>
+       <string>automatic</string>
+   </dict>
+</plist>

macos/Rockbox/RockboxApp.swift

···
 //
 //  Created by Tsiry Sandratraina on 13/12/2025.
 //
-
 import SwiftUI
 
 @main
···
     @StateObject private var player = PlayerState()
     @StateObject private var navigation = NavigationManager()
     @StateObject private var searchManager = SearchManager()
+    @State private var startupFailed = false
+    @State private var startupError: Error?
     
     var body: some Scene {
         WindowGroup {
···
                 .environmentObject(player)
                 .environmentObject(navigation)
                 .environmentObject(searchManager)
-                .task {
-                    player.startStreaming()
+                .alert("Connection Failed", isPresented: $startupFailed) {
+                    Button("Retry") {
+                        retry()
+                    }
+                    .keyboardShortcut(.defaultAction)
+                    
+                    Button("Quit") {
+                        NSApplication.shared.terminate(nil)
+                    }
+                    .keyboardShortcut(.cancelAction)
+                } message: {
+                    Text(startupError?.localizedDescription ?? "Failed to connect to the server. Please make sure the Rockbox server is running.")
                 }
                 .task {
-                    player.fetchSettings()
+                    await performStartup()
                 }
         }
         .windowStyle(.hiddenTitleBar)
+    }
+    
+    private func performStartup() async {
+        do {
+            // Check if server is available first
+            _ = try await fetchGlobalStatus()
+            
+            // If successful, start normal operations
+            player.startStreaming()
+            player.fetchSettings()
+            
+        } catch {
+            // Show error and allow retry or quit
+            startupError = error
+            startupFailed = true
+        }
+    }
+    
+    private func retry() {
+        Task {
+            await performStartup()
+        }
     }
 }