tsiry-sandratraina.com / rockbox-zig
Rockbox open source high quality audio player as a Music Player Daemon
mpris rockbox mpd libadwaita audio rust zig deno
2
fork

Configure Feed

Select the types of activity you want to include in your feed.

Reformat generated upnp gRPC code

Regenerate/format tonic-generated code for the UPnP rockbox proto.
Changes are whitespace, import ordering and line-wrapping only; no logic
changes.

Tsiry Sandratraina 4d60481d 93e0fc85

+1255 -2532
+1255 -2532
crates/upnp/src/api/rockbox.v1alpha1.rs
··· 43 43 dead_code, 44 44 missing_docs, 45 45 clippy::wildcard_imports, 46 - clippy::let_unit_value, 46 + clippy::let_unit_value 47 47 )] 48 - use tonic::codegen::*; 49 48 use tonic::codegen::http::Uri; 49 + use tonic::codegen::*; 50 50 #[derive(Debug, Clone)] 51 51 pub struct BrowseServiceClient<T> { 52 52 inner: tonic::client::Grpc<T>, ··· 90 90 <T as tonic::client::GrpcService<tonic::body::BoxBody>>::ResponseBody, 91 91 >, 92 92 >, 93 - <T as tonic::codegen::Service< 94 - http::Request<tonic::body::BoxBody>, 95 - >>::Error: Into<StdError> + std::marker::Send + std::marker::Sync, 93 + <T as tonic::codegen::Service<http::Request<tonic::body::BoxBody>>>::Error: 94 + Into<StdError> + std::marker::Send + std::marker::Sync, 96 95 { 97 96 BrowseServiceClient::new(InterceptedService::new(inner, interceptor)) 98 97 } ··· 130 129 pub async fn tree_get_entries( 131 130 &mut self, 132 131 request: impl tonic::IntoRequest<super::TreeGetEntriesRequest>, 133 - ) -> std::result::Result< 134 - tonic::Response<super::TreeGetEntriesResponse>, 135 - tonic::Status, 136 - > { 137 - self.inner 138 - .ready() 139 - .await 140 - .map_err(|e| { 141 - tonic::Status::unknown( 142 - format!("Service was not ready: {}", e.into()), 143 - ) 144 - })?; 132 + ) -> std::result::Result<tonic::Response<super::TreeGetEntriesResponse>, tonic::Status> 133 + { 134 + self.inner.ready().await.map_err(|e| { 135 + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 136 + })?; 145 137 let codec = tonic::codec::ProstCodec::default(); 146 138 let path = http::uri::PathAndQuery::from_static( 147 139 "/rockbox.v1alpha1.BrowseService/TreeGetEntries", 148 140 ); 149 141 let mut req = request.into_request(); 150 - req.extensions_mut() 151 - .insert( 152 - GrpcMethod::new("rockbox.v1alpha1.BrowseService", "TreeGetEntries"), 153 - ); 142 + req.extensions_mut().insert(GrpcMethod::new( 143 + "rockbox.v1alpha1.BrowseService", 144 + "TreeGetEntries", 145 + )); 154 146 self.inner.unary(req, path, codec).await 155 147 } 156 148 } ··· 162 154 dead_code, 163 155 missing_docs, 164 156 clippy::wildcard_imports, 165 - clippy::let_unit_value, 157 + clippy::let_unit_value 166 158 )] 167 159 use tonic::codegen::*; 168 160 /// Generated trait containing gRPC methods that should be implemented for use with BrowseServiceServer. ··· 171 163 async fn tree_get_entries( 172 164 &self, 173 165 request: tonic::Request<super::TreeGetEntriesRequest>, 174 - ) -> std::result::Result< 175 - tonic::Response<super::TreeGetEntriesResponse>, 176 - tonic::Status, 177 - >; 166 + ) -> std::result::Result<tonic::Response<super::TreeGetEntriesResponse>, tonic::Status>; 178 167 } 179 168 #[derive(Debug)] 180 169 pub struct BrowseServiceServer<T> { ··· 197 186 max_encoding_message_size: None, 198 187 } 199 188 } 200 - pub fn with_interceptor<F>( 201 - inner: T, 202 - interceptor: F, 203 - ) -> InterceptedService<Self, F> 189 + pub fn with_interceptor<F>(inner: T, interceptor: F) -> InterceptedService<Self, F> 204 190 where 205 191 F: tonic::service::Interceptor, 206 192 { ··· 255 241 "/rockbox.v1alpha1.BrowseService/TreeGetEntries" => { 256 242 #[allow(non_camel_case_types)] 257 243 struct TreeGetEntriesSvc<T: BrowseService>(pub Arc<T>); 258 - impl< 259 - T: BrowseService, 260 - > tonic::server::UnaryService<super::TreeGetEntriesRequest> 261 - for TreeGetEntriesSvc<T> { 244 + impl<T: BrowseService> tonic::server::UnaryService<super::TreeGetEntriesRequest> 245 + for TreeGetEntriesSvc<T> 246 + { 262 247 type Response = super::TreeGetEntriesResponse; 263 - type Future = BoxFuture< 264 - tonic::Response<Self::Response>, 265 - tonic::Status, 266 - >; 248 + type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 267 249 fn call( 268 250 &mut self, 269 251 request: tonic::Request<super::TreeGetEntriesRequest>, 270 252 ) -> Self::Future { 271 253 let inner = Arc::clone(&self.0); 272 254 let fut = async move { 273 - <T as BrowseService>::tree_get_entries(&inner, request) 274 - .await 255 + <T as BrowseService>::tree_get_entries(&inner, request).await 275 256 }; 276 257 Box::pin(fut) 277 258 } ··· 298 279 }; 299 280 Box::pin(fut) 300 281 } 301 - _ => { 302 - Box::pin(async move { 303 - let mut response = http::Response::new(empty_body()); 304 - let headers = response.headers_mut(); 305 - headers 306 - .insert( 307 - tonic::Status::GRPC_STATUS, 308 - (tonic::Code::Unimplemented as i32).into(), 309 - ); 310 - headers 311 - .insert( 312 - http::header::CONTENT_TYPE, 313 - tonic::metadata::GRPC_CONTENT_TYPE, 314 - ); 315 - Ok(response) 316 - }) 317 - } 282 + _ => Box::pin(async move { 283 + let mut response = http::Response::new(empty_body()); 284 + let headers = response.headers_mut(); 285 + headers.insert( 286 + tonic::Status::GRPC_STATUS, 287 + (tonic::Code::Unimplemented as i32).into(), 288 + ); 289 + headers.insert( 290 + http::header::CONTENT_TYPE, 291 + tonic::metadata::GRPC_CONTENT_TYPE, 292 + ); 293 + Ok(response) 294 + }), 318 295 } 319 296 } 320 297 } ··· 571 548 dead_code, 572 549 missing_docs, 573 550 clippy::wildcard_imports, 574 - clippy::let_unit_value, 551 + clippy::let_unit_value 575 552 )] 576 - use tonic::codegen::*; 577 553 use tonic::codegen::http::Uri; 554 + use tonic::codegen::*; 578 555 #[derive(Debug, Clone)] 579 556 pub struct LibraryServiceClient<T> { 580 557 inner: tonic::client::Grpc<T>, ··· 618 595 <T as tonic::client::GrpcService<tonic::body::BoxBody>>::ResponseBody, 619 596 >, 620 597 >, 621 - <T as tonic::codegen::Service< 622 - http::Request<tonic::body::BoxBody>, 623 - >>::Error: Into<StdError> + std::marker::Send + std::marker::Sync, 598 + <T as tonic::codegen::Service<http::Request<tonic::body::BoxBody>>>::Error: 599 + Into<StdError> + std::marker::Send + std::marker::Sync, 624 600 { 625 601 LibraryServiceClient::new(InterceptedService::new(inner, interceptor)) 626 602 } ··· 658 634 pub async fn get_albums( 659 635 &mut self, 660 636 request: impl tonic::IntoRequest<super::GetAlbumsRequest>, 661 - ) -> std::result::Result< 662 - tonic::Response<super::GetAlbumsResponse>, 663 - tonic::Status, 664 - > { 665 - self.inner 666 - .ready() 667 - .await 668 - .map_err(|e| { 669 - tonic::Status::unknown( 670 - format!("Service was not ready: {}", e.into()), 671 - ) 672 - })?; 637 + ) -> std::result::Result<tonic::Response<super::GetAlbumsResponse>, tonic::Status> { 638 + self.inner.ready().await.map_err(|e| { 639 + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 640 + })?; 673 641 let codec = tonic::codec::ProstCodec::default(); 674 - let path = http::uri::PathAndQuery::from_static( 675 - "/rockbox.v1alpha1.LibraryService/GetAlbums", 676 - ); 642 + let path = 643 + http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.LibraryService/GetAlbums"); 677 644 let mut req = request.into_request(); 678 - req.extensions_mut() 679 - .insert(GrpcMethod::new("rockbox.v1alpha1.LibraryService", "GetAlbums")); 645 + req.extensions_mut().insert(GrpcMethod::new( 646 + "rockbox.v1alpha1.LibraryService", 647 + "GetAlbums", 648 + )); 680 649 self.inner.unary(req, path, codec).await 681 650 } 682 651 pub async fn get_artists( 683 652 &mut self, 684 653 request: impl tonic::IntoRequest<super::GetArtistsRequest>, 685 - ) -> std::result::Result< 686 - tonic::Response<super::GetArtistsResponse>, 687 - tonic::Status, 688 - > { 689 - self.inner 690 - .ready() 691 - .await 692 - .map_err(|e| { 693 - tonic::Status::unknown( 694 - format!("Service was not ready: {}", e.into()), 695 - ) 696 - })?; 654 + ) -> std::result::Result<tonic::Response<super::GetArtistsResponse>, tonic::Status> 655 + { 656 + self.inner.ready().await.map_err(|e| { 657 + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 658 + })?; 697 659 let codec = tonic::codec::ProstCodec::default(); 698 - let path = http::uri::PathAndQuery::from_static( 699 - "/rockbox.v1alpha1.LibraryService/GetArtists", 700 - ); 660 + let path = 661 + http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.LibraryService/GetArtists"); 701 662 let mut req = request.into_request(); 702 - req.extensions_mut() 703 - .insert( 704 - GrpcMethod::new("rockbox.v1alpha1.LibraryService", "GetArtists"), 705 - ); 663 + req.extensions_mut().insert(GrpcMethod::new( 664 + "rockbox.v1alpha1.LibraryService", 665 + "GetArtists", 666 + )); 706 667 self.inner.unary(req, path, codec).await 707 668 } 708 669 pub async fn get_tracks( 709 670 &mut self, 710 671 request: impl tonic::IntoRequest<super::GetTracksRequest>, 711 - ) -> std::result::Result< 712 - tonic::Response<super::GetTracksResponse>, 713 - tonic::Status, 714 - > { 715 - self.inner 716 - .ready() 717 - .await 718 - .map_err(|e| { 719 - tonic::Status::unknown( 720 - format!("Service was not ready: {}", e.into()), 721 - ) 722 - })?; 672 + ) -> std::result::Result<tonic::Response<super::GetTracksResponse>, tonic::Status> { 673 + self.inner.ready().await.map_err(|e| { 674 + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 675 + })?; 723 676 let codec = tonic::codec::ProstCodec::default(); 724 - let path = http::uri::PathAndQuery::from_static( 725 - "/rockbox.v1alpha1.LibraryService/GetTracks", 726 - ); 677 + let path = 678 + http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.LibraryService/GetTracks"); 727 679 let mut req = request.into_request(); 728 - req.extensions_mut() 729 - .insert(GrpcMethod::new("rockbox.v1alpha1.LibraryService", "GetTracks")); 680 + req.extensions_mut().insert(GrpcMethod::new( 681 + "rockbox.v1alpha1.LibraryService", 682 + "GetTracks", 683 + )); 730 684 self.inner.unary(req, path, codec).await 731 685 } 732 686 pub async fn get_album( 733 687 &mut self, 734 688 request: impl tonic::IntoRequest<super::GetAlbumRequest>, 735 - ) -> std::result::Result< 736 - tonic::Response<super::GetAlbumResponse>, 737 - tonic::Status, 738 - > { 739 - self.inner 740 - .ready() 741 - .await 742 - .map_err(|e| { 743 - tonic::Status::unknown( 744 - format!("Service was not ready: {}", e.into()), 745 - ) 746 - })?; 689 + ) -> std::result::Result<tonic::Response<super::GetAlbumResponse>, tonic::Status> { 690 + self.inner.ready().await.map_err(|e| { 691 + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 692 + })?; 747 693 let codec = tonic::codec::ProstCodec::default(); 748 - let path = http::uri::PathAndQuery::from_static( 749 - "/rockbox.v1alpha1.LibraryService/GetAlbum", 750 - ); 694 + let path = 695 + http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.LibraryService/GetAlbum"); 751 696 let mut req = request.into_request(); 752 - req.extensions_mut() 753 - .insert(GrpcMethod::new("rockbox.v1alpha1.LibraryService", "GetAlbum")); 697 + req.extensions_mut().insert(GrpcMethod::new( 698 + "rockbox.v1alpha1.LibraryService", 699 + "GetAlbum", 700 + )); 754 701 self.inner.unary(req, path, codec).await 755 702 } 756 703 pub async fn get_artist( 757 704 &mut self, 758 705 request: impl tonic::IntoRequest<super::GetArtistRequest>, 759 - ) -> std::result::Result< 760 - tonic::Response<super::GetArtistResponse>, 761 - tonic::Status, 762 - > { 763 - self.inner 764 - .ready() 765 - .await 766 - .map_err(|e| { 767 - tonic::Status::unknown( 768 - format!("Service was not ready: {}", e.into()), 769 - ) 770 - })?; 706 + ) -> std::result::Result<tonic::Response<super::GetArtistResponse>, tonic::Status> { 707 + self.inner.ready().await.map_err(|e| { 708 + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 709 + })?; 771 710 let codec = tonic::codec::ProstCodec::default(); 772 - let path = http::uri::PathAndQuery::from_static( 773 - "/rockbox.v1alpha1.LibraryService/GetArtist", 774 - ); 711 + let path = 712 + http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.LibraryService/GetArtist"); 775 713 let mut req = request.into_request(); 776 - req.extensions_mut() 777 - .insert(GrpcMethod::new("rockbox.v1alpha1.LibraryService", "GetArtist")); 714 + req.extensions_mut().insert(GrpcMethod::new( 715 + "rockbox.v1alpha1.LibraryService", 716 + "GetArtist", 717 + )); 778 718 self.inner.unary(req, path, codec).await 779 719 } 780 720 pub async fn get_track( 781 721 &mut self, 782 722 request: impl tonic::IntoRequest<super::GetTrackRequest>, 783 - ) -> std::result::Result< 784 - tonic::Response<super::GetTrackResponse>, 785 - tonic::Status, 786 - > { 787 - self.inner 788 - .ready() 789 - .await 790 - .map_err(|e| { 791 - tonic::Status::unknown( 792 - format!("Service was not ready: {}", e.into()), 793 - ) 794 - })?; 723 + ) -> std::result::Result<tonic::Response<super::GetTrackResponse>, tonic::Status> { 724 + self.inner.ready().await.map_err(|e| { 725 + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 726 + })?; 795 727 let codec = tonic::codec::ProstCodec::default(); 796 - let path = http::uri::PathAndQuery::from_static( 797 - "/rockbox.v1alpha1.LibraryService/GetTrack", 798 - ); 728 + let path = 729 + http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.LibraryService/GetTrack"); 799 730 let mut req = request.into_request(); 800 - req.extensions_mut() 801 - .insert(GrpcMethod::new("rockbox.v1alpha1.LibraryService", "GetTrack")); 731 + req.extensions_mut().insert(GrpcMethod::new( 732 + "rockbox.v1alpha1.LibraryService", 733 + "GetTrack", 734 + )); 802 735 self.inner.unary(req, path, codec).await 803 736 } 804 737 pub async fn like_track( 805 738 &mut self, 806 739 request: impl tonic::IntoRequest<super::LikeTrackRequest>, 807 - ) -> std::result::Result< 808 - tonic::Response<super::LikeTrackResponse>, 809 - tonic::Status, 810 - > { 811 - self.inner 812 - .ready() 813 - .await 814 - .map_err(|e| { 815 - tonic::Status::unknown( 816 - format!("Service was not ready: {}", e.into()), 817 - ) 818 - })?; 740 + ) -> std::result::Result<tonic::Response<super::LikeTrackResponse>, tonic::Status> { 741 + self.inner.ready().await.map_err(|e| { 742 + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 743 + })?; 819 744 let codec = tonic::codec::ProstCodec::default(); 820 - let path = http::uri::PathAndQuery::from_static( 821 - "/rockbox.v1alpha1.LibraryService/LikeTrack", 822 - ); 745 + let path = 746 + http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.LibraryService/LikeTrack"); 823 747 let mut req = request.into_request(); 824 - req.extensions_mut() 825 - .insert(GrpcMethod::new("rockbox.v1alpha1.LibraryService", "LikeTrack")); 748 + req.extensions_mut().insert(GrpcMethod::new( 749 + "rockbox.v1alpha1.LibraryService", 750 + "LikeTrack", 751 + )); 826 752 self.inner.unary(req, path, codec).await 827 753 } 828 754 pub async fn unlike_track( 829 755 &mut self, 830 756 request: impl tonic::IntoRequest<super::UnlikeTrackRequest>, 831 - ) -> std::result::Result< 832 - tonic::Response<super::UnlikeTrackResponse>, 833 - tonic::Status, 834 - > { 835 - self.inner 836 - .ready() 837 - .await 838 - .map_err(|e| { 839 - tonic::Status::unknown( 840 - format!("Service was not ready: {}", e.into()), 841 - ) 842 - })?; 757 + ) -> std::result::Result<tonic::Response<super::UnlikeTrackResponse>, tonic::Status> 758 + { 759 + self.inner.ready().await.map_err(|e| { 760 + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 761 + })?; 843 762 let codec = tonic::codec::ProstCodec::default(); 844 763 let path = http::uri::PathAndQuery::from_static( 845 764 "/rockbox.v1alpha1.LibraryService/UnlikeTrack", 846 765 ); 847 766 let mut req = request.into_request(); 848 - req.extensions_mut() 849 - .insert( 850 - GrpcMethod::new("rockbox.v1alpha1.LibraryService", "UnlikeTrack"), 851 - ); 767 + req.extensions_mut().insert(GrpcMethod::new( 768 + "rockbox.v1alpha1.LibraryService", 769 + "UnlikeTrack", 770 + )); 852 771 self.inner.unary(req, path, codec).await 853 772 } 854 773 pub async fn like_album( 855 774 &mut self, 856 775 request: impl tonic::IntoRequest<super::LikeAlbumRequest>, 857 - ) -> std::result::Result< 858 - tonic::Response<super::LikeAlbumResponse>, 859 - tonic::Status, 860 - > { 861 - self.inner 862 - .ready() 863 - .await 864 - .map_err(|e| { 865 - tonic::Status::unknown( 866 - format!("Service was not ready: {}", e.into()), 867 - ) 868 - })?; 776 + ) -> std::result::Result<tonic::Response<super::LikeAlbumResponse>, tonic::Status> { 777 + self.inner.ready().await.map_err(|e| { 778 + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 779 + })?; 869 780 let codec = tonic::codec::ProstCodec::default(); 870 - let path = http::uri::PathAndQuery::from_static( 871 - "/rockbox.v1alpha1.LibraryService/LikeAlbum", 872 - ); 781 + let path = 782 + http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.LibraryService/LikeAlbum"); 873 783 let mut req = request.into_request(); 874 - req.extensions_mut() 875 - .insert(GrpcMethod::new("rockbox.v1alpha1.LibraryService", "LikeAlbum")); 784 + req.extensions_mut().insert(GrpcMethod::new( 785 + "rockbox.v1alpha1.LibraryService", 786 + "LikeAlbum", 787 + )); 876 788 self.inner.unary(req, path, codec).await 877 789 } 878 790 pub async fn unlike_album( 879 791 &mut self, 880 792 request: impl tonic::IntoRequest<super::UnlikeAlbumRequest>, 881 - ) -> std::result::Result< 882 - tonic::Response<super::UnlikeAlbumResponse>, 883 - tonic::Status, 884 - > { 885 - self.inner 886 - .ready() 887 - .await 888 - .map_err(|e| { 889 - tonic::Status::unknown( 890 - format!("Service was not ready: {}", e.into()), 891 - ) 892 - })?; 793 + ) -> std::result::Result<tonic::Response<super::UnlikeAlbumResponse>, tonic::Status> 794 + { 795 + self.inner.ready().await.map_err(|e| { 796 + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 797 + })?; 893 798 let codec = tonic::codec::ProstCodec::default(); 894 799 let path = http::uri::PathAndQuery::from_static( 895 800 "/rockbox.v1alpha1.LibraryService/UnlikeAlbum", 896 801 ); 897 802 let mut req = request.into_request(); 898 - req.extensions_mut() 899 - .insert( 900 - GrpcMethod::new("rockbox.v1alpha1.LibraryService", "UnlikeAlbum"), 901 - ); 803 + req.extensions_mut().insert(GrpcMethod::new( 804 + "rockbox.v1alpha1.LibraryService", 805 + "UnlikeAlbum", 806 + )); 902 807 self.inner.unary(req, path, codec).await 903 808 } 904 809 pub async fn get_liked_tracks( 905 810 &mut self, 906 811 request: impl tonic::IntoRequest<super::GetLikedTracksRequest>, 907 - ) -> std::result::Result< 908 - tonic::Response<super::GetLikedTracksResponse>, 909 - tonic::Status, 910 - > { 911 - self.inner 912 - .ready() 913 - .await 914 - .map_err(|e| { 915 - tonic::Status::unknown( 916 - format!("Service was not ready: {}", e.into()), 917 - ) 918 - })?; 812 + ) -> std::result::Result<tonic::Response<super::GetLikedTracksResponse>, tonic::Status> 813 + { 814 + self.inner.ready().await.map_err(|e| { 815 + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 816 + })?; 919 817 let codec = tonic::codec::ProstCodec::default(); 920 818 let path = http::uri::PathAndQuery::from_static( 921 819 "/rockbox.v1alpha1.LibraryService/GetLikedTracks", 922 820 ); 923 821 let mut req = request.into_request(); 924 - req.extensions_mut() 925 - .insert( 926 - GrpcMethod::new("rockbox.v1alpha1.LibraryService", "GetLikedTracks"), 927 - ); 822 + req.extensions_mut().insert(GrpcMethod::new( 823 + "rockbox.v1alpha1.LibraryService", 824 + "GetLikedTracks", 825 + )); 928 826 self.inner.unary(req, path, codec).await 929 827 } 930 828 pub async fn get_liked_albums( 931 829 &mut self, 932 830 request: impl tonic::IntoRequest<super::GetLikedAlbumsRequest>, 933 - ) -> std::result::Result< 934 - tonic::Response<super::GetLikedAlbumsResponse>, 935 - tonic::Status, 936 - > { 937 - self.inner 938 - .ready() 939 - .await 940 - .map_err(|e| { 941 - tonic::Status::unknown( 942 - format!("Service was not ready: {}", e.into()), 943 - ) 944 - })?; 831 + ) -> std::result::Result<tonic::Response<super::GetLikedAlbumsResponse>, tonic::Status> 832 + { 833 + self.inner.ready().await.map_err(|e| { 834 + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 835 + })?; 945 836 let codec = tonic::codec::ProstCodec::default(); 946 837 let path = http::uri::PathAndQuery::from_static( 947 838 "/rockbox.v1alpha1.LibraryService/GetLikedAlbums", 948 839 ); 949 840 let mut req = request.into_request(); 950 - req.extensions_mut() 951 - .insert( 952 - GrpcMethod::new("rockbox.v1alpha1.LibraryService", "GetLikedAlbums"), 953 - ); 841 + req.extensions_mut().insert(GrpcMethod::new( 842 + "rockbox.v1alpha1.LibraryService", 843 + "GetLikedAlbums", 844 + )); 954 845 self.inner.unary(req, path, codec).await 955 846 } 956 847 pub async fn scan_library( 957 848 &mut self, 958 849 request: impl tonic::IntoRequest<super::ScanLibraryRequest>, 959 - ) -> std::result::Result< 960 - tonic::Response<super::ScanLibraryResponse>, 961 - tonic::Status, 962 - > { 963 - self.inner 964 - .ready() 965 - .await 966 - .map_err(|e| { 967 - tonic::Status::unknown( 968 - format!("Service was not ready: {}", e.into()), 969 - ) 970 - })?; 850 + ) -> std::result::Result<tonic::Response<super::ScanLibraryResponse>, tonic::Status> 851 + { 852 + self.inner.ready().await.map_err(|e| { 853 + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 854 + })?; 971 855 let codec = tonic::codec::ProstCodec::default(); 972 856 let path = http::uri::PathAndQuery::from_static( 973 857 "/rockbox.v1alpha1.LibraryService/ScanLibrary", 974 858 ); 975 859 let mut req = request.into_request(); 976 - req.extensions_mut() 977 - .insert( 978 - GrpcMethod::new("rockbox.v1alpha1.LibraryService", "ScanLibrary"), 979 - ); 860 + req.extensions_mut().insert(GrpcMethod::new( 861 + "rockbox.v1alpha1.LibraryService", 862 + "ScanLibrary", 863 + )); 980 864 self.inner.unary(req, path, codec).await 981 865 } 982 866 pub async fn stream_library( ··· 986 870 tonic::Response<tonic::codec::Streaming<super::StreamLibraryResponse>>, 987 871 tonic::Status, 988 872 > { 989 - self.inner 990 - .ready() 991 - .await 992 - .map_err(|e| { 993 - tonic::Status::unknown( 994 - format!("Service was not ready: {}", e.into()), 995 - ) 996 - })?; 873 + self.inner.ready().await.map_err(|e| { 874 + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 875 + })?; 997 876 let codec = tonic::codec::ProstCodec::default(); 998 877 let path = http::uri::PathAndQuery::from_static( 999 878 "/rockbox.v1alpha1.LibraryService/StreamLibrary", 1000 879 ); 1001 880 let mut req = request.into_request(); 1002 - req.extensions_mut() 1003 - .insert( 1004 - GrpcMethod::new("rockbox.v1alpha1.LibraryService", "StreamLibrary"), 1005 - ); 881 + req.extensions_mut().insert(GrpcMethod::new( 882 + "rockbox.v1alpha1.LibraryService", 883 + "StreamLibrary", 884 + )); 1006 885 self.inner.server_streaming(req, path, codec).await 1007 886 } 1008 887 pub async fn search( 1009 888 &mut self, 1010 889 request: impl tonic::IntoRequest<super::SearchRequest>, 1011 890 ) -> std::result::Result<tonic::Response<super::SearchResponse>, tonic::Status> { 1012 - self.inner 1013 - .ready() 1014 - .await 1015 - .map_err(|e| { 1016 - tonic::Status::unknown( 1017 - format!("Service was not ready: {}", e.into()), 1018 - ) 1019 - })?; 891 + self.inner.ready().await.map_err(|e| { 892 + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 893 + })?; 1020 894 let codec = tonic::codec::ProstCodec::default(); 1021 - let path = http::uri::PathAndQuery::from_static( 1022 - "/rockbox.v1alpha1.LibraryService/Search", 1023 - ); 895 + let path = 896 + http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.LibraryService/Search"); 1024 897 let mut req = request.into_request(); 1025 898 req.extensions_mut() 1026 899 .insert(GrpcMethod::new("rockbox.v1alpha1.LibraryService", "Search")); ··· 1035 908 dead_code, 1036 909 missing_docs, 1037 910 clippy::wildcard_imports, 1038 - clippy::let_unit_value, 911 + clippy::let_unit_value 1039 912 )] 1040 913 use tonic::codegen::*; 1041 914 /// Generated trait containing gRPC methods that should be implemented for use with LibraryServiceServer. ··· 1044 917 async fn get_albums( 1045 918 &self, 1046 919 request: tonic::Request<super::GetAlbumsRequest>, 1047 - ) -> std::result::Result< 1048 - tonic::Response<super::GetAlbumsResponse>, 1049 - tonic::Status, 1050 - >; 920 + ) -> std::result::Result<tonic::Response<super::GetAlbumsResponse>, tonic::Status>; 1051 921 async fn get_artists( 1052 922 &self, 1053 923 request: tonic::Request<super::GetArtistsRequest>, 1054 - ) -> std::result::Result< 1055 - tonic::Response<super::GetArtistsResponse>, 1056 - tonic::Status, 1057 - >; 924 + ) -> std::result::Result<tonic::Response<super::GetArtistsResponse>, tonic::Status>; 1058 925 async fn get_tracks( 1059 926 &self, 1060 927 request: tonic::Request<super::GetTracksRequest>, 1061 - ) -> std::result::Result< 1062 - tonic::Response<super::GetTracksResponse>, 1063 - tonic::Status, 1064 - >; 928 + ) -> std::result::Result<tonic::Response<super::GetTracksResponse>, tonic::Status>; 1065 929 async fn get_album( 1066 930 &self, 1067 931 request: tonic::Request<super::GetAlbumRequest>, 1068 - ) -> std::result::Result< 1069 - tonic::Response<super::GetAlbumResponse>, 1070 - tonic::Status, 1071 - >; 932 + ) -> std::result::Result<tonic::Response<super::GetAlbumResponse>, tonic::Status>; 1072 933 async fn get_artist( 1073 934 &self, 1074 935 request: tonic::Request<super::GetArtistRequest>, 1075 - ) -> std::result::Result< 1076 - tonic::Response<super::GetArtistResponse>, 1077 - tonic::Status, 1078 - >; 936 + ) -> std::result::Result<tonic::Response<super::GetArtistResponse>, tonic::Status>; 1079 937 async fn get_track( 1080 938 &self, 1081 939 request: tonic::Request<super::GetTrackRequest>, 1082 - ) -> std::result::Result< 1083 - tonic::Response<super::GetTrackResponse>, 1084 - tonic::Status, 1085 - >; 940 + ) -> std::result::Result<tonic::Response<super::GetTrackResponse>, tonic::Status>; 1086 941 async fn like_track( 1087 942 &self, 1088 943 request: tonic::Request<super::LikeTrackRequest>, 1089 - ) -> std::result::Result< 1090 - tonic::Response<super::LikeTrackResponse>, 1091 - tonic::Status, 1092 - >; 944 + ) -> std::result::Result<tonic::Response<super::LikeTrackResponse>, tonic::Status>; 1093 945 async fn unlike_track( 1094 946 &self, 1095 947 request: tonic::Request<super::UnlikeTrackRequest>, 1096 - ) -> std::result::Result< 1097 - tonic::Response<super::UnlikeTrackResponse>, 1098 - tonic::Status, 1099 - >; 948 + ) -> std::result::Result<tonic::Response<super::UnlikeTrackResponse>, tonic::Status>; 1100 949 async fn like_album( 1101 950 &self, 1102 951 request: tonic::Request<super::LikeAlbumRequest>, 1103 - ) -> std::result::Result< 1104 - tonic::Response<super::LikeAlbumResponse>, 1105 - tonic::Status, 1106 - >; 952 + ) -> std::result::Result<tonic::Response<super::LikeAlbumResponse>, tonic::Status>; 1107 953 async fn unlike_album( 1108 954 &self, 1109 955 request: tonic::Request<super::UnlikeAlbumRequest>, 1110 - ) -> std::result::Result< 1111 - tonic::Response<super::UnlikeAlbumResponse>, 1112 - tonic::Status, 1113 - >; 956 + ) -> std::result::Result<tonic::Response<super::UnlikeAlbumResponse>, tonic::Status>; 1114 957 async fn get_liked_tracks( 1115 958 &self, 1116 959 request: tonic::Request<super::GetLikedTracksRequest>, 1117 - ) -> std::result::Result< 1118 - tonic::Response<super::GetLikedTracksResponse>, 1119 - tonic::Status, 1120 - >; 960 + ) -> std::result::Result<tonic::Response<super::GetLikedTracksResponse>, tonic::Status>; 1121 961 async fn get_liked_albums( 1122 962 &self, 1123 963 request: tonic::Request<super::GetLikedAlbumsRequest>, 1124 - ) -> std::result::Result< 1125 - tonic::Response<super::GetLikedAlbumsResponse>, 1126 - tonic::Status, 1127 - >; 964 + ) -> std::result::Result<tonic::Response<super::GetLikedAlbumsResponse>, tonic::Status>; 1128 965 async fn scan_library( 1129 966 &self, 1130 967 request: tonic::Request<super::ScanLibraryRequest>, 1131 - ) -> std::result::Result< 1132 - tonic::Response<super::ScanLibraryResponse>, 1133 - tonic::Status, 1134 - >; 968 + ) -> std::result::Result<tonic::Response<super::ScanLibraryResponse>, tonic::Status>; 1135 969 /// Server streaming response type for the StreamLibrary method. 1136 970 type StreamLibraryStream: tonic::codegen::tokio_stream::Stream< 1137 971 Item = std::result::Result<super::StreamLibraryResponse, tonic::Status>, 1138 - > 1139 - + std::marker::Send 972 + > + std::marker::Send 1140 973 + 'static; 1141 974 async fn stream_library( 1142 975 &self, 1143 976 request: tonic::Request<super::StreamLibraryRequest>, 1144 - ) -> std::result::Result< 1145 - tonic::Response<Self::StreamLibraryStream>, 1146 - tonic::Status, 1147 - >; 977 + ) -> std::result::Result<tonic::Response<Self::StreamLibraryStream>, tonic::Status>; 1148 978 async fn search( 1149 979 &self, 1150 980 request: tonic::Request<super::SearchRequest>, ··· 1171 1001 max_encoding_message_size: None, 1172 1002 } 1173 1003 } 1174 - pub fn with_interceptor<F>( 1175 - inner: T, 1176 - interceptor: F, 1177 - ) -> InterceptedService<Self, F> 1004 + pub fn with_interceptor<F>(inner: T, interceptor: F) -> InterceptedService<Self, F> 1178 1005 where 1179 1006 F: tonic::service::Interceptor, 1180 1007 { ··· 1229 1056 "/rockbox.v1alpha1.LibraryService/GetAlbums" => { 1230 1057 #[allow(non_camel_case_types)] 1231 1058 struct GetAlbumsSvc<T: LibraryService>(pub Arc<T>); 1232 - impl< 1233 - T: LibraryService, 1234 - > tonic::server::UnaryService<super::GetAlbumsRequest> 1235 - for GetAlbumsSvc<T> { 1059 + impl<T: LibraryService> tonic::server::UnaryService<super::GetAlbumsRequest> for GetAlbumsSvc<T> { 1236 1060 type Response = super::GetAlbumsResponse; 1237 - type Future = BoxFuture< 1238 - tonic::Response<Self::Response>, 1239 - tonic::Status, 1240 - >; 1061 + type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 1241 1062 fn call( 1242 1063 &mut self, 1243 1064 request: tonic::Request<super::GetAlbumsRequest>, ··· 1274 1095 "/rockbox.v1alpha1.LibraryService/GetArtists" => { 1275 1096 #[allow(non_camel_case_types)] 1276 1097 struct GetArtistsSvc<T: LibraryService>(pub Arc<T>); 1277 - impl< 1278 - T: LibraryService, 1279 - > tonic::server::UnaryService<super::GetArtistsRequest> 1280 - for GetArtistsSvc<T> { 1098 + impl<T: LibraryService> tonic::server::UnaryService<super::GetArtistsRequest> for GetArtistsSvc<T> { 1281 1099 type Response = super::GetArtistsResponse; 1282 - type Future = BoxFuture< 1283 - tonic::Response<Self::Response>, 1284 - tonic::Status, 1285 - >; 1100 + type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 1286 1101 fn call( 1287 1102 &mut self, 1288 1103 request: tonic::Request<super::GetArtistsRequest>, ··· 1319 1134 "/rockbox.v1alpha1.LibraryService/GetTracks" => { 1320 1135 #[allow(non_camel_case_types)] 1321 1136 struct GetTracksSvc<T: LibraryService>(pub Arc<T>); 1322 - impl< 1323 - T: LibraryService, 1324 - > tonic::server::UnaryService<super::GetTracksRequest> 1325 - for GetTracksSvc<T> { 1137 + impl<T: LibraryService> tonic::server::UnaryService<super::GetTracksRequest> for GetTracksSvc<T> { 1326 1138 type Response = super::GetTracksResponse; 1327 - type Future = BoxFuture< 1328 - tonic::Response<Self::Response>, 1329 - tonic::Status, 1330 - >; 1139 + type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 1331 1140 fn call( 1332 1141 &mut self, 1333 1142 request: tonic::Request<super::GetTracksRequest>, ··· 1364 1173 "/rockbox.v1alpha1.LibraryService/GetAlbum" => { 1365 1174 #[allow(non_camel_case_types)] 1366 1175 struct GetAlbumSvc<T: LibraryService>(pub Arc<T>); 1367 - impl< 1368 - T: LibraryService, 1369 - > tonic::server::UnaryService<super::GetAlbumRequest> 1370 - for GetAlbumSvc<T> { 1176 + impl<T: LibraryService> tonic::server::UnaryService<super::GetAlbumRequest> for GetAlbumSvc<T> { 1371 1177 type Response = super::GetAlbumResponse; 1372 - type Future = BoxFuture< 1373 - tonic::Response<Self::Response>, 1374 - tonic::Status, 1375 - >; 1178 + type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 1376 1179 fn call( 1377 1180 &mut self, 1378 1181 request: tonic::Request<super::GetAlbumRequest>, ··· 1409 1212 "/rockbox.v1alpha1.LibraryService/GetArtist" => { 1410 1213 #[allow(non_camel_case_types)] 1411 1214 struct GetArtistSvc<T: LibraryService>(pub Arc<T>); 1412 - impl< 1413 - T: LibraryService, 1414 - > tonic::server::UnaryService<super::GetArtistRequest> 1415 - for GetArtistSvc<T> { 1215 + impl<T: LibraryService> tonic::server::UnaryService<super::GetArtistRequest> for GetArtistSvc<T> { 1416 1216 type Response = super::GetArtistResponse; 1417 - type Future = BoxFuture< 1418 - tonic::Response<Self::Response>, 1419 - tonic::Status, 1420 - >; 1217 + type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 1421 1218 fn call( 1422 1219 &mut self, 1423 1220 request: tonic::Request<super::GetArtistRequest>, ··· 1454 1251 "/rockbox.v1alpha1.LibraryService/GetTrack" => { 1455 1252 #[allow(non_camel_case_types)] 1456 1253 struct GetTrackSvc<T: LibraryService>(pub Arc<T>); 1457 - impl< 1458 - T: LibraryService, 1459 - > tonic::server::UnaryService<super::GetTrackRequest> 1460 - for GetTrackSvc<T> { 1254 + impl<T: LibraryService> tonic::server::UnaryService<super::GetTrackRequest> for GetTrackSvc<T> { 1461 1255 type Response = super::GetTrackResponse; 1462 - type Future = BoxFuture< 1463 - tonic::Response<Self::Response>, 1464 - tonic::Status, 1465 - >; 1256 + type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 1466 1257 fn call( 1467 1258 &mut self, 1468 1259 request: tonic::Request<super::GetTrackRequest>, ··· 1499 1290 "/rockbox.v1alpha1.LibraryService/LikeTrack" => { 1500 1291 #[allow(non_camel_case_types)] 1501 1292 struct LikeTrackSvc<T: LibraryService>(pub Arc<T>); 1502 - impl< 1503 - T: LibraryService, 1504 - > tonic::server::UnaryService<super::LikeTrackRequest> 1505 - for LikeTrackSvc<T> { 1293 + impl<T: LibraryService> tonic::server::UnaryService<super::LikeTrackRequest> for LikeTrackSvc<T> { 1506 1294 type Response = super::LikeTrackResponse; 1507 - type Future = BoxFuture< 1508 - tonic::Response<Self::Response>, 1509 - tonic::Status, 1510 - >; 1295 + type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 1511 1296 fn call( 1512 1297 &mut self, 1513 1298 request: tonic::Request<super::LikeTrackRequest>, ··· 1544 1329 "/rockbox.v1alpha1.LibraryService/UnlikeTrack" => { 1545 1330 #[allow(non_camel_case_types)] 1546 1331 struct UnlikeTrackSvc<T: LibraryService>(pub Arc<T>); 1547 - impl< 1548 - T: LibraryService, 1549 - > tonic::server::UnaryService<super::UnlikeTrackRequest> 1550 - for UnlikeTrackSvc<T> { 1332 + impl<T: LibraryService> tonic::server::UnaryService<super::UnlikeTrackRequest> 1333 + for UnlikeTrackSvc<T> 1334 + { 1551 1335 type Response = super::UnlikeTrackResponse; 1552 - type Future = BoxFuture< 1553 - tonic::Response<Self::Response>, 1554 - tonic::Status, 1555 - >; 1336 + type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 1556 1337 fn call( 1557 1338 &mut self, 1558 1339 request: tonic::Request<super::UnlikeTrackRequest>, ··· 1589 1370 "/rockbox.v1alpha1.LibraryService/LikeAlbum" => { 1590 1371 #[allow(non_camel_case_types)] 1591 1372 struct LikeAlbumSvc<T: LibraryService>(pub Arc<T>); 1592 - impl< 1593 - T: LibraryService, 1594 - > tonic::server::UnaryService<super::LikeAlbumRequest> 1595 - for LikeAlbumSvc<T> { 1373 + impl<T: LibraryService> tonic::server::UnaryService<super::LikeAlbumRequest> for LikeAlbumSvc<T> { 1596 1374 type Response = super::LikeAlbumResponse; 1597 - type Future = BoxFuture< 1598 - tonic::Response<Self::Response>, 1599 - tonic::Status, 1600 - >; 1375 + type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 1601 1376 fn call( 1602 1377 &mut self, 1603 1378 request: tonic::Request<super::LikeAlbumRequest>, ··· 1634 1409 "/rockbox.v1alpha1.LibraryService/UnlikeAlbum" => { 1635 1410 #[allow(non_camel_case_types)] 1636 1411 struct UnlikeAlbumSvc<T: LibraryService>(pub Arc<T>); 1637 - impl< 1638 - T: LibraryService, 1639 - > tonic::server::UnaryService<super::UnlikeAlbumRequest> 1640 - for UnlikeAlbumSvc<T> { 1412 + impl<T: LibraryService> tonic::server::UnaryService<super::UnlikeAlbumRequest> 1413 + for UnlikeAlbumSvc<T> 1414 + { 1641 1415 type Response = super::UnlikeAlbumResponse; 1642 - type Future = BoxFuture< 1643 - tonic::Response<Self::Response>, 1644 - tonic::Status, 1645 - >; 1416 + type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 1646 1417 fn call( 1647 1418 &mut self, 1648 1419 request: tonic::Request<super::UnlikeAlbumRequest>, ··· 1679 1450 "/rockbox.v1alpha1.LibraryService/GetLikedTracks" => { 1680 1451 #[allow(non_camel_case_types)] 1681 1452 struct GetLikedTracksSvc<T: LibraryService>(pub Arc<T>); 1682 - impl< 1683 - T: LibraryService, 1684 - > tonic::server::UnaryService<super::GetLikedTracksRequest> 1685 - for GetLikedTracksSvc<T> { 1453 + impl<T: LibraryService> 1454 + tonic::server::UnaryService<super::GetLikedTracksRequest> 1455 + for GetLikedTracksSvc<T> 1456 + { 1686 1457 type Response = super::GetLikedTracksResponse; 1687 - type Future = BoxFuture< 1688 - tonic::Response<Self::Response>, 1689 - tonic::Status, 1690 - >; 1458 + type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 1691 1459 fn call( 1692 1460 &mut self, 1693 1461 request: tonic::Request<super::GetLikedTracksRequest>, 1694 1462 ) -> Self::Future { 1695 1463 let inner = Arc::clone(&self.0); 1696 1464 let fut = async move { 1697 - <T as LibraryService>::get_liked_tracks(&inner, request) 1698 - .await 1465 + <T as LibraryService>::get_liked_tracks(&inner, request).await 1699 1466 }; 1700 1467 Box::pin(fut) 1701 1468 } ··· 1725 1492 "/rockbox.v1alpha1.LibraryService/GetLikedAlbums" => { 1726 1493 #[allow(non_camel_case_types)] 1727 1494 struct GetLikedAlbumsSvc<T: LibraryService>(pub Arc<T>); 1728 - impl< 1729 - T: LibraryService, 1730 - > tonic::server::UnaryService<super::GetLikedAlbumsRequest> 1731 - for GetLikedAlbumsSvc<T> { 1495 + impl<T: LibraryService> 1496 + tonic::server::UnaryService<super::GetLikedAlbumsRequest> 1497 + for GetLikedAlbumsSvc<T> 1498 + { 1732 1499 type Response = super::GetLikedAlbumsResponse; 1733 - type Future = BoxFuture< 1734 - tonic::Response<Self::Response>, 1735 - tonic::Status, 1736 - >; 1500 + type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 1737 1501 fn call( 1738 1502 &mut self, 1739 1503 request: tonic::Request<super::GetLikedAlbumsRequest>, 1740 1504 ) -> Self::Future { 1741 1505 let inner = Arc::clone(&self.0); 1742 1506 let fut = async move { 1743 - <T as LibraryService>::get_liked_albums(&inner, request) 1744 - .await 1507 + <T as LibraryService>::get_liked_albums(&inner, request).await 1745 1508 }; 1746 1509 Box::pin(fut) 1747 1510 } ··· 1771 1534 "/rockbox.v1alpha1.LibraryService/ScanLibrary" => { 1772 1535 #[allow(non_camel_case_types)] 1773 1536 struct ScanLibrarySvc<T: LibraryService>(pub Arc<T>); 1774 - impl< 1775 - T: LibraryService, 1776 - > tonic::server::UnaryService<super::ScanLibraryRequest> 1777 - for ScanLibrarySvc<T> { 1537 + impl<T: LibraryService> tonic::server::UnaryService<super::ScanLibraryRequest> 1538 + for ScanLibrarySvc<T> 1539 + { 1778 1540 type Response = super::ScanLibraryResponse; 1779 - type Future = BoxFuture< 1780 - tonic::Response<Self::Response>, 1781 - tonic::Status, 1782 - >; 1541 + type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 1783 1542 fn call( 1784 1543 &mut self, 1785 1544 request: tonic::Request<super::ScanLibraryRequest>, ··· 1816 1575 "/rockbox.v1alpha1.LibraryService/StreamLibrary" => { 1817 1576 #[allow(non_camel_case_types)] 1818 1577 struct StreamLibrarySvc<T: LibraryService>(pub Arc<T>); 1819 - impl< 1820 - T: LibraryService, 1821 - > tonic::server::ServerStreamingService<super::StreamLibraryRequest> 1822 - for StreamLibrarySvc<T> { 1578 + impl<T: LibraryService> 1579 + tonic::server::ServerStreamingService<super::StreamLibraryRequest> 1580 + for StreamLibrarySvc<T> 1581 + { 1823 1582 type Response = super::StreamLibraryResponse; 1824 1583 type ResponseStream = T::StreamLibraryStream; 1825 - type Future = BoxFuture< 1826 - tonic::Response<Self::ResponseStream>, 1827 - tonic::Status, 1828 - >; 1584 + type Future = 1585 + BoxFuture<tonic::Response<Self::ResponseStream>, tonic::Status>; 1829 1586 fn call( 1830 1587 &mut self, 1831 1588 request: tonic::Request<super::StreamLibraryRequest>, ··· 1862 1619 "/rockbox.v1alpha1.LibraryService/Search" => { 1863 1620 #[allow(non_camel_case_types)] 1864 1621 struct SearchSvc<T: LibraryService>(pub Arc<T>); 1865 - impl< 1866 - T: LibraryService, 1867 - > tonic::server::UnaryService<super::SearchRequest> 1868 - for SearchSvc<T> { 1622 + impl<T: LibraryService> tonic::server::UnaryService<super::SearchRequest> for SearchSvc<T> { 1869 1623 type Response = super::SearchResponse; 1870 - type Future = BoxFuture< 1871 - tonic::Response<Self::Response>, 1872 - tonic::Status, 1873 - >; 1624 + type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 1874 1625 fn call( 1875 1626 &mut self, 1876 1627 request: tonic::Request<super::SearchRequest>, 1877 1628 ) -> Self::Future { 1878 1629 let inner = Arc::clone(&self.0); 1879 - let fut = async move { 1880 - <T as LibraryService>::search(&inner, request).await 1881 - }; 1630 + let fut = 1631 + async move { <T as LibraryService>::search(&inner, request).await }; 1882 1632 Box::pin(fut) 1883 1633 } 1884 1634 } ··· 1904 1654 }; 1905 1655 Box::pin(fut) 1906 1656 } 1907 - _ => { 1908 - Box::pin(async move { 1909 - let mut response = http::Response::new(empty_body()); 1910 - let headers = response.headers_mut(); 1911 - headers 1912 - .insert( 1913 - tonic::Status::GRPC_STATUS, 1914 - (tonic::Code::Unimplemented as i32).into(), 1915 - ); 1916 - headers 1917 - .insert( 1918 - http::header::CONTENT_TYPE, 1919 - tonic::metadata::GRPC_CONTENT_TYPE, 1920 - ); 1921 - Ok(response) 1922 - }) 1923 - } 1657 + _ => Box::pin(async move { 1658 + let mut response = http::Response::new(empty_body()); 1659 + let headers = response.headers_mut(); 1660 + headers.insert( 1661 + tonic::Status::GRPC_STATUS, 1662 + (tonic::Code::Unimplemented as i32).into(), 1663 + ); 1664 + headers.insert( 1665 + http::header::CONTENT_TYPE, 1666 + tonic::metadata::GRPC_CONTENT_TYPE, 1667 + ); 1668 + Ok(response) 1669 + }), 1924 1670 } 1925 1671 } 1926 1672 } ··· 1949 1695 dead_code, 1950 1696 missing_docs, 1951 1697 clippy::wildcard_imports, 1952 - clippy::let_unit_value, 1698 + clippy::let_unit_value 1953 1699 )] 1954 - use tonic::codegen::*; 1955 1700 use tonic::codegen::http::Uri; 1701 + use tonic::codegen::*; 1956 1702 #[derive(Debug, Clone)] 1957 1703 pub struct MetadataServiceClient<T> { 1958 1704 inner: tonic::client::Grpc<T>, ··· 1996 1742 <T as tonic::client::GrpcService<tonic::body::BoxBody>>::ResponseBody, 1997 1743 >, 1998 1744 >, 1999 - <T as tonic::codegen::Service< 2000 - http::Request<tonic::body::BoxBody>, 2001 - >>::Error: Into<StdError> + std::marker::Send + std::marker::Sync, 1745 + <T as tonic::codegen::Service<http::Request<tonic::body::BoxBody>>>::Error: 1746 + Into<StdError> + std::marker::Send + std::marker::Sync, 2002 1747 { 2003 1748 MetadataServiceClient::new(InterceptedService::new(inner, interceptor)) 2004 1749 } ··· 2042 1787 dead_code, 2043 1788 missing_docs, 2044 1789 clippy::wildcard_imports, 2045 - clippy::let_unit_value, 1790 + clippy::let_unit_value 2046 1791 )] 2047 1792 use tonic::codegen::*; 2048 1793 /// Generated trait containing gRPC methods that should be implemented for use with MetadataServiceServer. ··· 2069 1814 max_encoding_message_size: None, 2070 1815 } 2071 1816 } 2072 - pub fn with_interceptor<F>( 2073 - inner: T, 2074 - interceptor: F, 2075 - ) -> InterceptedService<Self, F> 1817 + pub fn with_interceptor<F>(inner: T, interceptor: F) -> InterceptedService<Self, F> 2076 1818 where 2077 1819 F: tonic::service::Interceptor, 2078 1820 { ··· 2124 1866 } 2125 1867 fn call(&mut self, req: http::Request<B>) -> Self::Future { 2126 1868 match req.uri().path() { 2127 - _ => { 2128 - Box::pin(async move { 2129 - let mut response = http::Response::new(empty_body()); 2130 - let headers = response.headers_mut(); 2131 - headers 2132 - .insert( 2133 - tonic::Status::GRPC_STATUS, 2134 - (tonic::Code::Unimplemented as i32).into(), 2135 - ); 2136 - headers 2137 - .insert( 2138 - http::header::CONTENT_TYPE, 2139 - tonic::metadata::GRPC_CONTENT_TYPE, 2140 - ); 2141 - Ok(response) 2142 - }) 2143 - } 1869 + _ => Box::pin(async move { 1870 + let mut response = http::Response::new(empty_body()); 1871 + let headers = response.headers_mut(); 1872 + headers.insert( 1873 + tonic::Status::GRPC_STATUS, 1874 + (tonic::Code::Unimplemented as i32).into(), 1875 + ); 1876 + headers.insert( 1877 + http::header::CONTENT_TYPE, 1878 + tonic::metadata::GRPC_CONTENT_TYPE, 1879 + ); 1880 + Ok(response) 1881 + }), 2144 1882 } 2145 1883 } 2146 1884 } ··· 2424 2162 dead_code, 2425 2163 missing_docs, 2426 2164 clippy::wildcard_imports, 2427 - clippy::let_unit_value, 2165 + clippy::let_unit_value 2428 2166 )] 2429 - use tonic::codegen::*; 2430 2167 use tonic::codegen::http::Uri; 2168 + use tonic::codegen::*; 2431 2169 #[derive(Debug, Clone)] 2432 2170 pub struct PlaybackServiceClient<T> { 2433 2171 inner: tonic::client::Grpc<T>, ··· 2471 2209 <T as tonic::client::GrpcService<tonic::body::BoxBody>>::ResponseBody, 2472 2210 >, 2473 2211 >, 2474 - <T as tonic::codegen::Service< 2475 - http::Request<tonic::body::BoxBody>, 2476 - >>::Error: Into<StdError> + std::marker::Send + std::marker::Sync, 2212 + <T as tonic::codegen::Service<http::Request<tonic::body::BoxBody>>>::Error: 2213 + Into<StdError> + std::marker::Send + std::marker::Sync, 2477 2214 { 2478 2215 PlaybackServiceClient::new(InterceptedService::new(inner, interceptor)) 2479 2216 } ··· 2512 2249 &mut self, 2513 2250 request: impl tonic::IntoRequest<super::PlayRequest>, 2514 2251 ) -> std::result::Result<tonic::Response<super::PlayResponse>, tonic::Status> { 2515 - self.inner 2516 - .ready() 2517 - .await 2518 - .map_err(|e| { 2519 - tonic::Status::unknown( 2520 - format!("Service was not ready: {}", e.into()), 2521 - ) 2522 - })?; 2252 + self.inner.ready().await.map_err(|e| { 2253 + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 2254 + })?; 2523 2255 let codec = tonic::codec::ProstCodec::default(); 2524 - let path = http::uri::PathAndQuery::from_static( 2525 - "/rockbox.v1alpha1.PlaybackService/Play", 2526 - ); 2256 + let path = 2257 + http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.PlaybackService/Play"); 2527 2258 let mut req = request.into_request(); 2528 2259 req.extensions_mut() 2529 2260 .insert(GrpcMethod::new("rockbox.v1alpha1.PlaybackService", "Play")); ··· 2533 2264 &mut self, 2534 2265 request: impl tonic::IntoRequest<super::PauseRequest>, 2535 2266 ) -> std::result::Result<tonic::Response<super::PauseResponse>, tonic::Status> { 2536 - self.inner 2537 - .ready() 2538 - .await 2539 - .map_err(|e| { 2540 - tonic::Status::unknown( 2541 - format!("Service was not ready: {}", e.into()), 2542 - ) 2543 - })?; 2267 + self.inner.ready().await.map_err(|e| { 2268 + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 2269 + })?; 2544 2270 let codec = tonic::codec::ProstCodec::default(); 2545 - let path = http::uri::PathAndQuery::from_static( 2546 - "/rockbox.v1alpha1.PlaybackService/Pause", 2547 - ); 2271 + let path = 2272 + http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.PlaybackService/Pause"); 2548 2273 let mut req = request.into_request(); 2549 2274 req.extensions_mut() 2550 2275 .insert(GrpcMethod::new("rockbox.v1alpha1.PlaybackService", "Pause")); ··· 2553 2278 pub async fn play_or_pause( 2554 2279 &mut self, 2555 2280 request: impl tonic::IntoRequest<super::PlayOrPauseRequest>, 2556 - ) -> std::result::Result< 2557 - tonic::Response<super::PlayOrPauseResponse>, 2558 - tonic::Status, 2559 - > { 2560 - self.inner 2561 - .ready() 2562 - .await 2563 - .map_err(|e| { 2564 - tonic::Status::unknown( 2565 - format!("Service was not ready: {}", e.into()), 2566 - ) 2567 - })?; 2281 + ) -> std::result::Result<tonic::Response<super::PlayOrPauseResponse>, tonic::Status> 2282 + { 2283 + self.inner.ready().await.map_err(|e| { 2284 + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 2285 + })?; 2568 2286 let codec = tonic::codec::ProstCodec::default(); 2569 2287 let path = http::uri::PathAndQuery::from_static( 2570 2288 "/rockbox.v1alpha1.PlaybackService/PlayOrPause", 2571 2289 ); 2572 2290 let mut req = request.into_request(); 2573 - req.extensions_mut() 2574 - .insert( 2575 - GrpcMethod::new("rockbox.v1alpha1.PlaybackService", "PlayOrPause"), 2576 - ); 2291 + req.extensions_mut().insert(GrpcMethod::new( 2292 + "rockbox.v1alpha1.PlaybackService", 2293 + "PlayOrPause", 2294 + )); 2577 2295 self.inner.unary(req, path, codec).await 2578 2296 } 2579 2297 pub async fn resume( 2580 2298 &mut self, 2581 2299 request: impl tonic::IntoRequest<super::ResumeRequest>, 2582 2300 ) -> std::result::Result<tonic::Response<super::ResumeResponse>, tonic::Status> { 2583 - self.inner 2584 - .ready() 2585 - .await 2586 - .map_err(|e| { 2587 - tonic::Status::unknown( 2588 - format!("Service was not ready: {}", e.into()), 2589 - ) 2590 - })?; 2301 + self.inner.ready().await.map_err(|e| { 2302 + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 2303 + })?; 2591 2304 let codec = tonic::codec::ProstCodec::default(); 2592 - let path = http::uri::PathAndQuery::from_static( 2593 - "/rockbox.v1alpha1.PlaybackService/Resume", 2594 - ); 2305 + let path = 2306 + http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.PlaybackService/Resume"); 2595 2307 let mut req = request.into_request(); 2596 - req.extensions_mut() 2597 - .insert(GrpcMethod::new("rockbox.v1alpha1.PlaybackService", "Resume")); 2308 + req.extensions_mut().insert(GrpcMethod::new( 2309 + "rockbox.v1alpha1.PlaybackService", 2310 + "Resume", 2311 + )); 2598 2312 self.inner.unary(req, path, codec).await 2599 2313 } 2600 2314 pub async fn next( 2601 2315 &mut self, 2602 2316 request: impl tonic::IntoRequest<super::NextRequest>, 2603 2317 ) -> std::result::Result<tonic::Response<super::NextResponse>, tonic::Status> { 2604 - self.inner 2605 - .ready() 2606 - .await 2607 - .map_err(|e| { 2608 - tonic::Status::unknown( 2609 - format!("Service was not ready: {}", e.into()), 2610 - ) 2611 - })?; 2318 + self.inner.ready().await.map_err(|e| { 2319 + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 2320 + })?; 2612 2321 let codec = tonic::codec::ProstCodec::default(); 2613 - let path = http::uri::PathAndQuery::from_static( 2614 - "/rockbox.v1alpha1.PlaybackService/Next", 2615 - ); 2322 + let path = 2323 + http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.PlaybackService/Next"); 2616 2324 let mut req = request.into_request(); 2617 2325 req.extensions_mut() 2618 2326 .insert(GrpcMethod::new("rockbox.v1alpha1.PlaybackService", "Next")); ··· 2621 2329 pub async fn previous( 2622 2330 &mut self, 2623 2331 request: impl tonic::IntoRequest<super::PreviousRequest>, 2624 - ) -> std::result::Result< 2625 - tonic::Response<super::PreviousResponse>, 2626 - tonic::Status, 2627 - > { 2628 - self.inner 2629 - .ready() 2630 - .await 2631 - .map_err(|e| { 2632 - tonic::Status::unknown( 2633 - format!("Service was not ready: {}", e.into()), 2634 - ) 2635 - })?; 2332 + ) -> std::result::Result<tonic::Response<super::PreviousResponse>, tonic::Status> { 2333 + self.inner.ready().await.map_err(|e| { 2334 + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 2335 + })?; 2636 2336 let codec = tonic::codec::ProstCodec::default(); 2637 - let path = http::uri::PathAndQuery::from_static( 2638 - "/rockbox.v1alpha1.PlaybackService/Previous", 2639 - ); 2337 + let path = 2338 + http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.PlaybackService/Previous"); 2640 2339 let mut req = request.into_request(); 2641 - req.extensions_mut() 2642 - .insert(GrpcMethod::new("rockbox.v1alpha1.PlaybackService", "Previous")); 2340 + req.extensions_mut().insert(GrpcMethod::new( 2341 + "rockbox.v1alpha1.PlaybackService", 2342 + "Previous", 2343 + )); 2643 2344 self.inner.unary(req, path, codec).await 2644 2345 } 2645 2346 pub async fn fast_forward_rewind( 2646 2347 &mut self, 2647 2348 request: impl tonic::IntoRequest<super::FastForwardRewindRequest>, 2648 - ) -> std::result::Result< 2649 - tonic::Response<super::FastForwardRewindResponse>, 2650 - tonic::Status, 2651 - > { 2652 - self.inner 2653 - .ready() 2654 - .await 2655 - .map_err(|e| { 2656 - tonic::Status::unknown( 2657 - format!("Service was not ready: {}", e.into()), 2658 - ) 2659 - })?; 2349 + ) -> std::result::Result<tonic::Response<super::FastForwardRewindResponse>, tonic::Status> 2350 + { 2351 + self.inner.ready().await.map_err(|e| { 2352 + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 2353 + })?; 2660 2354 let codec = tonic::codec::ProstCodec::default(); 2661 2355 let path = http::uri::PathAndQuery::from_static( 2662 2356 "/rockbox.v1alpha1.PlaybackService/FastForwardRewind", 2663 2357 ); 2664 2358 let mut req = request.into_request(); 2665 - req.extensions_mut() 2666 - .insert( 2667 - GrpcMethod::new( 2668 - "rockbox.v1alpha1.PlaybackService", 2669 - "FastForwardRewind", 2670 - ), 2671 - ); 2359 + req.extensions_mut().insert(GrpcMethod::new( 2360 + "rockbox.v1alpha1.PlaybackService", 2361 + "FastForwardRewind", 2362 + )); 2672 2363 self.inner.unary(req, path, codec).await 2673 2364 } 2674 2365 pub async fn status( 2675 2366 &mut self, 2676 2367 request: impl tonic::IntoRequest<super::StatusRequest>, 2677 2368 ) -> std::result::Result<tonic::Response<super::StatusResponse>, tonic::Status> { 2678 - self.inner 2679 - .ready() 2680 - .await 2681 - .map_err(|e| { 2682 - tonic::Status::unknown( 2683 - format!("Service was not ready: {}", e.into()), 2684 - ) 2685 - })?; 2369 + self.inner.ready().await.map_err(|e| { 2370 + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 2371 + })?; 2686 2372 let codec = tonic::codec::ProstCodec::default(); 2687 - let path = http::uri::PathAndQuery::from_static( 2688 - "/rockbox.v1alpha1.PlaybackService/Status", 2689 - ); 2373 + let path = 2374 + http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.PlaybackService/Status"); 2690 2375 let mut req = request.into_request(); 2691 - req.extensions_mut() 2692 - .insert(GrpcMethod::new("rockbox.v1alpha1.PlaybackService", "Status")); 2376 + req.extensions_mut().insert(GrpcMethod::new( 2377 + "rockbox.v1alpha1.PlaybackService", 2378 + "Status", 2379 + )); 2693 2380 self.inner.unary(req, path, codec).await 2694 2381 } 2695 2382 pub async fn current_track( 2696 2383 &mut self, 2697 2384 request: impl tonic::IntoRequest<super::CurrentTrackRequest>, 2698 - ) -> std::result::Result< 2699 - tonic::Response<super::CurrentTrackResponse>, 2700 - tonic::Status, 2701 - > { 2702 - self.inner 2703 - .ready() 2704 - .await 2705 - .map_err(|e| { 2706 - tonic::Status::unknown( 2707 - format!("Service was not ready: {}", e.into()), 2708 - ) 2709 - })?; 2385 + ) -> std::result::Result<tonic::Response<super::CurrentTrackResponse>, tonic::Status> 2386 + { 2387 + self.inner.ready().await.map_err(|e| { 2388 + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 2389 + })?; 2710 2390 let codec = tonic::codec::ProstCodec::default(); 2711 2391 let path = http::uri::PathAndQuery::from_static( 2712 2392 "/rockbox.v1alpha1.PlaybackService/CurrentTrack", 2713 2393 ); 2714 2394 let mut req = request.into_request(); 2715 - req.extensions_mut() 2716 - .insert( 2717 - GrpcMethod::new("rockbox.v1alpha1.PlaybackService", "CurrentTrack"), 2718 - ); 2395 + req.extensions_mut().insert(GrpcMethod::new( 2396 + "rockbox.v1alpha1.PlaybackService", 2397 + "CurrentTrack", 2398 + )); 2719 2399 self.inner.unary(req, path, codec).await 2720 2400 } 2721 2401 pub async fn next_track( 2722 2402 &mut self, 2723 2403 request: impl tonic::IntoRequest<super::NextTrackRequest>, 2724 - ) -> std::result::Result< 2725 - tonic::Response<super::NextTrackResponse>, 2726 - tonic::Status, 2727 - > { 2728 - self.inner 2729 - .ready() 2730 - .await 2731 - .map_err(|e| { 2732 - tonic::Status::unknown( 2733 - format!("Service was not ready: {}", e.into()), 2734 - ) 2735 - })?; 2404 + ) -> std::result::Result<tonic::Response<super::NextTrackResponse>, tonic::Status> { 2405 + self.inner.ready().await.map_err(|e| { 2406 + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 2407 + })?; 2736 2408 let codec = tonic::codec::ProstCodec::default(); 2737 - let path = http::uri::PathAndQuery::from_static( 2738 - "/rockbox.v1alpha1.PlaybackService/NextTrack", 2739 - ); 2409 + let path = 2410 + http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.PlaybackService/NextTrack"); 2740 2411 let mut req = request.into_request(); 2741 - req.extensions_mut() 2742 - .insert( 2743 - GrpcMethod::new("rockbox.v1alpha1.PlaybackService", "NextTrack"), 2744 - ); 2412 + req.extensions_mut().insert(GrpcMethod::new( 2413 + "rockbox.v1alpha1.PlaybackService", 2414 + "NextTrack", 2415 + )); 2745 2416 self.inner.unary(req, path, codec).await 2746 2417 } 2747 2418 pub async fn flush_and_reload_tracks( 2748 2419 &mut self, 2749 2420 request: impl tonic::IntoRequest<super::FlushAndReloadTracksRequest>, 2750 - ) -> std::result::Result< 2751 - tonic::Response<super::FlushAndReloadTracksResponse>, 2752 - tonic::Status, 2753 - > { 2754 - self.inner 2755 - .ready() 2756 - .await 2757 - .map_err(|e| { 2758 - tonic::Status::unknown( 2759 - format!("Service was not ready: {}", e.into()), 2760 - ) 2761 - })?; 2421 + ) -> std::result::Result<tonic::Response<super::FlushAndReloadTracksResponse>, tonic::Status> 2422 + { 2423 + self.inner.ready().await.map_err(|e| { 2424 + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 2425 + })?; 2762 2426 let codec = tonic::codec::ProstCodec::default(); 2763 2427 let path = http::uri::PathAndQuery::from_static( 2764 2428 "/rockbox.v1alpha1.PlaybackService/FlushAndReloadTracks", 2765 2429 ); 2766 2430 let mut req = request.into_request(); 2767 - req.extensions_mut() 2768 - .insert( 2769 - GrpcMethod::new( 2770 - "rockbox.v1alpha1.PlaybackService", 2771 - "FlushAndReloadTracks", 2772 - ), 2773 - ); 2431 + req.extensions_mut().insert(GrpcMethod::new( 2432 + "rockbox.v1alpha1.PlaybackService", 2433 + "FlushAndReloadTracks", 2434 + )); 2774 2435 self.inner.unary(req, path, codec).await 2775 2436 } 2776 2437 pub async fn get_file_position( 2777 2438 &mut self, 2778 2439 request: impl tonic::IntoRequest<super::GetFilePositionRequest>, 2779 - ) -> std::result::Result< 2780 - tonic::Response<super::GetFilePositionResponse>, 2781 - tonic::Status, 2782 - > { 2783 - self.inner 2784 - .ready() 2785 - .await 2786 - .map_err(|e| { 2787 - tonic::Status::unknown( 2788 - format!("Service was not ready: {}", e.into()), 2789 - ) 2790 - })?; 2440 + ) -> std::result::Result<tonic::Response<super::GetFilePositionResponse>, tonic::Status> 2441 + { 2442 + self.inner.ready().await.map_err(|e| { 2443 + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 2444 + })?; 2791 2445 let codec = tonic::codec::ProstCodec::default(); 2792 2446 let path = http::uri::PathAndQuery::from_static( 2793 2447 "/rockbox.v1alpha1.PlaybackService/GetFilePosition", 2794 2448 ); 2795 2449 let mut req = request.into_request(); 2796 - req.extensions_mut() 2797 - .insert( 2798 - GrpcMethod::new( 2799 - "rockbox.v1alpha1.PlaybackService", 2800 - "GetFilePosition", 2801 - ), 2802 - ); 2450 + req.extensions_mut().insert(GrpcMethod::new( 2451 + "rockbox.v1alpha1.PlaybackService", 2452 + "GetFilePosition", 2453 + )); 2803 2454 self.inner.unary(req, path, codec).await 2804 2455 } 2805 2456 pub async fn hard_stop( 2806 2457 &mut self, 2807 2458 request: impl tonic::IntoRequest<super::HardStopRequest>, 2808 - ) -> std::result::Result< 2809 - tonic::Response<super::HardStopResponse>, 2810 - tonic::Status, 2811 - > { 2812 - self.inner 2813 - .ready() 2814 - .await 2815 - .map_err(|e| { 2816 - tonic::Status::unknown( 2817 - format!("Service was not ready: {}", e.into()), 2818 - ) 2819 - })?; 2459 + ) -> std::result::Result<tonic::Response<super::HardStopResponse>, tonic::Status> { 2460 + self.inner.ready().await.map_err(|e| { 2461 + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 2462 + })?; 2820 2463 let codec = tonic::codec::ProstCodec::default(); 2821 - let path = http::uri::PathAndQuery::from_static( 2822 - "/rockbox.v1alpha1.PlaybackService/HardStop", 2823 - ); 2464 + let path = 2465 + http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.PlaybackService/HardStop"); 2824 2466 let mut req = request.into_request(); 2825 - req.extensions_mut() 2826 - .insert(GrpcMethod::new("rockbox.v1alpha1.PlaybackService", "HardStop")); 2467 + req.extensions_mut().insert(GrpcMethod::new( 2468 + "rockbox.v1alpha1.PlaybackService", 2469 + "HardStop", 2470 + )); 2827 2471 self.inner.unary(req, path, codec).await 2828 2472 } 2829 2473 pub async fn play_album( 2830 2474 &mut self, 2831 2475 request: impl tonic::IntoRequest<super::PlayAlbumRequest>, 2832 - ) -> std::result::Result< 2833 - tonic::Response<super::PlayAlbumResponse>, 2834 - tonic::Status, 2835 - > { 2836 - self.inner 2837 - .ready() 2838 - .await 2839 - .map_err(|e| { 2840 - tonic::Status::unknown( 2841 - format!("Service was not ready: {}", e.into()), 2842 - ) 2843 - })?; 2476 + ) -> std::result::Result<tonic::Response<super::PlayAlbumResponse>, tonic::Status> { 2477 + self.inner.ready().await.map_err(|e| { 2478 + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 2479 + })?; 2844 2480 let codec = tonic::codec::ProstCodec::default(); 2845 - let path = http::uri::PathAndQuery::from_static( 2846 - "/rockbox.v1alpha1.PlaybackService/PlayAlbum", 2847 - ); 2481 + let path = 2482 + http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.PlaybackService/PlayAlbum"); 2848 2483 let mut req = request.into_request(); 2849 - req.extensions_mut() 2850 - .insert( 2851 - GrpcMethod::new("rockbox.v1alpha1.PlaybackService", "PlayAlbum"), 2852 - ); 2484 + req.extensions_mut().insert(GrpcMethod::new( 2485 + "rockbox.v1alpha1.PlaybackService", 2486 + "PlayAlbum", 2487 + )); 2853 2488 self.inner.unary(req, path, codec).await 2854 2489 } 2855 2490 pub async fn play_artist_tracks( 2856 2491 &mut self, 2857 2492 request: impl tonic::IntoRequest<super::PlayArtistTracksRequest>, 2858 - ) -> std::result::Result< 2859 - tonic::Response<super::PlayArtistTracksResponse>, 2860 - tonic::Status, 2861 - > { 2862 - self.inner 2863 - .ready() 2864 - .await 2865 - .map_err(|e| { 2866 - tonic::Status::unknown( 2867 - format!("Service was not ready: {}", e.into()), 2868 - ) 2869 - })?; 2493 + ) -> std::result::Result<tonic::Response<super::PlayArtistTracksResponse>, tonic::Status> 2494 + { 2495 + self.inner.ready().await.map_err(|e| { 2496 + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 2497 + })?; 2870 2498 let codec = tonic::codec::ProstCodec::default(); 2871 2499 let path = http::uri::PathAndQuery::from_static( 2872 2500 "/rockbox.v1alpha1.PlaybackService/PlayArtistTracks", 2873 2501 ); 2874 2502 let mut req = request.into_request(); 2875 - req.extensions_mut() 2876 - .insert( 2877 - GrpcMethod::new( 2878 - "rockbox.v1alpha1.PlaybackService", 2879 - "PlayArtistTracks", 2880 - ), 2881 - ); 2503 + req.extensions_mut().insert(GrpcMethod::new( 2504 + "rockbox.v1alpha1.PlaybackService", 2505 + "PlayArtistTracks", 2506 + )); 2882 2507 self.inner.unary(req, path, codec).await 2883 2508 } 2884 2509 pub async fn play_playlist( 2885 2510 &mut self, 2886 2511 request: impl tonic::IntoRequest<super::PlayPlaylistRequest>, 2887 - ) -> std::result::Result< 2888 - tonic::Response<super::PlayPlaylistResponse>, 2889 - tonic::Status, 2890 - > { 2891 - self.inner 2892 - .ready() 2893 - .await 2894 - .map_err(|e| { 2895 - tonic::Status::unknown( 2896 - format!("Service was not ready: {}", e.into()), 2897 - ) 2898 - })?; 2512 + ) -> std::result::Result<tonic::Response<super::PlayPlaylistResponse>, tonic::Status> 2513 + { 2514 + self.inner.ready().await.map_err(|e| { 2515 + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 2516 + })?; 2899 2517 let codec = tonic::codec::ProstCodec::default(); 2900 2518 let path = http::uri::PathAndQuery::from_static( 2901 2519 "/rockbox.v1alpha1.PlaybackService/PlayPlaylist", 2902 2520 ); 2903 2521 let mut req = request.into_request(); 2904 - req.extensions_mut() 2905 - .insert( 2906 - GrpcMethod::new("rockbox.v1alpha1.PlaybackService", "PlayPlaylist"), 2907 - ); 2522 + req.extensions_mut().insert(GrpcMethod::new( 2523 + "rockbox.v1alpha1.PlaybackService", 2524 + "PlayPlaylist", 2525 + )); 2908 2526 self.inner.unary(req, path, codec).await 2909 2527 } 2910 2528 pub async fn play_directory( 2911 2529 &mut self, 2912 2530 request: impl tonic::IntoRequest<super::PlayDirectoryRequest>, 2913 - ) -> std::result::Result< 2914 - tonic::Response<super::PlayDirectoryResponse>, 2915 - tonic::Status, 2916 - > { 2917 - self.inner 2918 - .ready() 2919 - .await 2920 - .map_err(|e| { 2921 - tonic::Status::unknown( 2922 - format!("Service was not ready: {}", e.into()), 2923 - ) 2924 - })?; 2531 + ) -> std::result::Result<tonic::Response<super::PlayDirectoryResponse>, tonic::Status> 2532 + { 2533 + self.inner.ready().await.map_err(|e| { 2534 + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 2535 + })?; 2925 2536 let codec = tonic::codec::ProstCodec::default(); 2926 2537 let path = http::uri::PathAndQuery::from_static( 2927 2538 "/rockbox.v1alpha1.PlaybackService/PlayDirectory", 2928 2539 ); 2929 2540 let mut req = request.into_request(); 2930 - req.extensions_mut() 2931 - .insert( 2932 - GrpcMethod::new("rockbox.v1alpha1.PlaybackService", "PlayDirectory"), 2933 - ); 2541 + req.extensions_mut().insert(GrpcMethod::new( 2542 + "rockbox.v1alpha1.PlaybackService", 2543 + "PlayDirectory", 2544 + )); 2934 2545 self.inner.unary(req, path, codec).await 2935 2546 } 2936 2547 pub async fn play_music_directory( 2937 2548 &mut self, 2938 2549 request: impl tonic::IntoRequest<super::PlayMusicDirectoryRequest>, 2939 - ) -> std::result::Result< 2940 - tonic::Response<super::PlayMusicDirectoryResponse>, 2941 - tonic::Status, 2942 - > { 2943 - self.inner 2944 - .ready() 2945 - .await 2946 - .map_err(|e| { 2947 - tonic::Status::unknown( 2948 - format!("Service was not ready: {}", e.into()), 2949 - ) 2950 - })?; 2550 + ) -> std::result::Result<tonic::Response<super::PlayMusicDirectoryResponse>, tonic::Status> 2551 + { 2552 + self.inner.ready().await.map_err(|e| { 2553 + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 2554 + })?; 2951 2555 let codec = tonic::codec::ProstCodec::default(); 2952 2556 let path = http::uri::PathAndQuery::from_static( 2953 2557 "/rockbox.v1alpha1.PlaybackService/PlayMusicDirectory", 2954 2558 ); 2955 2559 let mut req = request.into_request(); 2956 - req.extensions_mut() 2957 - .insert( 2958 - GrpcMethod::new( 2959 - "rockbox.v1alpha1.PlaybackService", 2960 - "PlayMusicDirectory", 2961 - ), 2962 - ); 2560 + req.extensions_mut().insert(GrpcMethod::new( 2561 + "rockbox.v1alpha1.PlaybackService", 2562 + "PlayMusicDirectory", 2563 + )); 2963 2564 self.inner.unary(req, path, codec).await 2964 2565 } 2965 2566 pub async fn play_track( 2966 2567 &mut self, 2967 2568 request: impl tonic::IntoRequest<super::PlayTrackRequest>, 2968 - ) -> std::result::Result< 2969 - tonic::Response<super::PlayTrackResponse>, 2970 - tonic::Status, 2971 - > { 2972 - self.inner 2973 - .ready() 2974 - .await 2975 - .map_err(|e| { 2976 - tonic::Status::unknown( 2977 - format!("Service was not ready: {}", e.into()), 2978 - ) 2979 - })?; 2569 + ) -> std::result::Result<tonic::Response<super::PlayTrackResponse>, tonic::Status> { 2570 + self.inner.ready().await.map_err(|e| { 2571 + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 2572 + })?; 2980 2573 let codec = tonic::codec::ProstCodec::default(); 2981 - let path = http::uri::PathAndQuery::from_static( 2982 - "/rockbox.v1alpha1.PlaybackService/PlayTrack", 2983 - ); 2574 + let path = 2575 + http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.PlaybackService/PlayTrack"); 2984 2576 let mut req = request.into_request(); 2985 - req.extensions_mut() 2986 - .insert( 2987 - GrpcMethod::new("rockbox.v1alpha1.PlaybackService", "PlayTrack"), 2988 - ); 2577 + req.extensions_mut().insert(GrpcMethod::new( 2578 + "rockbox.v1alpha1.PlaybackService", 2579 + "PlayTrack", 2580 + )); 2989 2581 self.inner.unary(req, path, codec).await 2990 2582 } 2991 2583 pub async fn play_liked_tracks( 2992 2584 &mut self, 2993 2585 request: impl tonic::IntoRequest<super::PlayLikedTracksRequest>, 2994 - ) -> std::result::Result< 2995 - tonic::Response<super::PlayLikedTracksResponse>, 2996 - tonic::Status, 2997 - > { 2998 - self.inner 2999 - .ready() 3000 - .await 3001 - .map_err(|e| { 3002 - tonic::Status::unknown( 3003 - format!("Service was not ready: {}", e.into()), 3004 - ) 3005 - })?; 2586 + ) -> std::result::Result<tonic::Response<super::PlayLikedTracksResponse>, tonic::Status> 2587 + { 2588 + self.inner.ready().await.map_err(|e| { 2589 + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 2590 + })?; 3006 2591 let codec = tonic::codec::ProstCodec::default(); 3007 2592 let path = http::uri::PathAndQuery::from_static( 3008 2593 "/rockbox.v1alpha1.PlaybackService/PlayLikedTracks", 3009 2594 ); 3010 2595 let mut req = request.into_request(); 3011 - req.extensions_mut() 3012 - .insert( 3013 - GrpcMethod::new( 3014 - "rockbox.v1alpha1.PlaybackService", 3015 - "PlayLikedTracks", 3016 - ), 3017 - ); 2596 + req.extensions_mut().insert(GrpcMethod::new( 2597 + "rockbox.v1alpha1.PlaybackService", 2598 + "PlayLikedTracks", 2599 + )); 3018 2600 self.inner.unary(req, path, codec).await 3019 2601 } 3020 2602 pub async fn play_all_tracks( 3021 2603 &mut self, 3022 2604 request: impl tonic::IntoRequest<super::PlayAllTracksRequest>, 3023 - ) -> std::result::Result< 3024 - tonic::Response<super::PlayAllTracksResponse>, 3025 - tonic::Status, 3026 - > { 3027 - self.inner 3028 - .ready() 3029 - .await 3030 - .map_err(|e| { 3031 - tonic::Status::unknown( 3032 - format!("Service was not ready: {}", e.into()), 3033 - ) 3034 - })?; 2605 + ) -> std::result::Result<tonic::Response<super::PlayAllTracksResponse>, tonic::Status> 2606 + { 2607 + self.inner.ready().await.map_err(|e| { 2608 + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 2609 + })?; 3035 2610 let codec = tonic::codec::ProstCodec::default(); 3036 2611 let path = http::uri::PathAndQuery::from_static( 3037 2612 "/rockbox.v1alpha1.PlaybackService/PlayAllTracks", 3038 2613 ); 3039 2614 let mut req = request.into_request(); 3040 - req.extensions_mut() 3041 - .insert( 3042 - GrpcMethod::new("rockbox.v1alpha1.PlaybackService", "PlayAllTracks"), 3043 - ); 2615 + req.extensions_mut().insert(GrpcMethod::new( 2616 + "rockbox.v1alpha1.PlaybackService", 2617 + "PlayAllTracks", 2618 + )); 3044 2619 self.inner.unary(req, path, codec).await 3045 2620 } 3046 2621 pub async fn stream_current_track( ··· 3050 2625 tonic::Response<tonic::codec::Streaming<super::CurrentTrackResponse>>, 3051 2626 tonic::Status, 3052 2627 > { 3053 - self.inner 3054 - .ready() 3055 - .await 3056 - .map_err(|e| { 3057 - tonic::Status::unknown( 3058 - format!("Service was not ready: {}", e.into()), 3059 - ) 3060 - })?; 2628 + self.inner.ready().await.map_err(|e| { 2629 + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 2630 + })?; 3061 2631 let codec = tonic::codec::ProstCodec::default(); 3062 2632 let path = http::uri::PathAndQuery::from_static( 3063 2633 "/rockbox.v1alpha1.PlaybackService/StreamCurrentTrack", 3064 2634 ); 3065 2635 let mut req = request.into_request(); 3066 - req.extensions_mut() 3067 - .insert( 3068 - GrpcMethod::new( 3069 - "rockbox.v1alpha1.PlaybackService", 3070 - "StreamCurrentTrack", 3071 - ), 3072 - ); 2636 + req.extensions_mut().insert(GrpcMethod::new( 2637 + "rockbox.v1alpha1.PlaybackService", 2638 + "StreamCurrentTrack", 2639 + )); 3073 2640 self.inner.server_streaming(req, path, codec).await 3074 2641 } 3075 2642 pub async fn stream_status( ··· 3079 2646 tonic::Response<tonic::codec::Streaming<super::StatusResponse>>, 3080 2647 tonic::Status, 3081 2648 > { 3082 - self.inner 3083 - .ready() 3084 - .await 3085 - .map_err(|e| { 3086 - tonic::Status::unknown( 3087 - format!("Service was not ready: {}", e.into()), 3088 - ) 3089 - })?; 2649 + self.inner.ready().await.map_err(|e| { 2650 + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 2651 + })?; 3090 2652 let codec = tonic::codec::ProstCodec::default(); 3091 2653 let path = http::uri::PathAndQuery::from_static( 3092 2654 "/rockbox.v1alpha1.PlaybackService/StreamStatus", 3093 2655 ); 3094 2656 let mut req = request.into_request(); 3095 - req.extensions_mut() 3096 - .insert( 3097 - GrpcMethod::new("rockbox.v1alpha1.PlaybackService", "StreamStatus"), 3098 - ); 2657 + req.extensions_mut().insert(GrpcMethod::new( 2658 + "rockbox.v1alpha1.PlaybackService", 2659 + "StreamStatus", 2660 + )); 3099 2661 self.inner.server_streaming(req, path, codec).await 3100 2662 } 3101 2663 pub async fn stream_playlist( ··· 3105 2667 tonic::Response<tonic::codec::Streaming<super::PlaylistResponse>>, 3106 2668 tonic::Status, 3107 2669 > { 3108 - self.inner 3109 - .ready() 3110 - .await 3111 - .map_err(|e| { 3112 - tonic::Status::unknown( 3113 - format!("Service was not ready: {}", e.into()), 3114 - ) 3115 - })?; 2670 + self.inner.ready().await.map_err(|e| { 2671 + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 2672 + })?; 3116 2673 let codec = tonic::codec::ProstCodec::default(); 3117 2674 let path = http::uri::PathAndQuery::from_static( 3118 2675 "/rockbox.v1alpha1.PlaybackService/StreamPlaylist", 3119 2676 ); 3120 2677 let mut req = request.into_request(); 3121 - req.extensions_mut() 3122 - .insert( 3123 - GrpcMethod::new("rockbox.v1alpha1.PlaybackService", "StreamPlaylist"), 3124 - ); 2678 + req.extensions_mut().insert(GrpcMethod::new( 2679 + "rockbox.v1alpha1.PlaybackService", 2680 + "StreamPlaylist", 2681 + )); 3125 2682 self.inner.server_streaming(req, path, codec).await 3126 2683 } 3127 2684 } ··· 3133 2690 dead_code, 3134 2691 missing_docs, 3135 2692 clippy::wildcard_imports, 3136 - clippy::let_unit_value, 2693 + clippy::let_unit_value 3137 2694 )] 3138 2695 use tonic::codegen::*; 3139 2696 /// Generated trait containing gRPC methods that should be implemented for use with PlaybackServiceServer. ··· 3150 2707 async fn play_or_pause( 3151 2708 &self, 3152 2709 request: tonic::Request<super::PlayOrPauseRequest>, 3153 - ) -> std::result::Result< 3154 - tonic::Response<super::PlayOrPauseResponse>, 3155 - tonic::Status, 3156 - >; 2710 + ) -> std::result::Result<tonic::Response<super::PlayOrPauseResponse>, tonic::Status>; 3157 2711 async fn resume( 3158 2712 &self, 3159 2713 request: tonic::Request<super::ResumeRequest>, ··· 3165 2719 async fn previous( 3166 2720 &self, 3167 2721 request: tonic::Request<super::PreviousRequest>, 3168 - ) -> std::result::Result< 3169 - tonic::Response<super::PreviousResponse>, 3170 - tonic::Status, 3171 - >; 2722 + ) -> std::result::Result<tonic::Response<super::PreviousResponse>, tonic::Status>; 3172 2723 async fn fast_forward_rewind( 3173 2724 &self, 3174 2725 request: tonic::Request<super::FastForwardRewindRequest>, 3175 - ) -> std::result::Result< 3176 - tonic::Response<super::FastForwardRewindResponse>, 3177 - tonic::Status, 3178 - >; 2726 + ) -> std::result::Result<tonic::Response<super::FastForwardRewindResponse>, tonic::Status>; 3179 2727 async fn status( 3180 2728 &self, 3181 2729 request: tonic::Request<super::StatusRequest>, ··· 3183 2731 async fn current_track( 3184 2732 &self, 3185 2733 request: tonic::Request<super::CurrentTrackRequest>, 3186 - ) -> std::result::Result< 3187 - tonic::Response<super::CurrentTrackResponse>, 3188 - tonic::Status, 3189 - >; 2734 + ) -> std::result::Result<tonic::Response<super::CurrentTrackResponse>, tonic::Status>; 3190 2735 async fn next_track( 3191 2736 &self, 3192 2737 request: tonic::Request<super::NextTrackRequest>, 3193 - ) -> std::result::Result< 3194 - tonic::Response<super::NextTrackResponse>, 3195 - tonic::Status, 3196 - >; 2738 + ) -> std::result::Result<tonic::Response<super::NextTrackResponse>, tonic::Status>; 3197 2739 async fn flush_and_reload_tracks( 3198 2740 &self, 3199 2741 request: tonic::Request<super::FlushAndReloadTracksRequest>, 3200 - ) -> std::result::Result< 3201 - tonic::Response<super::FlushAndReloadTracksResponse>, 3202 - tonic::Status, 3203 - >; 2742 + ) -> std::result::Result<tonic::Response<super::FlushAndReloadTracksResponse>, tonic::Status>; 3204 2743 async fn get_file_position( 3205 2744 &self, 3206 2745 request: tonic::Request<super::GetFilePositionRequest>, 3207 - ) -> std::result::Result< 3208 - tonic::Response<super::GetFilePositionResponse>, 3209 - tonic::Status, 3210 - >; 2746 + ) -> std::result::Result<tonic::Response<super::GetFilePositionResponse>, tonic::Status>; 3211 2747 async fn hard_stop( 3212 2748 &self, 3213 2749 request: tonic::Request<super::HardStopRequest>, 3214 - ) -> std::result::Result< 3215 - tonic::Response<super::HardStopResponse>, 3216 - tonic::Status, 3217 - >; 2750 + ) -> std::result::Result<tonic::Response<super::HardStopResponse>, tonic::Status>; 3218 2751 async fn play_album( 3219 2752 &self, 3220 2753 request: tonic::Request<super::PlayAlbumRequest>, 3221 - ) -> std::result::Result< 3222 - tonic::Response<super::PlayAlbumResponse>, 3223 - tonic::Status, 3224 - >; 2754 + ) -> std::result::Result<tonic::Response<super::PlayAlbumResponse>, tonic::Status>; 3225 2755 async fn play_artist_tracks( 3226 2756 &self, 3227 2757 request: tonic::Request<super::PlayArtistTracksRequest>, 3228 - ) -> std::result::Result< 3229 - tonic::Response<super::PlayArtistTracksResponse>, 3230 - tonic::Status, 3231 - >; 2758 + ) -> std::result::Result<tonic::Response<super::PlayArtistTracksResponse>, tonic::Status>; 3232 2759 async fn play_playlist( 3233 2760 &self, 3234 2761 request: tonic::Request<super::PlayPlaylistRequest>, 3235 - ) -> std::result::Result< 3236 - tonic::Response<super::PlayPlaylistResponse>, 3237 - tonic::Status, 3238 - >; 2762 + ) -> std::result::Result<tonic::Response<super::PlayPlaylistResponse>, tonic::Status>; 3239 2763 async fn play_directory( 3240 2764 &self, 3241 2765 request: tonic::Request<super::PlayDirectoryRequest>, 3242 - ) -> std::result::Result< 3243 - tonic::Response<super::PlayDirectoryResponse>, 3244 - tonic::Status, 3245 - >; 2766 + ) -> std::result::Result<tonic::Response<super::PlayDirectoryResponse>, tonic::Status>; 3246 2767 async fn play_music_directory( 3247 2768 &self, 3248 2769 request: tonic::Request<super::PlayMusicDirectoryRequest>, 3249 - ) -> std::result::Result< 3250 - tonic::Response<super::PlayMusicDirectoryResponse>, 3251 - tonic::Status, 3252 - >; 2770 + ) -> std::result::Result<tonic::Response<super::PlayMusicDirectoryResponse>, tonic::Status>; 3253 2771 async fn play_track( 3254 2772 &self, 3255 2773 request: tonic::Request<super::PlayTrackRequest>, 3256 - ) -> std::result::Result< 3257 - tonic::Response<super::PlayTrackResponse>, 3258 - tonic::Status, 3259 - >; 2774 + ) -> std::result::Result<tonic::Response<super::PlayTrackResponse>, tonic::Status>; 3260 2775 async fn play_liked_tracks( 3261 2776 &self, 3262 2777 request: tonic::Request<super::PlayLikedTracksRequest>, 3263 - ) -> std::result::Result< 3264 - tonic::Response<super::PlayLikedTracksResponse>, 3265 - tonic::Status, 3266 - >; 2778 + ) -> std::result::Result<tonic::Response<super::PlayLikedTracksResponse>, tonic::Status>; 3267 2779 async fn play_all_tracks( 3268 2780 &self, 3269 2781 request: tonic::Request<super::PlayAllTracksRequest>, 3270 - ) -> std::result::Result< 3271 - tonic::Response<super::PlayAllTracksResponse>, 3272 - tonic::Status, 3273 - >; 2782 + ) -> std::result::Result<tonic::Response<super::PlayAllTracksResponse>, tonic::Status>; 3274 2783 /// Server streaming response type for the StreamCurrentTrack method. 3275 2784 type StreamCurrentTrackStream: tonic::codegen::tokio_stream::Stream< 3276 2785 Item = std::result::Result<super::CurrentTrackResponse, tonic::Status>, 3277 - > 3278 - + std::marker::Send 2786 + > + std::marker::Send 3279 2787 + 'static; 3280 2788 async fn stream_current_track( 3281 2789 &self, 3282 2790 request: tonic::Request<super::StreamCurrentTrackRequest>, 3283 - ) -> std::result::Result< 3284 - tonic::Response<Self::StreamCurrentTrackStream>, 3285 - tonic::Status, 3286 - >; 2791 + ) -> std::result::Result<tonic::Response<Self::StreamCurrentTrackStream>, tonic::Status>; 3287 2792 /// Server streaming response type for the StreamStatus method. 3288 2793 type StreamStatusStream: tonic::codegen::tokio_stream::Stream< 3289 2794 Item = std::result::Result<super::StatusResponse, tonic::Status>, 3290 - > 3291 - + std::marker::Send 2795 + > + std::marker::Send 3292 2796 + 'static; 3293 2797 async fn stream_status( 3294 2798 &self, 3295 2799 request: tonic::Request<super::StreamStatusRequest>, 3296 - ) -> std::result::Result< 3297 - tonic::Response<Self::StreamStatusStream>, 3298 - tonic::Status, 3299 - >; 2800 + ) -> std::result::Result<tonic::Response<Self::StreamStatusStream>, tonic::Status>; 3300 2801 /// Server streaming response type for the StreamPlaylist method. 3301 2802 type StreamPlaylistStream: tonic::codegen::tokio_stream::Stream< 3302 2803 Item = std::result::Result<super::PlaylistResponse, tonic::Status>, 3303 - > 3304 - + std::marker::Send 2804 + > + std::marker::Send 3305 2805 + 'static; 3306 2806 async fn stream_playlist( 3307 2807 &self, 3308 2808 request: tonic::Request<super::StreamPlaylistRequest>, 3309 - ) -> std::result::Result< 3310 - tonic::Response<Self::StreamPlaylistStream>, 3311 - tonic::Status, 3312 - >; 2809 + ) -> std::result::Result<tonic::Response<Self::StreamPlaylistStream>, tonic::Status>; 3313 2810 } 3314 2811 #[derive(Debug)] 3315 2812 pub struct PlaybackServiceServer<T> { ··· 3332 2829 max_encoding_message_size: None, 3333 2830 } 3334 2831 } 3335 - pub fn with_interceptor<F>( 3336 - inner: T, 3337 - interceptor: F, 3338 - ) -> InterceptedService<Self, F> 2832 + pub fn with_interceptor<F>(inner: T, interceptor: F) -> InterceptedService<Self, F> 3339 2833 where 3340 2834 F: tonic::service::Interceptor, 3341 2835 { ··· 3390 2884 "/rockbox.v1alpha1.PlaybackService/Play" => { 3391 2885 #[allow(non_camel_case_types)] 3392 2886 struct PlaySvc<T: PlaybackService>(pub Arc<T>); 3393 - impl< 3394 - T: PlaybackService, 3395 - > tonic::server::UnaryService<super::PlayRequest> for PlaySvc<T> { 2887 + impl<T: PlaybackService> tonic::server::UnaryService<super::PlayRequest> for PlaySvc<T> { 3396 2888 type Response = super::PlayResponse; 3397 - type Future = BoxFuture< 3398 - tonic::Response<Self::Response>, 3399 - tonic::Status, 3400 - >; 2889 + type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 3401 2890 fn call( 3402 2891 &mut self, 3403 2892 request: tonic::Request<super::PlayRequest>, 3404 2893 ) -> Self::Future { 3405 2894 let inner = Arc::clone(&self.0); 3406 - let fut = async move { 3407 - <T as PlaybackService>::play(&inner, request).await 3408 - }; 2895 + let fut = 2896 + async move { <T as PlaybackService>::play(&inner, request).await }; 3409 2897 Box::pin(fut) 3410 2898 } 3411 2899 } ··· 3434 2922 "/rockbox.v1alpha1.PlaybackService/Pause" => { 3435 2923 #[allow(non_camel_case_types)] 3436 2924 struct PauseSvc<T: PlaybackService>(pub Arc<T>); 3437 - impl< 3438 - T: PlaybackService, 3439 - > tonic::server::UnaryService<super::PauseRequest> for PauseSvc<T> { 2925 + impl<T: PlaybackService> tonic::server::UnaryService<super::PauseRequest> for PauseSvc<T> { 3440 2926 type Response = super::PauseResponse; 3441 - type Future = BoxFuture< 3442 - tonic::Response<Self::Response>, 3443 - tonic::Status, 3444 - >; 2927 + type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 3445 2928 fn call( 3446 2929 &mut self, 3447 2930 request: tonic::Request<super::PauseRequest>, 3448 2931 ) -> Self::Future { 3449 2932 let inner = Arc::clone(&self.0); 3450 - let fut = async move { 3451 - <T as PlaybackService>::pause(&inner, request).await 3452 - }; 2933 + let fut = 2934 + async move { <T as PlaybackService>::pause(&inner, request).await }; 3453 2935 Box::pin(fut) 3454 2936 } 3455 2937 } ··· 3478 2960 "/rockbox.v1alpha1.PlaybackService/PlayOrPause" => { 3479 2961 #[allow(non_camel_case_types)] 3480 2962 struct PlayOrPauseSvc<T: PlaybackService>(pub Arc<T>); 3481 - impl< 3482 - T: PlaybackService, 3483 - > tonic::server::UnaryService<super::PlayOrPauseRequest> 3484 - for PlayOrPauseSvc<T> { 2963 + impl<T: PlaybackService> tonic::server::UnaryService<super::PlayOrPauseRequest> 2964 + for PlayOrPauseSvc<T> 2965 + { 3485 2966 type Response = super::PlayOrPauseResponse; 3486 - type Future = BoxFuture< 3487 - tonic::Response<Self::Response>, 3488 - tonic::Status, 3489 - >; 2967 + type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 3490 2968 fn call( 3491 2969 &mut self, 3492 2970 request: tonic::Request<super::PlayOrPauseRequest>, ··· 3523 3001 "/rockbox.v1alpha1.PlaybackService/Resume" => { 3524 3002 #[allow(non_camel_case_types)] 3525 3003 struct ResumeSvc<T: PlaybackService>(pub Arc<T>); 3526 - impl< 3527 - T: PlaybackService, 3528 - > tonic::server::UnaryService<super::ResumeRequest> 3529 - for ResumeSvc<T> { 3004 + impl<T: PlaybackService> tonic::server::UnaryService<super::ResumeRequest> for ResumeSvc<T> { 3530 3005 type Response = super::ResumeResponse; 3531 - type Future = BoxFuture< 3532 - tonic::Response<Self::Response>, 3533 - tonic::Status, 3534 - >; 3006 + type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 3535 3007 fn call( 3536 3008 &mut self, 3537 3009 request: tonic::Request<super::ResumeRequest>, ··· 3568 3040 "/rockbox.v1alpha1.PlaybackService/Next" => { 3569 3041 #[allow(non_camel_case_types)] 3570 3042 struct NextSvc<T: PlaybackService>(pub Arc<T>); 3571 - impl< 3572 - T: PlaybackService, 3573 - > tonic::server::UnaryService<super::NextRequest> for NextSvc<T> { 3043 + impl<T: PlaybackService> tonic::server::UnaryService<super::NextRequest> for NextSvc<T> { 3574 3044 type Response = super::NextResponse; 3575 - type Future = BoxFuture< 3576 - tonic::Response<Self::Response>, 3577 - tonic::Status, 3578 - >; 3045 + type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 3579 3046 fn call( 3580 3047 &mut self, 3581 3048 request: tonic::Request<super::NextRequest>, 3582 3049 ) -> Self::Future { 3583 3050 let inner = Arc::clone(&self.0); 3584 - let fut = async move { 3585 - <T as PlaybackService>::next(&inner, request).await 3586 - }; 3051 + let fut = 3052 + async move { <T as PlaybackService>::next(&inner, request).await }; 3587 3053 Box::pin(fut) 3588 3054 } 3589 3055 } ··· 3612 3078 "/rockbox.v1alpha1.PlaybackService/Previous" => { 3613 3079 #[allow(non_camel_case_types)] 3614 3080 struct PreviousSvc<T: PlaybackService>(pub Arc<T>); 3615 - impl< 3616 - T: PlaybackService, 3617 - > tonic::server::UnaryService<super::PreviousRequest> 3618 - for PreviousSvc<T> { 3081 + impl<T: PlaybackService> tonic::server::UnaryService<super::PreviousRequest> for PreviousSvc<T> { 3619 3082 type Response = super::PreviousResponse; 3620 - type Future = BoxFuture< 3621 - tonic::Response<Self::Response>, 3622 - tonic::Status, 3623 - >; 3083 + type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 3624 3084 fn call( 3625 3085 &mut self, 3626 3086 request: tonic::Request<super::PreviousRequest>, ··· 3657 3117 "/rockbox.v1alpha1.PlaybackService/FastForwardRewind" => { 3658 3118 #[allow(non_camel_case_types)] 3659 3119 struct FastForwardRewindSvc<T: PlaybackService>(pub Arc<T>); 3660 - impl< 3661 - T: PlaybackService, 3662 - > tonic::server::UnaryService<super::FastForwardRewindRequest> 3663 - for FastForwardRewindSvc<T> { 3120 + impl<T: PlaybackService> 3121 + tonic::server::UnaryService<super::FastForwardRewindRequest> 3122 + for FastForwardRewindSvc<T> 3123 + { 3664 3124 type Response = super::FastForwardRewindResponse; 3665 - type Future = BoxFuture< 3666 - tonic::Response<Self::Response>, 3667 - tonic::Status, 3668 - >; 3125 + type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 3669 3126 fn call( 3670 3127 &mut self, 3671 3128 request: tonic::Request<super::FastForwardRewindRequest>, 3672 3129 ) -> Self::Future { 3673 3130 let inner = Arc::clone(&self.0); 3674 3131 let fut = async move { 3675 - <T as PlaybackService>::fast_forward_rewind(&inner, request) 3676 - .await 3132 + <T as PlaybackService>::fast_forward_rewind(&inner, request).await 3677 3133 }; 3678 3134 Box::pin(fut) 3679 3135 } ··· 3703 3159 "/rockbox.v1alpha1.PlaybackService/Status" => { 3704 3160 #[allow(non_camel_case_types)] 3705 3161 struct StatusSvc<T: PlaybackService>(pub Arc<T>); 3706 - impl< 3707 - T: PlaybackService, 3708 - > tonic::server::UnaryService<super::StatusRequest> 3709 - for StatusSvc<T> { 3162 + impl<T: PlaybackService> tonic::server::UnaryService<super::StatusRequest> for StatusSvc<T> { 3710 3163 type Response = super::StatusResponse; 3711 - type Future = BoxFuture< 3712 - tonic::Response<Self::Response>, 3713 - tonic::Status, 3714 - >; 3164 + type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 3715 3165 fn call( 3716 3166 &mut self, 3717 3167 request: tonic::Request<super::StatusRequest>, ··· 3748 3198 "/rockbox.v1alpha1.PlaybackService/CurrentTrack" => { 3749 3199 #[allow(non_camel_case_types)] 3750 3200 struct CurrentTrackSvc<T: PlaybackService>(pub Arc<T>); 3751 - impl< 3752 - T: PlaybackService, 3753 - > tonic::server::UnaryService<super::CurrentTrackRequest> 3754 - for CurrentTrackSvc<T> { 3201 + impl<T: PlaybackService> tonic::server::UnaryService<super::CurrentTrackRequest> 3202 + for CurrentTrackSvc<T> 3203 + { 3755 3204 type Response = super::CurrentTrackResponse; 3756 - type Future = BoxFuture< 3757 - tonic::Response<Self::Response>, 3758 - tonic::Status, 3759 - >; 3205 + type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 3760 3206 fn call( 3761 3207 &mut self, 3762 3208 request: tonic::Request<super::CurrentTrackRequest>, ··· 3793 3239 "/rockbox.v1alpha1.PlaybackService/NextTrack" => { 3794 3240 #[allow(non_camel_case_types)] 3795 3241 struct NextTrackSvc<T: PlaybackService>(pub Arc<T>); 3796 - impl< 3797 - T: PlaybackService, 3798 - > tonic::server::UnaryService<super::NextTrackRequest> 3799 - for NextTrackSvc<T> { 3242 + impl<T: PlaybackService> tonic::server::UnaryService<super::NextTrackRequest> for NextTrackSvc<T> { 3800 3243 type Response = super::NextTrackResponse; 3801 - type Future = BoxFuture< 3802 - tonic::Response<Self::Response>, 3803 - tonic::Status, 3804 - >; 3244 + type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 3805 3245 fn call( 3806 3246 &mut self, 3807 3247 request: tonic::Request<super::NextTrackRequest>, ··· 3838 3278 "/rockbox.v1alpha1.PlaybackService/FlushAndReloadTracks" => { 3839 3279 #[allow(non_camel_case_types)] 3840 3280 struct FlushAndReloadTracksSvc<T: PlaybackService>(pub Arc<T>); 3841 - impl< 3842 - T: PlaybackService, 3843 - > tonic::server::UnaryService<super::FlushAndReloadTracksRequest> 3844 - for FlushAndReloadTracksSvc<T> { 3281 + impl<T: PlaybackService> 3282 + tonic::server::UnaryService<super::FlushAndReloadTracksRequest> 3283 + for FlushAndReloadTracksSvc<T> 3284 + { 3845 3285 type Response = super::FlushAndReloadTracksResponse; 3846 - type Future = BoxFuture< 3847 - tonic::Response<Self::Response>, 3848 - tonic::Status, 3849 - >; 3286 + type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 3850 3287 fn call( 3851 3288 &mut self, 3852 3289 request: tonic::Request<super::FlushAndReloadTracksRequest>, 3853 3290 ) -> Self::Future { 3854 3291 let inner = Arc::clone(&self.0); 3855 3292 let fut = async move { 3856 - <T as PlaybackService>::flush_and_reload_tracks( 3857 - &inner, 3858 - request, 3859 - ) 3293 + <T as PlaybackService>::flush_and_reload_tracks(&inner, request) 3860 3294 .await 3861 3295 }; 3862 3296 Box::pin(fut) ··· 3887 3321 "/rockbox.v1alpha1.PlaybackService/GetFilePosition" => { 3888 3322 #[allow(non_camel_case_types)] 3889 3323 struct GetFilePositionSvc<T: PlaybackService>(pub Arc<T>); 3890 - impl< 3891 - T: PlaybackService, 3892 - > tonic::server::UnaryService<super::GetFilePositionRequest> 3893 - for GetFilePositionSvc<T> { 3324 + impl<T: PlaybackService> 3325 + tonic::server::UnaryService<super::GetFilePositionRequest> 3326 + for GetFilePositionSvc<T> 3327 + { 3894 3328 type Response = super::GetFilePositionResponse; 3895 - type Future = BoxFuture< 3896 - tonic::Response<Self::Response>, 3897 - tonic::Status, 3898 - >; 3329 + type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 3899 3330 fn call( 3900 3331 &mut self, 3901 3332 request: tonic::Request<super::GetFilePositionRequest>, 3902 3333 ) -> Self::Future { 3903 3334 let inner = Arc::clone(&self.0); 3904 3335 let fut = async move { 3905 - <T as PlaybackService>::get_file_position(&inner, request) 3906 - .await 3336 + <T as PlaybackService>::get_file_position(&inner, request).await 3907 3337 }; 3908 3338 Box::pin(fut) 3909 3339 } ··· 3933 3363 "/rockbox.v1alpha1.PlaybackService/HardStop" => { 3934 3364 #[allow(non_camel_case_types)] 3935 3365 struct HardStopSvc<T: PlaybackService>(pub Arc<T>); 3936 - impl< 3937 - T: PlaybackService, 3938 - > tonic::server::UnaryService<super::HardStopRequest> 3939 - for HardStopSvc<T> { 3366 + impl<T: PlaybackService> tonic::server::UnaryService<super::HardStopRequest> for HardStopSvc<T> { 3940 3367 type Response = super::HardStopResponse; 3941 - type Future = BoxFuture< 3942 - tonic::Response<Self::Response>, 3943 - tonic::Status, 3944 - >; 3368 + type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 3945 3369 fn call( 3946 3370 &mut self, 3947 3371 request: tonic::Request<super::HardStopRequest>, ··· 3978 3402 "/rockbox.v1alpha1.PlaybackService/PlayAlbum" => { 3979 3403 #[allow(non_camel_case_types)] 3980 3404 struct PlayAlbumSvc<T: PlaybackService>(pub Arc<T>); 3981 - impl< 3982 - T: PlaybackService, 3983 - > tonic::server::UnaryService<super::PlayAlbumRequest> 3984 - for PlayAlbumSvc<T> { 3405 + impl<T: PlaybackService> tonic::server::UnaryService<super::PlayAlbumRequest> for PlayAlbumSvc<T> { 3985 3406 type Response = super::PlayAlbumResponse; 3986 - type Future = BoxFuture< 3987 - tonic::Response<Self::Response>, 3988 - tonic::Status, 3989 - >; 3407 + type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 3990 3408 fn call( 3991 3409 &mut self, 3992 3410 request: tonic::Request<super::PlayAlbumRequest>, ··· 4023 3441 "/rockbox.v1alpha1.PlaybackService/PlayArtistTracks" => { 4024 3442 #[allow(non_camel_case_types)] 4025 3443 struct PlayArtistTracksSvc<T: PlaybackService>(pub Arc<T>); 4026 - impl< 4027 - T: PlaybackService, 4028 - > tonic::server::UnaryService<super::PlayArtistTracksRequest> 4029 - for PlayArtistTracksSvc<T> { 3444 + impl<T: PlaybackService> 3445 + tonic::server::UnaryService<super::PlayArtistTracksRequest> 3446 + for PlayArtistTracksSvc<T> 3447 + { 4030 3448 type Response = super::PlayArtistTracksResponse; 4031 - type Future = BoxFuture< 4032 - tonic::Response<Self::Response>, 4033 - tonic::Status, 4034 - >; 3449 + type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 4035 3450 fn call( 4036 3451 &mut self, 4037 3452 request: tonic::Request<super::PlayArtistTracksRequest>, 4038 3453 ) -> Self::Future { 4039 3454 let inner = Arc::clone(&self.0); 4040 3455 let fut = async move { 4041 - <T as PlaybackService>::play_artist_tracks(&inner, request) 4042 - .await 3456 + <T as PlaybackService>::play_artist_tracks(&inner, request).await 4043 3457 }; 4044 3458 Box::pin(fut) 4045 3459 } ··· 4069 3483 "/rockbox.v1alpha1.PlaybackService/PlayPlaylist" => { 4070 3484 #[allow(non_camel_case_types)] 4071 3485 struct PlayPlaylistSvc<T: PlaybackService>(pub Arc<T>); 4072 - impl< 4073 - T: PlaybackService, 4074 - > tonic::server::UnaryService<super::PlayPlaylistRequest> 4075 - for PlayPlaylistSvc<T> { 3486 + impl<T: PlaybackService> tonic::server::UnaryService<super::PlayPlaylistRequest> 3487 + for PlayPlaylistSvc<T> 3488 + { 4076 3489 type Response = super::PlayPlaylistResponse; 4077 - type Future = BoxFuture< 4078 - tonic::Response<Self::Response>, 4079 - tonic::Status, 4080 - >; 3490 + type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 4081 3491 fn call( 4082 3492 &mut self, 4083 3493 request: tonic::Request<super::PlayPlaylistRequest>, ··· 4114 3524 "/rockbox.v1alpha1.PlaybackService/PlayDirectory" => { 4115 3525 #[allow(non_camel_case_types)] 4116 3526 struct PlayDirectorySvc<T: PlaybackService>(pub Arc<T>); 4117 - impl< 4118 - T: PlaybackService, 4119 - > tonic::server::UnaryService<super::PlayDirectoryRequest> 4120 - for PlayDirectorySvc<T> { 3527 + impl<T: PlaybackService> 3528 + tonic::server::UnaryService<super::PlayDirectoryRequest> 3529 + for PlayDirectorySvc<T> 3530 + { 4121 3531 type Response = super::PlayDirectoryResponse; 4122 - type Future = BoxFuture< 4123 - tonic::Response<Self::Response>, 4124 - tonic::Status, 4125 - >; 3532 + type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 4126 3533 fn call( 4127 3534 &mut self, 4128 3535 request: tonic::Request<super::PlayDirectoryRequest>, 4129 3536 ) -> Self::Future { 4130 3537 let inner = Arc::clone(&self.0); 4131 3538 let fut = async move { 4132 - <T as PlaybackService>::play_directory(&inner, request) 4133 - .await 3539 + <T as PlaybackService>::play_directory(&inner, request).await 4134 3540 }; 4135 3541 Box::pin(fut) 4136 3542 } ··· 4160 3566 "/rockbox.v1alpha1.PlaybackService/PlayMusicDirectory" => { 4161 3567 #[allow(non_camel_case_types)] 4162 3568 struct PlayMusicDirectorySvc<T: PlaybackService>(pub Arc<T>); 4163 - impl< 4164 - T: PlaybackService, 4165 - > tonic::server::UnaryService<super::PlayMusicDirectoryRequest> 4166 - for PlayMusicDirectorySvc<T> { 3569 + impl<T: PlaybackService> 3570 + tonic::server::UnaryService<super::PlayMusicDirectoryRequest> 3571 + for PlayMusicDirectorySvc<T> 3572 + { 4167 3573 type Response = super::PlayMusicDirectoryResponse; 4168 - type Future = BoxFuture< 4169 - tonic::Response<Self::Response>, 4170 - tonic::Status, 4171 - >; 3574 + type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 4172 3575 fn call( 4173 3576 &mut self, 4174 3577 request: tonic::Request<super::PlayMusicDirectoryRequest>, 4175 3578 ) -> Self::Future { 4176 3579 let inner = Arc::clone(&self.0); 4177 3580 let fut = async move { 4178 - <T as PlaybackService>::play_music_directory( 4179 - &inner, 4180 - request, 4181 - ) 4182 - .await 3581 + <T as PlaybackService>::play_music_directory(&inner, request).await 4183 3582 }; 4184 3583 Box::pin(fut) 4185 3584 } ··· 4209 3608 "/rockbox.v1alpha1.PlaybackService/PlayTrack" => { 4210 3609 #[allow(non_camel_case_types)] 4211 3610 struct PlayTrackSvc<T: PlaybackService>(pub Arc<T>); 4212 - impl< 4213 - T: PlaybackService, 4214 - > tonic::server::UnaryService<super::PlayTrackRequest> 4215 - for PlayTrackSvc<T> { 3611 + impl<T: PlaybackService> tonic::server::UnaryService<super::PlayTrackRequest> for PlayTrackSvc<T> { 4216 3612 type Response = super::PlayTrackResponse; 4217 - type Future = BoxFuture< 4218 - tonic::Response<Self::Response>, 4219 - tonic::Status, 4220 - >; 3613 + type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 4221 3614 fn call( 4222 3615 &mut self, 4223 3616 request: tonic::Request<super::PlayTrackRequest>, ··· 4254 3647 "/rockbox.v1alpha1.PlaybackService/PlayLikedTracks" => { 4255 3648 #[allow(non_camel_case_types)] 4256 3649 struct PlayLikedTracksSvc<T: PlaybackService>(pub Arc<T>); 4257 - impl< 4258 - T: PlaybackService, 4259 - > tonic::server::UnaryService<super::PlayLikedTracksRequest> 4260 - for PlayLikedTracksSvc<T> { 3650 + impl<T: PlaybackService> 3651 + tonic::server::UnaryService<super::PlayLikedTracksRequest> 3652 + for PlayLikedTracksSvc<T> 3653 + { 4261 3654 type Response = super::PlayLikedTracksResponse; 4262 - type Future = BoxFuture< 4263 - tonic::Response<Self::Response>, 4264 - tonic::Status, 4265 - >; 3655 + type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 4266 3656 fn call( 4267 3657 &mut self, 4268 3658 request: tonic::Request<super::PlayLikedTracksRequest>, 4269 3659 ) -> Self::Future { 4270 3660 let inner = Arc::clone(&self.0); 4271 3661 let fut = async move { 4272 - <T as PlaybackService>::play_liked_tracks(&inner, request) 4273 - .await 3662 + <T as PlaybackService>::play_liked_tracks(&inner, request).await 4274 3663 }; 4275 3664 Box::pin(fut) 4276 3665 } ··· 4300 3689 "/rockbox.v1alpha1.PlaybackService/PlayAllTracks" => { 4301 3690 #[allow(non_camel_case_types)] 4302 3691 struct PlayAllTracksSvc<T: PlaybackService>(pub Arc<T>); 4303 - impl< 4304 - T: PlaybackService, 4305 - > tonic::server::UnaryService<super::PlayAllTracksRequest> 4306 - for PlayAllTracksSvc<T> { 3692 + impl<T: PlaybackService> 3693 + tonic::server::UnaryService<super::PlayAllTracksRequest> 3694 + for PlayAllTracksSvc<T> 3695 + { 4307 3696 type Response = super::PlayAllTracksResponse; 4308 - type Future = BoxFuture< 4309 - tonic::Response<Self::Response>, 4310 - tonic::Status, 4311 - >; 3697 + type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 4312 3698 fn call( 4313 3699 &mut self, 4314 3700 request: tonic::Request<super::PlayAllTracksRequest>, 4315 3701 ) -> Self::Future { 4316 3702 let inner = Arc::clone(&self.0); 4317 3703 let fut = async move { 4318 - <T as PlaybackService>::play_all_tracks(&inner, request) 4319 - .await 3704 + <T as PlaybackService>::play_all_tracks(&inner, request).await 4320 3705 }; 4321 3706 Box::pin(fut) 4322 3707 } ··· 4346 3731 "/rockbox.v1alpha1.PlaybackService/StreamCurrentTrack" => { 4347 3732 #[allow(non_camel_case_types)] 4348 3733 struct StreamCurrentTrackSvc<T: PlaybackService>(pub Arc<T>); 4349 - impl< 4350 - T: PlaybackService, 4351 - > tonic::server::ServerStreamingService< 4352 - super::StreamCurrentTrackRequest, 4353 - > for StreamCurrentTrackSvc<T> { 3734 + impl<T: PlaybackService> 3735 + tonic::server::ServerStreamingService<super::StreamCurrentTrackRequest> 3736 + for StreamCurrentTrackSvc<T> 3737 + { 4354 3738 type Response = super::CurrentTrackResponse; 4355 3739 type ResponseStream = T::StreamCurrentTrackStream; 4356 - type Future = BoxFuture< 4357 - tonic::Response<Self::ResponseStream>, 4358 - tonic::Status, 4359 - >; 3740 + type Future = 3741 + BoxFuture<tonic::Response<Self::ResponseStream>, tonic::Status>; 4360 3742 fn call( 4361 3743 &mut self, 4362 3744 request: tonic::Request<super::StreamCurrentTrackRequest>, 4363 3745 ) -> Self::Future { 4364 3746 let inner = Arc::clone(&self.0); 4365 3747 let fut = async move { 4366 - <T as PlaybackService>::stream_current_track( 4367 - &inner, 4368 - request, 4369 - ) 4370 - .await 3748 + <T as PlaybackService>::stream_current_track(&inner, request).await 4371 3749 }; 4372 3750 Box::pin(fut) 4373 3751 } ··· 4397 3775 "/rockbox.v1alpha1.PlaybackService/StreamStatus" => { 4398 3776 #[allow(non_camel_case_types)] 4399 3777 struct StreamStatusSvc<T: PlaybackService>(pub Arc<T>); 4400 - impl< 4401 - T: PlaybackService, 4402 - > tonic::server::ServerStreamingService<super::StreamStatusRequest> 4403 - for StreamStatusSvc<T> { 3778 + impl<T: PlaybackService> 3779 + tonic::server::ServerStreamingService<super::StreamStatusRequest> 3780 + for StreamStatusSvc<T> 3781 + { 4404 3782 type Response = super::StatusResponse; 4405 3783 type ResponseStream = T::StreamStatusStream; 4406 - type Future = BoxFuture< 4407 - tonic::Response<Self::ResponseStream>, 4408 - tonic::Status, 4409 - >; 3784 + type Future = 3785 + BoxFuture<tonic::Response<Self::ResponseStream>, tonic::Status>; 4410 3786 fn call( 4411 3787 &mut self, 4412 3788 request: tonic::Request<super::StreamStatusRequest>, ··· 4443 3819 "/rockbox.v1alpha1.PlaybackService/StreamPlaylist" => { 4444 3820 #[allow(non_camel_case_types)] 4445 3821 struct StreamPlaylistSvc<T: PlaybackService>(pub Arc<T>); 4446 - impl< 4447 - T: PlaybackService, 4448 - > tonic::server::ServerStreamingService<super::StreamPlaylistRequest> 4449 - for StreamPlaylistSvc<T> { 3822 + impl<T: PlaybackService> 3823 + tonic::server::ServerStreamingService<super::StreamPlaylistRequest> 3824 + for StreamPlaylistSvc<T> 3825 + { 4450 3826 type Response = super::PlaylistResponse; 4451 3827 type ResponseStream = T::StreamPlaylistStream; 4452 - type Future = BoxFuture< 4453 - tonic::Response<Self::ResponseStream>, 4454 - tonic::Status, 4455 - >; 3828 + type Future = 3829 + BoxFuture<tonic::Response<Self::ResponseStream>, tonic::Status>; 4456 3830 fn call( 4457 3831 &mut self, 4458 3832 request: tonic::Request<super::StreamPlaylistRequest>, 4459 3833 ) -> Self::Future { 4460 3834 let inner = Arc::clone(&self.0); 4461 3835 let fut = async move { 4462 - <T as PlaybackService>::stream_playlist(&inner, request) 4463 - .await 3836 + <T as PlaybackService>::stream_playlist(&inner, request).await 4464 3837 }; 4465 3838 Box::pin(fut) 4466 3839 } ··· 4487 3860 }; 4488 3861 Box::pin(fut) 4489 3862 } 4490 - _ => { 4491 - Box::pin(async move { 4492 - let mut response = http::Response::new(empty_body()); 4493 - let headers = response.headers_mut(); 4494 - headers 4495 - .insert( 4496 - tonic::Status::GRPC_STATUS, 4497 - (tonic::Code::Unimplemented as i32).into(), 4498 - ); 4499 - headers 4500 - .insert( 4501 - http::header::CONTENT_TYPE, 4502 - tonic::metadata::GRPC_CONTENT_TYPE, 4503 - ); 4504 - Ok(response) 4505 - }) 4506 - } 3863 + _ => Box::pin(async move { 3864 + let mut response = http::Response::new(empty_body()); 3865 + let headers = response.headers_mut(); 3866 + headers.insert( 3867 + tonic::Status::GRPC_STATUS, 3868 + (tonic::Code::Unimplemented as i32).into(), 3869 + ); 3870 + headers.insert( 3871 + http::header::CONTENT_TYPE, 3872 + tonic::metadata::GRPC_CONTENT_TYPE, 3873 + ); 3874 + Ok(response) 3875 + }), 4507 3876 } 4508 3877 } 4509 3878 } ··· 4710 4079 dead_code, 4711 4080 missing_docs, 4712 4081 clippy::wildcard_imports, 4713 - clippy::let_unit_value, 4082 + clippy::let_unit_value 4714 4083 )] 4715 - use tonic::codegen::*; 4716 4084 use tonic::codegen::http::Uri; 4085 + use tonic::codegen::*; 4717 4086 #[derive(Debug, Clone)] 4718 4087 pub struct PlaylistServiceClient<T> { 4719 4088 inner: tonic::client::Grpc<T>, ··· 4757 4126 <T as tonic::client::GrpcService<tonic::body::BoxBody>>::ResponseBody, 4758 4127 >, 4759 4128 >, 4760 - <T as tonic::codegen::Service< 4761 - http::Request<tonic::body::BoxBody>, 4762 - >>::Error: Into<StdError> + std::marker::Send + std::marker::Sync, 4129 + <T as tonic::codegen::Service<http::Request<tonic::body::BoxBody>>>::Error: 4130 + Into<StdError> + std::marker::Send + std::marker::Sync, 4763 4131 { 4764 4132 PlaylistServiceClient::new(InterceptedService::new(inner, interceptor)) 4765 4133 } ··· 4797 4165 pub async fn get_current( 4798 4166 &mut self, 4799 4167 request: impl tonic::IntoRequest<super::GetCurrentRequest>, 4800 - ) -> std::result::Result< 4801 - tonic::Response<super::GetCurrentResponse>, 4802 - tonic::Status, 4803 - > { 4804 - self.inner 4805 - .ready() 4806 - .await 4807 - .map_err(|e| { 4808 - tonic::Status::unknown( 4809 - format!("Service was not ready: {}", e.into()), 4810 - ) 4811 - })?; 4168 + ) -> std::result::Result<tonic::Response<super::GetCurrentResponse>, tonic::Status> 4169 + { 4170 + self.inner.ready().await.map_err(|e| { 4171 + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 4172 + })?; 4812 4173 let codec = tonic::codec::ProstCodec::default(); 4813 4174 let path = http::uri::PathAndQuery::from_static( 4814 4175 "/rockbox.v1alpha1.PlaylistService/GetCurrent", 4815 4176 ); 4816 4177 let mut req = request.into_request(); 4817 - req.extensions_mut() 4818 - .insert( 4819 - GrpcMethod::new("rockbox.v1alpha1.PlaylistService", "GetCurrent"), 4820 - ); 4178 + req.extensions_mut().insert(GrpcMethod::new( 4179 + "rockbox.v1alpha1.PlaylistService", 4180 + "GetCurrent", 4181 + )); 4821 4182 self.inner.unary(req, path, codec).await 4822 4183 } 4823 4184 pub async fn get_resume_info( 4824 4185 &mut self, 4825 4186 request: impl tonic::IntoRequest<super::GetResumeInfoRequest>, 4826 - ) -> std::result::Result< 4827 - tonic::Response<super::GetResumeInfoResponse>, 4828 - tonic::Status, 4829 - > { 4830 - self.inner 4831 - .ready() 4832 - .await 4833 - .map_err(|e| { 4834 - tonic::Status::unknown( 4835 - format!("Service was not ready: {}", e.into()), 4836 - ) 4837 - })?; 4187 + ) -> std::result::Result<tonic::Response<super::GetResumeInfoResponse>, tonic::Status> 4188 + { 4189 + self.inner.ready().await.map_err(|e| { 4190 + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 4191 + })?; 4838 4192 let codec = tonic::codec::ProstCodec::default(); 4839 4193 let path = http::uri::PathAndQuery::from_static( 4840 4194 "/rockbox.v1alpha1.PlaylistService/GetResumeInfo", 4841 4195 ); 4842 4196 let mut req = request.into_request(); 4843 - req.extensions_mut() 4844 - .insert( 4845 - GrpcMethod::new("rockbox.v1alpha1.PlaylistService", "GetResumeInfo"), 4846 - ); 4197 + req.extensions_mut().insert(GrpcMethod::new( 4198 + "rockbox.v1alpha1.PlaylistService", 4199 + "GetResumeInfo", 4200 + )); 4847 4201 self.inner.unary(req, path, codec).await 4848 4202 } 4849 4203 pub async fn get_track_info( 4850 4204 &mut self, 4851 4205 request: impl tonic::IntoRequest<super::GetTrackInfoRequest>, 4852 - ) -> std::result::Result< 4853 - tonic::Response<super::GetTrackInfoResponse>, 4854 - tonic::Status, 4855 - > { 4856 - self.inner 4857 - .ready() 4858 - .await 4859 - .map_err(|e| { 4860 - tonic::Status::unknown( 4861 - format!("Service was not ready: {}", e.into()), 4862 - ) 4863 - })?; 4206 + ) -> std::result::Result<tonic::Response<super::GetTrackInfoResponse>, tonic::Status> 4207 + { 4208 + self.inner.ready().await.map_err(|e| { 4209 + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 4210 + })?; 4864 4211 let codec = tonic::codec::ProstCodec::default(); 4865 4212 let path = http::uri::PathAndQuery::from_static( 4866 4213 "/rockbox.v1alpha1.PlaylistService/GetTrackInfo", 4867 4214 ); 4868 4215 let mut req = request.into_request(); 4869 - req.extensions_mut() 4870 - .insert( 4871 - GrpcMethod::new("rockbox.v1alpha1.PlaylistService", "GetTrackInfo"), 4872 - ); 4216 + req.extensions_mut().insert(GrpcMethod::new( 4217 + "rockbox.v1alpha1.PlaylistService", 4218 + "GetTrackInfo", 4219 + )); 4873 4220 self.inner.unary(req, path, codec).await 4874 4221 } 4875 4222 pub async fn get_first_index( 4876 4223 &mut self, 4877 4224 request: impl tonic::IntoRequest<super::GetFirstIndexRequest>, 4878 - ) -> std::result::Result< 4879 - tonic::Response<super::GetFirstIndexResponse>, 4880 - tonic::Status, 4881 - > { 4882 - self.inner 4883 - .ready() 4884 - .await 4885 - .map_err(|e| { 4886 - tonic::Status::unknown( 4887 - format!("Service was not ready: {}", e.into()), 4888 - ) 4889 - })?; 4225 + ) -> std::result::Result<tonic::Response<super::GetFirstIndexResponse>, tonic::Status> 4226 + { 4227 + self.inner.ready().await.map_err(|e| { 4228 + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 4229 + })?; 4890 4230 let codec = tonic::codec::ProstCodec::default(); 4891 4231 let path = http::uri::PathAndQuery::from_static( 4892 4232 "/rockbox.v1alpha1.PlaylistService/GetFirstIndex", 4893 4233 ); 4894 4234 let mut req = request.into_request(); 4895 - req.extensions_mut() 4896 - .insert( 4897 - GrpcMethod::new("rockbox.v1alpha1.PlaylistService", "GetFirstIndex"), 4898 - ); 4235 + req.extensions_mut().insert(GrpcMethod::new( 4236 + "rockbox.v1alpha1.PlaylistService", 4237 + "GetFirstIndex", 4238 + )); 4899 4239 self.inner.unary(req, path, codec).await 4900 4240 } 4901 4241 pub async fn get_display_index( 4902 4242 &mut self, 4903 4243 request: impl tonic::IntoRequest<super::GetDisplayIndexRequest>, 4904 - ) -> std::result::Result< 4905 - tonic::Response<super::GetDisplayIndexResponse>, 4906 - tonic::Status, 4907 - > { 4908 - self.inner 4909 - .ready() 4910 - .await 4911 - .map_err(|e| { 4912 - tonic::Status::unknown( 4913 - format!("Service was not ready: {}", e.into()), 4914 - ) 4915 - })?; 4244 + ) -> std::result::Result<tonic::Response<super::GetDisplayIndexResponse>, tonic::Status> 4245 + { 4246 + self.inner.ready().await.map_err(|e| { 4247 + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 4248 + })?; 4916 4249 let codec = tonic::codec::ProstCodec::default(); 4917 4250 let path = http::uri::PathAndQuery::from_static( 4918 4251 "/rockbox.v1alpha1.PlaylistService/GetDisplayIndex", 4919 4252 ); 4920 4253 let mut req = request.into_request(); 4921 - req.extensions_mut() 4922 - .insert( 4923 - GrpcMethod::new( 4924 - "rockbox.v1alpha1.PlaylistService", 4925 - "GetDisplayIndex", 4926 - ), 4927 - ); 4254 + req.extensions_mut().insert(GrpcMethod::new( 4255 + "rockbox.v1alpha1.PlaylistService", 4256 + "GetDisplayIndex", 4257 + )); 4928 4258 self.inner.unary(req, path, codec).await 4929 4259 } 4930 4260 pub async fn amount( 4931 4261 &mut self, 4932 4262 request: impl tonic::IntoRequest<super::AmountRequest>, 4933 4263 ) -> std::result::Result<tonic::Response<super::AmountResponse>, tonic::Status> { 4934 - self.inner 4935 - .ready() 4936 - .await 4937 - .map_err(|e| { 4938 - tonic::Status::unknown( 4939 - format!("Service was not ready: {}", e.into()), 4940 - ) 4941 - })?; 4264 + self.inner.ready().await.map_err(|e| { 4265 + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 4266 + })?; 4942 4267 let codec = tonic::codec::ProstCodec::default(); 4943 - let path = http::uri::PathAndQuery::from_static( 4944 - "/rockbox.v1alpha1.PlaylistService/Amount", 4945 - ); 4268 + let path = 4269 + http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.PlaylistService/Amount"); 4946 4270 let mut req = request.into_request(); 4947 - req.extensions_mut() 4948 - .insert(GrpcMethod::new("rockbox.v1alpha1.PlaylistService", "Amount")); 4271 + req.extensions_mut().insert(GrpcMethod::new( 4272 + "rockbox.v1alpha1.PlaylistService", 4273 + "Amount", 4274 + )); 4949 4275 self.inner.unary(req, path, codec).await 4950 4276 } 4951 4277 pub async fn playlist_resume( 4952 4278 &mut self, 4953 4279 request: impl tonic::IntoRequest<super::PlaylistResumeRequest>, 4954 - ) -> std::result::Result< 4955 - tonic::Response<super::PlaylistResumeResponse>, 4956 - tonic::Status, 4957 - > { 4958 - self.inner 4959 - .ready() 4960 - .await 4961 - .map_err(|e| { 4962 - tonic::Status::unknown( 4963 - format!("Service was not ready: {}", e.into()), 4964 - ) 4965 - })?; 4280 + ) -> std::result::Result<tonic::Response<super::PlaylistResumeResponse>, tonic::Status> 4281 + { 4282 + self.inner.ready().await.map_err(|e| { 4283 + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 4284 + })?; 4966 4285 let codec = tonic::codec::ProstCodec::default(); 4967 4286 let path = http::uri::PathAndQuery::from_static( 4968 4287 "/rockbox.v1alpha1.PlaylistService/PlaylistResume", 4969 4288 ); 4970 4289 let mut req = request.into_request(); 4971 - req.extensions_mut() 4972 - .insert( 4973 - GrpcMethod::new("rockbox.v1alpha1.PlaylistService", "PlaylistResume"), 4974 - ); 4290 + req.extensions_mut().insert(GrpcMethod::new( 4291 + "rockbox.v1alpha1.PlaylistService", 4292 + "PlaylistResume", 4293 + )); 4975 4294 self.inner.unary(req, path, codec).await 4976 4295 } 4977 4296 pub async fn resume_track( 4978 4297 &mut self, 4979 4298 request: impl tonic::IntoRequest<super::ResumeTrackRequest>, 4980 - ) -> std::result::Result< 4981 - tonic::Response<super::ResumeTrackResponse>, 4982 - tonic::Status, 4983 - > { 4984 - self.inner 4985 - .ready() 4986 - .await 4987 - .map_err(|e| { 4988 - tonic::Status::unknown( 4989 - format!("Service was not ready: {}", e.into()), 4990 - ) 4991 - })?; 4299 + ) -> std::result::Result<tonic::Response<super::ResumeTrackResponse>, tonic::Status> 4300 + { 4301 + self.inner.ready().await.map_err(|e| { 4302 + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 4303 + })?; 4992 4304 let codec = tonic::codec::ProstCodec::default(); 4993 4305 let path = http::uri::PathAndQuery::from_static( 4994 4306 "/rockbox.v1alpha1.PlaylistService/ResumeTrack", 4995 4307 ); 4996 4308 let mut req = request.into_request(); 4997 - req.extensions_mut() 4998 - .insert( 4999 - GrpcMethod::new("rockbox.v1alpha1.PlaylistService", "ResumeTrack"), 5000 - ); 4309 + req.extensions_mut().insert(GrpcMethod::new( 4310 + "rockbox.v1alpha1.PlaylistService", 4311 + "ResumeTrack", 4312 + )); 5001 4313 self.inner.unary(req, path, codec).await 5002 4314 } 5003 4315 pub async fn set_modified( 5004 4316 &mut self, 5005 4317 request: impl tonic::IntoRequest<super::SetModifiedRequest>, 5006 - ) -> std::result::Result< 5007 - tonic::Response<super::SetModifiedResponse>, 5008 - tonic::Status, 5009 - > { 5010 - self.inner 5011 - .ready() 5012 - .await 5013 - .map_err(|e| { 5014 - tonic::Status::unknown( 5015 - format!("Service was not ready: {}", e.into()), 5016 - ) 5017 - })?; 4318 + ) -> std::result::Result<tonic::Response<super::SetModifiedResponse>, tonic::Status> 4319 + { 4320 + self.inner.ready().await.map_err(|e| { 4321 + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 4322 + })?; 5018 4323 let codec = tonic::codec::ProstCodec::default(); 5019 4324 let path = http::uri::PathAndQuery::from_static( 5020 4325 "/rockbox.v1alpha1.PlaylistService/SetModified", 5021 4326 ); 5022 4327 let mut req = request.into_request(); 5023 - req.extensions_mut() 5024 - .insert( 5025 - GrpcMethod::new("rockbox.v1alpha1.PlaylistService", "SetModified"), 5026 - ); 4328 + req.extensions_mut().insert(GrpcMethod::new( 4329 + "rockbox.v1alpha1.PlaylistService", 4330 + "SetModified", 4331 + )); 5027 4332 self.inner.unary(req, path, codec).await 5028 4333 } 5029 4334 pub async fn start( 5030 4335 &mut self, 5031 4336 request: impl tonic::IntoRequest<super::StartRequest>, 5032 4337 ) -> std::result::Result<tonic::Response<super::StartResponse>, tonic::Status> { 5033 - self.inner 5034 - .ready() 5035 - .await 5036 - .map_err(|e| { 5037 - tonic::Status::unknown( 5038 - format!("Service was not ready: {}", e.into()), 5039 - ) 5040 - })?; 4338 + self.inner.ready().await.map_err(|e| { 4339 + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 4340 + })?; 5041 4341 let codec = tonic::codec::ProstCodec::default(); 5042 - let path = http::uri::PathAndQuery::from_static( 5043 - "/rockbox.v1alpha1.PlaylistService/Start", 5044 - ); 4342 + let path = 4343 + http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.PlaylistService/Start"); 5045 4344 let mut req = request.into_request(); 5046 4345 req.extensions_mut() 5047 4346 .insert(GrpcMethod::new("rockbox.v1alpha1.PlaylistService", "Start")); ··· 5051 4350 &mut self, 5052 4351 request: impl tonic::IntoRequest<super::SyncRequest>, 5053 4352 ) -> std::result::Result<tonic::Response<super::SyncResponse>, tonic::Status> { 5054 - self.inner 5055 - .ready() 5056 - .await 5057 - .map_err(|e| { 5058 - tonic::Status::unknown( 5059 - format!("Service was not ready: {}", e.into()), 5060 - ) 5061 - })?; 4353 + self.inner.ready().await.map_err(|e| { 4354 + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 4355 + })?; 5062 4356 let codec = tonic::codec::ProstCodec::default(); 5063 - let path = http::uri::PathAndQuery::from_static( 5064 - "/rockbox.v1alpha1.PlaylistService/Sync", 5065 - ); 4357 + let path = 4358 + http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.PlaylistService/Sync"); 5066 4359 let mut req = request.into_request(); 5067 4360 req.extensions_mut() 5068 4361 .insert(GrpcMethod::new("rockbox.v1alpha1.PlaylistService", "Sync")); ··· 5071 4364 pub async fn remove_all_tracks( 5072 4365 &mut self, 5073 4366 request: impl tonic::IntoRequest<super::RemoveAllTracksRequest>, 5074 - ) -> std::result::Result< 5075 - tonic::Response<super::RemoveAllTracksResponse>, 5076 - tonic::Status, 5077 - > { 5078 - self.inner 5079 - .ready() 5080 - .await 5081 - .map_err(|e| { 5082 - tonic::Status::unknown( 5083 - format!("Service was not ready: {}", e.into()), 5084 - ) 5085 - })?; 4367 + ) -> std::result::Result<tonic::Response<super::RemoveAllTracksResponse>, tonic::Status> 4368 + { 4369 + self.inner.ready().await.map_err(|e| { 4370 + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 4371 + })?; 5086 4372 let codec = tonic::codec::ProstCodec::default(); 5087 4373 let path = http::uri::PathAndQuery::from_static( 5088 4374 "/rockbox.v1alpha1.PlaylistService/RemoveAllTracks", 5089 4375 ); 5090 4376 let mut req = request.into_request(); 5091 - req.extensions_mut() 5092 - .insert( 5093 - GrpcMethod::new( 5094 - "rockbox.v1alpha1.PlaylistService", 5095 - "RemoveAllTracks", 5096 - ), 5097 - ); 4377 + req.extensions_mut().insert(GrpcMethod::new( 4378 + "rockbox.v1alpha1.PlaylistService", 4379 + "RemoveAllTracks", 4380 + )); 5098 4381 self.inner.unary(req, path, codec).await 5099 4382 } 5100 4383 pub async fn remove_tracks( 5101 4384 &mut self, 5102 4385 request: impl tonic::IntoRequest<super::RemoveTracksRequest>, 5103 - ) -> std::result::Result< 5104 - tonic::Response<super::RemoveTracksResponse>, 5105 - tonic::Status, 5106 - > { 5107 - self.inner 5108 - .ready() 5109 - .await 5110 - .map_err(|e| { 5111 - tonic::Status::unknown( 5112 - format!("Service was not ready: {}", e.into()), 5113 - ) 5114 - })?; 4386 + ) -> std::result::Result<tonic::Response<super::RemoveTracksResponse>, tonic::Status> 4387 + { 4388 + self.inner.ready().await.map_err(|e| { 4389 + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 4390 + })?; 5115 4391 let codec = tonic::codec::ProstCodec::default(); 5116 4392 let path = http::uri::PathAndQuery::from_static( 5117 4393 "/rockbox.v1alpha1.PlaylistService/RemoveTracks", 5118 4394 ); 5119 4395 let mut req = request.into_request(); 5120 - req.extensions_mut() 5121 - .insert( 5122 - GrpcMethod::new("rockbox.v1alpha1.PlaylistService", "RemoveTracks"), 5123 - ); 4396 + req.extensions_mut().insert(GrpcMethod::new( 4397 + "rockbox.v1alpha1.PlaylistService", 4398 + "RemoveTracks", 4399 + )); 5124 4400 self.inner.unary(req, path, codec).await 5125 4401 } 5126 4402 pub async fn create_playlist( 5127 4403 &mut self, 5128 4404 request: impl tonic::IntoRequest<super::CreatePlaylistRequest>, 5129 - ) -> std::result::Result< 5130 - tonic::Response<super::CreatePlaylistResponse>, 5131 - tonic::Status, 5132 - > { 5133 - self.inner 5134 - .ready() 5135 - .await 5136 - .map_err(|e| { 5137 - tonic::Status::unknown( 5138 - format!("Service was not ready: {}", e.into()), 5139 - ) 5140 - })?; 4405 + ) -> std::result::Result<tonic::Response<super::CreatePlaylistResponse>, tonic::Status> 4406 + { 4407 + self.inner.ready().await.map_err(|e| { 4408 + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 4409 + })?; 5141 4410 let codec = tonic::codec::ProstCodec::default(); 5142 4411 let path = http::uri::PathAndQuery::from_static( 5143 4412 "/rockbox.v1alpha1.PlaylistService/CreatePlaylist", 5144 4413 ); 5145 4414 let mut req = request.into_request(); 5146 - req.extensions_mut() 5147 - .insert( 5148 - GrpcMethod::new("rockbox.v1alpha1.PlaylistService", "CreatePlaylist"), 5149 - ); 4415 + req.extensions_mut().insert(GrpcMethod::new( 4416 + "rockbox.v1alpha1.PlaylistService", 4417 + "CreatePlaylist", 4418 + )); 5150 4419 self.inner.unary(req, path, codec).await 5151 4420 } 5152 4421 pub async fn insert_tracks( 5153 4422 &mut self, 5154 4423 request: impl tonic::IntoRequest<super::InsertTracksRequest>, 5155 - ) -> std::result::Result< 5156 - tonic::Response<super::InsertTracksResponse>, 5157 - tonic::Status, 5158 - > { 5159 - self.inner 5160 - .ready() 5161 - .await 5162 - .map_err(|e| { 5163 - tonic::Status::unknown( 5164 - format!("Service was not ready: {}", e.into()), 5165 - ) 5166 - })?; 4424 + ) -> std::result::Result<tonic::Response<super::InsertTracksResponse>, tonic::Status> 4425 + { 4426 + self.inner.ready().await.map_err(|e| { 4427 + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 4428 + })?; 5167 4429 let codec = tonic::codec::ProstCodec::default(); 5168 4430 let path = http::uri::PathAndQuery::from_static( 5169 4431 "/rockbox.v1alpha1.PlaylistService/InsertTracks", 5170 4432 ); 5171 4433 let mut req = request.into_request(); 5172 - req.extensions_mut() 5173 - .insert( 5174 - GrpcMethod::new("rockbox.v1alpha1.PlaylistService", "InsertTracks"), 5175 - ); 4434 + req.extensions_mut().insert(GrpcMethod::new( 4435 + "rockbox.v1alpha1.PlaylistService", 4436 + "InsertTracks", 4437 + )); 5176 4438 self.inner.unary(req, path, codec).await 5177 4439 } 5178 4440 pub async fn insert_directory( 5179 4441 &mut self, 5180 4442 request: impl tonic::IntoRequest<super::InsertDirectoryRequest>, 5181 - ) -> std::result::Result< 5182 - tonic::Response<super::InsertDirectoryResponse>, 5183 - tonic::Status, 5184 - > { 5185 - self.inner 5186 - .ready() 5187 - .await 5188 - .map_err(|e| { 5189 - tonic::Status::unknown( 5190 - format!("Service was not ready: {}", e.into()), 5191 - ) 5192 - })?; 4443 + ) -> std::result::Result<tonic::Response<super::InsertDirectoryResponse>, tonic::Status> 4444 + { 4445 + self.inner.ready().await.map_err(|e| { 4446 + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 4447 + })?; 5193 4448 let codec = tonic::codec::ProstCodec::default(); 5194 4449 let path = http::uri::PathAndQuery::from_static( 5195 4450 "/rockbox.v1alpha1.PlaylistService/InsertDirectory", 5196 4451 ); 5197 4452 let mut req = request.into_request(); 5198 - req.extensions_mut() 5199 - .insert( 5200 - GrpcMethod::new( 5201 - "rockbox.v1alpha1.PlaylistService", 5202 - "InsertDirectory", 5203 - ), 5204 - ); 4453 + req.extensions_mut().insert(GrpcMethod::new( 4454 + "rockbox.v1alpha1.PlaylistService", 4455 + "InsertDirectory", 4456 + )); 5205 4457 self.inner.unary(req, path, codec).await 5206 4458 } 5207 4459 pub async fn insert_playlist( 5208 4460 &mut self, 5209 4461 request: impl tonic::IntoRequest<super::InsertPlaylistRequest>, 5210 - ) -> std::result::Result< 5211 - tonic::Response<super::InsertPlaylistResponse>, 5212 - tonic::Status, 5213 - > { 5214 - self.inner 5215 - .ready() 5216 - .await 5217 - .map_err(|e| { 5218 - tonic::Status::unknown( 5219 - format!("Service was not ready: {}", e.into()), 5220 - ) 5221 - })?; 4462 + ) -> std::result::Result<tonic::Response<super::InsertPlaylistResponse>, tonic::Status> 4463 + { 4464 + self.inner.ready().await.map_err(|e| { 4465 + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 4466 + })?; 5222 4467 let codec = tonic::codec::ProstCodec::default(); 5223 4468 let path = http::uri::PathAndQuery::from_static( 5224 4469 "/rockbox.v1alpha1.PlaylistService/InsertPlaylist", 5225 4470 ); 5226 4471 let mut req = request.into_request(); 5227 - req.extensions_mut() 5228 - .insert( 5229 - GrpcMethod::new("rockbox.v1alpha1.PlaylistService", "InsertPlaylist"), 5230 - ); 4472 + req.extensions_mut().insert(GrpcMethod::new( 4473 + "rockbox.v1alpha1.PlaylistService", 4474 + "InsertPlaylist", 4475 + )); 5231 4476 self.inner.unary(req, path, codec).await 5232 4477 } 5233 4478 pub async fn insert_album( 5234 4479 &mut self, 5235 4480 request: impl tonic::IntoRequest<super::InsertAlbumRequest>, 5236 - ) -> std::result::Result< 5237 - tonic::Response<super::InsertAlbumResponse>, 5238 - tonic::Status, 5239 - > { 5240 - self.inner 5241 - .ready() 5242 - .await 5243 - .map_err(|e| { 5244 - tonic::Status::unknown( 5245 - format!("Service was not ready: {}", e.into()), 5246 - ) 5247 - })?; 4481 + ) -> std::result::Result<tonic::Response<super::InsertAlbumResponse>, tonic::Status> 4482 + { 4483 + self.inner.ready().await.map_err(|e| { 4484 + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 4485 + })?; 5248 4486 let codec = tonic::codec::ProstCodec::default(); 5249 4487 let path = http::uri::PathAndQuery::from_static( 5250 4488 "/rockbox.v1alpha1.PlaylistService/InsertAlbum", 5251 4489 ); 5252 4490 let mut req = request.into_request(); 5253 - req.extensions_mut() 5254 - .insert( 5255 - GrpcMethod::new("rockbox.v1alpha1.PlaylistService", "InsertAlbum"), 5256 - ); 4491 + req.extensions_mut().insert(GrpcMethod::new( 4492 + "rockbox.v1alpha1.PlaylistService", 4493 + "InsertAlbum", 4494 + )); 5257 4495 self.inner.unary(req, path, codec).await 5258 4496 } 5259 4497 pub async fn insert_artist_tracks( 5260 4498 &mut self, 5261 4499 request: impl tonic::IntoRequest<super::InsertArtistTracksRequest>, 5262 - ) -> std::result::Result< 5263 - tonic::Response<super::InsertArtistTracksResponse>, 5264 - tonic::Status, 5265 - > { 5266 - self.inner 5267 - .ready() 5268 - .await 5269 - .map_err(|e| { 5270 - tonic::Status::unknown( 5271 - format!("Service was not ready: {}", e.into()), 5272 - ) 5273 - })?; 4500 + ) -> std::result::Result<tonic::Response<super::InsertArtistTracksResponse>, tonic::Status> 4501 + { 4502 + self.inner.ready().await.map_err(|e| { 4503 + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 4504 + })?; 5274 4505 let codec = tonic::codec::ProstCodec::default(); 5275 4506 let path = http::uri::PathAndQuery::from_static( 5276 4507 "/rockbox.v1alpha1.PlaylistService/InsertArtistTracks", 5277 4508 ); 5278 4509 let mut req = request.into_request(); 5279 - req.extensions_mut() 5280 - .insert( 5281 - GrpcMethod::new( 5282 - "rockbox.v1alpha1.PlaylistService", 5283 - "InsertArtistTracks", 5284 - ), 5285 - ); 4510 + req.extensions_mut().insert(GrpcMethod::new( 4511 + "rockbox.v1alpha1.PlaylistService", 4512 + "InsertArtistTracks", 4513 + )); 5286 4514 self.inner.unary(req, path, codec).await 5287 4515 } 5288 4516 pub async fn shuffle_playlist( 5289 4517 &mut self, 5290 4518 request: impl tonic::IntoRequest<super::ShufflePlaylistRequest>, 5291 - ) -> std::result::Result< 5292 - tonic::Response<super::ShufflePlaylistResponse>, 5293 - tonic::Status, 5294 - > { 5295 - self.inner 5296 - .ready() 5297 - .await 5298 - .map_err(|e| { 5299 - tonic::Status::unknown( 5300 - format!("Service was not ready: {}", e.into()), 5301 - ) 5302 - })?; 4519 + ) -> std::result::Result<tonic::Response<super::ShufflePlaylistResponse>, tonic::Status> 4520 + { 4521 + self.inner.ready().await.map_err(|e| { 4522 + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 4523 + })?; 5303 4524 let codec = tonic::codec::ProstCodec::default(); 5304 4525 let path = http::uri::PathAndQuery::from_static( 5305 4526 "/rockbox.v1alpha1.PlaylistService/ShufflePlaylist", 5306 4527 ); 5307 4528 let mut req = request.into_request(); 5308 - req.extensions_mut() 5309 - .insert( 5310 - GrpcMethod::new( 5311 - "rockbox.v1alpha1.PlaylistService", 5312 - "ShufflePlaylist", 5313 - ), 5314 - ); 4529 + req.extensions_mut().insert(GrpcMethod::new( 4530 + "rockbox.v1alpha1.PlaylistService", 4531 + "ShufflePlaylist", 4532 + )); 5315 4533 self.inner.unary(req, path, codec).await 5316 4534 } 5317 4535 } ··· 5323 4541 dead_code, 5324 4542 missing_docs, 5325 4543 clippy::wildcard_imports, 5326 - clippy::let_unit_value, 4544 + clippy::let_unit_value 5327 4545 )] 5328 4546 use tonic::codegen::*; 5329 4547 /// Generated trait containing gRPC methods that should be implemented for use with PlaylistServiceServer. ··· 5332 4550 async fn get_current( 5333 4551 &self, 5334 4552 request: tonic::Request<super::GetCurrentRequest>, 5335 - ) -> std::result::Result< 5336 - tonic::Response<super::GetCurrentResponse>, 5337 - tonic::Status, 5338 - >; 4553 + ) -> std::result::Result<tonic::Response<super::GetCurrentResponse>, tonic::Status>; 5339 4554 async fn get_resume_info( 5340 4555 &self, 5341 4556 request: tonic::Request<super::GetResumeInfoRequest>, 5342 - ) -> std::result::Result< 5343 - tonic::Response<super::GetResumeInfoResponse>, 5344 - tonic::Status, 5345 - >; 4557 + ) -> std::result::Result<tonic::Response<super::GetResumeInfoResponse>, tonic::Status>; 5346 4558 async fn get_track_info( 5347 4559 &self, 5348 4560 request: tonic::Request<super::GetTrackInfoRequest>, 5349 - ) -> std::result::Result< 5350 - tonic::Response<super::GetTrackInfoResponse>, 5351 - tonic::Status, 5352 - >; 4561 + ) -> std::result::Result<tonic::Response<super::GetTrackInfoResponse>, tonic::Status>; 5353 4562 async fn get_first_index( 5354 4563 &self, 5355 4564 request: tonic::Request<super::GetFirstIndexRequest>, 5356 - ) -> std::result::Result< 5357 - tonic::Response<super::GetFirstIndexResponse>, 5358 - tonic::Status, 5359 - >; 4565 + ) -> std::result::Result<tonic::Response<super::GetFirstIndexResponse>, tonic::Status>; 5360 4566 async fn get_display_index( 5361 4567 &self, 5362 4568 request: tonic::Request<super::GetDisplayIndexRequest>, 5363 - ) -> std::result::Result< 5364 - tonic::Response<super::GetDisplayIndexResponse>, 5365 - tonic::Status, 5366 - >; 4569 + ) -> std::result::Result<tonic::Response<super::GetDisplayIndexResponse>, tonic::Status>; 5367 4570 async fn amount( 5368 4571 &self, 5369 4572 request: tonic::Request<super::AmountRequest>, ··· 5371 4574 async fn playlist_resume( 5372 4575 &self, 5373 4576 request: tonic::Request<super::PlaylistResumeRequest>, 5374 - ) -> std::result::Result< 5375 - tonic::Response<super::PlaylistResumeResponse>, 5376 - tonic::Status, 5377 - >; 4577 + ) -> std::result::Result<tonic::Response<super::PlaylistResumeResponse>, tonic::Status>; 5378 4578 async fn resume_track( 5379 4579 &self, 5380 4580 request: tonic::Request<super::ResumeTrackRequest>, 5381 - ) -> std::result::Result< 5382 - tonic::Response<super::ResumeTrackResponse>, 5383 - tonic::Status, 5384 - >; 4581 + ) -> std::result::Result<tonic::Response<super::ResumeTrackResponse>, tonic::Status>; 5385 4582 async fn set_modified( 5386 4583 &self, 5387 4584 request: tonic::Request<super::SetModifiedRequest>, 5388 - ) -> std::result::Result< 5389 - tonic::Response<super::SetModifiedResponse>, 5390 - tonic::Status, 5391 - >; 4585 + ) -> std::result::Result<tonic::Response<super::SetModifiedResponse>, tonic::Status>; 5392 4586 async fn start( 5393 4587 &self, 5394 4588 request: tonic::Request<super::StartRequest>, ··· 5400 4594 async fn remove_all_tracks( 5401 4595 &self, 5402 4596 request: tonic::Request<super::RemoveAllTracksRequest>, 5403 - ) -> std::result::Result< 5404 - tonic::Response<super::RemoveAllTracksResponse>, 5405 - tonic::Status, 5406 - >; 4597 + ) -> std::result::Result<tonic::Response<super::RemoveAllTracksResponse>, tonic::Status>; 5407 4598 async fn remove_tracks( 5408 4599 &self, 5409 4600 request: tonic::Request<super::RemoveTracksRequest>, 5410 - ) -> std::result::Result< 5411 - tonic::Response<super::RemoveTracksResponse>, 5412 - tonic::Status, 5413 - >; 4601 + ) -> std::result::Result<tonic::Response<super::RemoveTracksResponse>, tonic::Status>; 5414 4602 async fn create_playlist( 5415 4603 &self, 5416 4604 request: tonic::Request<super::CreatePlaylistRequest>, 5417 - ) -> std::result::Result< 5418 - tonic::Response<super::CreatePlaylistResponse>, 5419 - tonic::Status, 5420 - >; 4605 + ) -> std::result::Result<tonic::Response<super::CreatePlaylistResponse>, tonic::Status>; 5421 4606 async fn insert_tracks( 5422 4607 &self, 5423 4608 request: tonic::Request<super::InsertTracksRequest>, 5424 - ) -> std::result::Result< 5425 - tonic::Response<super::InsertTracksResponse>, 5426 - tonic::Status, 5427 - >; 4609 + ) -> std::result::Result<tonic::Response<super::InsertTracksResponse>, tonic::Status>; 5428 4610 async fn insert_directory( 5429 4611 &self, 5430 4612 request: tonic::Request<super::InsertDirectoryRequest>, 5431 - ) -> std::result::Result< 5432 - tonic::Response<super::InsertDirectoryResponse>, 5433 - tonic::Status, 5434 - >; 4613 + ) -> std::result::Result<tonic::Response<super::InsertDirectoryResponse>, tonic::Status>; 5435 4614 async fn insert_playlist( 5436 4615 &self, 5437 4616 request: tonic::Request<super::InsertPlaylistRequest>, 5438 - ) -> std::result::Result< 5439 - tonic::Response<super::InsertPlaylistResponse>, 5440 - tonic::Status, 5441 - >; 4617 + ) -> std::result::Result<tonic::Response<super::InsertPlaylistResponse>, tonic::Status>; 5442 4618 async fn insert_album( 5443 4619 &self, 5444 4620 request: tonic::Request<super::InsertAlbumRequest>, 5445 - ) -> std::result::Result< 5446 - tonic::Response<super::InsertAlbumResponse>, 5447 - tonic::Status, 5448 - >; 4621 + ) -> std::result::Result<tonic::Response<super::InsertAlbumResponse>, tonic::Status>; 5449 4622 async fn insert_artist_tracks( 5450 4623 &self, 5451 4624 request: tonic::Request<super::InsertArtistTracksRequest>, 5452 - ) -> std::result::Result< 5453 - tonic::Response<super::InsertArtistTracksResponse>, 5454 - tonic::Status, 5455 - >; 4625 + ) -> std::result::Result<tonic::Response<super::InsertArtistTracksResponse>, tonic::Status>; 5456 4626 async fn shuffle_playlist( 5457 4627 &self, 5458 4628 request: tonic::Request<super::ShufflePlaylistRequest>, 5459 - ) -> std::result::Result< 5460 - tonic::Response<super::ShufflePlaylistResponse>, 5461 - tonic::Status, 5462 - >; 4629 + ) -> std::result::Result<tonic::Response<super::ShufflePlaylistResponse>, tonic::Status>; 5463 4630 } 5464 4631 #[derive(Debug)] 5465 4632 pub struct PlaylistServiceServer<T> { ··· 5482 4649 max_encoding_message_size: None, 5483 4650 } 5484 4651 } 5485 - pub fn with_interceptor<F>( 5486 - inner: T, 5487 - interceptor: F, 5488 - ) -> InterceptedService<Self, F> 4652 + pub fn with_interceptor<F>(inner: T, interceptor: F) -> InterceptedService<Self, F> 5489 4653 where 5490 4654 F: tonic::service::Interceptor, 5491 4655 { ··· 5540 4704 "/rockbox.v1alpha1.PlaylistService/GetCurrent" => { 5541 4705 #[allow(non_camel_case_types)] 5542 4706 struct GetCurrentSvc<T: PlaylistService>(pub Arc<T>); 5543 - impl< 5544 - T: PlaylistService, 5545 - > tonic::server::UnaryService<super::GetCurrentRequest> 5546 - for GetCurrentSvc<T> { 4707 + impl<T: PlaylistService> tonic::server::UnaryService<super::GetCurrentRequest> 4708 + for GetCurrentSvc<T> 4709 + { 5547 4710 type Response = super::GetCurrentResponse; 5548 - type Future = BoxFuture< 5549 - tonic::Response<Self::Response>, 5550 - tonic::Status, 5551 - >; 4711 + type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 5552 4712 fn call( 5553 4713 &mut self, 5554 4714 request: tonic::Request<super::GetCurrentRequest>, ··· 5585 4745 "/rockbox.v1alpha1.PlaylistService/GetResumeInfo" => { 5586 4746 #[allow(non_camel_case_types)] 5587 4747 struct GetResumeInfoSvc<T: PlaylistService>(pub Arc<T>); 5588 - impl< 5589 - T: PlaylistService, 5590 - > tonic::server::UnaryService<super::GetResumeInfoRequest> 5591 - for GetResumeInfoSvc<T> { 4748 + impl<T: PlaylistService> 4749 + tonic::server::UnaryService<super::GetResumeInfoRequest> 4750 + for GetResumeInfoSvc<T> 4751 + { 5592 4752 type Response = super::GetResumeInfoResponse; 5593 - type Future = BoxFuture< 5594 - tonic::Response<Self::Response>, 5595 - tonic::Status, 5596 - >; 4753 + type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 5597 4754 fn call( 5598 4755 &mut self, 5599 4756 request: tonic::Request<super::GetResumeInfoRequest>, 5600 4757 ) -> Self::Future { 5601 4758 let inner = Arc::clone(&self.0); 5602 4759 let fut = async move { 5603 - <T as PlaylistService>::get_resume_info(&inner, request) 5604 - .await 4760 + <T as PlaylistService>::get_resume_info(&inner, request).await 5605 4761 }; 5606 4762 Box::pin(fut) 5607 4763 } ··· 5631 4787 "/rockbox.v1alpha1.PlaylistService/GetTrackInfo" => { 5632 4788 #[allow(non_camel_case_types)] 5633 4789 struct GetTrackInfoSvc<T: PlaylistService>(pub Arc<T>); 5634 - impl< 5635 - T: PlaylistService, 5636 - > tonic::server::UnaryService<super::GetTrackInfoRequest> 5637 - for GetTrackInfoSvc<T> { 4790 + impl<T: PlaylistService> tonic::server::UnaryService<super::GetTrackInfoRequest> 4791 + for GetTrackInfoSvc<T> 4792 + { 5638 4793 type Response = super::GetTrackInfoResponse; 5639 - type Future = BoxFuture< 5640 - tonic::Response<Self::Response>, 5641 - tonic::Status, 5642 - >; 4794 + type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 5643 4795 fn call( 5644 4796 &mut self, 5645 4797 request: tonic::Request<super::GetTrackInfoRequest>, 5646 4798 ) -> Self::Future { 5647 4799 let inner = Arc::clone(&self.0); 5648 4800 let fut = async move { 5649 - <T as PlaylistService>::get_track_info(&inner, request) 5650 - .await 4801 + <T as PlaylistService>::get_track_info(&inner, request).await 5651 4802 }; 5652 4803 Box::pin(fut) 5653 4804 } ··· 5677 4828 "/rockbox.v1alpha1.PlaylistService/GetFirstIndex" => { 5678 4829 #[allow(non_camel_case_types)] 5679 4830 struct GetFirstIndexSvc<T: PlaylistService>(pub Arc<T>); 5680 - impl< 5681 - T: PlaylistService, 5682 - > tonic::server::UnaryService<super::GetFirstIndexRequest> 5683 - for GetFirstIndexSvc<T> { 4831 + impl<T: PlaylistService> 4832 + tonic::server::UnaryService<super::GetFirstIndexRequest> 4833 + for GetFirstIndexSvc<T> 4834 + { 5684 4835 type Response = super::GetFirstIndexResponse; 5685 - type Future = BoxFuture< 5686 - tonic::Response<Self::Response>, 5687 - tonic::Status, 5688 - >; 4836 + type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 5689 4837 fn call( 5690 4838 &mut self, 5691 4839 request: tonic::Request<super::GetFirstIndexRequest>, 5692 4840 ) -> Self::Future { 5693 4841 let inner = Arc::clone(&self.0); 5694 4842 let fut = async move { 5695 - <T as PlaylistService>::get_first_index(&inner, request) 5696 - .await 4843 + <T as PlaylistService>::get_first_index(&inner, request).await 5697 4844 }; 5698 4845 Box::pin(fut) 5699 4846 } ··· 5723 4870 "/rockbox.v1alpha1.PlaylistService/GetDisplayIndex" => { 5724 4871 #[allow(non_camel_case_types)] 5725 4872 struct GetDisplayIndexSvc<T: PlaylistService>(pub Arc<T>); 5726 - impl< 5727 - T: PlaylistService, 5728 - > tonic::server::UnaryService<super::GetDisplayIndexRequest> 5729 - for GetDisplayIndexSvc<T> { 4873 + impl<T: PlaylistService> 4874 + tonic::server::UnaryService<super::GetDisplayIndexRequest> 4875 + for GetDisplayIndexSvc<T> 4876 + { 5730 4877 type Response = super::GetDisplayIndexResponse; 5731 - type Future = BoxFuture< 5732 - tonic::Response<Self::Response>, 5733 - tonic::Status, 5734 - >; 4878 + type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 5735 4879 fn call( 5736 4880 &mut self, 5737 4881 request: tonic::Request<super::GetDisplayIndexRequest>, 5738 4882 ) -> Self::Future { 5739 4883 let inner = Arc::clone(&self.0); 5740 4884 let fut = async move { 5741 - <T as PlaylistService>::get_display_index(&inner, request) 5742 - .await 4885 + <T as PlaylistService>::get_display_index(&inner, request).await 5743 4886 }; 5744 4887 Box::pin(fut) 5745 4888 } ··· 5769 4912 "/rockbox.v1alpha1.PlaylistService/Amount" => { 5770 4913 #[allow(non_camel_case_types)] 5771 4914 struct AmountSvc<T: PlaylistService>(pub Arc<T>); 5772 - impl< 5773 - T: PlaylistService, 5774 - > tonic::server::UnaryService<super::AmountRequest> 5775 - for AmountSvc<T> { 4915 + impl<T: PlaylistService> tonic::server::UnaryService<super::AmountRequest> for AmountSvc<T> { 5776 4916 type Response = super::AmountResponse; 5777 - type Future = BoxFuture< 5778 - tonic::Response<Self::Response>, 5779 - tonic::Status, 5780 - >; 4917 + type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 5781 4918 fn call( 5782 4919 &mut self, 5783 4920 request: tonic::Request<super::AmountRequest>, ··· 5814 4951 "/rockbox.v1alpha1.PlaylistService/PlaylistResume" => { 5815 4952 #[allow(non_camel_case_types)] 5816 4953 struct PlaylistResumeSvc<T: PlaylistService>(pub Arc<T>); 5817 - impl< 5818 - T: PlaylistService, 5819 - > tonic::server::UnaryService<super::PlaylistResumeRequest> 5820 - for PlaylistResumeSvc<T> { 4954 + impl<T: PlaylistService> 4955 + tonic::server::UnaryService<super::PlaylistResumeRequest> 4956 + for PlaylistResumeSvc<T> 4957 + { 5821 4958 type Response = super::PlaylistResumeResponse; 5822 - type Future = BoxFuture< 5823 - tonic::Response<Self::Response>, 5824 - tonic::Status, 5825 - >; 4959 + type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 5826 4960 fn call( 5827 4961 &mut self, 5828 4962 request: tonic::Request<super::PlaylistResumeRequest>, 5829 4963 ) -> Self::Future { 5830 4964 let inner = Arc::clone(&self.0); 5831 4965 let fut = async move { 5832 - <T as PlaylistService>::playlist_resume(&inner, request) 5833 - .await 4966 + <T as PlaylistService>::playlist_resume(&inner, request).await 5834 4967 }; 5835 4968 Box::pin(fut) 5836 4969 } ··· 5860 4993 "/rockbox.v1alpha1.PlaylistService/ResumeTrack" => { 5861 4994 #[allow(non_camel_case_types)] 5862 4995 struct ResumeTrackSvc<T: PlaylistService>(pub Arc<T>); 5863 - impl< 5864 - T: PlaylistService, 5865 - > tonic::server::UnaryService<super::ResumeTrackRequest> 5866 - for ResumeTrackSvc<T> { 4996 + impl<T: PlaylistService> tonic::server::UnaryService<super::ResumeTrackRequest> 4997 + for ResumeTrackSvc<T> 4998 + { 5867 4999 type Response = super::ResumeTrackResponse; 5868 - type Future = BoxFuture< 5869 - tonic::Response<Self::Response>, 5870 - tonic::Status, 5871 - >; 5000 + type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 5872 5001 fn call( 5873 5002 &mut self, 5874 5003 request: tonic::Request<super::ResumeTrackRequest>, ··· 5905 5034 "/rockbox.v1alpha1.PlaylistService/SetModified" => { 5906 5035 #[allow(non_camel_case_types)] 5907 5036 struct SetModifiedSvc<T: PlaylistService>(pub Arc<T>); 5908 - impl< 5909 - T: PlaylistService, 5910 - > tonic::server::UnaryService<super::SetModifiedRequest> 5911 - for SetModifiedSvc<T> { 5037 + impl<T: PlaylistService> tonic::server::UnaryService<super::SetModifiedRequest> 5038 + for SetModifiedSvc<T> 5039 + { 5912 5040 type Response = super::SetModifiedResponse; 5913 - type Future = BoxFuture< 5914 - tonic::Response<Self::Response>, 5915 - tonic::Status, 5916 - >; 5041 + type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 5917 5042 fn call( 5918 5043 &mut self, 5919 5044 request: tonic::Request<super::SetModifiedRequest>, ··· 5950 5075 "/rockbox.v1alpha1.PlaylistService/Start" => { 5951 5076 #[allow(non_camel_case_types)] 5952 5077 struct StartSvc<T: PlaylistService>(pub Arc<T>); 5953 - impl< 5954 - T: PlaylistService, 5955 - > tonic::server::UnaryService<super::StartRequest> for StartSvc<T> { 5078 + impl<T: PlaylistService> tonic::server::UnaryService<super::StartRequest> for StartSvc<T> { 5956 5079 type Response = super::StartResponse; 5957 - type Future = BoxFuture< 5958 - tonic::Response<Self::Response>, 5959 - tonic::Status, 5960 - >; 5080 + type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 5961 5081 fn call( 5962 5082 &mut self, 5963 5083 request: tonic::Request<super::StartRequest>, 5964 5084 ) -> Self::Future { 5965 5085 let inner = Arc::clone(&self.0); 5966 - let fut = async move { 5967 - <T as PlaylistService>::start(&inner, request).await 5968 - }; 5086 + let fut = 5087 + async move { <T as PlaylistService>::start(&inner, request).await }; 5969 5088 Box::pin(fut) 5970 5089 } 5971 5090 } ··· 5994 5113 "/rockbox.v1alpha1.PlaylistService/Sync" => { 5995 5114 #[allow(non_camel_case_types)] 5996 5115 struct SyncSvc<T: PlaylistService>(pub Arc<T>); 5997 - impl< 5998 - T: PlaylistService, 5999 - > tonic::server::UnaryService<super::SyncRequest> for SyncSvc<T> { 5116 + impl<T: PlaylistService> tonic::server::UnaryService<super::SyncRequest> for SyncSvc<T> { 6000 5117 type Response = super::SyncResponse; 6001 - type Future = BoxFuture< 6002 - tonic::Response<Self::Response>, 6003 - tonic::Status, 6004 - >; 5118 + type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 6005 5119 fn call( 6006 5120 &mut self, 6007 5121 request: tonic::Request<super::SyncRequest>, 6008 5122 ) -> Self::Future { 6009 5123 let inner = Arc::clone(&self.0); 6010 - let fut = async move { 6011 - <T as PlaylistService>::sync(&inner, request).await 6012 - }; 5124 + let fut = 5125 + async move { <T as PlaylistService>::sync(&inner, request).await }; 6013 5126 Box::pin(fut) 6014 5127 } 6015 5128 } ··· 6038 5151 "/rockbox.v1alpha1.PlaylistService/RemoveAllTracks" => { 6039 5152 #[allow(non_camel_case_types)] 6040 5153 struct RemoveAllTracksSvc<T: PlaylistService>(pub Arc<T>); 6041 - impl< 6042 - T: PlaylistService, 6043 - > tonic::server::UnaryService<super::RemoveAllTracksRequest> 6044 - for RemoveAllTracksSvc<T> { 5154 + impl<T: PlaylistService> 5155 + tonic::server::UnaryService<super::RemoveAllTracksRequest> 5156 + for RemoveAllTracksSvc<T> 5157 + { 6045 5158 type Response = super::RemoveAllTracksResponse; 6046 - type Future = BoxFuture< 6047 - tonic::Response<Self::Response>, 6048 - tonic::Status, 6049 - >; 5159 + type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 6050 5160 fn call( 6051 5161 &mut self, 6052 5162 request: tonic::Request<super::RemoveAllTracksRequest>, 6053 5163 ) -> Self::Future { 6054 5164 let inner = Arc::clone(&self.0); 6055 5165 let fut = async move { 6056 - <T as PlaylistService>::remove_all_tracks(&inner, request) 6057 - .await 5166 + <T as PlaylistService>::remove_all_tracks(&inner, request).await 6058 5167 }; 6059 5168 Box::pin(fut) 6060 5169 } ··· 6084 5193 "/rockbox.v1alpha1.PlaylistService/RemoveTracks" => { 6085 5194 #[allow(non_camel_case_types)] 6086 5195 struct RemoveTracksSvc<T: PlaylistService>(pub Arc<T>); 6087 - impl< 6088 - T: PlaylistService, 6089 - > tonic::server::UnaryService<super::RemoveTracksRequest> 6090 - for RemoveTracksSvc<T> { 5196 + impl<T: PlaylistService> tonic::server::UnaryService<super::RemoveTracksRequest> 5197 + for RemoveTracksSvc<T> 5198 + { 6091 5199 type Response = super::RemoveTracksResponse; 6092 - type Future = BoxFuture< 6093 - tonic::Response<Self::Response>, 6094 - tonic::Status, 6095 - >; 5200 + type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 6096 5201 fn call( 6097 5202 &mut self, 6098 5203 request: tonic::Request<super::RemoveTracksRequest>, ··· 6129 5234 "/rockbox.v1alpha1.PlaylistService/CreatePlaylist" => { 6130 5235 #[allow(non_camel_case_types)] 6131 5236 struct CreatePlaylistSvc<T: PlaylistService>(pub Arc<T>); 6132 - impl< 6133 - T: PlaylistService, 6134 - > tonic::server::UnaryService<super::CreatePlaylistRequest> 6135 - for CreatePlaylistSvc<T> { 5237 + impl<T: PlaylistService> 5238 + tonic::server::UnaryService<super::CreatePlaylistRequest> 5239 + for CreatePlaylistSvc<T> 5240 + { 6136 5241 type Response = super::CreatePlaylistResponse; 6137 - type Future = BoxFuture< 6138 - tonic::Response<Self::Response>, 6139 - tonic::Status, 6140 - >; 5242 + type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 6141 5243 fn call( 6142 5244 &mut self, 6143 5245 request: tonic::Request<super::CreatePlaylistRequest>, 6144 5246 ) -> Self::Future { 6145 5247 let inner = Arc::clone(&self.0); 6146 5248 let fut = async move { 6147 - <T as PlaylistService>::create_playlist(&inner, request) 6148 - .await 5249 + <T as PlaylistService>::create_playlist(&inner, request).await 6149 5250 }; 6150 5251 Box::pin(fut) 6151 5252 } ··· 6175 5276 "/rockbox.v1alpha1.PlaylistService/InsertTracks" => { 6176 5277 #[allow(non_camel_case_types)] 6177 5278 struct InsertTracksSvc<T: PlaylistService>(pub Arc<T>); 6178 - impl< 6179 - T: PlaylistService, 6180 - > tonic::server::UnaryService<super::InsertTracksRequest> 6181 - for InsertTracksSvc<T> { 5279 + impl<T: PlaylistService> tonic::server::UnaryService<super::InsertTracksRequest> 5280 + for InsertTracksSvc<T> 5281 + { 6182 5282 type Response = super::InsertTracksResponse; 6183 - type Future = BoxFuture< 6184 - tonic::Response<Self::Response>, 6185 - tonic::Status, 6186 - >; 5283 + type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 6187 5284 fn call( 6188 5285 &mut self, 6189 5286 request: tonic::Request<super::InsertTracksRequest>, ··· 6220 5317 "/rockbox.v1alpha1.PlaylistService/InsertDirectory" => { 6221 5318 #[allow(non_camel_case_types)] 6222 5319 struct InsertDirectorySvc<T: PlaylistService>(pub Arc<T>); 6223 - impl< 6224 - T: PlaylistService, 6225 - > tonic::server::UnaryService<super::InsertDirectoryRequest> 6226 - for InsertDirectorySvc<T> { 5320 + impl<T: PlaylistService> 5321 + tonic::server::UnaryService<super::InsertDirectoryRequest> 5322 + for InsertDirectorySvc<T> 5323 + { 6227 5324 type Response = super::InsertDirectoryResponse; 6228 - type Future = BoxFuture< 6229 - tonic::Response<Self::Response>, 6230 - tonic::Status, 6231 - >; 5325 + type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 6232 5326 fn call( 6233 5327 &mut self, 6234 5328 request: tonic::Request<super::InsertDirectoryRequest>, 6235 5329 ) -> Self::Future { 6236 5330 let inner = Arc::clone(&self.0); 6237 5331 let fut = async move { 6238 - <T as PlaylistService>::insert_directory(&inner, request) 6239 - .await 5332 + <T as PlaylistService>::insert_directory(&inner, request).await 6240 5333 }; 6241 5334 Box::pin(fut) 6242 5335 } ··· 6266 5359 "/rockbox.v1alpha1.PlaylistService/InsertPlaylist" => { 6267 5360 #[allow(non_camel_case_types)] 6268 5361 struct InsertPlaylistSvc<T: PlaylistService>(pub Arc<T>); 6269 - impl< 6270 - T: PlaylistService, 6271 - > tonic::server::UnaryService<super::InsertPlaylistRequest> 6272 - for InsertPlaylistSvc<T> { 5362 + impl<T: PlaylistService> 5363 + tonic::server::UnaryService<super::InsertPlaylistRequest> 5364 + for InsertPlaylistSvc<T> 5365 + { 6273 5366 type Response = super::InsertPlaylistResponse; 6274 - type Future = BoxFuture< 6275 - tonic::Response<Self::Response>, 6276 - tonic::Status, 6277 - >; 5367 + type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 6278 5368 fn call( 6279 5369 &mut self, 6280 5370 request: tonic::Request<super::InsertPlaylistRequest>, 6281 5371 ) -> Self::Future { 6282 5372 let inner = Arc::clone(&self.0); 6283 5373 let fut = async move { 6284 - <T as PlaylistService>::insert_playlist(&inner, request) 6285 - .await 5374 + <T as PlaylistService>::insert_playlist(&inner, request).await 6286 5375 }; 6287 5376 Box::pin(fut) 6288 5377 } ··· 6312 5401 "/rockbox.v1alpha1.PlaylistService/InsertAlbum" => { 6313 5402 #[allow(non_camel_case_types)] 6314 5403 struct InsertAlbumSvc<T: PlaylistService>(pub Arc<T>); 6315 - impl< 6316 - T: PlaylistService, 6317 - > tonic::server::UnaryService<super::InsertAlbumRequest> 6318 - for InsertAlbumSvc<T> { 5404 + impl<T: PlaylistService> tonic::server::UnaryService<super::InsertAlbumRequest> 5405 + for InsertAlbumSvc<T> 5406 + { 6319 5407 type Response = super::InsertAlbumResponse; 6320 - type Future = BoxFuture< 6321 - tonic::Response<Self::Response>, 6322 - tonic::Status, 6323 - >; 5408 + type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 6324 5409 fn call( 6325 5410 &mut self, 6326 5411 request: tonic::Request<super::InsertAlbumRequest>, ··· 6357 5442 "/rockbox.v1alpha1.PlaylistService/InsertArtistTracks" => { 6358 5443 #[allow(non_camel_case_types)] 6359 5444 struct InsertArtistTracksSvc<T: PlaylistService>(pub Arc<T>); 6360 - impl< 6361 - T: PlaylistService, 6362 - > tonic::server::UnaryService<super::InsertArtistTracksRequest> 6363 - for InsertArtistTracksSvc<T> { 5445 + impl<T: PlaylistService> 5446 + tonic::server::UnaryService<super::InsertArtistTracksRequest> 5447 + for InsertArtistTracksSvc<T> 5448 + { 6364 5449 type Response = super::InsertArtistTracksResponse; 6365 - type Future = BoxFuture< 6366 - tonic::Response<Self::Response>, 6367 - tonic::Status, 6368 - >; 5450 + type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 6369 5451 fn call( 6370 5452 &mut self, 6371 5453 request: tonic::Request<super::InsertArtistTracksRequest>, 6372 5454 ) -> Self::Future { 6373 5455 let inner = Arc::clone(&self.0); 6374 5456 let fut = async move { 6375 - <T as PlaylistService>::insert_artist_tracks( 6376 - &inner, 6377 - request, 6378 - ) 6379 - .await 5457 + <T as PlaylistService>::insert_artist_tracks(&inner, request).await 6380 5458 }; 6381 5459 Box::pin(fut) 6382 5460 } ··· 6406 5484 "/rockbox.v1alpha1.PlaylistService/ShufflePlaylist" => { 6407 5485 #[allow(non_camel_case_types)] 6408 5486 struct ShufflePlaylistSvc<T: PlaylistService>(pub Arc<T>); 6409 - impl< 6410 - T: PlaylistService, 6411 - > tonic::server::UnaryService<super::ShufflePlaylistRequest> 6412 - for ShufflePlaylistSvc<T> { 5487 + impl<T: PlaylistService> 5488 + tonic::server::UnaryService<super::ShufflePlaylistRequest> 5489 + for ShufflePlaylistSvc<T> 5490 + { 6413 5491 type Response = super::ShufflePlaylistResponse; 6414 - type Future = BoxFuture< 6415 - tonic::Response<Self::Response>, 6416 - tonic::Status, 6417 - >; 5492 + type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 6418 5493 fn call( 6419 5494 &mut self, 6420 5495 request: tonic::Request<super::ShufflePlaylistRequest>, 6421 5496 ) -> Self::Future { 6422 5497 let inner = Arc::clone(&self.0); 6423 5498 let fut = async move { 6424 - <T as PlaylistService>::shuffle_playlist(&inner, request) 6425 - .await 5499 + <T as PlaylistService>::shuffle_playlist(&inner, request).await 6426 5500 }; 6427 5501 Box::pin(fut) 6428 5502 } ··· 6449 5523 }; 6450 5524 Box::pin(fut) 6451 5525 } 6452 - _ => { 6453 - Box::pin(async move { 6454 - let mut response = http::Response::new(empty_body()); 6455 - let headers = response.headers_mut(); 6456 - headers 6457 - .insert( 6458 - tonic::Status::GRPC_STATUS, 6459 - (tonic::Code::Unimplemented as i32).into(), 6460 - ); 6461 - headers 6462 - .insert( 6463 - http::header::CONTENT_TYPE, 6464 - tonic::metadata::GRPC_CONTENT_TYPE, 6465 - ); 6466 - Ok(response) 6467 - }) 6468 - } 5526 + _ => Box::pin(async move { 5527 + let mut response = http::Response::new(empty_body()); 5528 + let headers = response.headers_mut(); 5529 + headers.insert( 5530 + tonic::Status::GRPC_STATUS, 5531 + (tonic::Code::Unimplemented as i32).into(), 5532 + ); 5533 + headers.insert( 5534 + http::header::CONTENT_TYPE, 5535 + tonic::metadata::GRPC_CONTENT_TYPE, 5536 + ); 5537 + Ok(response) 5538 + }), 6469 5539 } 6470 5540 } 6471 5541 } ··· 6975 6045 dead_code, 6976 6046 missing_docs, 6977 6047 clippy::wildcard_imports, 6978 - clippy::let_unit_value, 6048 + clippy::let_unit_value 6979 6049 )] 6980 - use tonic::codegen::*; 6981 6050 use tonic::codegen::http::Uri; 6051 + use tonic::codegen::*; 6982 6052 #[derive(Debug, Clone)] 6983 6053 pub struct SettingsServiceClient<T> { 6984 6054 inner: tonic::client::Grpc<T>, ··· 7022 6092 <T as tonic::client::GrpcService<tonic::body::BoxBody>>::ResponseBody, 7023 6093 >, 7024 6094 >, 7025 - <T as tonic::codegen::Service< 7026 - http::Request<tonic::body::BoxBody>, 7027 - >>::Error: Into<StdError> + std::marker::Send + std::marker::Sync, 6095 + <T as tonic::codegen::Service<http::Request<tonic::body::BoxBody>>>::Error: 6096 + Into<StdError> + std::marker::Send + std::marker::Sync, 7028 6097 { 7029 6098 SettingsServiceClient::new(InterceptedService::new(inner, interceptor)) 7030 6099 } ··· 7062 6131 pub async fn get_settings_list( 7063 6132 &mut self, 7064 6133 request: impl tonic::IntoRequest<super::GetSettingsListRequest>, 7065 - ) -> std::result::Result< 7066 - tonic::Response<super::GetSettingsListResponse>, 7067 - tonic::Status, 7068 - > { 7069 - self.inner 7070 - .ready() 7071 - .await 7072 - .map_err(|e| { 7073 - tonic::Status::unknown( 7074 - format!("Service was not ready: {}", e.into()), 7075 - ) 7076 - })?; 6134 + ) -> std::result::Result<tonic::Response<super::GetSettingsListResponse>, tonic::Status> 6135 + { 6136 + self.inner.ready().await.map_err(|e| { 6137 + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 6138 + })?; 7077 6139 let codec = tonic::codec::ProstCodec::default(); 7078 6140 let path = http::uri::PathAndQuery::from_static( 7079 6141 "/rockbox.v1alpha1.SettingsService/GetSettingsList", 7080 6142 ); 7081 6143 let mut req = request.into_request(); 7082 - req.extensions_mut() 7083 - .insert( 7084 - GrpcMethod::new( 7085 - "rockbox.v1alpha1.SettingsService", 7086 - "GetSettingsList", 7087 - ), 7088 - ); 6144 + req.extensions_mut().insert(GrpcMethod::new( 6145 + "rockbox.v1alpha1.SettingsService", 6146 + "GetSettingsList", 6147 + )); 7089 6148 self.inner.unary(req, path, codec).await 7090 6149 } 7091 6150 pub async fn get_global_settings( 7092 6151 &mut self, 7093 6152 request: impl tonic::IntoRequest<super::GetGlobalSettingsRequest>, 7094 - ) -> std::result::Result< 7095 - tonic::Response<super::GetGlobalSettingsResponse>, 7096 - tonic::Status, 7097 - > { 7098 - self.inner 7099 - .ready() 7100 - .await 7101 - .map_err(|e| { 7102 - tonic::Status::unknown( 7103 - format!("Service was not ready: {}", e.into()), 7104 - ) 7105 - })?; 6153 + ) -> std::result::Result<tonic::Response<super::GetGlobalSettingsResponse>, tonic::Status> 6154 + { 6155 + self.inner.ready().await.map_err(|e| { 6156 + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 6157 + })?; 7106 6158 let codec = tonic::codec::ProstCodec::default(); 7107 6159 let path = http::uri::PathAndQuery::from_static( 7108 6160 "/rockbox.v1alpha1.SettingsService/GetGlobalSettings", 7109 6161 ); 7110 6162 let mut req = request.into_request(); 7111 - req.extensions_mut() 7112 - .insert( 7113 - GrpcMethod::new( 7114 - "rockbox.v1alpha1.SettingsService", 7115 - "GetGlobalSettings", 7116 - ), 7117 - ); 6163 + req.extensions_mut().insert(GrpcMethod::new( 6164 + "rockbox.v1alpha1.SettingsService", 6165 + "GetGlobalSettings", 6166 + )); 7118 6167 self.inner.unary(req, path, codec).await 7119 6168 } 7120 6169 pub async fn save_settings( 7121 6170 &mut self, 7122 6171 request: impl tonic::IntoRequest<super::SaveSettingsRequest>, 7123 - ) -> std::result::Result< 7124 - tonic::Response<super::SaveSettingsResponse>, 7125 - tonic::Status, 7126 - > { 7127 - self.inner 7128 - .ready() 7129 - .await 7130 - .map_err(|e| { 7131 - tonic::Status::unknown( 7132 - format!("Service was not ready: {}", e.into()), 7133 - ) 7134 - })?; 6172 + ) -> std::result::Result<tonic::Response<super::SaveSettingsResponse>, tonic::Status> 6173 + { 6174 + self.inner.ready().await.map_err(|e| { 6175 + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 6176 + })?; 7135 6177 let codec = tonic::codec::ProstCodec::default(); 7136 6178 let path = http::uri::PathAndQuery::from_static( 7137 6179 "/rockbox.v1alpha1.SettingsService/SaveSettings", 7138 6180 ); 7139 6181 let mut req = request.into_request(); 7140 - req.extensions_mut() 7141 - .insert( 7142 - GrpcMethod::new("rockbox.v1alpha1.SettingsService", "SaveSettings"), 7143 - ); 6182 + req.extensions_mut().insert(GrpcMethod::new( 6183 + "rockbox.v1alpha1.SettingsService", 6184 + "SaveSettings", 6185 + )); 7144 6186 self.inner.unary(req, path, codec).await 7145 6187 } 7146 6188 } ··· 7152 6194 dead_code, 7153 6195 missing_docs, 7154 6196 clippy::wildcard_imports, 7155 - clippy::let_unit_value, 6197 + clippy::let_unit_value 7156 6198 )] 7157 6199 use tonic::codegen::*; 7158 6200 /// Generated trait containing gRPC methods that should be implemented for use with SettingsServiceServer. ··· 7161 6203 async fn get_settings_list( 7162 6204 &self, 7163 6205 request: tonic::Request<super::GetSettingsListRequest>, 7164 - ) -> std::result::Result< 7165 - tonic::Response<super::GetSettingsListResponse>, 7166 - tonic::Status, 7167 - >; 6206 + ) -> std::result::Result<tonic::Response<super::GetSettingsListResponse>, tonic::Status>; 7168 6207 async fn get_global_settings( 7169 6208 &self, 7170 6209 request: tonic::Request<super::GetGlobalSettingsRequest>, 7171 - ) -> std::result::Result< 7172 - tonic::Response<super::GetGlobalSettingsResponse>, 7173 - tonic::Status, 7174 - >; 6210 + ) -> std::result::Result<tonic::Response<super::GetGlobalSettingsResponse>, tonic::Status>; 7175 6211 async fn save_settings( 7176 6212 &self, 7177 6213 request: tonic::Request<super::SaveSettingsRequest>, 7178 - ) -> std::result::Result< 7179 - tonic::Response<super::SaveSettingsResponse>, 7180 - tonic::Status, 7181 - >; 6214 + ) -> std::result::Result<tonic::Response<super::SaveSettingsResponse>, tonic::Status>; 7182 6215 } 7183 6216 #[derive(Debug)] 7184 6217 pub struct SettingsServiceServer<T> { ··· 7201 6234 max_encoding_message_size: None, 7202 6235 } 7203 6236 } 7204 - pub fn with_interceptor<F>( 7205 - inner: T, 7206 - interceptor: F, 7207 - ) -> InterceptedService<Self, F> 6237 + pub fn with_interceptor<F>(inner: T, interceptor: F) -> InterceptedService<Self, F> 7208 6238 where 7209 6239 F: tonic::service::Interceptor, 7210 6240 { ··· 7259 6289 "/rockbox.v1alpha1.SettingsService/GetSettingsList" => { 7260 6290 #[allow(non_camel_case_types)] 7261 6291 struct GetSettingsListSvc<T: SettingsService>(pub Arc<T>); 7262 - impl< 7263 - T: SettingsService, 7264 - > tonic::server::UnaryService<super::GetSettingsListRequest> 7265 - for GetSettingsListSvc<T> { 6292 + impl<T: SettingsService> 6293 + tonic::server::UnaryService<super::GetSettingsListRequest> 6294 + for GetSettingsListSvc<T> 6295 + { 7266 6296 type Response = super::GetSettingsListResponse; 7267 - type Future = BoxFuture< 7268 - tonic::Response<Self::Response>, 7269 - tonic::Status, 7270 - >; 6297 + type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 7271 6298 fn call( 7272 6299 &mut self, 7273 6300 request: tonic::Request<super::GetSettingsListRequest>, 7274 6301 ) -> Self::Future { 7275 6302 let inner = Arc::clone(&self.0); 7276 6303 let fut = async move { 7277 - <T as SettingsService>::get_settings_list(&inner, request) 7278 - .await 6304 + <T as SettingsService>::get_settings_list(&inner, request).await 7279 6305 }; 7280 6306 Box::pin(fut) 7281 6307 } ··· 7305 6331 "/rockbox.v1alpha1.SettingsService/GetGlobalSettings" => { 7306 6332 #[allow(non_camel_case_types)] 7307 6333 struct GetGlobalSettingsSvc<T: SettingsService>(pub Arc<T>); 7308 - impl< 7309 - T: SettingsService, 7310 - > tonic::server::UnaryService<super::GetGlobalSettingsRequest> 7311 - for GetGlobalSettingsSvc<T> { 6334 + impl<T: SettingsService> 6335 + tonic::server::UnaryService<super::GetGlobalSettingsRequest> 6336 + for GetGlobalSettingsSvc<T> 6337 + { 7312 6338 type Response = super::GetGlobalSettingsResponse; 7313 - type Future = BoxFuture< 7314 - tonic::Response<Self::Response>, 7315 - tonic::Status, 7316 - >; 6339 + type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 7317 6340 fn call( 7318 6341 &mut self, 7319 6342 request: tonic::Request<super::GetGlobalSettingsRequest>, 7320 6343 ) -> Self::Future { 7321 6344 let inner = Arc::clone(&self.0); 7322 6345 let fut = async move { 7323 - <T as SettingsService>::get_global_settings(&inner, request) 7324 - .await 6346 + <T as SettingsService>::get_global_settings(&inner, request).await 7325 6347 }; 7326 6348 Box::pin(fut) 7327 6349 } ··· 7351 6373 "/rockbox.v1alpha1.SettingsService/SaveSettings" => { 7352 6374 #[allow(non_camel_case_types)] 7353 6375 struct SaveSettingsSvc<T: SettingsService>(pub Arc<T>); 7354 - impl< 7355 - T: SettingsService, 7356 - > tonic::server::UnaryService<super::SaveSettingsRequest> 7357 - for SaveSettingsSvc<T> { 6376 + impl<T: SettingsService> tonic::server::UnaryService<super::SaveSettingsRequest> 6377 + for SaveSettingsSvc<T> 6378 + { 7358 6379 type Response = super::SaveSettingsResponse; 7359 - type Future = BoxFuture< 7360 - tonic::Response<Self::Response>, 7361 - tonic::Status, 7362 - >; 6380 + type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 7363 6381 fn call( 7364 6382 &mut self, 7365 6383 request: tonic::Request<super::SaveSettingsRequest>, ··· 7393 6411 }; 7394 6412 Box::pin(fut) 7395 6413 } 7396 - _ => { 7397 - Box::pin(async move { 7398 - let mut response = http::Response::new(empty_body()); 7399 - let headers = response.headers_mut(); 7400 - headers 7401 - .insert( 7402 - tonic::Status::GRPC_STATUS, 7403 - (tonic::Code::Unimplemented as i32).into(), 7404 - ); 7405 - headers 7406 - .insert( 7407 - http::header::CONTENT_TYPE, 7408 - tonic::metadata::GRPC_CONTENT_TYPE, 7409 - ); 7410 - Ok(response) 7411 - }) 7412 - } 6414 + _ => Box::pin(async move { 6415 + let mut response = http::Response::new(empty_body()); 6416 + let headers = response.headers_mut(); 6417 + headers.insert( 6418 + tonic::Status::GRPC_STATUS, 6419 + (tonic::Code::Unimplemented as i32).into(), 6420 + ); 6421 + headers.insert( 6422 + http::header::CONTENT_TYPE, 6423 + tonic::metadata::GRPC_CONTENT_TYPE, 6424 + ); 6425 + Ok(response) 6426 + }), 7413 6427 } 7414 6428 } 7415 6429 } ··· 7567 6581 dead_code, 7568 6582 missing_docs, 7569 6583 clippy::wildcard_imports, 7570 - clippy::let_unit_value, 6584 + clippy::let_unit_value 7571 6585 )] 7572 - use tonic::codegen::*; 7573 6586 use tonic::codegen::http::Uri; 6587 + use tonic::codegen::*; 7574 6588 #[derive(Debug, Clone)] 7575 6589 pub struct SoundServiceClient<T> { 7576 6590 inner: tonic::client::Grpc<T>, ··· 7614 6628 <T as tonic::client::GrpcService<tonic::body::BoxBody>>::ResponseBody, 7615 6629 >, 7616 6630 >, 7617 - <T as tonic::codegen::Service< 7618 - http::Request<tonic::body::BoxBody>, 7619 - >>::Error: Into<StdError> + std::marker::Send + std::marker::Sync, 6631 + <T as tonic::codegen::Service<http::Request<tonic::body::BoxBody>>>::Error: 6632 + Into<StdError> + std::marker::Send + std::marker::Sync, 7620 6633 { 7621 6634 SoundServiceClient::new(InterceptedService::new(inner, interceptor)) 7622 6635 } ··· 7654 6667 pub async fn adjust_volume( 7655 6668 &mut self, 7656 6669 request: impl tonic::IntoRequest<super::AdjustVolumeRequest>, 7657 - ) -> std::result::Result< 7658 - tonic::Response<super::AdjustVolumeResponse>, 7659 - tonic::Status, 7660 - > { 7661 - self.inner 7662 - .ready() 7663 - .await 7664 - .map_err(|e| { 7665 - tonic::Status::unknown( 7666 - format!("Service was not ready: {}", e.into()), 7667 - ) 7668 - })?; 6670 + ) -> std::result::Result<tonic::Response<super::AdjustVolumeResponse>, tonic::Status> 6671 + { 6672 + self.inner.ready().await.map_err(|e| { 6673 + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 6674 + })?; 7669 6675 let codec = tonic::codec::ProstCodec::default(); 7670 - let path = http::uri::PathAndQuery::from_static( 7671 - "/rockbox.v1alpha1.SoundService/AdjustVolume", 7672 - ); 6676 + let path = 6677 + http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.SoundService/AdjustVolume"); 7673 6678 let mut req = request.into_request(); 7674 - req.extensions_mut() 7675 - .insert( 7676 - GrpcMethod::new("rockbox.v1alpha1.SoundService", "AdjustVolume"), 7677 - ); 6679 + req.extensions_mut().insert(GrpcMethod::new( 6680 + "rockbox.v1alpha1.SoundService", 6681 + "AdjustVolume", 6682 + )); 7678 6683 self.inner.unary(req, path, codec).await 7679 6684 } 7680 6685 pub async fn sound_set( 7681 6686 &mut self, 7682 6687 request: impl tonic::IntoRequest<super::SoundSetRequest>, 7683 - ) -> std::result::Result< 7684 - tonic::Response<super::SoundSetResponse>, 7685 - tonic::Status, 7686 - > { 7687 - self.inner 7688 - .ready() 7689 - .await 7690 - .map_err(|e| { 7691 - tonic::Status::unknown( 7692 - format!("Service was not ready: {}", e.into()), 7693 - ) 7694 - })?; 6688 + ) -> std::result::Result<tonic::Response<super::SoundSetResponse>, tonic::Status> { 6689 + self.inner.ready().await.map_err(|e| { 6690 + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 6691 + })?; 7695 6692 let codec = tonic::codec::ProstCodec::default(); 7696 - let path = http::uri::PathAndQuery::from_static( 7697 - "/rockbox.v1alpha1.SoundService/SoundSet", 7698 - ); 6693 + let path = 6694 + http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.SoundService/SoundSet"); 7699 6695 let mut req = request.into_request(); 7700 6696 req.extensions_mut() 7701 6697 .insert(GrpcMethod::new("rockbox.v1alpha1.SoundService", "SoundSet")); ··· 7704 6700 pub async fn sound_current( 7705 6701 &mut self, 7706 6702 request: impl tonic::IntoRequest<super::SoundCurrentRequest>, 7707 - ) -> std::result::Result< 7708 - tonic::Response<super::SoundCurrentResponse>, 7709 - tonic::Status, 7710 - > { 7711 - self.inner 7712 - .ready() 7713 - .await 7714 - .map_err(|e| { 7715 - tonic::Status::unknown( 7716 - format!("Service was not ready: {}", e.into()), 7717 - ) 7718 - })?; 6703 + ) -> std::result::Result<tonic::Response<super::SoundCurrentResponse>, tonic::Status> 6704 + { 6705 + self.inner.ready().await.map_err(|e| { 6706 + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 6707 + })?; 7719 6708 let codec = tonic::codec::ProstCodec::default(); 7720 - let path = http::uri::PathAndQuery::from_static( 7721 - "/rockbox.v1alpha1.SoundService/SoundCurrent", 7722 - ); 6709 + let path = 6710 + http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.SoundService/SoundCurrent"); 7723 6711 let mut req = request.into_request(); 7724 - req.extensions_mut() 7725 - .insert( 7726 - GrpcMethod::new("rockbox.v1alpha1.SoundService", "SoundCurrent"), 7727 - ); 6712 + req.extensions_mut().insert(GrpcMethod::new( 6713 + "rockbox.v1alpha1.SoundService", 6714 + "SoundCurrent", 6715 + )); 7728 6716 self.inner.unary(req, path, codec).await 7729 6717 } 7730 6718 pub async fn sound_default( 7731 6719 &mut self, 7732 6720 request: impl tonic::IntoRequest<super::SoundDefaultRequest>, 7733 - ) -> std::result::Result< 7734 - tonic::Response<super::SoundDefaultResponse>, 7735 - tonic::Status, 7736 - > { 7737 - self.inner 7738 - .ready() 7739 - .await 7740 - .map_err(|e| { 7741 - tonic::Status::unknown( 7742 - format!("Service was not ready: {}", e.into()), 7743 - ) 7744 - })?; 6721 + ) -> std::result::Result<tonic::Response<super::SoundDefaultResponse>, tonic::Status> 6722 + { 6723 + self.inner.ready().await.map_err(|e| { 6724 + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 6725 + })?; 7745 6726 let codec = tonic::codec::ProstCodec::default(); 7746 - let path = http::uri::PathAndQuery::from_static( 7747 - "/rockbox.v1alpha1.SoundService/SoundDefault", 7748 - ); 6727 + let path = 6728 + http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.SoundService/SoundDefault"); 7749 6729 let mut req = request.into_request(); 7750 - req.extensions_mut() 7751 - .insert( 7752 - GrpcMethod::new("rockbox.v1alpha1.SoundService", "SoundDefault"), 7753 - ); 6730 + req.extensions_mut().insert(GrpcMethod::new( 6731 + "rockbox.v1alpha1.SoundService", 6732 + "SoundDefault", 6733 + )); 7754 6734 self.inner.unary(req, path, codec).await 7755 6735 } 7756 6736 pub async fn sound_min( 7757 6737 &mut self, 7758 6738 request: impl tonic::IntoRequest<super::SoundMinRequest>, 7759 - ) -> std::result::Result< 7760 - tonic::Response<super::SoundMinResponse>, 7761 - tonic::Status, 7762 - > { 7763 - self.inner 7764 - .ready() 7765 - .await 7766 - .map_err(|e| { 7767 - tonic::Status::unknown( 7768 - format!("Service was not ready: {}", e.into()), 7769 - ) 7770 - })?; 6739 + ) -> std::result::Result<tonic::Response<super::SoundMinResponse>, tonic::Status> { 6740 + self.inner.ready().await.map_err(|e| { 6741 + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 6742 + })?; 7771 6743 let codec = tonic::codec::ProstCodec::default(); 7772 - let path = http::uri::PathAndQuery::from_static( 7773 - "/rockbox.v1alpha1.SoundService/SoundMin", 7774 - ); 6744 + let path = 6745 + http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.SoundService/SoundMin"); 7775 6746 let mut req = request.into_request(); 7776 6747 req.extensions_mut() 7777 6748 .insert(GrpcMethod::new("rockbox.v1alpha1.SoundService", "SoundMin")); ··· 7780 6751 pub async fn sound_max( 7781 6752 &mut self, 7782 6753 request: impl tonic::IntoRequest<super::SoundMaxRequest>, 7783 - ) -> std::result::Result< 7784 - tonic::Response<super::SoundMaxResponse>, 7785 - tonic::Status, 7786 - > { 7787 - self.inner 7788 - .ready() 7789 - .await 7790 - .map_err(|e| { 7791 - tonic::Status::unknown( 7792 - format!("Service was not ready: {}", e.into()), 7793 - ) 7794 - })?; 6754 + ) -> std::result::Result<tonic::Response<super::SoundMaxResponse>, tonic::Status> { 6755 + self.inner.ready().await.map_err(|e| { 6756 + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 6757 + })?; 7795 6758 let codec = tonic::codec::ProstCodec::default(); 7796 - let path = http::uri::PathAndQuery::from_static( 7797 - "/rockbox.v1alpha1.SoundService/SoundMax", 7798 - ); 6759 + let path = 6760 + http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.SoundService/SoundMax"); 7799 6761 let mut req = request.into_request(); 7800 6762 req.extensions_mut() 7801 6763 .insert(GrpcMethod::new("rockbox.v1alpha1.SoundService", "SoundMax")); ··· 7804 6766 pub async fn sound_unit( 7805 6767 &mut self, 7806 6768 request: impl tonic::IntoRequest<super::SoundUnitRequest>, 7807 - ) -> std::result::Result< 7808 - tonic::Response<super::SoundUnitResponse>, 7809 - tonic::Status, 7810 - > { 7811 - self.inner 7812 - .ready() 7813 - .await 7814 - .map_err(|e| { 7815 - tonic::Status::unknown( 7816 - format!("Service was not ready: {}", e.into()), 7817 - ) 7818 - })?; 6769 + ) -> std::result::Result<tonic::Response<super::SoundUnitResponse>, tonic::Status> { 6770 + self.inner.ready().await.map_err(|e| { 6771 + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 6772 + })?; 7819 6773 let codec = tonic::codec::ProstCodec::default(); 7820 - let path = http::uri::PathAndQuery::from_static( 7821 - "/rockbox.v1alpha1.SoundService/SoundUnit", 7822 - ); 6774 + let path = 6775 + http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.SoundService/SoundUnit"); 7823 6776 let mut req = request.into_request(); 7824 - req.extensions_mut() 7825 - .insert(GrpcMethod::new("rockbox.v1alpha1.SoundService", "SoundUnit")); 6777 + req.extensions_mut().insert(GrpcMethod::new( 6778 + "rockbox.v1alpha1.SoundService", 6779 + "SoundUnit", 6780 + )); 7826 6781 self.inner.unary(req, path, codec).await 7827 6782 } 7828 6783 pub async fn sound_val2_phys( 7829 6784 &mut self, 7830 6785 request: impl tonic::IntoRequest<super::SoundVal2PhysRequest>, 7831 - ) -> std::result::Result< 7832 - tonic::Response<super::SoundVal2PhysResponse>, 7833 - tonic::Status, 7834 - > { 7835 - self.inner 7836 - .ready() 7837 - .await 7838 - .map_err(|e| { 7839 - tonic::Status::unknown( 7840 - format!("Service was not ready: {}", e.into()), 7841 - ) 7842 - })?; 6786 + ) -> std::result::Result<tonic::Response<super::SoundVal2PhysResponse>, tonic::Status> 6787 + { 6788 + self.inner.ready().await.map_err(|e| { 6789 + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 6790 + })?; 7843 6791 let codec = tonic::codec::ProstCodec::default(); 7844 6792 let path = http::uri::PathAndQuery::from_static( 7845 6793 "/rockbox.v1alpha1.SoundService/SoundVal2Phys", 7846 6794 ); 7847 6795 let mut req = request.into_request(); 7848 - req.extensions_mut() 7849 - .insert( 7850 - GrpcMethod::new("rockbox.v1alpha1.SoundService", "SoundVal2Phys"), 7851 - ); 6796 + req.extensions_mut().insert(GrpcMethod::new( 6797 + "rockbox.v1alpha1.SoundService", 6798 + "SoundVal2Phys", 6799 + )); 7852 6800 self.inner.unary(req, path, codec).await 7853 6801 } 7854 6802 pub async fn get_pitch( 7855 6803 &mut self, 7856 6804 request: impl tonic::IntoRequest<super::GetPitchRequest>, 7857 - ) -> std::result::Result< 7858 - tonic::Response<super::GetPitchResponse>, 7859 - tonic::Status, 7860 - > { 7861 - self.inner 7862 - .ready() 7863 - .await 7864 - .map_err(|e| { 7865 - tonic::Status::unknown( 7866 - format!("Service was not ready: {}", e.into()), 7867 - ) 7868 - })?; 6805 + ) -> std::result::Result<tonic::Response<super::GetPitchResponse>, tonic::Status> { 6806 + self.inner.ready().await.map_err(|e| { 6807 + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 6808 + })?; 7869 6809 let codec = tonic::codec::ProstCodec::default(); 7870 - let path = http::uri::PathAndQuery::from_static( 7871 - "/rockbox.v1alpha1.SoundService/GetPitch", 7872 - ); 6810 + let path = 6811 + http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.SoundService/GetPitch"); 7873 6812 let mut req = request.into_request(); 7874 6813 req.extensions_mut() 7875 6814 .insert(GrpcMethod::new("rockbox.v1alpha1.SoundService", "GetPitch")); ··· 7878 6817 pub async fn set_pitch( 7879 6818 &mut self, 7880 6819 request: impl tonic::IntoRequest<super::SetPitchRequest>, 7881 - ) -> std::result::Result< 7882 - tonic::Response<super::SetPitchResponse>, 7883 - tonic::Status, 7884 - > { 7885 - self.inner 7886 - .ready() 7887 - .await 7888 - .map_err(|e| { 7889 - tonic::Status::unknown( 7890 - format!("Service was not ready: {}", e.into()), 7891 - ) 7892 - })?; 6820 + ) -> std::result::Result<tonic::Response<super::SetPitchResponse>, tonic::Status> { 6821 + self.inner.ready().await.map_err(|e| { 6822 + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 6823 + })?; 7893 6824 let codec = tonic::codec::ProstCodec::default(); 7894 - let path = http::uri::PathAndQuery::from_static( 7895 - "/rockbox.v1alpha1.SoundService/SetPitch", 7896 - ); 6825 + let path = 6826 + http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.SoundService/SetPitch"); 7897 6827 let mut req = request.into_request(); 7898 6828 req.extensions_mut() 7899 6829 .insert(GrpcMethod::new("rockbox.v1alpha1.SoundService", "SetPitch")); ··· 7902 6832 pub async fn beep_play( 7903 6833 &mut self, 7904 6834 request: impl tonic::IntoRequest<super::BeepPlayRequest>, 7905 - ) -> std::result::Result< 7906 - tonic::Response<super::BeepPlayResponse>, 7907 - tonic::Status, 7908 - > { 7909 - self.inner 7910 - .ready() 7911 - .await 7912 - .map_err(|e| { 7913 - tonic::Status::unknown( 7914 - format!("Service was not ready: {}", e.into()), 7915 - ) 7916 - })?; 6835 + ) -> std::result::Result<tonic::Response<super::BeepPlayResponse>, tonic::Status> { 6836 + self.inner.ready().await.map_err(|e| { 6837 + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 6838 + })?; 7917 6839 let codec = tonic::codec::ProstCodec::default(); 7918 - let path = http::uri::PathAndQuery::from_static( 7919 - "/rockbox.v1alpha1.SoundService/BeepPlay", 7920 - ); 6840 + let path = 6841 + http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.SoundService/BeepPlay"); 7921 6842 let mut req = request.into_request(); 7922 6843 req.extensions_mut() 7923 6844 .insert(GrpcMethod::new("rockbox.v1alpha1.SoundService", "BeepPlay")); ··· 7926 6847 pub async fn pcmbuf_fade( 7927 6848 &mut self, 7928 6849 request: impl tonic::IntoRequest<super::PcmbufFadeRequest>, 7929 - ) -> std::result::Result< 7930 - tonic::Response<super::PcmbufFadeResponse>, 7931 - tonic::Status, 7932 - > { 7933 - self.inner 7934 - .ready() 7935 - .await 7936 - .map_err(|e| { 7937 - tonic::Status::unknown( 7938 - format!("Service was not ready: {}", e.into()), 7939 - ) 7940 - })?; 6850 + ) -> std::result::Result<tonic::Response<super::PcmbufFadeResponse>, tonic::Status> 6851 + { 6852 + self.inner.ready().await.map_err(|e| { 6853 + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 6854 + })?; 7941 6855 let codec = tonic::codec::ProstCodec::default(); 7942 - let path = http::uri::PathAndQuery::from_static( 7943 - "/rockbox.v1alpha1.SoundService/PcmbufFade", 7944 - ); 6856 + let path = 6857 + http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.SoundService/PcmbufFade"); 7945 6858 let mut req = request.into_request(); 7946 - req.extensions_mut() 7947 - .insert(GrpcMethod::new("rockbox.v1alpha1.SoundService", "PcmbufFade")); 6859 + req.extensions_mut().insert(GrpcMethod::new( 6860 + "rockbox.v1alpha1.SoundService", 6861 + "PcmbufFade", 6862 + )); 7948 6863 self.inner.unary(req, path, codec).await 7949 6864 } 7950 6865 pub async fn pcmbuf_set_low_latency( 7951 6866 &mut self, 7952 6867 request: impl tonic::IntoRequest<super::PcmbufSetLowLatencyRequest>, 7953 - ) -> std::result::Result< 7954 - tonic::Response<super::PcmbufSetLowLatencyResponse>, 7955 - tonic::Status, 7956 - > { 7957 - self.inner 7958 - .ready() 7959 - .await 7960 - .map_err(|e| { 7961 - tonic::Status::unknown( 7962 - format!("Service was not ready: {}", e.into()), 7963 - ) 7964 - })?; 6868 + ) -> std::result::Result<tonic::Response<super::PcmbufSetLowLatencyResponse>, tonic::Status> 6869 + { 6870 + self.inner.ready().await.map_err(|e| { 6871 + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 6872 + })?; 7965 6873 let codec = tonic::codec::ProstCodec::default(); 7966 6874 let path = http::uri::PathAndQuery::from_static( 7967 6875 "/rockbox.v1alpha1.SoundService/PcmbufSetLowLatency", 7968 6876 ); 7969 6877 let mut req = request.into_request(); 7970 - req.extensions_mut() 7971 - .insert( 7972 - GrpcMethod::new( 7973 - "rockbox.v1alpha1.SoundService", 7974 - "PcmbufSetLowLatency", 7975 - ), 7976 - ); 6878 + req.extensions_mut().insert(GrpcMethod::new( 6879 + "rockbox.v1alpha1.SoundService", 6880 + "PcmbufSetLowLatency", 6881 + )); 7977 6882 self.inner.unary(req, path, codec).await 7978 6883 } 7979 6884 pub async fn system_sound_play( 7980 6885 &mut self, 7981 6886 request: impl tonic::IntoRequest<super::SystemSoundPlayRequest>, 7982 - ) -> std::result::Result< 7983 - tonic::Response<super::SystemSoundPlayResponse>, 7984 - tonic::Status, 7985 - > { 7986 - self.inner 7987 - .ready() 7988 - .await 7989 - .map_err(|e| { 7990 - tonic::Status::unknown( 7991 - format!("Service was not ready: {}", e.into()), 7992 - ) 7993 - })?; 6887 + ) -> std::result::Result<tonic::Response<super::SystemSoundPlayResponse>, tonic::Status> 6888 + { 6889 + self.inner.ready().await.map_err(|e| { 6890 + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 6891 + })?; 7994 6892 let codec = tonic::codec::ProstCodec::default(); 7995 6893 let path = http::uri::PathAndQuery::from_static( 7996 6894 "/rockbox.v1alpha1.SoundService/SystemSoundPlay", 7997 6895 ); 7998 6896 let mut req = request.into_request(); 7999 - req.extensions_mut() 8000 - .insert( 8001 - GrpcMethod::new("rockbox.v1alpha1.SoundService", "SystemSoundPlay"), 8002 - ); 6897 + req.extensions_mut().insert(GrpcMethod::new( 6898 + "rockbox.v1alpha1.SoundService", 6899 + "SystemSoundPlay", 6900 + )); 8003 6901 self.inner.unary(req, path, codec).await 8004 6902 } 8005 6903 pub async fn keyclick_click( 8006 6904 &mut self, 8007 6905 request: impl tonic::IntoRequest<super::KeyclickClickRequest>, 8008 - ) -> std::result::Result< 8009 - tonic::Response<super::KeyclickClickResponse>, 8010 - tonic::Status, 8011 - > { 8012 - self.inner 8013 - .ready() 8014 - .await 8015 - .map_err(|e| { 8016 - tonic::Status::unknown( 8017 - format!("Service was not ready: {}", e.into()), 8018 - ) 8019 - })?; 6906 + ) -> std::result::Result<tonic::Response<super::KeyclickClickResponse>, tonic::Status> 6907 + { 6908 + self.inner.ready().await.map_err(|e| { 6909 + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 6910 + })?; 8020 6911 let codec = tonic::codec::ProstCodec::default(); 8021 6912 let path = http::uri::PathAndQuery::from_static( 8022 6913 "/rockbox.v1alpha1.SoundService/KeyclickClick", 8023 6914 ); 8024 6915 let mut req = request.into_request(); 8025 - req.extensions_mut() 8026 - .insert( 8027 - GrpcMethod::new("rockbox.v1alpha1.SoundService", "KeyclickClick"), 8028 - ); 6916 + req.extensions_mut().insert(GrpcMethod::new( 6917 + "rockbox.v1alpha1.SoundService", 6918 + "KeyclickClick", 6919 + )); 8029 6920 self.inner.unary(req, path, codec).await 8030 6921 } 8031 6922 } ··· 8037 6928 dead_code, 8038 6929 missing_docs, 8039 6930 clippy::wildcard_imports, 8040 - clippy::let_unit_value, 6931 + clippy::let_unit_value 8041 6932 )] 8042 6933 use tonic::codegen::*; 8043 6934 /// Generated trait containing gRPC methods that should be implemented for use with SoundServiceServer. ··· 8046 6937 async fn adjust_volume( 8047 6938 &self, 8048 6939 request: tonic::Request<super::AdjustVolumeRequest>, 8049 - ) -> std::result::Result< 8050 - tonic::Response<super::AdjustVolumeResponse>, 8051 - tonic::Status, 8052 - >; 6940 + ) -> std::result::Result<tonic::Response<super::AdjustVolumeResponse>, tonic::Status>; 8053 6941 async fn sound_set( 8054 6942 &self, 8055 6943 request: tonic::Request<super::SoundSetRequest>, 8056 - ) -> std::result::Result< 8057 - tonic::Response<super::SoundSetResponse>, 8058 - tonic::Status, 8059 - >; 6944 + ) -> std::result::Result<tonic::Response<super::SoundSetResponse>, tonic::Status>; 8060 6945 async fn sound_current( 8061 6946 &self, 8062 6947 request: tonic::Request<super::SoundCurrentRequest>, 8063 - ) -> std::result::Result< 8064 - tonic::Response<super::SoundCurrentResponse>, 8065 - tonic::Status, 8066 - >; 6948 + ) -> std::result::Result<tonic::Response<super::SoundCurrentResponse>, tonic::Status>; 8067 6949 async fn sound_default( 8068 6950 &self, 8069 6951 request: tonic::Request<super::SoundDefaultRequest>, 8070 - ) -> std::result::Result< 8071 - tonic::Response<super::SoundDefaultResponse>, 8072 - tonic::Status, 8073 - >; 6952 + ) -> std::result::Result<tonic::Response<super::SoundDefaultResponse>, tonic::Status>; 8074 6953 async fn sound_min( 8075 6954 &self, 8076 6955 request: tonic::Request<super::SoundMinRequest>, 8077 - ) -> std::result::Result< 8078 - tonic::Response<super::SoundMinResponse>, 8079 - tonic::Status, 8080 - >; 6956 + ) -> std::result::Result<tonic::Response<super::SoundMinResponse>, tonic::Status>; 8081 6957 async fn sound_max( 8082 6958 &self, 8083 6959 request: tonic::Request<super::SoundMaxRequest>, 8084 - ) -> std::result::Result< 8085 - tonic::Response<super::SoundMaxResponse>, 8086 - tonic::Status, 8087 - >; 6960 + ) -> std::result::Result<tonic::Response<super::SoundMaxResponse>, tonic::Status>; 8088 6961 async fn sound_unit( 8089 6962 &self, 8090 6963 request: tonic::Request<super::SoundUnitRequest>, 8091 - ) -> std::result::Result< 8092 - tonic::Response<super::SoundUnitResponse>, 8093 - tonic::Status, 8094 - >; 6964 + ) -> std::result::Result<tonic::Response<super::SoundUnitResponse>, tonic::Status>; 8095 6965 async fn sound_val2_phys( 8096 6966 &self, 8097 6967 request: tonic::Request<super::SoundVal2PhysRequest>, 8098 - ) -> std::result::Result< 8099 - tonic::Response<super::SoundVal2PhysResponse>, 8100 - tonic::Status, 8101 - >; 6968 + ) -> std::result::Result<tonic::Response<super::SoundVal2PhysResponse>, tonic::Status>; 8102 6969 async fn get_pitch( 8103 6970 &self, 8104 6971 request: tonic::Request<super::GetPitchRequest>, 8105 - ) -> std::result::Result< 8106 - tonic::Response<super::GetPitchResponse>, 8107 - tonic::Status, 8108 - >; 6972 + ) -> std::result::Result<tonic::Response<super::GetPitchResponse>, tonic::Status>; 8109 6973 async fn set_pitch( 8110 6974 &self, 8111 6975 request: tonic::Request<super::SetPitchRequest>, 8112 - ) -> std::result::Result< 8113 - tonic::Response<super::SetPitchResponse>, 8114 - tonic::Status, 8115 - >; 6976 + ) -> std::result::Result<tonic::Response<super::SetPitchResponse>, tonic::Status>; 8116 6977 async fn beep_play( 8117 6978 &self, 8118 6979 request: tonic::Request<super::BeepPlayRequest>, 8119 - ) -> std::result::Result< 8120 - tonic::Response<super::BeepPlayResponse>, 8121 - tonic::Status, 8122 - >; 6980 + ) -> std::result::Result<tonic::Response<super::BeepPlayResponse>, tonic::Status>; 8123 6981 async fn pcmbuf_fade( 8124 6982 &self, 8125 6983 request: tonic::Request<super::PcmbufFadeRequest>, 8126 - ) -> std::result::Result< 8127 - tonic::Response<super::PcmbufFadeResponse>, 8128 - tonic::Status, 8129 - >; 6984 + ) -> std::result::Result<tonic::Response<super::PcmbufFadeResponse>, tonic::Status>; 8130 6985 async fn pcmbuf_set_low_latency( 8131 6986 &self, 8132 6987 request: tonic::Request<super::PcmbufSetLowLatencyRequest>, 8133 - ) -> std::result::Result< 8134 - tonic::Response<super::PcmbufSetLowLatencyResponse>, 8135 - tonic::Status, 8136 - >; 6988 + ) -> std::result::Result<tonic::Response<super::PcmbufSetLowLatencyResponse>, tonic::Status>; 8137 6989 async fn system_sound_play( 8138 6990 &self, 8139 6991 request: tonic::Request<super::SystemSoundPlayRequest>, 8140 - ) -> std::result::Result< 8141 - tonic::Response<super::SystemSoundPlayResponse>, 8142 - tonic::Status, 8143 - >; 6992 + ) -> std::result::Result<tonic::Response<super::SystemSoundPlayResponse>, tonic::Status>; 8144 6993 async fn keyclick_click( 8145 6994 &self, 8146 6995 request: tonic::Request<super::KeyclickClickRequest>, 8147 - ) -> std::result::Result< 8148 - tonic::Response<super::KeyclickClickResponse>, 8149 - tonic::Status, 8150 - >; 6996 + ) -> std::result::Result<tonic::Response<super::KeyclickClickResponse>, tonic::Status>; 8151 6997 } 8152 6998 #[derive(Debug)] 8153 6999 pub struct SoundServiceServer<T> { ··· 8170 7016 max_encoding_message_size: None, 8171 7017 } 8172 7018 } 8173 - pub fn with_interceptor<F>( 8174 - inner: T, 8175 - interceptor: F, 8176 - ) -> InterceptedService<Self, F> 7019 + pub fn with_interceptor<F>(inner: T, interceptor: F) -> InterceptedService<Self, F> 8177 7020 where 8178 7021 F: tonic::service::Interceptor, 8179 7022 { ··· 8228 7071 "/rockbox.v1alpha1.SoundService/AdjustVolume" => { 8229 7072 #[allow(non_camel_case_types)] 8230 7073 struct AdjustVolumeSvc<T: SoundService>(pub Arc<T>); 8231 - impl< 8232 - T: SoundService, 8233 - > tonic::server::UnaryService<super::AdjustVolumeRequest> 8234 - for AdjustVolumeSvc<T> { 7074 + impl<T: SoundService> tonic::server::UnaryService<super::AdjustVolumeRequest> 7075 + for AdjustVolumeSvc<T> 7076 + { 8235 7077 type Response = super::AdjustVolumeResponse; 8236 - type Future = BoxFuture< 8237 - tonic::Response<Self::Response>, 8238 - tonic::Status, 8239 - >; 7078 + type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 8240 7079 fn call( 8241 7080 &mut self, 8242 7081 request: tonic::Request<super::AdjustVolumeRequest>, ··· 8273 7112 "/rockbox.v1alpha1.SoundService/SoundSet" => { 8274 7113 #[allow(non_camel_case_types)] 8275 7114 struct SoundSetSvc<T: SoundService>(pub Arc<T>); 8276 - impl< 8277 - T: SoundService, 8278 - > tonic::server::UnaryService<super::SoundSetRequest> 8279 - for SoundSetSvc<T> { 7115 + impl<T: SoundService> tonic::server::UnaryService<super::SoundSetRequest> for SoundSetSvc<T> { 8280 7116 type Response = super::SoundSetResponse; 8281 - type Future = BoxFuture< 8282 - tonic::Response<Self::Response>, 8283 - tonic::Status, 8284 - >; 7117 + type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 8285 7118 fn call( 8286 7119 &mut self, 8287 7120 request: tonic::Request<super::SoundSetRequest>, ··· 8318 7151 "/rockbox.v1alpha1.SoundService/SoundCurrent" => { 8319 7152 #[allow(non_camel_case_types)] 8320 7153 struct SoundCurrentSvc<T: SoundService>(pub Arc<T>); 8321 - impl< 8322 - T: SoundService, 8323 - > tonic::server::UnaryService<super::SoundCurrentRequest> 8324 - for SoundCurrentSvc<T> { 7154 + impl<T: SoundService> tonic::server::UnaryService<super::SoundCurrentRequest> 7155 + for SoundCurrentSvc<T> 7156 + { 8325 7157 type Response = super::SoundCurrentResponse; 8326 - type Future = BoxFuture< 8327 - tonic::Response<Self::Response>, 8328 - tonic::Status, 8329 - >; 7158 + type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 8330 7159 fn call( 8331 7160 &mut self, 8332 7161 request: tonic::Request<super::SoundCurrentRequest>, ··· 8363 7192 "/rockbox.v1alpha1.SoundService/SoundDefault" => { 8364 7193 #[allow(non_camel_case_types)] 8365 7194 struct SoundDefaultSvc<T: SoundService>(pub Arc<T>); 8366 - impl< 8367 - T: SoundService, 8368 - > tonic::server::UnaryService<super::SoundDefaultRequest> 8369 - for SoundDefaultSvc<T> { 7195 + impl<T: SoundService> tonic::server::UnaryService<super::SoundDefaultRequest> 7196 + for SoundDefaultSvc<T> 7197 + { 8370 7198 type Response = super::SoundDefaultResponse; 8371 - type Future = BoxFuture< 8372 - tonic::Response<Self::Response>, 8373 - tonic::Status, 8374 - >; 7199 + type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 8375 7200 fn call( 8376 7201 &mut self, 8377 7202 request: tonic::Request<super::SoundDefaultRequest>, ··· 8408 7233 "/rockbox.v1alpha1.SoundService/SoundMin" => { 8409 7234 #[allow(non_camel_case_types)] 8410 7235 struct SoundMinSvc<T: SoundService>(pub Arc<T>); 8411 - impl< 8412 - T: SoundService, 8413 - > tonic::server::UnaryService<super::SoundMinRequest> 8414 - for SoundMinSvc<T> { 7236 + impl<T: SoundService> tonic::server::UnaryService<super::SoundMinRequest> for SoundMinSvc<T> { 8415 7237 type Response = super::SoundMinResponse; 8416 - type Future = BoxFuture< 8417 - tonic::Response<Self::Response>, 8418 - tonic::Status, 8419 - >; 7238 + type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 8420 7239 fn call( 8421 7240 &mut self, 8422 7241 request: tonic::Request<super::SoundMinRequest>, ··· 8453 7272 "/rockbox.v1alpha1.SoundService/SoundMax" => { 8454 7273 #[allow(non_camel_case_types)] 8455 7274 struct SoundMaxSvc<T: SoundService>(pub Arc<T>); 8456 - impl< 8457 - T: SoundService, 8458 - > tonic::server::UnaryService<super::SoundMaxRequest> 8459 - for SoundMaxSvc<T> { 7275 + impl<T: SoundService> tonic::server::UnaryService<super::SoundMaxRequest> for SoundMaxSvc<T> { 8460 7276 type Response = super::SoundMaxResponse; 8461 - type Future = BoxFuture< 8462 - tonic::Response<Self::Response>, 8463 - tonic::Status, 8464 - >; 7277 + type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 8465 7278 fn call( 8466 7279 &mut self, 8467 7280 request: tonic::Request<super::SoundMaxRequest>, ··· 8498 7311 "/rockbox.v1alpha1.SoundService/SoundUnit" => { 8499 7312 #[allow(non_camel_case_types)] 8500 7313 struct SoundUnitSvc<T: SoundService>(pub Arc<T>); 8501 - impl< 8502 - T: SoundService, 8503 - > tonic::server::UnaryService<super::SoundUnitRequest> 8504 - for SoundUnitSvc<T> { 7314 + impl<T: SoundService> tonic::server::UnaryService<super::SoundUnitRequest> for SoundUnitSvc<T> { 8505 7315 type Response = super::SoundUnitResponse; 8506 - type Future = BoxFuture< 8507 - tonic::Response<Self::Response>, 8508 - tonic::Status, 8509 - >; 7316 + type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 8510 7317 fn call( 8511 7318 &mut self, 8512 7319 request: tonic::Request<super::SoundUnitRequest>, ··· 8543 7350 "/rockbox.v1alpha1.SoundService/SoundVal2Phys" => { 8544 7351 #[allow(non_camel_case_types)] 8545 7352 struct SoundVal2PhysSvc<T: SoundService>(pub Arc<T>); 8546 - impl< 8547 - T: SoundService, 8548 - > tonic::server::UnaryService<super::SoundVal2PhysRequest> 8549 - for SoundVal2PhysSvc<T> { 7353 + impl<T: SoundService> tonic::server::UnaryService<super::SoundVal2PhysRequest> 7354 + for SoundVal2PhysSvc<T> 7355 + { 8550 7356 type Response = super::SoundVal2PhysResponse; 8551 - type Future = BoxFuture< 8552 - tonic::Response<Self::Response>, 8553 - tonic::Status, 8554 - >; 7357 + type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 8555 7358 fn call( 8556 7359 &mut self, 8557 7360 request: tonic::Request<super::SoundVal2PhysRequest>, ··· 8588 7391 "/rockbox.v1alpha1.SoundService/GetPitch" => { 8589 7392 #[allow(non_camel_case_types)] 8590 7393 struct GetPitchSvc<T: SoundService>(pub Arc<T>); 8591 - impl< 8592 - T: SoundService, 8593 - > tonic::server::UnaryService<super::GetPitchRequest> 8594 - for GetPitchSvc<T> { 7394 + impl<T: SoundService> tonic::server::UnaryService<super::GetPitchRequest> for GetPitchSvc<T> { 8595 7395 type Response = super::GetPitchResponse; 8596 - type Future = BoxFuture< 8597 - tonic::Response<Self::Response>, 8598 - tonic::Status, 8599 - >; 7396 + type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 8600 7397 fn call( 8601 7398 &mut self, 8602 7399 request: tonic::Request<super::GetPitchRequest>, ··· 8633 7430 "/rockbox.v1alpha1.SoundService/SetPitch" => { 8634 7431 #[allow(non_camel_case_types)] 8635 7432 struct SetPitchSvc<T: SoundService>(pub Arc<T>); 8636 - impl< 8637 - T: SoundService, 8638 - > tonic::server::UnaryService<super::SetPitchRequest> 8639 - for SetPitchSvc<T> { 7433 + impl<T: SoundService> tonic::server::UnaryService<super::SetPitchRequest> for SetPitchSvc<T> { 8640 7434 type Response = super::SetPitchResponse; 8641 - type Future = BoxFuture< 8642 - tonic::Response<Self::Response>, 8643 - tonic::Status, 8644 - >; 7435 + type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 8645 7436 fn call( 8646 7437 &mut self, 8647 7438 request: tonic::Request<super::SetPitchRequest>, ··· 8678 7469 "/rockbox.v1alpha1.SoundService/BeepPlay" => { 8679 7470 #[allow(non_camel_case_types)] 8680 7471 struct BeepPlaySvc<T: SoundService>(pub Arc<T>); 8681 - impl< 8682 - T: SoundService, 8683 - > tonic::server::UnaryService<super::BeepPlayRequest> 8684 - for BeepPlaySvc<T> { 7472 + impl<T: SoundService> tonic::server::UnaryService<super::BeepPlayRequest> for BeepPlaySvc<T> { 8685 7473 type Response = super::BeepPlayResponse; 8686 - type Future = BoxFuture< 8687 - tonic::Response<Self::Response>, 8688 - tonic::Status, 8689 - >; 7474 + type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 8690 7475 fn call( 8691 7476 &mut self, 8692 7477 request: tonic::Request<super::BeepPlayRequest>, ··· 8723 7508 "/rockbox.v1alpha1.SoundService/PcmbufFade" => { 8724 7509 #[allow(non_camel_case_types)] 8725 7510 struct PcmbufFadeSvc<T: SoundService>(pub Arc<T>); 8726 - impl< 8727 - T: SoundService, 8728 - > tonic::server::UnaryService<super::PcmbufFadeRequest> 8729 - for PcmbufFadeSvc<T> { 7511 + impl<T: SoundService> tonic::server::UnaryService<super::PcmbufFadeRequest> for PcmbufFadeSvc<T> { 8730 7512 type Response = super::PcmbufFadeResponse; 8731 - type Future = BoxFuture< 8732 - tonic::Response<Self::Response>, 8733 - tonic::Status, 8734 - >; 7513 + type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 8735 7514 fn call( 8736 7515 &mut self, 8737 7516 request: tonic::Request<super::PcmbufFadeRequest>, ··· 8768 7547 "/rockbox.v1alpha1.SoundService/PcmbufSetLowLatency" => { 8769 7548 #[allow(non_camel_case_types)] 8770 7549 struct PcmbufSetLowLatencySvc<T: SoundService>(pub Arc<T>); 8771 - impl< 8772 - T: SoundService, 8773 - > tonic::server::UnaryService<super::PcmbufSetLowLatencyRequest> 8774 - for PcmbufSetLowLatencySvc<T> { 7550 + impl<T: SoundService> 7551 + tonic::server::UnaryService<super::PcmbufSetLowLatencyRequest> 7552 + for PcmbufSetLowLatencySvc<T> 7553 + { 8775 7554 type Response = super::PcmbufSetLowLatencyResponse; 8776 - type Future = BoxFuture< 8777 - tonic::Response<Self::Response>, 8778 - tonic::Status, 8779 - >; 7555 + type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 8780 7556 fn call( 8781 7557 &mut self, 8782 7558 request: tonic::Request<super::PcmbufSetLowLatencyRequest>, 8783 7559 ) -> Self::Future { 8784 7560 let inner = Arc::clone(&self.0); 8785 7561 let fut = async move { 8786 - <T as SoundService>::pcmbuf_set_low_latency(&inner, request) 8787 - .await 7562 + <T as SoundService>::pcmbuf_set_low_latency(&inner, request).await 8788 7563 }; 8789 7564 Box::pin(fut) 8790 7565 } ··· 8814 7589 "/rockbox.v1alpha1.SoundService/SystemSoundPlay" => { 8815 7590 #[allow(non_camel_case_types)] 8816 7591 struct SystemSoundPlaySvc<T: SoundService>(pub Arc<T>); 8817 - impl< 8818 - T: SoundService, 8819 - > tonic::server::UnaryService<super::SystemSoundPlayRequest> 8820 - for SystemSoundPlaySvc<T> { 7592 + impl<T: SoundService> tonic::server::UnaryService<super::SystemSoundPlayRequest> 7593 + for SystemSoundPlaySvc<T> 7594 + { 8821 7595 type Response = super::SystemSoundPlayResponse; 8822 - type Future = BoxFuture< 8823 - tonic::Response<Self::Response>, 8824 - tonic::Status, 8825 - >; 7596 + type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 8826 7597 fn call( 8827 7598 &mut self, 8828 7599 request: tonic::Request<super::SystemSoundPlayRequest>, 8829 7600 ) -> Self::Future { 8830 7601 let inner = Arc::clone(&self.0); 8831 7602 let fut = async move { 8832 - <T as SoundService>::system_sound_play(&inner, request) 8833 - .await 7603 + <T as SoundService>::system_sound_play(&inner, request).await 8834 7604 }; 8835 7605 Box::pin(fut) 8836 7606 } ··· 8860 7630 "/rockbox.v1alpha1.SoundService/KeyclickClick" => { 8861 7631 #[allow(non_camel_case_types)] 8862 7632 struct KeyclickClickSvc<T: SoundService>(pub Arc<T>); 8863 - impl< 8864 - T: SoundService, 8865 - > tonic::server::UnaryService<super::KeyclickClickRequest> 8866 - for KeyclickClickSvc<T> { 7633 + impl<T: SoundService> tonic::server::UnaryService<super::KeyclickClickRequest> 7634 + for KeyclickClickSvc<T> 7635 + { 8867 7636 type Response = super::KeyclickClickResponse; 8868 - type Future = BoxFuture< 8869 - tonic::Response<Self::Response>, 8870 - tonic::Status, 8871 - >; 7637 + type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 8872 7638 fn call( 8873 7639 &mut self, 8874 7640 request: tonic::Request<super::KeyclickClickRequest>, ··· 8902 7668 }; 8903 7669 Box::pin(fut) 8904 7670 } 8905 - _ => { 8906 - Box::pin(async move { 8907 - let mut response = http::Response::new(empty_body()); 8908 - let headers = response.headers_mut(); 8909 - headers 8910 - .insert( 8911 - tonic::Status::GRPC_STATUS, 8912 - (tonic::Code::Unimplemented as i32).into(), 8913 - ); 8914 - headers 8915 - .insert( 8916 - http::header::CONTENT_TYPE, 8917 - tonic::metadata::GRPC_CONTENT_TYPE, 8918 - ); 8919 - Ok(response) 8920 - }) 8921 - } 7671 + _ => Box::pin(async move { 7672 + let mut response = http::Response::new(empty_body()); 7673 + let headers = response.headers_mut(); 7674 + headers.insert( 7675 + tonic::Status::GRPC_STATUS, 7676 + (tonic::Code::Unimplemented as i32).into(), 7677 + ); 7678 + headers.insert( 7679 + http::header::CONTENT_TYPE, 7680 + tonic::metadata::GRPC_CONTENT_TYPE, 7681 + ); 7682 + Ok(response) 7683 + }), 8922 7684 } 8923 7685 } 8924 7686 } ··· 8979 7741 dead_code, 8980 7742 missing_docs, 8981 7743 clippy::wildcard_imports, 8982 - clippy::let_unit_value, 7744 + clippy::let_unit_value 8983 7745 )] 8984 - use tonic::codegen::*; 8985 7746 use tonic::codegen::http::Uri; 7747 + use tonic::codegen::*; 8986 7748 #[derive(Debug, Clone)] 8987 7749 pub struct SystemServiceClient<T> { 8988 7750 inner: tonic::client::Grpc<T>, ··· 9026 7788 <T as tonic::client::GrpcService<tonic::body::BoxBody>>::ResponseBody, 9027 7789 >, 9028 7790 >, 9029 - <T as tonic::codegen::Service< 9030 - http::Request<tonic::body::BoxBody>, 9031 - >>::Error: Into<StdError> + std::marker::Send + std::marker::Sync, 7791 + <T as tonic::codegen::Service<http::Request<tonic::body::BoxBody>>>::Error: 7792 + Into<StdError> + std::marker::Send + std::marker::Sync, 9032 7793 { 9033 7794 SystemServiceClient::new(InterceptedService::new(inner, interceptor)) 9034 7795 } ··· 9066 7827 pub async fn get_rockbox_version( 9067 7828 &mut self, 9068 7829 request: impl tonic::IntoRequest<super::GetRockboxVersionRequest>, 9069 - ) -> std::result::Result< 9070 - tonic::Response<super::GetRockboxVersionResponse>, 9071 - tonic::Status, 9072 - > { 9073 - self.inner 9074 - .ready() 9075 - .await 9076 - .map_err(|e| { 9077 - tonic::Status::unknown( 9078 - format!("Service was not ready: {}", e.into()), 9079 - ) 9080 - })?; 7830 + ) -> std::result::Result<tonic::Response<super::GetRockboxVersionResponse>, tonic::Status> 7831 + { 7832 + self.inner.ready().await.map_err(|e| { 7833 + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 7834 + })?; 9081 7835 let codec = tonic::codec::ProstCodec::default(); 9082 7836 let path = http::uri::PathAndQuery::from_static( 9083 7837 "/rockbox.v1alpha1.SystemService/GetRockboxVersion", 9084 7838 ); 9085 7839 let mut req = request.into_request(); 9086 - req.extensions_mut() 9087 - .insert( 9088 - GrpcMethod::new( 9089 - "rockbox.v1alpha1.SystemService", 9090 - "GetRockboxVersion", 9091 - ), 9092 - ); 7840 + req.extensions_mut().insert(GrpcMethod::new( 7841 + "rockbox.v1alpha1.SystemService", 7842 + "GetRockboxVersion", 7843 + )); 9093 7844 self.inner.unary(req, path, codec).await 9094 7845 } 9095 7846 pub async fn get_global_status( 9096 7847 &mut self, 9097 7848 request: impl tonic::IntoRequest<super::GetGlobalStatusRequest>, 9098 - ) -> std::result::Result< 9099 - tonic::Response<super::GetGlobalStatusResponse>, 9100 - tonic::Status, 9101 - > { 9102 - self.inner 9103 - .ready() 9104 - .await 9105 - .map_err(|e| { 9106 - tonic::Status::unknown( 9107 - format!("Service was not ready: {}", e.into()), 9108 - ) 9109 - })?; 7849 + ) -> std::result::Result<tonic::Response<super::GetGlobalStatusResponse>, tonic::Status> 7850 + { 7851 + self.inner.ready().await.map_err(|e| { 7852 + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 7853 + })?; 9110 7854 let codec = tonic::codec::ProstCodec::default(); 9111 7855 let path = http::uri::PathAndQuery::from_static( 9112 7856 "/rockbox.v1alpha1.SystemService/GetGlobalStatus", 9113 7857 ); 9114 7858 let mut req = request.into_request(); 9115 - req.extensions_mut() 9116 - .insert( 9117 - GrpcMethod::new("rockbox.v1alpha1.SystemService", "GetGlobalStatus"), 9118 - ); 7859 + req.extensions_mut().insert(GrpcMethod::new( 7860 + "rockbox.v1alpha1.SystemService", 7861 + "GetGlobalStatus", 7862 + )); 9119 7863 self.inner.unary(req, path, codec).await 9120 7864 } 9121 7865 } ··· 9127 7871 dead_code, 9128 7872 missing_docs, 9129 7873 clippy::wildcard_imports, 9130 - clippy::let_unit_value, 7874 + clippy::let_unit_value 9131 7875 )] 9132 7876 use tonic::codegen::*; 9133 7877 /// Generated trait containing gRPC methods that should be implemented for use with SystemServiceServer. ··· 9136 7880 async fn get_rockbox_version( 9137 7881 &self, 9138 7882 request: tonic::Request<super::GetRockboxVersionRequest>, 9139 - ) -> std::result::Result< 9140 - tonic::Response<super::GetRockboxVersionResponse>, 9141 - tonic::Status, 9142 - >; 7883 + ) -> std::result::Result<tonic::Response<super::GetRockboxVersionResponse>, tonic::Status>; 9143 7884 async fn get_global_status( 9144 7885 &self, 9145 7886 request: tonic::Request<super::GetGlobalStatusRequest>, 9146 - ) -> std::result::Result< 9147 - tonic::Response<super::GetGlobalStatusResponse>, 9148 - tonic::Status, 9149 - >; 7887 + ) -> std::result::Result<tonic::Response<super::GetGlobalStatusResponse>, tonic::Status>; 9150 7888 } 9151 7889 #[derive(Debug)] 9152 7890 pub struct SystemServiceServer<T> { ··· 9169 7907 max_encoding_message_size: None, 9170 7908 } 9171 7909 } 9172 - pub fn with_interceptor<F>( 9173 - inner: T, 9174 - interceptor: F, 9175 - ) -> InterceptedService<Self, F> 7910 + pub fn with_interceptor<F>(inner: T, interceptor: F) -> InterceptedService<Self, F> 9176 7911 where 9177 7912 F: tonic::service::Interceptor, 9178 7913 { ··· 9227 7962 "/rockbox.v1alpha1.SystemService/GetRockboxVersion" => { 9228 7963 #[allow(non_camel_case_types)] 9229 7964 struct GetRockboxVersionSvc<T: SystemService>(pub Arc<T>); 9230 - impl< 9231 - T: SystemService, 9232 - > tonic::server::UnaryService<super::GetRockboxVersionRequest> 9233 - for GetRockboxVersionSvc<T> { 7965 + impl<T: SystemService> 7966 + tonic::server::UnaryService<super::GetRockboxVersionRequest> 7967 + for GetRockboxVersionSvc<T> 7968 + { 9234 7969 type Response = super::GetRockboxVersionResponse; 9235 - type Future = BoxFuture< 9236 - tonic::Response<Self::Response>, 9237 - tonic::Status, 9238 - >; 7970 + type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 9239 7971 fn call( 9240 7972 &mut self, 9241 7973 request: tonic::Request<super::GetRockboxVersionRequest>, 9242 7974 ) -> Self::Future { 9243 7975 let inner = Arc::clone(&self.0); 9244 7976 let fut = async move { 9245 - <T as SystemService>::get_rockbox_version(&inner, request) 9246 - .await 7977 + <T as SystemService>::get_rockbox_version(&inner, request).await 9247 7978 }; 9248 7979 Box::pin(fut) 9249 7980 } ··· 9273 8004 "/rockbox.v1alpha1.SystemService/GetGlobalStatus" => { 9274 8005 #[allow(non_camel_case_types)] 9275 8006 struct GetGlobalStatusSvc<T: SystemService>(pub Arc<T>); 9276 - impl< 9277 - T: SystemService, 9278 - > tonic::server::UnaryService<super::GetGlobalStatusRequest> 9279 - for GetGlobalStatusSvc<T> { 8007 + impl<T: SystemService> 8008 + tonic::server::UnaryService<super::GetGlobalStatusRequest> 8009 + for GetGlobalStatusSvc<T> 8010 + { 9280 8011 type Response = super::GetGlobalStatusResponse; 9281 - type Future = BoxFuture< 9282 - tonic::Response<Self::Response>, 9283 - tonic::Status, 9284 - >; 8012 + type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 9285 8013 fn call( 9286 8014 &mut self, 9287 8015 request: tonic::Request<super::GetGlobalStatusRequest>, 9288 8016 ) -> Self::Future { 9289 8017 let inner = Arc::clone(&self.0); 9290 8018 let fut = async move { 9291 - <T as SystemService>::get_global_status(&inner, request) 9292 - .await 8019 + <T as SystemService>::get_global_status(&inner, request).await 9293 8020 }; 9294 8021 Box::pin(fut) 9295 8022 } ··· 9316 8043 }; 9317 8044 Box::pin(fut) 9318 8045 } 9319 - _ => { 9320 - Box::pin(async move { 9321 - let mut response = http::Response::new(empty_body()); 9322 - let headers = response.headers_mut(); 9323 - headers 9324 - .insert( 9325 - tonic::Status::GRPC_STATUS, 9326 - (tonic::Code::Unimplemented as i32).into(), 9327 - ); 9328 - headers 9329 - .insert( 9330 - http::header::CONTENT_TYPE, 9331 - tonic::metadata::GRPC_CONTENT_TYPE, 9332 - ); 9333 - Ok(response) 9334 - }) 9335 - } 8046 + _ => Box::pin(async move { 8047 + let mut response = http::Response::new(empty_body()); 8048 + let headers = response.headers_mut(); 8049 + headers.insert( 8050 + tonic::Status::GRPC_STATUS, 8051 + (tonic::Code::Unimplemented as i32).into(), 8052 + ); 8053 + headers.insert( 8054 + http::header::CONTENT_TYPE, 8055 + tonic::metadata::GRPC_CONTENT_TYPE, 8056 + ); 8057 + Ok(response) 8058 + }), 9336 8059 } 9337 8060 } 9338 8061 }