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.

run cargo fmt

+2450 -4948
+1240 -2506
cli/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 } ··· 550 527 dead_code, 551 528 missing_docs, 552 529 clippy::wildcard_imports, 553 - clippy::let_unit_value, 530 + clippy::let_unit_value 554 531 )] 555 - use tonic::codegen::*; 556 532 use tonic::codegen::http::Uri; 533 + use tonic::codegen::*; 557 534 #[derive(Debug, Clone)] 558 535 pub struct LibraryServiceClient<T> { 559 536 inner: tonic::client::Grpc<T>, ··· 597 574 <T as tonic::client::GrpcService<tonic::body::BoxBody>>::ResponseBody, 598 575 >, 599 576 >, 600 - <T as tonic::codegen::Service< 601 - http::Request<tonic::body::BoxBody>, 602 - >>::Error: Into<StdError> + std::marker::Send + std::marker::Sync, 577 + <T as tonic::codegen::Service<http::Request<tonic::body::BoxBody>>>::Error: 578 + Into<StdError> + std::marker::Send + std::marker::Sync, 603 579 { 604 580 LibraryServiceClient::new(InterceptedService::new(inner, interceptor)) 605 581 } ··· 637 613 pub async fn get_albums( 638 614 &mut self, 639 615 request: impl tonic::IntoRequest<super::GetAlbumsRequest>, 640 - ) -> std::result::Result< 641 - tonic::Response<super::GetAlbumsResponse>, 642 - tonic::Status, 643 - > { 644 - self.inner 645 - .ready() 646 - .await 647 - .map_err(|e| { 648 - tonic::Status::unknown( 649 - format!("Service was not ready: {}", e.into()), 650 - ) 651 - })?; 616 + ) -> std::result::Result<tonic::Response<super::GetAlbumsResponse>, tonic::Status> { 617 + self.inner.ready().await.map_err(|e| { 618 + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 619 + })?; 652 620 let codec = tonic::codec::ProstCodec::default(); 653 - let path = http::uri::PathAndQuery::from_static( 654 - "/rockbox.v1alpha1.LibraryService/GetAlbums", 655 - ); 621 + let path = 622 + http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.LibraryService/GetAlbums"); 656 623 let mut req = request.into_request(); 657 - req.extensions_mut() 658 - .insert(GrpcMethod::new("rockbox.v1alpha1.LibraryService", "GetAlbums")); 624 + req.extensions_mut().insert(GrpcMethod::new( 625 + "rockbox.v1alpha1.LibraryService", 626 + "GetAlbums", 627 + )); 659 628 self.inner.unary(req, path, codec).await 660 629 } 661 630 pub async fn get_artists( 662 631 &mut self, 663 632 request: impl tonic::IntoRequest<super::GetArtistsRequest>, 664 - ) -> std::result::Result< 665 - tonic::Response<super::GetArtistsResponse>, 666 - tonic::Status, 667 - > { 668 - self.inner 669 - .ready() 670 - .await 671 - .map_err(|e| { 672 - tonic::Status::unknown( 673 - format!("Service was not ready: {}", e.into()), 674 - ) 675 - })?; 633 + ) -> std::result::Result<tonic::Response<super::GetArtistsResponse>, tonic::Status> 634 + { 635 + self.inner.ready().await.map_err(|e| { 636 + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 637 + })?; 676 638 let codec = tonic::codec::ProstCodec::default(); 677 - let path = http::uri::PathAndQuery::from_static( 678 - "/rockbox.v1alpha1.LibraryService/GetArtists", 679 - ); 639 + let path = 640 + http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.LibraryService/GetArtists"); 680 641 let mut req = request.into_request(); 681 - req.extensions_mut() 682 - .insert( 683 - GrpcMethod::new("rockbox.v1alpha1.LibraryService", "GetArtists"), 684 - ); 642 + req.extensions_mut().insert(GrpcMethod::new( 643 + "rockbox.v1alpha1.LibraryService", 644 + "GetArtists", 645 + )); 685 646 self.inner.unary(req, path, codec).await 686 647 } 687 648 pub async fn get_tracks( 688 649 &mut self, 689 650 request: impl tonic::IntoRequest<super::GetTracksRequest>, 690 - ) -> std::result::Result< 691 - tonic::Response<super::GetTracksResponse>, 692 - tonic::Status, 693 - > { 694 - self.inner 695 - .ready() 696 - .await 697 - .map_err(|e| { 698 - tonic::Status::unknown( 699 - format!("Service was not ready: {}", e.into()), 700 - ) 701 - })?; 651 + ) -> std::result::Result<tonic::Response<super::GetTracksResponse>, tonic::Status> { 652 + self.inner.ready().await.map_err(|e| { 653 + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 654 + })?; 702 655 let codec = tonic::codec::ProstCodec::default(); 703 - let path = http::uri::PathAndQuery::from_static( 704 - "/rockbox.v1alpha1.LibraryService/GetTracks", 705 - ); 656 + let path = 657 + http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.LibraryService/GetTracks"); 706 658 let mut req = request.into_request(); 707 - req.extensions_mut() 708 - .insert(GrpcMethod::new("rockbox.v1alpha1.LibraryService", "GetTracks")); 659 + req.extensions_mut().insert(GrpcMethod::new( 660 + "rockbox.v1alpha1.LibraryService", 661 + "GetTracks", 662 + )); 709 663 self.inner.unary(req, path, codec).await 710 664 } 711 665 pub async fn get_album( 712 666 &mut self, 713 667 request: impl tonic::IntoRequest<super::GetAlbumRequest>, 714 - ) -> std::result::Result< 715 - tonic::Response<super::GetAlbumResponse>, 716 - tonic::Status, 717 - > { 718 - self.inner 719 - .ready() 720 - .await 721 - .map_err(|e| { 722 - tonic::Status::unknown( 723 - format!("Service was not ready: {}", e.into()), 724 - ) 725 - })?; 668 + ) -> std::result::Result<tonic::Response<super::GetAlbumResponse>, tonic::Status> { 669 + self.inner.ready().await.map_err(|e| { 670 + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 671 + })?; 726 672 let codec = tonic::codec::ProstCodec::default(); 727 - let path = http::uri::PathAndQuery::from_static( 728 - "/rockbox.v1alpha1.LibraryService/GetAlbum", 729 - ); 673 + let path = 674 + http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.LibraryService/GetAlbum"); 730 675 let mut req = request.into_request(); 731 - req.extensions_mut() 732 - .insert(GrpcMethod::new("rockbox.v1alpha1.LibraryService", "GetAlbum")); 676 + req.extensions_mut().insert(GrpcMethod::new( 677 + "rockbox.v1alpha1.LibraryService", 678 + "GetAlbum", 679 + )); 733 680 self.inner.unary(req, path, codec).await 734 681 } 735 682 pub async fn get_artist( 736 683 &mut self, 737 684 request: impl tonic::IntoRequest<super::GetArtistRequest>, 738 - ) -> std::result::Result< 739 - tonic::Response<super::GetArtistResponse>, 740 - tonic::Status, 741 - > { 742 - self.inner 743 - .ready() 744 - .await 745 - .map_err(|e| { 746 - tonic::Status::unknown( 747 - format!("Service was not ready: {}", e.into()), 748 - ) 749 - })?; 685 + ) -> std::result::Result<tonic::Response<super::GetArtistResponse>, tonic::Status> { 686 + self.inner.ready().await.map_err(|e| { 687 + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 688 + })?; 750 689 let codec = tonic::codec::ProstCodec::default(); 751 - let path = http::uri::PathAndQuery::from_static( 752 - "/rockbox.v1alpha1.LibraryService/GetArtist", 753 - ); 690 + let path = 691 + http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.LibraryService/GetArtist"); 754 692 let mut req = request.into_request(); 755 - req.extensions_mut() 756 - .insert(GrpcMethod::new("rockbox.v1alpha1.LibraryService", "GetArtist")); 693 + req.extensions_mut().insert(GrpcMethod::new( 694 + "rockbox.v1alpha1.LibraryService", 695 + "GetArtist", 696 + )); 757 697 self.inner.unary(req, path, codec).await 758 698 } 759 699 pub async fn get_track( 760 700 &mut self, 761 701 request: impl tonic::IntoRequest<super::GetTrackRequest>, 762 - ) -> std::result::Result< 763 - tonic::Response<super::GetTrackResponse>, 764 - tonic::Status, 765 - > { 766 - self.inner 767 - .ready() 768 - .await 769 - .map_err(|e| { 770 - tonic::Status::unknown( 771 - format!("Service was not ready: {}", e.into()), 772 - ) 773 - })?; 702 + ) -> std::result::Result<tonic::Response<super::GetTrackResponse>, tonic::Status> { 703 + self.inner.ready().await.map_err(|e| { 704 + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 705 + })?; 774 706 let codec = tonic::codec::ProstCodec::default(); 775 - let path = http::uri::PathAndQuery::from_static( 776 - "/rockbox.v1alpha1.LibraryService/GetTrack", 777 - ); 707 + let path = 708 + http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.LibraryService/GetTrack"); 778 709 let mut req = request.into_request(); 779 - req.extensions_mut() 780 - .insert(GrpcMethod::new("rockbox.v1alpha1.LibraryService", "GetTrack")); 710 + req.extensions_mut().insert(GrpcMethod::new( 711 + "rockbox.v1alpha1.LibraryService", 712 + "GetTrack", 713 + )); 781 714 self.inner.unary(req, path, codec).await 782 715 } 783 716 pub async fn like_track( 784 717 &mut self, 785 718 request: impl tonic::IntoRequest<super::LikeTrackRequest>, 786 - ) -> std::result::Result< 787 - tonic::Response<super::LikeTrackResponse>, 788 - tonic::Status, 789 - > { 790 - self.inner 791 - .ready() 792 - .await 793 - .map_err(|e| { 794 - tonic::Status::unknown( 795 - format!("Service was not ready: {}", e.into()), 796 - ) 797 - })?; 719 + ) -> std::result::Result<tonic::Response<super::LikeTrackResponse>, tonic::Status> { 720 + self.inner.ready().await.map_err(|e| { 721 + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 722 + })?; 798 723 let codec = tonic::codec::ProstCodec::default(); 799 - let path = http::uri::PathAndQuery::from_static( 800 - "/rockbox.v1alpha1.LibraryService/LikeTrack", 801 - ); 724 + let path = 725 + http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.LibraryService/LikeTrack"); 802 726 let mut req = request.into_request(); 803 - req.extensions_mut() 804 - .insert(GrpcMethod::new("rockbox.v1alpha1.LibraryService", "LikeTrack")); 727 + req.extensions_mut().insert(GrpcMethod::new( 728 + "rockbox.v1alpha1.LibraryService", 729 + "LikeTrack", 730 + )); 805 731 self.inner.unary(req, path, codec).await 806 732 } 807 733 pub async fn unlike_track( 808 734 &mut self, 809 735 request: impl tonic::IntoRequest<super::UnlikeTrackRequest>, 810 - ) -> std::result::Result< 811 - tonic::Response<super::UnlikeTrackResponse>, 812 - tonic::Status, 813 - > { 814 - self.inner 815 - .ready() 816 - .await 817 - .map_err(|e| { 818 - tonic::Status::unknown( 819 - format!("Service was not ready: {}", e.into()), 820 - ) 821 - })?; 736 + ) -> std::result::Result<tonic::Response<super::UnlikeTrackResponse>, tonic::Status> 737 + { 738 + self.inner.ready().await.map_err(|e| { 739 + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 740 + })?; 822 741 let codec = tonic::codec::ProstCodec::default(); 823 742 let path = http::uri::PathAndQuery::from_static( 824 743 "/rockbox.v1alpha1.LibraryService/UnlikeTrack", 825 744 ); 826 745 let mut req = request.into_request(); 827 - req.extensions_mut() 828 - .insert( 829 - GrpcMethod::new("rockbox.v1alpha1.LibraryService", "UnlikeTrack"), 830 - ); 746 + req.extensions_mut().insert(GrpcMethod::new( 747 + "rockbox.v1alpha1.LibraryService", 748 + "UnlikeTrack", 749 + )); 831 750 self.inner.unary(req, path, codec).await 832 751 } 833 752 pub async fn like_album( 834 753 &mut self, 835 754 request: impl tonic::IntoRequest<super::LikeAlbumRequest>, 836 - ) -> std::result::Result< 837 - tonic::Response<super::LikeAlbumResponse>, 838 - tonic::Status, 839 - > { 840 - self.inner 841 - .ready() 842 - .await 843 - .map_err(|e| { 844 - tonic::Status::unknown( 845 - format!("Service was not ready: {}", e.into()), 846 - ) 847 - })?; 755 + ) -> std::result::Result<tonic::Response<super::LikeAlbumResponse>, tonic::Status> { 756 + self.inner.ready().await.map_err(|e| { 757 + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 758 + })?; 848 759 let codec = tonic::codec::ProstCodec::default(); 849 - let path = http::uri::PathAndQuery::from_static( 850 - "/rockbox.v1alpha1.LibraryService/LikeAlbum", 851 - ); 760 + let path = 761 + http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.LibraryService/LikeAlbum"); 852 762 let mut req = request.into_request(); 853 - req.extensions_mut() 854 - .insert(GrpcMethod::new("rockbox.v1alpha1.LibraryService", "LikeAlbum")); 763 + req.extensions_mut().insert(GrpcMethod::new( 764 + "rockbox.v1alpha1.LibraryService", 765 + "LikeAlbum", 766 + )); 855 767 self.inner.unary(req, path, codec).await 856 768 } 857 769 pub async fn unlike_album( 858 770 &mut self, 859 771 request: impl tonic::IntoRequest<super::UnlikeAlbumRequest>, 860 - ) -> std::result::Result< 861 - tonic::Response<super::UnlikeAlbumResponse>, 862 - tonic::Status, 863 - > { 864 - self.inner 865 - .ready() 866 - .await 867 - .map_err(|e| { 868 - tonic::Status::unknown( 869 - format!("Service was not ready: {}", e.into()), 870 - ) 871 - })?; 772 + ) -> std::result::Result<tonic::Response<super::UnlikeAlbumResponse>, tonic::Status> 773 + { 774 + self.inner.ready().await.map_err(|e| { 775 + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 776 + })?; 872 777 let codec = tonic::codec::ProstCodec::default(); 873 778 let path = http::uri::PathAndQuery::from_static( 874 779 "/rockbox.v1alpha1.LibraryService/UnlikeAlbum", 875 780 ); 876 781 let mut req = request.into_request(); 877 - req.extensions_mut() 878 - .insert( 879 - GrpcMethod::new("rockbox.v1alpha1.LibraryService", "UnlikeAlbum"), 880 - ); 782 + req.extensions_mut().insert(GrpcMethod::new( 783 + "rockbox.v1alpha1.LibraryService", 784 + "UnlikeAlbum", 785 + )); 881 786 self.inner.unary(req, path, codec).await 882 787 } 883 788 pub async fn get_liked_tracks( 884 789 &mut self, 885 790 request: impl tonic::IntoRequest<super::GetLikedTracksRequest>, 886 - ) -> std::result::Result< 887 - tonic::Response<super::GetLikedTracksResponse>, 888 - tonic::Status, 889 - > { 890 - self.inner 891 - .ready() 892 - .await 893 - .map_err(|e| { 894 - tonic::Status::unknown( 895 - format!("Service was not ready: {}", e.into()), 896 - ) 897 - })?; 791 + ) -> std::result::Result<tonic::Response<super::GetLikedTracksResponse>, tonic::Status> 792 + { 793 + self.inner.ready().await.map_err(|e| { 794 + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 795 + })?; 898 796 let codec = tonic::codec::ProstCodec::default(); 899 797 let path = http::uri::PathAndQuery::from_static( 900 798 "/rockbox.v1alpha1.LibraryService/GetLikedTracks", 901 799 ); 902 800 let mut req = request.into_request(); 903 - req.extensions_mut() 904 - .insert( 905 - GrpcMethod::new("rockbox.v1alpha1.LibraryService", "GetLikedTracks"), 906 - ); 801 + req.extensions_mut().insert(GrpcMethod::new( 802 + "rockbox.v1alpha1.LibraryService", 803 + "GetLikedTracks", 804 + )); 907 805 self.inner.unary(req, path, codec).await 908 806 } 909 807 pub async fn get_liked_albums( 910 808 &mut self, 911 809 request: impl tonic::IntoRequest<super::GetLikedAlbumsRequest>, 912 - ) -> std::result::Result< 913 - tonic::Response<super::GetLikedAlbumsResponse>, 914 - tonic::Status, 915 - > { 916 - self.inner 917 - .ready() 918 - .await 919 - .map_err(|e| { 920 - tonic::Status::unknown( 921 - format!("Service was not ready: {}", e.into()), 922 - ) 923 - })?; 810 + ) -> std::result::Result<tonic::Response<super::GetLikedAlbumsResponse>, tonic::Status> 811 + { 812 + self.inner.ready().await.map_err(|e| { 813 + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 814 + })?; 924 815 let codec = tonic::codec::ProstCodec::default(); 925 816 let path = http::uri::PathAndQuery::from_static( 926 817 "/rockbox.v1alpha1.LibraryService/GetLikedAlbums", 927 818 ); 928 819 let mut req = request.into_request(); 929 - req.extensions_mut() 930 - .insert( 931 - GrpcMethod::new("rockbox.v1alpha1.LibraryService", "GetLikedAlbums"), 932 - ); 820 + req.extensions_mut().insert(GrpcMethod::new( 821 + "rockbox.v1alpha1.LibraryService", 822 + "GetLikedAlbums", 823 + )); 933 824 self.inner.unary(req, path, codec).await 934 825 } 935 826 pub async fn scan_library( 936 827 &mut self, 937 828 request: impl tonic::IntoRequest<super::ScanLibraryRequest>, 938 - ) -> std::result::Result< 939 - tonic::Response<super::ScanLibraryResponse>, 940 - tonic::Status, 941 - > { 942 - self.inner 943 - .ready() 944 - .await 945 - .map_err(|e| { 946 - tonic::Status::unknown( 947 - format!("Service was not ready: {}", e.into()), 948 - ) 949 - })?; 829 + ) -> std::result::Result<tonic::Response<super::ScanLibraryResponse>, tonic::Status> 830 + { 831 + self.inner.ready().await.map_err(|e| { 832 + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 833 + })?; 950 834 let codec = tonic::codec::ProstCodec::default(); 951 835 let path = http::uri::PathAndQuery::from_static( 952 836 "/rockbox.v1alpha1.LibraryService/ScanLibrary", 953 837 ); 954 838 let mut req = request.into_request(); 955 - req.extensions_mut() 956 - .insert( 957 - GrpcMethod::new("rockbox.v1alpha1.LibraryService", "ScanLibrary"), 958 - ); 839 + req.extensions_mut().insert(GrpcMethod::new( 840 + "rockbox.v1alpha1.LibraryService", 841 + "ScanLibrary", 842 + )); 959 843 self.inner.unary(req, path, codec).await 960 844 } 961 845 pub async fn search( 962 846 &mut self, 963 847 request: impl tonic::IntoRequest<super::SearchRequest>, 964 848 ) -> std::result::Result<tonic::Response<super::SearchResponse>, tonic::Status> { 965 - self.inner 966 - .ready() 967 - .await 968 - .map_err(|e| { 969 - tonic::Status::unknown( 970 - format!("Service was not ready: {}", e.into()), 971 - ) 972 - })?; 849 + self.inner.ready().await.map_err(|e| { 850 + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 851 + })?; 973 852 let codec = tonic::codec::ProstCodec::default(); 974 - let path = http::uri::PathAndQuery::from_static( 975 - "/rockbox.v1alpha1.LibraryService/Search", 976 - ); 853 + let path = 854 + http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.LibraryService/Search"); 977 855 let mut req = request.into_request(); 978 856 req.extensions_mut() 979 857 .insert(GrpcMethod::new("rockbox.v1alpha1.LibraryService", "Search")); ··· 988 866 dead_code, 989 867 missing_docs, 990 868 clippy::wildcard_imports, 991 - clippy::let_unit_value, 869 + clippy::let_unit_value 992 870 )] 993 871 use tonic::codegen::*; 994 872 /// Generated trait containing gRPC methods that should be implemented for use with LibraryServiceServer. ··· 997 875 async fn get_albums( 998 876 &self, 999 877 request: tonic::Request<super::GetAlbumsRequest>, 1000 - ) -> std::result::Result< 1001 - tonic::Response<super::GetAlbumsResponse>, 1002 - tonic::Status, 1003 - >; 878 + ) -> std::result::Result<tonic::Response<super::GetAlbumsResponse>, tonic::Status>; 1004 879 async fn get_artists( 1005 880 &self, 1006 881 request: tonic::Request<super::GetArtistsRequest>, 1007 - ) -> std::result::Result< 1008 - tonic::Response<super::GetArtistsResponse>, 1009 - tonic::Status, 1010 - >; 882 + ) -> std::result::Result<tonic::Response<super::GetArtistsResponse>, tonic::Status>; 1011 883 async fn get_tracks( 1012 884 &self, 1013 885 request: tonic::Request<super::GetTracksRequest>, 1014 - ) -> std::result::Result< 1015 - tonic::Response<super::GetTracksResponse>, 1016 - tonic::Status, 1017 - >; 886 + ) -> std::result::Result<tonic::Response<super::GetTracksResponse>, tonic::Status>; 1018 887 async fn get_album( 1019 888 &self, 1020 889 request: tonic::Request<super::GetAlbumRequest>, 1021 - ) -> std::result::Result< 1022 - tonic::Response<super::GetAlbumResponse>, 1023 - tonic::Status, 1024 - >; 890 + ) -> std::result::Result<tonic::Response<super::GetAlbumResponse>, tonic::Status>; 1025 891 async fn get_artist( 1026 892 &self, 1027 893 request: tonic::Request<super::GetArtistRequest>, 1028 - ) -> std::result::Result< 1029 - tonic::Response<super::GetArtistResponse>, 1030 - tonic::Status, 1031 - >; 894 + ) -> std::result::Result<tonic::Response<super::GetArtistResponse>, tonic::Status>; 1032 895 async fn get_track( 1033 896 &self, 1034 897 request: tonic::Request<super::GetTrackRequest>, 1035 - ) -> std::result::Result< 1036 - tonic::Response<super::GetTrackResponse>, 1037 - tonic::Status, 1038 - >; 898 + ) -> std::result::Result<tonic::Response<super::GetTrackResponse>, tonic::Status>; 1039 899 async fn like_track( 1040 900 &self, 1041 901 request: tonic::Request<super::LikeTrackRequest>, 1042 - ) -> std::result::Result< 1043 - tonic::Response<super::LikeTrackResponse>, 1044 - tonic::Status, 1045 - >; 902 + ) -> std::result::Result<tonic::Response<super::LikeTrackResponse>, tonic::Status>; 1046 903 async fn unlike_track( 1047 904 &self, 1048 905 request: tonic::Request<super::UnlikeTrackRequest>, 1049 - ) -> std::result::Result< 1050 - tonic::Response<super::UnlikeTrackResponse>, 1051 - tonic::Status, 1052 - >; 906 + ) -> std::result::Result<tonic::Response<super::UnlikeTrackResponse>, tonic::Status>; 1053 907 async fn like_album( 1054 908 &self, 1055 909 request: tonic::Request<super::LikeAlbumRequest>, 1056 - ) -> std::result::Result< 1057 - tonic::Response<super::LikeAlbumResponse>, 1058 - tonic::Status, 1059 - >; 910 + ) -> std::result::Result<tonic::Response<super::LikeAlbumResponse>, tonic::Status>; 1060 911 async fn unlike_album( 1061 912 &self, 1062 913 request: tonic::Request<super::UnlikeAlbumRequest>, 1063 - ) -> std::result::Result< 1064 - tonic::Response<super::UnlikeAlbumResponse>, 1065 - tonic::Status, 1066 - >; 914 + ) -> std::result::Result<tonic::Response<super::UnlikeAlbumResponse>, tonic::Status>; 1067 915 async fn get_liked_tracks( 1068 916 &self, 1069 917 request: tonic::Request<super::GetLikedTracksRequest>, 1070 - ) -> std::result::Result< 1071 - tonic::Response<super::GetLikedTracksResponse>, 1072 - tonic::Status, 1073 - >; 918 + ) -> std::result::Result<tonic::Response<super::GetLikedTracksResponse>, tonic::Status>; 1074 919 async fn get_liked_albums( 1075 920 &self, 1076 921 request: tonic::Request<super::GetLikedAlbumsRequest>, 1077 - ) -> std::result::Result< 1078 - tonic::Response<super::GetLikedAlbumsResponse>, 1079 - tonic::Status, 1080 - >; 922 + ) -> std::result::Result<tonic::Response<super::GetLikedAlbumsResponse>, tonic::Status>; 1081 923 async fn scan_library( 1082 924 &self, 1083 925 request: tonic::Request<super::ScanLibraryRequest>, 1084 - ) -> std::result::Result< 1085 - tonic::Response<super::ScanLibraryResponse>, 1086 - tonic::Status, 1087 - >; 926 + ) -> std::result::Result<tonic::Response<super::ScanLibraryResponse>, tonic::Status>; 1088 927 async fn search( 1089 928 &self, 1090 929 request: tonic::Request<super::SearchRequest>, ··· 1111 950 max_encoding_message_size: None, 1112 951 } 1113 952 } 1114 - pub fn with_interceptor<F>( 1115 - inner: T, 1116 - interceptor: F, 1117 - ) -> InterceptedService<Self, F> 953 + pub fn with_interceptor<F>(inner: T, interceptor: F) -> InterceptedService<Self, F> 1118 954 where 1119 955 F: tonic::service::Interceptor, 1120 956 { ··· 1169 1005 "/rockbox.v1alpha1.LibraryService/GetAlbums" => { 1170 1006 #[allow(non_camel_case_types)] 1171 1007 struct GetAlbumsSvc<T: LibraryService>(pub Arc<T>); 1172 - impl< 1173 - T: LibraryService, 1174 - > tonic::server::UnaryService<super::GetAlbumsRequest> 1175 - for GetAlbumsSvc<T> { 1008 + impl<T: LibraryService> tonic::server::UnaryService<super::GetAlbumsRequest> for GetAlbumsSvc<T> { 1176 1009 type Response = super::GetAlbumsResponse; 1177 - type Future = BoxFuture< 1178 - tonic::Response<Self::Response>, 1179 - tonic::Status, 1180 - >; 1010 + type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 1181 1011 fn call( 1182 1012 &mut self, 1183 1013 request: tonic::Request<super::GetAlbumsRequest>, ··· 1214 1044 "/rockbox.v1alpha1.LibraryService/GetArtists" => { 1215 1045 #[allow(non_camel_case_types)] 1216 1046 struct GetArtistsSvc<T: LibraryService>(pub Arc<T>); 1217 - impl< 1218 - T: LibraryService, 1219 - > tonic::server::UnaryService<super::GetArtistsRequest> 1220 - for GetArtistsSvc<T> { 1047 + impl<T: LibraryService> tonic::server::UnaryService<super::GetArtistsRequest> for GetArtistsSvc<T> { 1221 1048 type Response = super::GetArtistsResponse; 1222 - type Future = BoxFuture< 1223 - tonic::Response<Self::Response>, 1224 - tonic::Status, 1225 - >; 1049 + type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 1226 1050 fn call( 1227 1051 &mut self, 1228 1052 request: tonic::Request<super::GetArtistsRequest>, ··· 1259 1083 "/rockbox.v1alpha1.LibraryService/GetTracks" => { 1260 1084 #[allow(non_camel_case_types)] 1261 1085 struct GetTracksSvc<T: LibraryService>(pub Arc<T>); 1262 - impl< 1263 - T: LibraryService, 1264 - > tonic::server::UnaryService<super::GetTracksRequest> 1265 - for GetTracksSvc<T> { 1086 + impl<T: LibraryService> tonic::server::UnaryService<super::GetTracksRequest> for GetTracksSvc<T> { 1266 1087 type Response = super::GetTracksResponse; 1267 - type Future = BoxFuture< 1268 - tonic::Response<Self::Response>, 1269 - tonic::Status, 1270 - >; 1088 + type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 1271 1089 fn call( 1272 1090 &mut self, 1273 1091 request: tonic::Request<super::GetTracksRequest>, ··· 1304 1122 "/rockbox.v1alpha1.LibraryService/GetAlbum" => { 1305 1123 #[allow(non_camel_case_types)] 1306 1124 struct GetAlbumSvc<T: LibraryService>(pub Arc<T>); 1307 - impl< 1308 - T: LibraryService, 1309 - > tonic::server::UnaryService<super::GetAlbumRequest> 1310 - for GetAlbumSvc<T> { 1125 + impl<T: LibraryService> tonic::server::UnaryService<super::GetAlbumRequest> for GetAlbumSvc<T> { 1311 1126 type Response = super::GetAlbumResponse; 1312 - type Future = BoxFuture< 1313 - tonic::Response<Self::Response>, 1314 - tonic::Status, 1315 - >; 1127 + type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 1316 1128 fn call( 1317 1129 &mut self, 1318 1130 request: tonic::Request<super::GetAlbumRequest>, ··· 1349 1161 "/rockbox.v1alpha1.LibraryService/GetArtist" => { 1350 1162 #[allow(non_camel_case_types)] 1351 1163 struct GetArtistSvc<T: LibraryService>(pub Arc<T>); 1352 - impl< 1353 - T: LibraryService, 1354 - > tonic::server::UnaryService<super::GetArtistRequest> 1355 - for GetArtistSvc<T> { 1164 + impl<T: LibraryService> tonic::server::UnaryService<super::GetArtistRequest> for GetArtistSvc<T> { 1356 1165 type Response = super::GetArtistResponse; 1357 - type Future = BoxFuture< 1358 - tonic::Response<Self::Response>, 1359 - tonic::Status, 1360 - >; 1166 + type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 1361 1167 fn call( 1362 1168 &mut self, 1363 1169 request: tonic::Request<super::GetArtistRequest>, ··· 1394 1200 "/rockbox.v1alpha1.LibraryService/GetTrack" => { 1395 1201 #[allow(non_camel_case_types)] 1396 1202 struct GetTrackSvc<T: LibraryService>(pub Arc<T>); 1397 - impl< 1398 - T: LibraryService, 1399 - > tonic::server::UnaryService<super::GetTrackRequest> 1400 - for GetTrackSvc<T> { 1203 + impl<T: LibraryService> tonic::server::UnaryService<super::GetTrackRequest> for GetTrackSvc<T> { 1401 1204 type Response = super::GetTrackResponse; 1402 - type Future = BoxFuture< 1403 - tonic::Response<Self::Response>, 1404 - tonic::Status, 1405 - >; 1205 + type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 1406 1206 fn call( 1407 1207 &mut self, 1408 1208 request: tonic::Request<super::GetTrackRequest>, ··· 1439 1239 "/rockbox.v1alpha1.LibraryService/LikeTrack" => { 1440 1240 #[allow(non_camel_case_types)] 1441 1241 struct LikeTrackSvc<T: LibraryService>(pub Arc<T>); 1442 - impl< 1443 - T: LibraryService, 1444 - > tonic::server::UnaryService<super::LikeTrackRequest> 1445 - for LikeTrackSvc<T> { 1242 + impl<T: LibraryService> tonic::server::UnaryService<super::LikeTrackRequest> for LikeTrackSvc<T> { 1446 1243 type Response = super::LikeTrackResponse; 1447 - type Future = BoxFuture< 1448 - tonic::Response<Self::Response>, 1449 - tonic::Status, 1450 - >; 1244 + type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 1451 1245 fn call( 1452 1246 &mut self, 1453 1247 request: tonic::Request<super::LikeTrackRequest>, ··· 1484 1278 "/rockbox.v1alpha1.LibraryService/UnlikeTrack" => { 1485 1279 #[allow(non_camel_case_types)] 1486 1280 struct UnlikeTrackSvc<T: LibraryService>(pub Arc<T>); 1487 - impl< 1488 - T: LibraryService, 1489 - > tonic::server::UnaryService<super::UnlikeTrackRequest> 1490 - for UnlikeTrackSvc<T> { 1281 + impl<T: LibraryService> tonic::server::UnaryService<super::UnlikeTrackRequest> 1282 + for UnlikeTrackSvc<T> 1283 + { 1491 1284 type Response = super::UnlikeTrackResponse; 1492 - type Future = BoxFuture< 1493 - tonic::Response<Self::Response>, 1494 - tonic::Status, 1495 - >; 1285 + type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 1496 1286 fn call( 1497 1287 &mut self, 1498 1288 request: tonic::Request<super::UnlikeTrackRequest>, ··· 1529 1319 "/rockbox.v1alpha1.LibraryService/LikeAlbum" => { 1530 1320 #[allow(non_camel_case_types)] 1531 1321 struct LikeAlbumSvc<T: LibraryService>(pub Arc<T>); 1532 - impl< 1533 - T: LibraryService, 1534 - > tonic::server::UnaryService<super::LikeAlbumRequest> 1535 - for LikeAlbumSvc<T> { 1322 + impl<T: LibraryService> tonic::server::UnaryService<super::LikeAlbumRequest> for LikeAlbumSvc<T> { 1536 1323 type Response = super::LikeAlbumResponse; 1537 - type Future = BoxFuture< 1538 - tonic::Response<Self::Response>, 1539 - tonic::Status, 1540 - >; 1324 + type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 1541 1325 fn call( 1542 1326 &mut self, 1543 1327 request: tonic::Request<super::LikeAlbumRequest>, ··· 1574 1358 "/rockbox.v1alpha1.LibraryService/UnlikeAlbum" => { 1575 1359 #[allow(non_camel_case_types)] 1576 1360 struct UnlikeAlbumSvc<T: LibraryService>(pub Arc<T>); 1577 - impl< 1578 - T: LibraryService, 1579 - > tonic::server::UnaryService<super::UnlikeAlbumRequest> 1580 - for UnlikeAlbumSvc<T> { 1361 + impl<T: LibraryService> tonic::server::UnaryService<super::UnlikeAlbumRequest> 1362 + for UnlikeAlbumSvc<T> 1363 + { 1581 1364 type Response = super::UnlikeAlbumResponse; 1582 - type Future = BoxFuture< 1583 - tonic::Response<Self::Response>, 1584 - tonic::Status, 1585 - >; 1365 + type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 1586 1366 fn call( 1587 1367 &mut self, 1588 1368 request: tonic::Request<super::UnlikeAlbumRequest>, ··· 1619 1399 "/rockbox.v1alpha1.LibraryService/GetLikedTracks" => { 1620 1400 #[allow(non_camel_case_types)] 1621 1401 struct GetLikedTracksSvc<T: LibraryService>(pub Arc<T>); 1622 - impl< 1623 - T: LibraryService, 1624 - > tonic::server::UnaryService<super::GetLikedTracksRequest> 1625 - for GetLikedTracksSvc<T> { 1402 + impl<T: LibraryService> 1403 + tonic::server::UnaryService<super::GetLikedTracksRequest> 1404 + for GetLikedTracksSvc<T> 1405 + { 1626 1406 type Response = super::GetLikedTracksResponse; 1627 - type Future = BoxFuture< 1628 - tonic::Response<Self::Response>, 1629 - tonic::Status, 1630 - >; 1407 + type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 1631 1408 fn call( 1632 1409 &mut self, 1633 1410 request: tonic::Request<super::GetLikedTracksRequest>, 1634 1411 ) -> Self::Future { 1635 1412 let inner = Arc::clone(&self.0); 1636 1413 let fut = async move { 1637 - <T as LibraryService>::get_liked_tracks(&inner, request) 1638 - .await 1414 + <T as LibraryService>::get_liked_tracks(&inner, request).await 1639 1415 }; 1640 1416 Box::pin(fut) 1641 1417 } ··· 1665 1441 "/rockbox.v1alpha1.LibraryService/GetLikedAlbums" => { 1666 1442 #[allow(non_camel_case_types)] 1667 1443 struct GetLikedAlbumsSvc<T: LibraryService>(pub Arc<T>); 1668 - impl< 1669 - T: LibraryService, 1670 - > tonic::server::UnaryService<super::GetLikedAlbumsRequest> 1671 - for GetLikedAlbumsSvc<T> { 1444 + impl<T: LibraryService> 1445 + tonic::server::UnaryService<super::GetLikedAlbumsRequest> 1446 + for GetLikedAlbumsSvc<T> 1447 + { 1672 1448 type Response = super::GetLikedAlbumsResponse; 1673 - type Future = BoxFuture< 1674 - tonic::Response<Self::Response>, 1675 - tonic::Status, 1676 - >; 1449 + type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 1677 1450 fn call( 1678 1451 &mut self, 1679 1452 request: tonic::Request<super::GetLikedAlbumsRequest>, 1680 1453 ) -> Self::Future { 1681 1454 let inner = Arc::clone(&self.0); 1682 1455 let fut = async move { 1683 - <T as LibraryService>::get_liked_albums(&inner, request) 1684 - .await 1456 + <T as LibraryService>::get_liked_albums(&inner, request).await 1685 1457 }; 1686 1458 Box::pin(fut) 1687 1459 } ··· 1711 1483 "/rockbox.v1alpha1.LibraryService/ScanLibrary" => { 1712 1484 #[allow(non_camel_case_types)] 1713 1485 struct ScanLibrarySvc<T: LibraryService>(pub Arc<T>); 1714 - impl< 1715 - T: LibraryService, 1716 - > tonic::server::UnaryService<super::ScanLibraryRequest> 1717 - for ScanLibrarySvc<T> { 1486 + impl<T: LibraryService> tonic::server::UnaryService<super::ScanLibraryRequest> 1487 + for ScanLibrarySvc<T> 1488 + { 1718 1489 type Response = super::ScanLibraryResponse; 1719 - type Future = BoxFuture< 1720 - tonic::Response<Self::Response>, 1721 - tonic::Status, 1722 - >; 1490 + type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 1723 1491 fn call( 1724 1492 &mut self, 1725 1493 request: tonic::Request<super::ScanLibraryRequest>, ··· 1756 1524 "/rockbox.v1alpha1.LibraryService/Search" => { 1757 1525 #[allow(non_camel_case_types)] 1758 1526 struct SearchSvc<T: LibraryService>(pub Arc<T>); 1759 - impl< 1760 - T: LibraryService, 1761 - > tonic::server::UnaryService<super::SearchRequest> 1762 - for SearchSvc<T> { 1527 + impl<T: LibraryService> tonic::server::UnaryService<super::SearchRequest> for SearchSvc<T> { 1763 1528 type Response = super::SearchResponse; 1764 - type Future = BoxFuture< 1765 - tonic::Response<Self::Response>, 1766 - tonic::Status, 1767 - >; 1529 + type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 1768 1530 fn call( 1769 1531 &mut self, 1770 1532 request: tonic::Request<super::SearchRequest>, 1771 1533 ) -> Self::Future { 1772 1534 let inner = Arc::clone(&self.0); 1773 - let fut = async move { 1774 - <T as LibraryService>::search(&inner, request).await 1775 - }; 1535 + let fut = 1536 + async move { <T as LibraryService>::search(&inner, request).await }; 1776 1537 Box::pin(fut) 1777 1538 } 1778 1539 } ··· 1798 1559 }; 1799 1560 Box::pin(fut) 1800 1561 } 1801 - _ => { 1802 - Box::pin(async move { 1803 - let mut response = http::Response::new(empty_body()); 1804 - let headers = response.headers_mut(); 1805 - headers 1806 - .insert( 1807 - tonic::Status::GRPC_STATUS, 1808 - (tonic::Code::Unimplemented as i32).into(), 1809 - ); 1810 - headers 1811 - .insert( 1812 - http::header::CONTENT_TYPE, 1813 - tonic::metadata::GRPC_CONTENT_TYPE, 1814 - ); 1815 - Ok(response) 1816 - }) 1817 - } 1562 + _ => Box::pin(async move { 1563 + let mut response = http::Response::new(empty_body()); 1564 + let headers = response.headers_mut(); 1565 + headers.insert( 1566 + tonic::Status::GRPC_STATUS, 1567 + (tonic::Code::Unimplemented as i32).into(), 1568 + ); 1569 + headers.insert( 1570 + http::header::CONTENT_TYPE, 1571 + tonic::metadata::GRPC_CONTENT_TYPE, 1572 + ); 1573 + Ok(response) 1574 + }), 1818 1575 } 1819 1576 } 1820 1577 } ··· 1843 1600 dead_code, 1844 1601 missing_docs, 1845 1602 clippy::wildcard_imports, 1846 - clippy::let_unit_value, 1603 + clippy::let_unit_value 1847 1604 )] 1848 - use tonic::codegen::*; 1849 1605 use tonic::codegen::http::Uri; 1606 + use tonic::codegen::*; 1850 1607 #[derive(Debug, Clone)] 1851 1608 pub struct MetadataServiceClient<T> { 1852 1609 inner: tonic::client::Grpc<T>, ··· 1890 1647 <T as tonic::client::GrpcService<tonic::body::BoxBody>>::ResponseBody, 1891 1648 >, 1892 1649 >, 1893 - <T as tonic::codegen::Service< 1894 - http::Request<tonic::body::BoxBody>, 1895 - >>::Error: Into<StdError> + std::marker::Send + std::marker::Sync, 1650 + <T as tonic::codegen::Service<http::Request<tonic::body::BoxBody>>>::Error: 1651 + Into<StdError> + std::marker::Send + std::marker::Sync, 1896 1652 { 1897 1653 MetadataServiceClient::new(InterceptedService::new(inner, interceptor)) 1898 1654 } ··· 1936 1692 dead_code, 1937 1693 missing_docs, 1938 1694 clippy::wildcard_imports, 1939 - clippy::let_unit_value, 1695 + clippy::let_unit_value 1940 1696 )] 1941 1697 use tonic::codegen::*; 1942 1698 /// Generated trait containing gRPC methods that should be implemented for use with MetadataServiceServer. ··· 1963 1719 max_encoding_message_size: None, 1964 1720 } 1965 1721 } 1966 - pub fn with_interceptor<F>( 1967 - inner: T, 1968 - interceptor: F, 1969 - ) -> InterceptedService<Self, F> 1722 + pub fn with_interceptor<F>(inner: T, interceptor: F) -> InterceptedService<Self, F> 1970 1723 where 1971 1724 F: tonic::service::Interceptor, 1972 1725 { ··· 2018 1771 } 2019 1772 fn call(&mut self, req: http::Request<B>) -> Self::Future { 2020 1773 match req.uri().path() { 2021 - _ => { 2022 - Box::pin(async move { 2023 - let mut response = http::Response::new(empty_body()); 2024 - let headers = response.headers_mut(); 2025 - headers 2026 - .insert( 2027 - tonic::Status::GRPC_STATUS, 2028 - (tonic::Code::Unimplemented as i32).into(), 2029 - ); 2030 - headers 2031 - .insert( 2032 - http::header::CONTENT_TYPE, 2033 - tonic::metadata::GRPC_CONTENT_TYPE, 2034 - ); 2035 - Ok(response) 2036 - }) 2037 - } 1774 + _ => Box::pin(async move { 1775 + let mut response = http::Response::new(empty_body()); 1776 + let headers = response.headers_mut(); 1777 + headers.insert( 1778 + tonic::Status::GRPC_STATUS, 1779 + (tonic::Code::Unimplemented as i32).into(), 1780 + ); 1781 + headers.insert( 1782 + http::header::CONTENT_TYPE, 1783 + tonic::metadata::GRPC_CONTENT_TYPE, 1784 + ); 1785 + Ok(response) 1786 + }), 2038 1787 } 2039 1788 } 2040 1789 } ··· 2318 2067 dead_code, 2319 2068 missing_docs, 2320 2069 clippy::wildcard_imports, 2321 - clippy::let_unit_value, 2070 + clippy::let_unit_value 2322 2071 )] 2323 - use tonic::codegen::*; 2324 2072 use tonic::codegen::http::Uri; 2073 + use tonic::codegen::*; 2325 2074 #[derive(Debug, Clone)] 2326 2075 pub struct PlaybackServiceClient<T> { 2327 2076 inner: tonic::client::Grpc<T>, ··· 2365 2114 <T as tonic::client::GrpcService<tonic::body::BoxBody>>::ResponseBody, 2366 2115 >, 2367 2116 >, 2368 - <T as tonic::codegen::Service< 2369 - http::Request<tonic::body::BoxBody>, 2370 - >>::Error: Into<StdError> + std::marker::Send + std::marker::Sync, 2117 + <T as tonic::codegen::Service<http::Request<tonic::body::BoxBody>>>::Error: 2118 + Into<StdError> + std::marker::Send + std::marker::Sync, 2371 2119 { 2372 2120 PlaybackServiceClient::new(InterceptedService::new(inner, interceptor)) 2373 2121 } ··· 2406 2154 &mut self, 2407 2155 request: impl tonic::IntoRequest<super::PlayRequest>, 2408 2156 ) -> std::result::Result<tonic::Response<super::PlayResponse>, tonic::Status> { 2409 - self.inner 2410 - .ready() 2411 - .await 2412 - .map_err(|e| { 2413 - tonic::Status::unknown( 2414 - format!("Service was not ready: {}", e.into()), 2415 - ) 2416 - })?; 2157 + self.inner.ready().await.map_err(|e| { 2158 + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 2159 + })?; 2417 2160 let codec = tonic::codec::ProstCodec::default(); 2418 - let path = http::uri::PathAndQuery::from_static( 2419 - "/rockbox.v1alpha1.PlaybackService/Play", 2420 - ); 2161 + let path = 2162 + http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.PlaybackService/Play"); 2421 2163 let mut req = request.into_request(); 2422 2164 req.extensions_mut() 2423 2165 .insert(GrpcMethod::new("rockbox.v1alpha1.PlaybackService", "Play")); ··· 2427 2169 &mut self, 2428 2170 request: impl tonic::IntoRequest<super::PauseRequest>, 2429 2171 ) -> std::result::Result<tonic::Response<super::PauseResponse>, tonic::Status> { 2430 - self.inner 2431 - .ready() 2432 - .await 2433 - .map_err(|e| { 2434 - tonic::Status::unknown( 2435 - format!("Service was not ready: {}", e.into()), 2436 - ) 2437 - })?; 2172 + self.inner.ready().await.map_err(|e| { 2173 + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 2174 + })?; 2438 2175 let codec = tonic::codec::ProstCodec::default(); 2439 - let path = http::uri::PathAndQuery::from_static( 2440 - "/rockbox.v1alpha1.PlaybackService/Pause", 2441 - ); 2176 + let path = 2177 + http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.PlaybackService/Pause"); 2442 2178 let mut req = request.into_request(); 2443 2179 req.extensions_mut() 2444 2180 .insert(GrpcMethod::new("rockbox.v1alpha1.PlaybackService", "Pause")); ··· 2447 2183 pub async fn play_or_pause( 2448 2184 &mut self, 2449 2185 request: impl tonic::IntoRequest<super::PlayOrPauseRequest>, 2450 - ) -> std::result::Result< 2451 - tonic::Response<super::PlayOrPauseResponse>, 2452 - tonic::Status, 2453 - > { 2454 - self.inner 2455 - .ready() 2456 - .await 2457 - .map_err(|e| { 2458 - tonic::Status::unknown( 2459 - format!("Service was not ready: {}", e.into()), 2460 - ) 2461 - })?; 2186 + ) -> std::result::Result<tonic::Response<super::PlayOrPauseResponse>, tonic::Status> 2187 + { 2188 + self.inner.ready().await.map_err(|e| { 2189 + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 2190 + })?; 2462 2191 let codec = tonic::codec::ProstCodec::default(); 2463 2192 let path = http::uri::PathAndQuery::from_static( 2464 2193 "/rockbox.v1alpha1.PlaybackService/PlayOrPause", 2465 2194 ); 2466 2195 let mut req = request.into_request(); 2467 - req.extensions_mut() 2468 - .insert( 2469 - GrpcMethod::new("rockbox.v1alpha1.PlaybackService", "PlayOrPause"), 2470 - ); 2196 + req.extensions_mut().insert(GrpcMethod::new( 2197 + "rockbox.v1alpha1.PlaybackService", 2198 + "PlayOrPause", 2199 + )); 2471 2200 self.inner.unary(req, path, codec).await 2472 2201 } 2473 2202 pub async fn resume( 2474 2203 &mut self, 2475 2204 request: impl tonic::IntoRequest<super::ResumeRequest>, 2476 2205 ) -> std::result::Result<tonic::Response<super::ResumeResponse>, tonic::Status> { 2477 - self.inner 2478 - .ready() 2479 - .await 2480 - .map_err(|e| { 2481 - tonic::Status::unknown( 2482 - format!("Service was not ready: {}", e.into()), 2483 - ) 2484 - })?; 2206 + self.inner.ready().await.map_err(|e| { 2207 + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 2208 + })?; 2485 2209 let codec = tonic::codec::ProstCodec::default(); 2486 - let path = http::uri::PathAndQuery::from_static( 2487 - "/rockbox.v1alpha1.PlaybackService/Resume", 2488 - ); 2210 + let path = 2211 + http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.PlaybackService/Resume"); 2489 2212 let mut req = request.into_request(); 2490 - req.extensions_mut() 2491 - .insert(GrpcMethod::new("rockbox.v1alpha1.PlaybackService", "Resume")); 2213 + req.extensions_mut().insert(GrpcMethod::new( 2214 + "rockbox.v1alpha1.PlaybackService", 2215 + "Resume", 2216 + )); 2492 2217 self.inner.unary(req, path, codec).await 2493 2218 } 2494 2219 pub async fn next( 2495 2220 &mut self, 2496 2221 request: impl tonic::IntoRequest<super::NextRequest>, 2497 2222 ) -> std::result::Result<tonic::Response<super::NextResponse>, tonic::Status> { 2498 - self.inner 2499 - .ready() 2500 - .await 2501 - .map_err(|e| { 2502 - tonic::Status::unknown( 2503 - format!("Service was not ready: {}", e.into()), 2504 - ) 2505 - })?; 2223 + self.inner.ready().await.map_err(|e| { 2224 + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 2225 + })?; 2506 2226 let codec = tonic::codec::ProstCodec::default(); 2507 - let path = http::uri::PathAndQuery::from_static( 2508 - "/rockbox.v1alpha1.PlaybackService/Next", 2509 - ); 2227 + let path = 2228 + http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.PlaybackService/Next"); 2510 2229 let mut req = request.into_request(); 2511 2230 req.extensions_mut() 2512 2231 .insert(GrpcMethod::new("rockbox.v1alpha1.PlaybackService", "Next")); ··· 2515 2234 pub async fn previous( 2516 2235 &mut self, 2517 2236 request: impl tonic::IntoRequest<super::PreviousRequest>, 2518 - ) -> std::result::Result< 2519 - tonic::Response<super::PreviousResponse>, 2520 - tonic::Status, 2521 - > { 2522 - self.inner 2523 - .ready() 2524 - .await 2525 - .map_err(|e| { 2526 - tonic::Status::unknown( 2527 - format!("Service was not ready: {}", e.into()), 2528 - ) 2529 - })?; 2237 + ) -> std::result::Result<tonic::Response<super::PreviousResponse>, tonic::Status> { 2238 + self.inner.ready().await.map_err(|e| { 2239 + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 2240 + })?; 2530 2241 let codec = tonic::codec::ProstCodec::default(); 2531 - let path = http::uri::PathAndQuery::from_static( 2532 - "/rockbox.v1alpha1.PlaybackService/Previous", 2533 - ); 2242 + let path = 2243 + http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.PlaybackService/Previous"); 2534 2244 let mut req = request.into_request(); 2535 - req.extensions_mut() 2536 - .insert(GrpcMethod::new("rockbox.v1alpha1.PlaybackService", "Previous")); 2245 + req.extensions_mut().insert(GrpcMethod::new( 2246 + "rockbox.v1alpha1.PlaybackService", 2247 + "Previous", 2248 + )); 2537 2249 self.inner.unary(req, path, codec).await 2538 2250 } 2539 2251 pub async fn fast_forward_rewind( 2540 2252 &mut self, 2541 2253 request: impl tonic::IntoRequest<super::FastForwardRewindRequest>, 2542 - ) -> std::result::Result< 2543 - tonic::Response<super::FastForwardRewindResponse>, 2544 - tonic::Status, 2545 - > { 2546 - self.inner 2547 - .ready() 2548 - .await 2549 - .map_err(|e| { 2550 - tonic::Status::unknown( 2551 - format!("Service was not ready: {}", e.into()), 2552 - ) 2553 - })?; 2254 + ) -> std::result::Result<tonic::Response<super::FastForwardRewindResponse>, tonic::Status> 2255 + { 2256 + self.inner.ready().await.map_err(|e| { 2257 + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 2258 + })?; 2554 2259 let codec = tonic::codec::ProstCodec::default(); 2555 2260 let path = http::uri::PathAndQuery::from_static( 2556 2261 "/rockbox.v1alpha1.PlaybackService/FastForwardRewind", 2557 2262 ); 2558 2263 let mut req = request.into_request(); 2559 - req.extensions_mut() 2560 - .insert( 2561 - GrpcMethod::new( 2562 - "rockbox.v1alpha1.PlaybackService", 2563 - "FastForwardRewind", 2564 - ), 2565 - ); 2264 + req.extensions_mut().insert(GrpcMethod::new( 2265 + "rockbox.v1alpha1.PlaybackService", 2266 + "FastForwardRewind", 2267 + )); 2566 2268 self.inner.unary(req, path, codec).await 2567 2269 } 2568 2270 pub async fn status( 2569 2271 &mut self, 2570 2272 request: impl tonic::IntoRequest<super::StatusRequest>, 2571 2273 ) -> std::result::Result<tonic::Response<super::StatusResponse>, tonic::Status> { 2572 - self.inner 2573 - .ready() 2574 - .await 2575 - .map_err(|e| { 2576 - tonic::Status::unknown( 2577 - format!("Service was not ready: {}", e.into()), 2578 - ) 2579 - })?; 2274 + self.inner.ready().await.map_err(|e| { 2275 + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 2276 + })?; 2580 2277 let codec = tonic::codec::ProstCodec::default(); 2581 - let path = http::uri::PathAndQuery::from_static( 2582 - "/rockbox.v1alpha1.PlaybackService/Status", 2583 - ); 2278 + let path = 2279 + http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.PlaybackService/Status"); 2584 2280 let mut req = request.into_request(); 2585 - req.extensions_mut() 2586 - .insert(GrpcMethod::new("rockbox.v1alpha1.PlaybackService", "Status")); 2281 + req.extensions_mut().insert(GrpcMethod::new( 2282 + "rockbox.v1alpha1.PlaybackService", 2283 + "Status", 2284 + )); 2587 2285 self.inner.unary(req, path, codec).await 2588 2286 } 2589 2287 pub async fn current_track( 2590 2288 &mut self, 2591 2289 request: impl tonic::IntoRequest<super::CurrentTrackRequest>, 2592 - ) -> std::result::Result< 2593 - tonic::Response<super::CurrentTrackResponse>, 2594 - tonic::Status, 2595 - > { 2596 - self.inner 2597 - .ready() 2598 - .await 2599 - .map_err(|e| { 2600 - tonic::Status::unknown( 2601 - format!("Service was not ready: {}", e.into()), 2602 - ) 2603 - })?; 2290 + ) -> std::result::Result<tonic::Response<super::CurrentTrackResponse>, tonic::Status> 2291 + { 2292 + self.inner.ready().await.map_err(|e| { 2293 + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 2294 + })?; 2604 2295 let codec = tonic::codec::ProstCodec::default(); 2605 2296 let path = http::uri::PathAndQuery::from_static( 2606 2297 "/rockbox.v1alpha1.PlaybackService/CurrentTrack", 2607 2298 ); 2608 2299 let mut req = request.into_request(); 2609 - req.extensions_mut() 2610 - .insert( 2611 - GrpcMethod::new("rockbox.v1alpha1.PlaybackService", "CurrentTrack"), 2612 - ); 2300 + req.extensions_mut().insert(GrpcMethod::new( 2301 + "rockbox.v1alpha1.PlaybackService", 2302 + "CurrentTrack", 2303 + )); 2613 2304 self.inner.unary(req, path, codec).await 2614 2305 } 2615 2306 pub async fn next_track( 2616 2307 &mut self, 2617 2308 request: impl tonic::IntoRequest<super::NextTrackRequest>, 2618 - ) -> std::result::Result< 2619 - tonic::Response<super::NextTrackResponse>, 2620 - tonic::Status, 2621 - > { 2622 - self.inner 2623 - .ready() 2624 - .await 2625 - .map_err(|e| { 2626 - tonic::Status::unknown( 2627 - format!("Service was not ready: {}", e.into()), 2628 - ) 2629 - })?; 2309 + ) -> std::result::Result<tonic::Response<super::NextTrackResponse>, tonic::Status> { 2310 + self.inner.ready().await.map_err(|e| { 2311 + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 2312 + })?; 2630 2313 let codec = tonic::codec::ProstCodec::default(); 2631 - let path = http::uri::PathAndQuery::from_static( 2632 - "/rockbox.v1alpha1.PlaybackService/NextTrack", 2633 - ); 2314 + let path = 2315 + http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.PlaybackService/NextTrack"); 2634 2316 let mut req = request.into_request(); 2635 - req.extensions_mut() 2636 - .insert( 2637 - GrpcMethod::new("rockbox.v1alpha1.PlaybackService", "NextTrack"), 2638 - ); 2317 + req.extensions_mut().insert(GrpcMethod::new( 2318 + "rockbox.v1alpha1.PlaybackService", 2319 + "NextTrack", 2320 + )); 2639 2321 self.inner.unary(req, path, codec).await 2640 2322 } 2641 2323 pub async fn flush_and_reload_tracks( 2642 2324 &mut self, 2643 2325 request: impl tonic::IntoRequest<super::FlushAndReloadTracksRequest>, 2644 - ) -> std::result::Result< 2645 - tonic::Response<super::FlushAndReloadTracksResponse>, 2646 - tonic::Status, 2647 - > { 2648 - self.inner 2649 - .ready() 2650 - .await 2651 - .map_err(|e| { 2652 - tonic::Status::unknown( 2653 - format!("Service was not ready: {}", e.into()), 2654 - ) 2655 - })?; 2326 + ) -> std::result::Result<tonic::Response<super::FlushAndReloadTracksResponse>, tonic::Status> 2327 + { 2328 + self.inner.ready().await.map_err(|e| { 2329 + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 2330 + })?; 2656 2331 let codec = tonic::codec::ProstCodec::default(); 2657 2332 let path = http::uri::PathAndQuery::from_static( 2658 2333 "/rockbox.v1alpha1.PlaybackService/FlushAndReloadTracks", 2659 2334 ); 2660 2335 let mut req = request.into_request(); 2661 - req.extensions_mut() 2662 - .insert( 2663 - GrpcMethod::new( 2664 - "rockbox.v1alpha1.PlaybackService", 2665 - "FlushAndReloadTracks", 2666 - ), 2667 - ); 2336 + req.extensions_mut().insert(GrpcMethod::new( 2337 + "rockbox.v1alpha1.PlaybackService", 2338 + "FlushAndReloadTracks", 2339 + )); 2668 2340 self.inner.unary(req, path, codec).await 2669 2341 } 2670 2342 pub async fn get_file_position( 2671 2343 &mut self, 2672 2344 request: impl tonic::IntoRequest<super::GetFilePositionRequest>, 2673 - ) -> std::result::Result< 2674 - tonic::Response<super::GetFilePositionResponse>, 2675 - tonic::Status, 2676 - > { 2677 - self.inner 2678 - .ready() 2679 - .await 2680 - .map_err(|e| { 2681 - tonic::Status::unknown( 2682 - format!("Service was not ready: {}", e.into()), 2683 - ) 2684 - })?; 2345 + ) -> std::result::Result<tonic::Response<super::GetFilePositionResponse>, tonic::Status> 2346 + { 2347 + self.inner.ready().await.map_err(|e| { 2348 + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 2349 + })?; 2685 2350 let codec = tonic::codec::ProstCodec::default(); 2686 2351 let path = http::uri::PathAndQuery::from_static( 2687 2352 "/rockbox.v1alpha1.PlaybackService/GetFilePosition", 2688 2353 ); 2689 2354 let mut req = request.into_request(); 2690 - req.extensions_mut() 2691 - .insert( 2692 - GrpcMethod::new( 2693 - "rockbox.v1alpha1.PlaybackService", 2694 - "GetFilePosition", 2695 - ), 2696 - ); 2355 + req.extensions_mut().insert(GrpcMethod::new( 2356 + "rockbox.v1alpha1.PlaybackService", 2357 + "GetFilePosition", 2358 + )); 2697 2359 self.inner.unary(req, path, codec).await 2698 2360 } 2699 2361 pub async fn hard_stop( 2700 2362 &mut self, 2701 2363 request: impl tonic::IntoRequest<super::HardStopRequest>, 2702 - ) -> std::result::Result< 2703 - tonic::Response<super::HardStopResponse>, 2704 - tonic::Status, 2705 - > { 2706 - self.inner 2707 - .ready() 2708 - .await 2709 - .map_err(|e| { 2710 - tonic::Status::unknown( 2711 - format!("Service was not ready: {}", e.into()), 2712 - ) 2713 - })?; 2364 + ) -> std::result::Result<tonic::Response<super::HardStopResponse>, tonic::Status> { 2365 + self.inner.ready().await.map_err(|e| { 2366 + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 2367 + })?; 2714 2368 let codec = tonic::codec::ProstCodec::default(); 2715 - let path = http::uri::PathAndQuery::from_static( 2716 - "/rockbox.v1alpha1.PlaybackService/HardStop", 2717 - ); 2369 + let path = 2370 + http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.PlaybackService/HardStop"); 2718 2371 let mut req = request.into_request(); 2719 - req.extensions_mut() 2720 - .insert(GrpcMethod::new("rockbox.v1alpha1.PlaybackService", "HardStop")); 2372 + req.extensions_mut().insert(GrpcMethod::new( 2373 + "rockbox.v1alpha1.PlaybackService", 2374 + "HardStop", 2375 + )); 2721 2376 self.inner.unary(req, path, codec).await 2722 2377 } 2723 2378 pub async fn play_album( 2724 2379 &mut self, 2725 2380 request: impl tonic::IntoRequest<super::PlayAlbumRequest>, 2726 - ) -> std::result::Result< 2727 - tonic::Response<super::PlayAlbumResponse>, 2728 - tonic::Status, 2729 - > { 2730 - self.inner 2731 - .ready() 2732 - .await 2733 - .map_err(|e| { 2734 - tonic::Status::unknown( 2735 - format!("Service was not ready: {}", e.into()), 2736 - ) 2737 - })?; 2381 + ) -> std::result::Result<tonic::Response<super::PlayAlbumResponse>, tonic::Status> { 2382 + self.inner.ready().await.map_err(|e| { 2383 + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 2384 + })?; 2738 2385 let codec = tonic::codec::ProstCodec::default(); 2739 - let path = http::uri::PathAndQuery::from_static( 2740 - "/rockbox.v1alpha1.PlaybackService/PlayAlbum", 2741 - ); 2386 + let path = 2387 + http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.PlaybackService/PlayAlbum"); 2742 2388 let mut req = request.into_request(); 2743 - req.extensions_mut() 2744 - .insert( 2745 - GrpcMethod::new("rockbox.v1alpha1.PlaybackService", "PlayAlbum"), 2746 - ); 2389 + req.extensions_mut().insert(GrpcMethod::new( 2390 + "rockbox.v1alpha1.PlaybackService", 2391 + "PlayAlbum", 2392 + )); 2747 2393 self.inner.unary(req, path, codec).await 2748 2394 } 2749 2395 pub async fn play_artist_tracks( 2750 2396 &mut self, 2751 2397 request: impl tonic::IntoRequest<super::PlayArtistTracksRequest>, 2752 - ) -> std::result::Result< 2753 - tonic::Response<super::PlayArtistTracksResponse>, 2754 - tonic::Status, 2755 - > { 2756 - self.inner 2757 - .ready() 2758 - .await 2759 - .map_err(|e| { 2760 - tonic::Status::unknown( 2761 - format!("Service was not ready: {}", e.into()), 2762 - ) 2763 - })?; 2398 + ) -> std::result::Result<tonic::Response<super::PlayArtistTracksResponse>, tonic::Status> 2399 + { 2400 + self.inner.ready().await.map_err(|e| { 2401 + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 2402 + })?; 2764 2403 let codec = tonic::codec::ProstCodec::default(); 2765 2404 let path = http::uri::PathAndQuery::from_static( 2766 2405 "/rockbox.v1alpha1.PlaybackService/PlayArtistTracks", 2767 2406 ); 2768 2407 let mut req = request.into_request(); 2769 - req.extensions_mut() 2770 - .insert( 2771 - GrpcMethod::new( 2772 - "rockbox.v1alpha1.PlaybackService", 2773 - "PlayArtistTracks", 2774 - ), 2775 - ); 2408 + req.extensions_mut().insert(GrpcMethod::new( 2409 + "rockbox.v1alpha1.PlaybackService", 2410 + "PlayArtistTracks", 2411 + )); 2776 2412 self.inner.unary(req, path, codec).await 2777 2413 } 2778 2414 pub async fn play_playlist( 2779 2415 &mut self, 2780 2416 request: impl tonic::IntoRequest<super::PlayPlaylistRequest>, 2781 - ) -> std::result::Result< 2782 - tonic::Response<super::PlayPlaylistResponse>, 2783 - tonic::Status, 2784 - > { 2785 - self.inner 2786 - .ready() 2787 - .await 2788 - .map_err(|e| { 2789 - tonic::Status::unknown( 2790 - format!("Service was not ready: {}", e.into()), 2791 - ) 2792 - })?; 2417 + ) -> std::result::Result<tonic::Response<super::PlayPlaylistResponse>, tonic::Status> 2418 + { 2419 + self.inner.ready().await.map_err(|e| { 2420 + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 2421 + })?; 2793 2422 let codec = tonic::codec::ProstCodec::default(); 2794 2423 let path = http::uri::PathAndQuery::from_static( 2795 2424 "/rockbox.v1alpha1.PlaybackService/PlayPlaylist", 2796 2425 ); 2797 2426 let mut req = request.into_request(); 2798 - req.extensions_mut() 2799 - .insert( 2800 - GrpcMethod::new("rockbox.v1alpha1.PlaybackService", "PlayPlaylist"), 2801 - ); 2427 + req.extensions_mut().insert(GrpcMethod::new( 2428 + "rockbox.v1alpha1.PlaybackService", 2429 + "PlayPlaylist", 2430 + )); 2802 2431 self.inner.unary(req, path, codec).await 2803 2432 } 2804 2433 pub async fn play_directory( 2805 2434 &mut self, 2806 2435 request: impl tonic::IntoRequest<super::PlayDirectoryRequest>, 2807 - ) -> std::result::Result< 2808 - tonic::Response<super::PlayDirectoryResponse>, 2809 - tonic::Status, 2810 - > { 2811 - self.inner 2812 - .ready() 2813 - .await 2814 - .map_err(|e| { 2815 - tonic::Status::unknown( 2816 - format!("Service was not ready: {}", e.into()), 2817 - ) 2818 - })?; 2436 + ) -> std::result::Result<tonic::Response<super::PlayDirectoryResponse>, tonic::Status> 2437 + { 2438 + self.inner.ready().await.map_err(|e| { 2439 + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 2440 + })?; 2819 2441 let codec = tonic::codec::ProstCodec::default(); 2820 2442 let path = http::uri::PathAndQuery::from_static( 2821 2443 "/rockbox.v1alpha1.PlaybackService/PlayDirectory", 2822 2444 ); 2823 2445 let mut req = request.into_request(); 2824 - req.extensions_mut() 2825 - .insert( 2826 - GrpcMethod::new("rockbox.v1alpha1.PlaybackService", "PlayDirectory"), 2827 - ); 2446 + req.extensions_mut().insert(GrpcMethod::new( 2447 + "rockbox.v1alpha1.PlaybackService", 2448 + "PlayDirectory", 2449 + )); 2828 2450 self.inner.unary(req, path, codec).await 2829 2451 } 2830 2452 pub async fn play_music_directory( 2831 2453 &mut self, 2832 2454 request: impl tonic::IntoRequest<super::PlayMusicDirectoryRequest>, 2833 - ) -> std::result::Result< 2834 - tonic::Response<super::PlayMusicDirectoryResponse>, 2835 - tonic::Status, 2836 - > { 2837 - self.inner 2838 - .ready() 2839 - .await 2840 - .map_err(|e| { 2841 - tonic::Status::unknown( 2842 - format!("Service was not ready: {}", e.into()), 2843 - ) 2844 - })?; 2455 + ) -> std::result::Result<tonic::Response<super::PlayMusicDirectoryResponse>, tonic::Status> 2456 + { 2457 + self.inner.ready().await.map_err(|e| { 2458 + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 2459 + })?; 2845 2460 let codec = tonic::codec::ProstCodec::default(); 2846 2461 let path = http::uri::PathAndQuery::from_static( 2847 2462 "/rockbox.v1alpha1.PlaybackService/PlayMusicDirectory", 2848 2463 ); 2849 2464 let mut req = request.into_request(); 2850 - req.extensions_mut() 2851 - .insert( 2852 - GrpcMethod::new( 2853 - "rockbox.v1alpha1.PlaybackService", 2854 - "PlayMusicDirectory", 2855 - ), 2856 - ); 2465 + req.extensions_mut().insert(GrpcMethod::new( 2466 + "rockbox.v1alpha1.PlaybackService", 2467 + "PlayMusicDirectory", 2468 + )); 2857 2469 self.inner.unary(req, path, codec).await 2858 2470 } 2859 2471 pub async fn play_track( 2860 2472 &mut self, 2861 2473 request: impl tonic::IntoRequest<super::PlayTrackRequest>, 2862 - ) -> std::result::Result< 2863 - tonic::Response<super::PlayTrackResponse>, 2864 - tonic::Status, 2865 - > { 2866 - self.inner 2867 - .ready() 2868 - .await 2869 - .map_err(|e| { 2870 - tonic::Status::unknown( 2871 - format!("Service was not ready: {}", e.into()), 2872 - ) 2873 - })?; 2474 + ) -> std::result::Result<tonic::Response<super::PlayTrackResponse>, tonic::Status> { 2475 + self.inner.ready().await.map_err(|e| { 2476 + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 2477 + })?; 2874 2478 let codec = tonic::codec::ProstCodec::default(); 2875 - let path = http::uri::PathAndQuery::from_static( 2876 - "/rockbox.v1alpha1.PlaybackService/PlayTrack", 2877 - ); 2479 + let path = 2480 + http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.PlaybackService/PlayTrack"); 2878 2481 let mut req = request.into_request(); 2879 - req.extensions_mut() 2880 - .insert( 2881 - GrpcMethod::new("rockbox.v1alpha1.PlaybackService", "PlayTrack"), 2882 - ); 2482 + req.extensions_mut().insert(GrpcMethod::new( 2483 + "rockbox.v1alpha1.PlaybackService", 2484 + "PlayTrack", 2485 + )); 2883 2486 self.inner.unary(req, path, codec).await 2884 2487 } 2885 2488 pub async fn play_liked_tracks( 2886 2489 &mut self, 2887 2490 request: impl tonic::IntoRequest<super::PlayLikedTracksRequest>, 2888 - ) -> std::result::Result< 2889 - tonic::Response<super::PlayLikedTracksResponse>, 2890 - tonic::Status, 2891 - > { 2892 - self.inner 2893 - .ready() 2894 - .await 2895 - .map_err(|e| { 2896 - tonic::Status::unknown( 2897 - format!("Service was not ready: {}", e.into()), 2898 - ) 2899 - })?; 2491 + ) -> std::result::Result<tonic::Response<super::PlayLikedTracksResponse>, tonic::Status> 2492 + { 2493 + self.inner.ready().await.map_err(|e| { 2494 + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 2495 + })?; 2900 2496 let codec = tonic::codec::ProstCodec::default(); 2901 2497 let path = http::uri::PathAndQuery::from_static( 2902 2498 "/rockbox.v1alpha1.PlaybackService/PlayLikedTracks", 2903 2499 ); 2904 2500 let mut req = request.into_request(); 2905 - req.extensions_mut() 2906 - .insert( 2907 - GrpcMethod::new( 2908 - "rockbox.v1alpha1.PlaybackService", 2909 - "PlayLikedTracks", 2910 - ), 2911 - ); 2501 + req.extensions_mut().insert(GrpcMethod::new( 2502 + "rockbox.v1alpha1.PlaybackService", 2503 + "PlayLikedTracks", 2504 + )); 2912 2505 self.inner.unary(req, path, codec).await 2913 2506 } 2914 2507 pub async fn play_all_tracks( 2915 2508 &mut self, 2916 2509 request: impl tonic::IntoRequest<super::PlayAllTracksRequest>, 2917 - ) -> std::result::Result< 2918 - tonic::Response<super::PlayAllTracksResponse>, 2919 - tonic::Status, 2920 - > { 2921 - self.inner 2922 - .ready() 2923 - .await 2924 - .map_err(|e| { 2925 - tonic::Status::unknown( 2926 - format!("Service was not ready: {}", e.into()), 2927 - ) 2928 - })?; 2510 + ) -> std::result::Result<tonic::Response<super::PlayAllTracksResponse>, tonic::Status> 2511 + { 2512 + self.inner.ready().await.map_err(|e| { 2513 + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 2514 + })?; 2929 2515 let codec = tonic::codec::ProstCodec::default(); 2930 2516 let path = http::uri::PathAndQuery::from_static( 2931 2517 "/rockbox.v1alpha1.PlaybackService/PlayAllTracks", 2932 2518 ); 2933 2519 let mut req = request.into_request(); 2934 - req.extensions_mut() 2935 - .insert( 2936 - GrpcMethod::new("rockbox.v1alpha1.PlaybackService", "PlayAllTracks"), 2937 - ); 2520 + req.extensions_mut().insert(GrpcMethod::new( 2521 + "rockbox.v1alpha1.PlaybackService", 2522 + "PlayAllTracks", 2523 + )); 2938 2524 self.inner.unary(req, path, codec).await 2939 2525 } 2940 2526 pub async fn stream_current_track( ··· 2944 2530 tonic::Response<tonic::codec::Streaming<super::CurrentTrackResponse>>, 2945 2531 tonic::Status, 2946 2532 > { 2947 - self.inner 2948 - .ready() 2949 - .await 2950 - .map_err(|e| { 2951 - tonic::Status::unknown( 2952 - format!("Service was not ready: {}", e.into()), 2953 - ) 2954 - })?; 2533 + self.inner.ready().await.map_err(|e| { 2534 + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 2535 + })?; 2955 2536 let codec = tonic::codec::ProstCodec::default(); 2956 2537 let path = http::uri::PathAndQuery::from_static( 2957 2538 "/rockbox.v1alpha1.PlaybackService/StreamCurrentTrack", 2958 2539 ); 2959 2540 let mut req = request.into_request(); 2960 - req.extensions_mut() 2961 - .insert( 2962 - GrpcMethod::new( 2963 - "rockbox.v1alpha1.PlaybackService", 2964 - "StreamCurrentTrack", 2965 - ), 2966 - ); 2541 + req.extensions_mut().insert(GrpcMethod::new( 2542 + "rockbox.v1alpha1.PlaybackService", 2543 + "StreamCurrentTrack", 2544 + )); 2967 2545 self.inner.server_streaming(req, path, codec).await 2968 2546 } 2969 2547 pub async fn stream_status( ··· 2973 2551 tonic::Response<tonic::codec::Streaming<super::StatusResponse>>, 2974 2552 tonic::Status, 2975 2553 > { 2976 - self.inner 2977 - .ready() 2978 - .await 2979 - .map_err(|e| { 2980 - tonic::Status::unknown( 2981 - format!("Service was not ready: {}", e.into()), 2982 - ) 2983 - })?; 2554 + self.inner.ready().await.map_err(|e| { 2555 + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 2556 + })?; 2984 2557 let codec = tonic::codec::ProstCodec::default(); 2985 2558 let path = http::uri::PathAndQuery::from_static( 2986 2559 "/rockbox.v1alpha1.PlaybackService/StreamStatus", 2987 2560 ); 2988 2561 let mut req = request.into_request(); 2989 - req.extensions_mut() 2990 - .insert( 2991 - GrpcMethod::new("rockbox.v1alpha1.PlaybackService", "StreamStatus"), 2992 - ); 2562 + req.extensions_mut().insert(GrpcMethod::new( 2563 + "rockbox.v1alpha1.PlaybackService", 2564 + "StreamStatus", 2565 + )); 2993 2566 self.inner.server_streaming(req, path, codec).await 2994 2567 } 2995 2568 pub async fn stream_playlist( ··· 2999 2572 tonic::Response<tonic::codec::Streaming<super::PlaylistResponse>>, 3000 2573 tonic::Status, 3001 2574 > { 3002 - self.inner 3003 - .ready() 3004 - .await 3005 - .map_err(|e| { 3006 - tonic::Status::unknown( 3007 - format!("Service was not ready: {}", e.into()), 3008 - ) 3009 - })?; 2575 + self.inner.ready().await.map_err(|e| { 2576 + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 2577 + })?; 3010 2578 let codec = tonic::codec::ProstCodec::default(); 3011 2579 let path = http::uri::PathAndQuery::from_static( 3012 2580 "/rockbox.v1alpha1.PlaybackService/StreamPlaylist", 3013 2581 ); 3014 2582 let mut req = request.into_request(); 3015 - req.extensions_mut() 3016 - .insert( 3017 - GrpcMethod::new("rockbox.v1alpha1.PlaybackService", "StreamPlaylist"), 3018 - ); 2583 + req.extensions_mut().insert(GrpcMethod::new( 2584 + "rockbox.v1alpha1.PlaybackService", 2585 + "StreamPlaylist", 2586 + )); 3019 2587 self.inner.server_streaming(req, path, codec).await 3020 2588 } 3021 2589 } ··· 3027 2595 dead_code, 3028 2596 missing_docs, 3029 2597 clippy::wildcard_imports, 3030 - clippy::let_unit_value, 2598 + clippy::let_unit_value 3031 2599 )] 3032 2600 use tonic::codegen::*; 3033 2601 /// Generated trait containing gRPC methods that should be implemented for use with PlaybackServiceServer. ··· 3044 2612 async fn play_or_pause( 3045 2613 &self, 3046 2614 request: tonic::Request<super::PlayOrPauseRequest>, 3047 - ) -> std::result::Result< 3048 - tonic::Response<super::PlayOrPauseResponse>, 3049 - tonic::Status, 3050 - >; 2615 + ) -> std::result::Result<tonic::Response<super::PlayOrPauseResponse>, tonic::Status>; 3051 2616 async fn resume( 3052 2617 &self, 3053 2618 request: tonic::Request<super::ResumeRequest>, ··· 3059 2624 async fn previous( 3060 2625 &self, 3061 2626 request: tonic::Request<super::PreviousRequest>, 3062 - ) -> std::result::Result< 3063 - tonic::Response<super::PreviousResponse>, 3064 - tonic::Status, 3065 - >; 2627 + ) -> std::result::Result<tonic::Response<super::PreviousResponse>, tonic::Status>; 3066 2628 async fn fast_forward_rewind( 3067 2629 &self, 3068 2630 request: tonic::Request<super::FastForwardRewindRequest>, 3069 - ) -> std::result::Result< 3070 - tonic::Response<super::FastForwardRewindResponse>, 3071 - tonic::Status, 3072 - >; 2631 + ) -> std::result::Result<tonic::Response<super::FastForwardRewindResponse>, tonic::Status>; 3073 2632 async fn status( 3074 2633 &self, 3075 2634 request: tonic::Request<super::StatusRequest>, ··· 3077 2636 async fn current_track( 3078 2637 &self, 3079 2638 request: tonic::Request<super::CurrentTrackRequest>, 3080 - ) -> std::result::Result< 3081 - tonic::Response<super::CurrentTrackResponse>, 3082 - tonic::Status, 3083 - >; 2639 + ) -> std::result::Result<tonic::Response<super::CurrentTrackResponse>, tonic::Status>; 3084 2640 async fn next_track( 3085 2641 &self, 3086 2642 request: tonic::Request<super::NextTrackRequest>, 3087 - ) -> std::result::Result< 3088 - tonic::Response<super::NextTrackResponse>, 3089 - tonic::Status, 3090 - >; 2643 + ) -> std::result::Result<tonic::Response<super::NextTrackResponse>, tonic::Status>; 3091 2644 async fn flush_and_reload_tracks( 3092 2645 &self, 3093 2646 request: tonic::Request<super::FlushAndReloadTracksRequest>, 3094 - ) -> std::result::Result< 3095 - tonic::Response<super::FlushAndReloadTracksResponse>, 3096 - tonic::Status, 3097 - >; 2647 + ) -> std::result::Result<tonic::Response<super::FlushAndReloadTracksResponse>, tonic::Status>; 3098 2648 async fn get_file_position( 3099 2649 &self, 3100 2650 request: tonic::Request<super::GetFilePositionRequest>, 3101 - ) -> std::result::Result< 3102 - tonic::Response<super::GetFilePositionResponse>, 3103 - tonic::Status, 3104 - >; 2651 + ) -> std::result::Result<tonic::Response<super::GetFilePositionResponse>, tonic::Status>; 3105 2652 async fn hard_stop( 3106 2653 &self, 3107 2654 request: tonic::Request<super::HardStopRequest>, 3108 - ) -> std::result::Result< 3109 - tonic::Response<super::HardStopResponse>, 3110 - tonic::Status, 3111 - >; 2655 + ) -> std::result::Result<tonic::Response<super::HardStopResponse>, tonic::Status>; 3112 2656 async fn play_album( 3113 2657 &self, 3114 2658 request: tonic::Request<super::PlayAlbumRequest>, 3115 - ) -> std::result::Result< 3116 - tonic::Response<super::PlayAlbumResponse>, 3117 - tonic::Status, 3118 - >; 2659 + ) -> std::result::Result<tonic::Response<super::PlayAlbumResponse>, tonic::Status>; 3119 2660 async fn play_artist_tracks( 3120 2661 &self, 3121 2662 request: tonic::Request<super::PlayArtistTracksRequest>, 3122 - ) -> std::result::Result< 3123 - tonic::Response<super::PlayArtistTracksResponse>, 3124 - tonic::Status, 3125 - >; 2663 + ) -> std::result::Result<tonic::Response<super::PlayArtistTracksResponse>, tonic::Status>; 3126 2664 async fn play_playlist( 3127 2665 &self, 3128 2666 request: tonic::Request<super::PlayPlaylistRequest>, 3129 - ) -> std::result::Result< 3130 - tonic::Response<super::PlayPlaylistResponse>, 3131 - tonic::Status, 3132 - >; 2667 + ) -> std::result::Result<tonic::Response<super::PlayPlaylistResponse>, tonic::Status>; 3133 2668 async fn play_directory( 3134 2669 &self, 3135 2670 request: tonic::Request<super::PlayDirectoryRequest>, 3136 - ) -> std::result::Result< 3137 - tonic::Response<super::PlayDirectoryResponse>, 3138 - tonic::Status, 3139 - >; 2671 + ) -> std::result::Result<tonic::Response<super::PlayDirectoryResponse>, tonic::Status>; 3140 2672 async fn play_music_directory( 3141 2673 &self, 3142 2674 request: tonic::Request<super::PlayMusicDirectoryRequest>, 3143 - ) -> std::result::Result< 3144 - tonic::Response<super::PlayMusicDirectoryResponse>, 3145 - tonic::Status, 3146 - >; 2675 + ) -> std::result::Result<tonic::Response<super::PlayMusicDirectoryResponse>, tonic::Status>; 3147 2676 async fn play_track( 3148 2677 &self, 3149 2678 request: tonic::Request<super::PlayTrackRequest>, 3150 - ) -> std::result::Result< 3151 - tonic::Response<super::PlayTrackResponse>, 3152 - tonic::Status, 3153 - >; 2679 + ) -> std::result::Result<tonic::Response<super::PlayTrackResponse>, tonic::Status>; 3154 2680 async fn play_liked_tracks( 3155 2681 &self, 3156 2682 request: tonic::Request<super::PlayLikedTracksRequest>, 3157 - ) -> std::result::Result< 3158 - tonic::Response<super::PlayLikedTracksResponse>, 3159 - tonic::Status, 3160 - >; 2683 + ) -> std::result::Result<tonic::Response<super::PlayLikedTracksResponse>, tonic::Status>; 3161 2684 async fn play_all_tracks( 3162 2685 &self, 3163 2686 request: tonic::Request<super::PlayAllTracksRequest>, 3164 - ) -> std::result::Result< 3165 - tonic::Response<super::PlayAllTracksResponse>, 3166 - tonic::Status, 3167 - >; 2687 + ) -> std::result::Result<tonic::Response<super::PlayAllTracksResponse>, tonic::Status>; 3168 2688 /// Server streaming response type for the StreamCurrentTrack method. 3169 2689 type StreamCurrentTrackStream: tonic::codegen::tokio_stream::Stream< 3170 2690 Item = std::result::Result<super::CurrentTrackResponse, tonic::Status>, 3171 - > 3172 - + std::marker::Send 2691 + > + std::marker::Send 3173 2692 + 'static; 3174 2693 async fn stream_current_track( 3175 2694 &self, 3176 2695 request: tonic::Request<super::StreamCurrentTrackRequest>, 3177 - ) -> std::result::Result< 3178 - tonic::Response<Self::StreamCurrentTrackStream>, 3179 - tonic::Status, 3180 - >; 2696 + ) -> std::result::Result<tonic::Response<Self::StreamCurrentTrackStream>, tonic::Status>; 3181 2697 /// Server streaming response type for the StreamStatus method. 3182 2698 type StreamStatusStream: tonic::codegen::tokio_stream::Stream< 3183 2699 Item = std::result::Result<super::StatusResponse, tonic::Status>, 3184 - > 3185 - + std::marker::Send 2700 + > + std::marker::Send 3186 2701 + 'static; 3187 2702 async fn stream_status( 3188 2703 &self, 3189 2704 request: tonic::Request<super::StreamStatusRequest>, 3190 - ) -> std::result::Result< 3191 - tonic::Response<Self::StreamStatusStream>, 3192 - tonic::Status, 3193 - >; 2705 + ) -> std::result::Result<tonic::Response<Self::StreamStatusStream>, tonic::Status>; 3194 2706 /// Server streaming response type for the StreamPlaylist method. 3195 2707 type StreamPlaylistStream: tonic::codegen::tokio_stream::Stream< 3196 2708 Item = std::result::Result<super::PlaylistResponse, tonic::Status>, 3197 - > 3198 - + std::marker::Send 2709 + > + std::marker::Send 3199 2710 + 'static; 3200 2711 async fn stream_playlist( 3201 2712 &self, 3202 2713 request: tonic::Request<super::StreamPlaylistRequest>, 3203 - ) -> std::result::Result< 3204 - tonic::Response<Self::StreamPlaylistStream>, 3205 - tonic::Status, 3206 - >; 2714 + ) -> std::result::Result<tonic::Response<Self::StreamPlaylistStream>, tonic::Status>; 3207 2715 } 3208 2716 #[derive(Debug)] 3209 2717 pub struct PlaybackServiceServer<T> { ··· 3226 2734 max_encoding_message_size: None, 3227 2735 } 3228 2736 } 3229 - pub fn with_interceptor<F>( 3230 - inner: T, 3231 - interceptor: F, 3232 - ) -> InterceptedService<Self, F> 2737 + pub fn with_interceptor<F>(inner: T, interceptor: F) -> InterceptedService<Self, F> 3233 2738 where 3234 2739 F: tonic::service::Interceptor, 3235 2740 { ··· 3284 2789 "/rockbox.v1alpha1.PlaybackService/Play" => { 3285 2790 #[allow(non_camel_case_types)] 3286 2791 struct PlaySvc<T: PlaybackService>(pub Arc<T>); 3287 - impl< 3288 - T: PlaybackService, 3289 - > tonic::server::UnaryService<super::PlayRequest> for PlaySvc<T> { 2792 + impl<T: PlaybackService> tonic::server::UnaryService<super::PlayRequest> for PlaySvc<T> { 3290 2793 type Response = super::PlayResponse; 3291 - type Future = BoxFuture< 3292 - tonic::Response<Self::Response>, 3293 - tonic::Status, 3294 - >; 2794 + type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 3295 2795 fn call( 3296 2796 &mut self, 3297 2797 request: tonic::Request<super::PlayRequest>, 3298 2798 ) -> Self::Future { 3299 2799 let inner = Arc::clone(&self.0); 3300 - let fut = async move { 3301 - <T as PlaybackService>::play(&inner, request).await 3302 - }; 2800 + let fut = 2801 + async move { <T as PlaybackService>::play(&inner, request).await }; 3303 2802 Box::pin(fut) 3304 2803 } 3305 2804 } ··· 3328 2827 "/rockbox.v1alpha1.PlaybackService/Pause" => { 3329 2828 #[allow(non_camel_case_types)] 3330 2829 struct PauseSvc<T: PlaybackService>(pub Arc<T>); 3331 - impl< 3332 - T: PlaybackService, 3333 - > tonic::server::UnaryService<super::PauseRequest> for PauseSvc<T> { 2830 + impl<T: PlaybackService> tonic::server::UnaryService<super::PauseRequest> for PauseSvc<T> { 3334 2831 type Response = super::PauseResponse; 3335 - type Future = BoxFuture< 3336 - tonic::Response<Self::Response>, 3337 - tonic::Status, 3338 - >; 2832 + type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 3339 2833 fn call( 3340 2834 &mut self, 3341 2835 request: tonic::Request<super::PauseRequest>, 3342 2836 ) -> Self::Future { 3343 2837 let inner = Arc::clone(&self.0); 3344 - let fut = async move { 3345 - <T as PlaybackService>::pause(&inner, request).await 3346 - }; 2838 + let fut = 2839 + async move { <T as PlaybackService>::pause(&inner, request).await }; 3347 2840 Box::pin(fut) 3348 2841 } 3349 2842 } ··· 3372 2865 "/rockbox.v1alpha1.PlaybackService/PlayOrPause" => { 3373 2866 #[allow(non_camel_case_types)] 3374 2867 struct PlayOrPauseSvc<T: PlaybackService>(pub Arc<T>); 3375 - impl< 3376 - T: PlaybackService, 3377 - > tonic::server::UnaryService<super::PlayOrPauseRequest> 3378 - for PlayOrPauseSvc<T> { 2868 + impl<T: PlaybackService> tonic::server::UnaryService<super::PlayOrPauseRequest> 2869 + for PlayOrPauseSvc<T> 2870 + { 3379 2871 type Response = super::PlayOrPauseResponse; 3380 - type Future = BoxFuture< 3381 - tonic::Response<Self::Response>, 3382 - tonic::Status, 3383 - >; 2872 + type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 3384 2873 fn call( 3385 2874 &mut self, 3386 2875 request: tonic::Request<super::PlayOrPauseRequest>, ··· 3417 2906 "/rockbox.v1alpha1.PlaybackService/Resume" => { 3418 2907 #[allow(non_camel_case_types)] 3419 2908 struct ResumeSvc<T: PlaybackService>(pub Arc<T>); 3420 - impl< 3421 - T: PlaybackService, 3422 - > tonic::server::UnaryService<super::ResumeRequest> 3423 - for ResumeSvc<T> { 2909 + impl<T: PlaybackService> tonic::server::UnaryService<super::ResumeRequest> for ResumeSvc<T> { 3424 2910 type Response = super::ResumeResponse; 3425 - type Future = BoxFuture< 3426 - tonic::Response<Self::Response>, 3427 - tonic::Status, 3428 - >; 2911 + type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 3429 2912 fn call( 3430 2913 &mut self, 3431 2914 request: tonic::Request<super::ResumeRequest>, ··· 3462 2945 "/rockbox.v1alpha1.PlaybackService/Next" => { 3463 2946 #[allow(non_camel_case_types)] 3464 2947 struct NextSvc<T: PlaybackService>(pub Arc<T>); 3465 - impl< 3466 - T: PlaybackService, 3467 - > tonic::server::UnaryService<super::NextRequest> for NextSvc<T> { 2948 + impl<T: PlaybackService> tonic::server::UnaryService<super::NextRequest> for NextSvc<T> { 3468 2949 type Response = super::NextResponse; 3469 - type Future = BoxFuture< 3470 - tonic::Response<Self::Response>, 3471 - tonic::Status, 3472 - >; 2950 + type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 3473 2951 fn call( 3474 2952 &mut self, 3475 2953 request: tonic::Request<super::NextRequest>, 3476 2954 ) -> Self::Future { 3477 2955 let inner = Arc::clone(&self.0); 3478 - let fut = async move { 3479 - <T as PlaybackService>::next(&inner, request).await 3480 - }; 2956 + let fut = 2957 + async move { <T as PlaybackService>::next(&inner, request).await }; 3481 2958 Box::pin(fut) 3482 2959 } 3483 2960 } ··· 3506 2983 "/rockbox.v1alpha1.PlaybackService/Previous" => { 3507 2984 #[allow(non_camel_case_types)] 3508 2985 struct PreviousSvc<T: PlaybackService>(pub Arc<T>); 3509 - impl< 3510 - T: PlaybackService, 3511 - > tonic::server::UnaryService<super::PreviousRequest> 3512 - for PreviousSvc<T> { 2986 + impl<T: PlaybackService> tonic::server::UnaryService<super::PreviousRequest> for PreviousSvc<T> { 3513 2987 type Response = super::PreviousResponse; 3514 - type Future = BoxFuture< 3515 - tonic::Response<Self::Response>, 3516 - tonic::Status, 3517 - >; 2988 + type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 3518 2989 fn call( 3519 2990 &mut self, 3520 2991 request: tonic::Request<super::PreviousRequest>, ··· 3551 3022 "/rockbox.v1alpha1.PlaybackService/FastForwardRewind" => { 3552 3023 #[allow(non_camel_case_types)] 3553 3024 struct FastForwardRewindSvc<T: PlaybackService>(pub Arc<T>); 3554 - impl< 3555 - T: PlaybackService, 3556 - > tonic::server::UnaryService<super::FastForwardRewindRequest> 3557 - for FastForwardRewindSvc<T> { 3025 + impl<T: PlaybackService> 3026 + tonic::server::UnaryService<super::FastForwardRewindRequest> 3027 + for FastForwardRewindSvc<T> 3028 + { 3558 3029 type Response = super::FastForwardRewindResponse; 3559 - type Future = BoxFuture< 3560 - tonic::Response<Self::Response>, 3561 - tonic::Status, 3562 - >; 3030 + type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 3563 3031 fn call( 3564 3032 &mut self, 3565 3033 request: tonic::Request<super::FastForwardRewindRequest>, 3566 3034 ) -> Self::Future { 3567 3035 let inner = Arc::clone(&self.0); 3568 3036 let fut = async move { 3569 - <T as PlaybackService>::fast_forward_rewind(&inner, request) 3570 - .await 3037 + <T as PlaybackService>::fast_forward_rewind(&inner, request).await 3571 3038 }; 3572 3039 Box::pin(fut) 3573 3040 } ··· 3597 3064 "/rockbox.v1alpha1.PlaybackService/Status" => { 3598 3065 #[allow(non_camel_case_types)] 3599 3066 struct StatusSvc<T: PlaybackService>(pub Arc<T>); 3600 - impl< 3601 - T: PlaybackService, 3602 - > tonic::server::UnaryService<super::StatusRequest> 3603 - for StatusSvc<T> { 3067 + impl<T: PlaybackService> tonic::server::UnaryService<super::StatusRequest> for StatusSvc<T> { 3604 3068 type Response = super::StatusResponse; 3605 - type Future = BoxFuture< 3606 - tonic::Response<Self::Response>, 3607 - tonic::Status, 3608 - >; 3069 + type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 3609 3070 fn call( 3610 3071 &mut self, 3611 3072 request: tonic::Request<super::StatusRequest>, ··· 3642 3103 "/rockbox.v1alpha1.PlaybackService/CurrentTrack" => { 3643 3104 #[allow(non_camel_case_types)] 3644 3105 struct CurrentTrackSvc<T: PlaybackService>(pub Arc<T>); 3645 - impl< 3646 - T: PlaybackService, 3647 - > tonic::server::UnaryService<super::CurrentTrackRequest> 3648 - for CurrentTrackSvc<T> { 3106 + impl<T: PlaybackService> tonic::server::UnaryService<super::CurrentTrackRequest> 3107 + for CurrentTrackSvc<T> 3108 + { 3649 3109 type Response = super::CurrentTrackResponse; 3650 - type Future = BoxFuture< 3651 - tonic::Response<Self::Response>, 3652 - tonic::Status, 3653 - >; 3110 + type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 3654 3111 fn call( 3655 3112 &mut self, 3656 3113 request: tonic::Request<super::CurrentTrackRequest>, ··· 3687 3144 "/rockbox.v1alpha1.PlaybackService/NextTrack" => { 3688 3145 #[allow(non_camel_case_types)] 3689 3146 struct NextTrackSvc<T: PlaybackService>(pub Arc<T>); 3690 - impl< 3691 - T: PlaybackService, 3692 - > tonic::server::UnaryService<super::NextTrackRequest> 3693 - for NextTrackSvc<T> { 3147 + impl<T: PlaybackService> tonic::server::UnaryService<super::NextTrackRequest> for NextTrackSvc<T> { 3694 3148 type Response = super::NextTrackResponse; 3695 - type Future = BoxFuture< 3696 - tonic::Response<Self::Response>, 3697 - tonic::Status, 3698 - >; 3149 + type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 3699 3150 fn call( 3700 3151 &mut self, 3701 3152 request: tonic::Request<super::NextTrackRequest>, ··· 3732 3183 "/rockbox.v1alpha1.PlaybackService/FlushAndReloadTracks" => { 3733 3184 #[allow(non_camel_case_types)] 3734 3185 struct FlushAndReloadTracksSvc<T: PlaybackService>(pub Arc<T>); 3735 - impl< 3736 - T: PlaybackService, 3737 - > tonic::server::UnaryService<super::FlushAndReloadTracksRequest> 3738 - for FlushAndReloadTracksSvc<T> { 3186 + impl<T: PlaybackService> 3187 + tonic::server::UnaryService<super::FlushAndReloadTracksRequest> 3188 + for FlushAndReloadTracksSvc<T> 3189 + { 3739 3190 type Response = super::FlushAndReloadTracksResponse; 3740 - type Future = BoxFuture< 3741 - tonic::Response<Self::Response>, 3742 - tonic::Status, 3743 - >; 3191 + type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 3744 3192 fn call( 3745 3193 &mut self, 3746 3194 request: tonic::Request<super::FlushAndReloadTracksRequest>, 3747 3195 ) -> Self::Future { 3748 3196 let inner = Arc::clone(&self.0); 3749 3197 let fut = async move { 3750 - <T as PlaybackService>::flush_and_reload_tracks( 3751 - &inner, 3752 - request, 3753 - ) 3198 + <T as PlaybackService>::flush_and_reload_tracks(&inner, request) 3754 3199 .await 3755 3200 }; 3756 3201 Box::pin(fut) ··· 3781 3226 "/rockbox.v1alpha1.PlaybackService/GetFilePosition" => { 3782 3227 #[allow(non_camel_case_types)] 3783 3228 struct GetFilePositionSvc<T: PlaybackService>(pub Arc<T>); 3784 - impl< 3785 - T: PlaybackService, 3786 - > tonic::server::UnaryService<super::GetFilePositionRequest> 3787 - for GetFilePositionSvc<T> { 3229 + impl<T: PlaybackService> 3230 + tonic::server::UnaryService<super::GetFilePositionRequest> 3231 + for GetFilePositionSvc<T> 3232 + { 3788 3233 type Response = super::GetFilePositionResponse; 3789 - type Future = BoxFuture< 3790 - tonic::Response<Self::Response>, 3791 - tonic::Status, 3792 - >; 3234 + type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 3793 3235 fn call( 3794 3236 &mut self, 3795 3237 request: tonic::Request<super::GetFilePositionRequest>, 3796 3238 ) -> Self::Future { 3797 3239 let inner = Arc::clone(&self.0); 3798 3240 let fut = async move { 3799 - <T as PlaybackService>::get_file_position(&inner, request) 3800 - .await 3241 + <T as PlaybackService>::get_file_position(&inner, request).await 3801 3242 }; 3802 3243 Box::pin(fut) 3803 3244 } ··· 3827 3268 "/rockbox.v1alpha1.PlaybackService/HardStop" => { 3828 3269 #[allow(non_camel_case_types)] 3829 3270 struct HardStopSvc<T: PlaybackService>(pub Arc<T>); 3830 - impl< 3831 - T: PlaybackService, 3832 - > tonic::server::UnaryService<super::HardStopRequest> 3833 - for HardStopSvc<T> { 3271 + impl<T: PlaybackService> tonic::server::UnaryService<super::HardStopRequest> for HardStopSvc<T> { 3834 3272 type Response = super::HardStopResponse; 3835 - type Future = BoxFuture< 3836 - tonic::Response<Self::Response>, 3837 - tonic::Status, 3838 - >; 3273 + type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 3839 3274 fn call( 3840 3275 &mut self, 3841 3276 request: tonic::Request<super::HardStopRequest>, ··· 3872 3307 "/rockbox.v1alpha1.PlaybackService/PlayAlbum" => { 3873 3308 #[allow(non_camel_case_types)] 3874 3309 struct PlayAlbumSvc<T: PlaybackService>(pub Arc<T>); 3875 - impl< 3876 - T: PlaybackService, 3877 - > tonic::server::UnaryService<super::PlayAlbumRequest> 3878 - for PlayAlbumSvc<T> { 3310 + impl<T: PlaybackService> tonic::server::UnaryService<super::PlayAlbumRequest> for PlayAlbumSvc<T> { 3879 3311 type Response = super::PlayAlbumResponse; 3880 - type Future = BoxFuture< 3881 - tonic::Response<Self::Response>, 3882 - tonic::Status, 3883 - >; 3312 + type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 3884 3313 fn call( 3885 3314 &mut self, 3886 3315 request: tonic::Request<super::PlayAlbumRequest>, ··· 3917 3346 "/rockbox.v1alpha1.PlaybackService/PlayArtistTracks" => { 3918 3347 #[allow(non_camel_case_types)] 3919 3348 struct PlayArtistTracksSvc<T: PlaybackService>(pub Arc<T>); 3920 - impl< 3921 - T: PlaybackService, 3922 - > tonic::server::UnaryService<super::PlayArtistTracksRequest> 3923 - for PlayArtistTracksSvc<T> { 3349 + impl<T: PlaybackService> 3350 + tonic::server::UnaryService<super::PlayArtistTracksRequest> 3351 + for PlayArtistTracksSvc<T> 3352 + { 3924 3353 type Response = super::PlayArtistTracksResponse; 3925 - type Future = BoxFuture< 3926 - tonic::Response<Self::Response>, 3927 - tonic::Status, 3928 - >; 3354 + type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 3929 3355 fn call( 3930 3356 &mut self, 3931 3357 request: tonic::Request<super::PlayArtistTracksRequest>, 3932 3358 ) -> Self::Future { 3933 3359 let inner = Arc::clone(&self.0); 3934 3360 let fut = async move { 3935 - <T as PlaybackService>::play_artist_tracks(&inner, request) 3936 - .await 3361 + <T as PlaybackService>::play_artist_tracks(&inner, request).await 3937 3362 }; 3938 3363 Box::pin(fut) 3939 3364 } ··· 3963 3388 "/rockbox.v1alpha1.PlaybackService/PlayPlaylist" => { 3964 3389 #[allow(non_camel_case_types)] 3965 3390 struct PlayPlaylistSvc<T: PlaybackService>(pub Arc<T>); 3966 - impl< 3967 - T: PlaybackService, 3968 - > tonic::server::UnaryService<super::PlayPlaylistRequest> 3969 - for PlayPlaylistSvc<T> { 3391 + impl<T: PlaybackService> tonic::server::UnaryService<super::PlayPlaylistRequest> 3392 + for PlayPlaylistSvc<T> 3393 + { 3970 3394 type Response = super::PlayPlaylistResponse; 3971 - type Future = BoxFuture< 3972 - tonic::Response<Self::Response>, 3973 - tonic::Status, 3974 - >; 3395 + type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 3975 3396 fn call( 3976 3397 &mut self, 3977 3398 request: tonic::Request<super::PlayPlaylistRequest>, ··· 4008 3429 "/rockbox.v1alpha1.PlaybackService/PlayDirectory" => { 4009 3430 #[allow(non_camel_case_types)] 4010 3431 struct PlayDirectorySvc<T: PlaybackService>(pub Arc<T>); 4011 - impl< 4012 - T: PlaybackService, 4013 - > tonic::server::UnaryService<super::PlayDirectoryRequest> 4014 - for PlayDirectorySvc<T> { 3432 + impl<T: PlaybackService> 3433 + tonic::server::UnaryService<super::PlayDirectoryRequest> 3434 + for PlayDirectorySvc<T> 3435 + { 4015 3436 type Response = super::PlayDirectoryResponse; 4016 - type Future = BoxFuture< 4017 - tonic::Response<Self::Response>, 4018 - tonic::Status, 4019 - >; 3437 + type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 4020 3438 fn call( 4021 3439 &mut self, 4022 3440 request: tonic::Request<super::PlayDirectoryRequest>, 4023 3441 ) -> Self::Future { 4024 3442 let inner = Arc::clone(&self.0); 4025 3443 let fut = async move { 4026 - <T as PlaybackService>::play_directory(&inner, request) 4027 - .await 3444 + <T as PlaybackService>::play_directory(&inner, request).await 4028 3445 }; 4029 3446 Box::pin(fut) 4030 3447 } ··· 4054 3471 "/rockbox.v1alpha1.PlaybackService/PlayMusicDirectory" => { 4055 3472 #[allow(non_camel_case_types)] 4056 3473 struct PlayMusicDirectorySvc<T: PlaybackService>(pub Arc<T>); 4057 - impl< 4058 - T: PlaybackService, 4059 - > tonic::server::UnaryService<super::PlayMusicDirectoryRequest> 4060 - for PlayMusicDirectorySvc<T> { 3474 + impl<T: PlaybackService> 3475 + tonic::server::UnaryService<super::PlayMusicDirectoryRequest> 3476 + for PlayMusicDirectorySvc<T> 3477 + { 4061 3478 type Response = super::PlayMusicDirectoryResponse; 4062 - type Future = BoxFuture< 4063 - tonic::Response<Self::Response>, 4064 - tonic::Status, 4065 - >; 3479 + type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 4066 3480 fn call( 4067 3481 &mut self, 4068 3482 request: tonic::Request<super::PlayMusicDirectoryRequest>, 4069 3483 ) -> Self::Future { 4070 3484 let inner = Arc::clone(&self.0); 4071 3485 let fut = async move { 4072 - <T as PlaybackService>::play_music_directory( 4073 - &inner, 4074 - request, 4075 - ) 4076 - .await 3486 + <T as PlaybackService>::play_music_directory(&inner, request).await 4077 3487 }; 4078 3488 Box::pin(fut) 4079 3489 } ··· 4103 3513 "/rockbox.v1alpha1.PlaybackService/PlayTrack" => { 4104 3514 #[allow(non_camel_case_types)] 4105 3515 struct PlayTrackSvc<T: PlaybackService>(pub Arc<T>); 4106 - impl< 4107 - T: PlaybackService, 4108 - > tonic::server::UnaryService<super::PlayTrackRequest> 4109 - for PlayTrackSvc<T> { 3516 + impl<T: PlaybackService> tonic::server::UnaryService<super::PlayTrackRequest> for PlayTrackSvc<T> { 4110 3517 type Response = super::PlayTrackResponse; 4111 - type Future = BoxFuture< 4112 - tonic::Response<Self::Response>, 4113 - tonic::Status, 4114 - >; 3518 + type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 4115 3519 fn call( 4116 3520 &mut self, 4117 3521 request: tonic::Request<super::PlayTrackRequest>, ··· 4148 3552 "/rockbox.v1alpha1.PlaybackService/PlayLikedTracks" => { 4149 3553 #[allow(non_camel_case_types)] 4150 3554 struct PlayLikedTracksSvc<T: PlaybackService>(pub Arc<T>); 4151 - impl< 4152 - T: PlaybackService, 4153 - > tonic::server::UnaryService<super::PlayLikedTracksRequest> 4154 - for PlayLikedTracksSvc<T> { 3555 + impl<T: PlaybackService> 3556 + tonic::server::UnaryService<super::PlayLikedTracksRequest> 3557 + for PlayLikedTracksSvc<T> 3558 + { 4155 3559 type Response = super::PlayLikedTracksResponse; 4156 - type Future = BoxFuture< 4157 - tonic::Response<Self::Response>, 4158 - tonic::Status, 4159 - >; 3560 + type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 4160 3561 fn call( 4161 3562 &mut self, 4162 3563 request: tonic::Request<super::PlayLikedTracksRequest>, 4163 3564 ) -> Self::Future { 4164 3565 let inner = Arc::clone(&self.0); 4165 3566 let fut = async move { 4166 - <T as PlaybackService>::play_liked_tracks(&inner, request) 4167 - .await 3567 + <T as PlaybackService>::play_liked_tracks(&inner, request).await 4168 3568 }; 4169 3569 Box::pin(fut) 4170 3570 } ··· 4194 3594 "/rockbox.v1alpha1.PlaybackService/PlayAllTracks" => { 4195 3595 #[allow(non_camel_case_types)] 4196 3596 struct PlayAllTracksSvc<T: PlaybackService>(pub Arc<T>); 4197 - impl< 4198 - T: PlaybackService, 4199 - > tonic::server::UnaryService<super::PlayAllTracksRequest> 4200 - for PlayAllTracksSvc<T> { 3597 + impl<T: PlaybackService> 3598 + tonic::server::UnaryService<super::PlayAllTracksRequest> 3599 + for PlayAllTracksSvc<T> 3600 + { 4201 3601 type Response = super::PlayAllTracksResponse; 4202 - type Future = BoxFuture< 4203 - tonic::Response<Self::Response>, 4204 - tonic::Status, 4205 - >; 3602 + type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 4206 3603 fn call( 4207 3604 &mut self, 4208 3605 request: tonic::Request<super::PlayAllTracksRequest>, 4209 3606 ) -> Self::Future { 4210 3607 let inner = Arc::clone(&self.0); 4211 3608 let fut = async move { 4212 - <T as PlaybackService>::play_all_tracks(&inner, request) 4213 - .await 3609 + <T as PlaybackService>::play_all_tracks(&inner, request).await 4214 3610 }; 4215 3611 Box::pin(fut) 4216 3612 } ··· 4240 3636 "/rockbox.v1alpha1.PlaybackService/StreamCurrentTrack" => { 4241 3637 #[allow(non_camel_case_types)] 4242 3638 struct StreamCurrentTrackSvc<T: PlaybackService>(pub Arc<T>); 4243 - impl< 4244 - T: PlaybackService, 4245 - > tonic::server::ServerStreamingService< 4246 - super::StreamCurrentTrackRequest, 4247 - > for StreamCurrentTrackSvc<T> { 3639 + impl<T: PlaybackService> 3640 + tonic::server::ServerStreamingService<super::StreamCurrentTrackRequest> 3641 + for StreamCurrentTrackSvc<T> 3642 + { 4248 3643 type Response = super::CurrentTrackResponse; 4249 3644 type ResponseStream = T::StreamCurrentTrackStream; 4250 - type Future = BoxFuture< 4251 - tonic::Response<Self::ResponseStream>, 4252 - tonic::Status, 4253 - >; 3645 + type Future = 3646 + BoxFuture<tonic::Response<Self::ResponseStream>, tonic::Status>; 4254 3647 fn call( 4255 3648 &mut self, 4256 3649 request: tonic::Request<super::StreamCurrentTrackRequest>, 4257 3650 ) -> Self::Future { 4258 3651 let inner = Arc::clone(&self.0); 4259 3652 let fut = async move { 4260 - <T as PlaybackService>::stream_current_track( 4261 - &inner, 4262 - request, 4263 - ) 4264 - .await 3653 + <T as PlaybackService>::stream_current_track(&inner, request).await 4265 3654 }; 4266 3655 Box::pin(fut) 4267 3656 } ··· 4291 3680 "/rockbox.v1alpha1.PlaybackService/StreamStatus" => { 4292 3681 #[allow(non_camel_case_types)] 4293 3682 struct StreamStatusSvc<T: PlaybackService>(pub Arc<T>); 4294 - impl< 4295 - T: PlaybackService, 4296 - > tonic::server::ServerStreamingService<super::StreamStatusRequest> 4297 - for StreamStatusSvc<T> { 3683 + impl<T: PlaybackService> 3684 + tonic::server::ServerStreamingService<super::StreamStatusRequest> 3685 + for StreamStatusSvc<T> 3686 + { 4298 3687 type Response = super::StatusResponse; 4299 3688 type ResponseStream = T::StreamStatusStream; 4300 - type Future = BoxFuture< 4301 - tonic::Response<Self::ResponseStream>, 4302 - tonic::Status, 4303 - >; 3689 + type Future = 3690 + BoxFuture<tonic::Response<Self::ResponseStream>, tonic::Status>; 4304 3691 fn call( 4305 3692 &mut self, 4306 3693 request: tonic::Request<super::StreamStatusRequest>, ··· 4337 3724 "/rockbox.v1alpha1.PlaybackService/StreamPlaylist" => { 4338 3725 #[allow(non_camel_case_types)] 4339 3726 struct StreamPlaylistSvc<T: PlaybackService>(pub Arc<T>); 4340 - impl< 4341 - T: PlaybackService, 4342 - > tonic::server::ServerStreamingService<super::StreamPlaylistRequest> 4343 - for StreamPlaylistSvc<T> { 3727 + impl<T: PlaybackService> 3728 + tonic::server::ServerStreamingService<super::StreamPlaylistRequest> 3729 + for StreamPlaylistSvc<T> 3730 + { 4344 3731 type Response = super::PlaylistResponse; 4345 3732 type ResponseStream = T::StreamPlaylistStream; 4346 - type Future = BoxFuture< 4347 - tonic::Response<Self::ResponseStream>, 4348 - tonic::Status, 4349 - >; 3733 + type Future = 3734 + BoxFuture<tonic::Response<Self::ResponseStream>, tonic::Status>; 4350 3735 fn call( 4351 3736 &mut self, 4352 3737 request: tonic::Request<super::StreamPlaylistRequest>, 4353 3738 ) -> Self::Future { 4354 3739 let inner = Arc::clone(&self.0); 4355 3740 let fut = async move { 4356 - <T as PlaybackService>::stream_playlist(&inner, request) 4357 - .await 3741 + <T as PlaybackService>::stream_playlist(&inner, request).await 4358 3742 }; 4359 3743 Box::pin(fut) 4360 3744 } ··· 4381 3765 }; 4382 3766 Box::pin(fut) 4383 3767 } 4384 - _ => { 4385 - Box::pin(async move { 4386 - let mut response = http::Response::new(empty_body()); 4387 - let headers = response.headers_mut(); 4388 - headers 4389 - .insert( 4390 - tonic::Status::GRPC_STATUS, 4391 - (tonic::Code::Unimplemented as i32).into(), 4392 - ); 4393 - headers 4394 - .insert( 4395 - http::header::CONTENT_TYPE, 4396 - tonic::metadata::GRPC_CONTENT_TYPE, 4397 - ); 4398 - Ok(response) 4399 - }) 4400 - } 3768 + _ => Box::pin(async move { 3769 + let mut response = http::Response::new(empty_body()); 3770 + let headers = response.headers_mut(); 3771 + headers.insert( 3772 + tonic::Status::GRPC_STATUS, 3773 + (tonic::Code::Unimplemented as i32).into(), 3774 + ); 3775 + headers.insert( 3776 + http::header::CONTENT_TYPE, 3777 + tonic::metadata::GRPC_CONTENT_TYPE, 3778 + ); 3779 + Ok(response) 3780 + }), 4401 3781 } 4402 3782 } 4403 3783 } ··· 4604 3984 dead_code, 4605 3985 missing_docs, 4606 3986 clippy::wildcard_imports, 4607 - clippy::let_unit_value, 3987 + clippy::let_unit_value 4608 3988 )] 4609 - use tonic::codegen::*; 4610 3989 use tonic::codegen::http::Uri; 3990 + use tonic::codegen::*; 4611 3991 #[derive(Debug, Clone)] 4612 3992 pub struct PlaylistServiceClient<T> { 4613 3993 inner: tonic::client::Grpc<T>, ··· 4651 4031 <T as tonic::client::GrpcService<tonic::body::BoxBody>>::ResponseBody, 4652 4032 >, 4653 4033 >, 4654 - <T as tonic::codegen::Service< 4655 - http::Request<tonic::body::BoxBody>, 4656 - >>::Error: Into<StdError> + std::marker::Send + std::marker::Sync, 4034 + <T as tonic::codegen::Service<http::Request<tonic::body::BoxBody>>>::Error: 4035 + Into<StdError> + std::marker::Send + std::marker::Sync, 4657 4036 { 4658 4037 PlaylistServiceClient::new(InterceptedService::new(inner, interceptor)) 4659 4038 } ··· 4691 4070 pub async fn get_current( 4692 4071 &mut self, 4693 4072 request: impl tonic::IntoRequest<super::GetCurrentRequest>, 4694 - ) -> std::result::Result< 4695 - tonic::Response<super::GetCurrentResponse>, 4696 - tonic::Status, 4697 - > { 4698 - self.inner 4699 - .ready() 4700 - .await 4701 - .map_err(|e| { 4702 - tonic::Status::unknown( 4703 - format!("Service was not ready: {}", e.into()), 4704 - ) 4705 - })?; 4073 + ) -> std::result::Result<tonic::Response<super::GetCurrentResponse>, tonic::Status> 4074 + { 4075 + self.inner.ready().await.map_err(|e| { 4076 + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 4077 + })?; 4706 4078 let codec = tonic::codec::ProstCodec::default(); 4707 4079 let path = http::uri::PathAndQuery::from_static( 4708 4080 "/rockbox.v1alpha1.PlaylistService/GetCurrent", 4709 4081 ); 4710 4082 let mut req = request.into_request(); 4711 - req.extensions_mut() 4712 - .insert( 4713 - GrpcMethod::new("rockbox.v1alpha1.PlaylistService", "GetCurrent"), 4714 - ); 4083 + req.extensions_mut().insert(GrpcMethod::new( 4084 + "rockbox.v1alpha1.PlaylistService", 4085 + "GetCurrent", 4086 + )); 4715 4087 self.inner.unary(req, path, codec).await 4716 4088 } 4717 4089 pub async fn get_resume_info( 4718 4090 &mut self, 4719 4091 request: impl tonic::IntoRequest<super::GetResumeInfoRequest>, 4720 - ) -> std::result::Result< 4721 - tonic::Response<super::GetResumeInfoResponse>, 4722 - tonic::Status, 4723 - > { 4724 - self.inner 4725 - .ready() 4726 - .await 4727 - .map_err(|e| { 4728 - tonic::Status::unknown( 4729 - format!("Service was not ready: {}", e.into()), 4730 - ) 4731 - })?; 4092 + ) -> std::result::Result<tonic::Response<super::GetResumeInfoResponse>, tonic::Status> 4093 + { 4094 + self.inner.ready().await.map_err(|e| { 4095 + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 4096 + })?; 4732 4097 let codec = tonic::codec::ProstCodec::default(); 4733 4098 let path = http::uri::PathAndQuery::from_static( 4734 4099 "/rockbox.v1alpha1.PlaylistService/GetResumeInfo", 4735 4100 ); 4736 4101 let mut req = request.into_request(); 4737 - req.extensions_mut() 4738 - .insert( 4739 - GrpcMethod::new("rockbox.v1alpha1.PlaylistService", "GetResumeInfo"), 4740 - ); 4102 + req.extensions_mut().insert(GrpcMethod::new( 4103 + "rockbox.v1alpha1.PlaylistService", 4104 + "GetResumeInfo", 4105 + )); 4741 4106 self.inner.unary(req, path, codec).await 4742 4107 } 4743 4108 pub async fn get_track_info( 4744 4109 &mut self, 4745 4110 request: impl tonic::IntoRequest<super::GetTrackInfoRequest>, 4746 - ) -> std::result::Result< 4747 - tonic::Response<super::GetTrackInfoResponse>, 4748 - tonic::Status, 4749 - > { 4750 - self.inner 4751 - .ready() 4752 - .await 4753 - .map_err(|e| { 4754 - tonic::Status::unknown( 4755 - format!("Service was not ready: {}", e.into()), 4756 - ) 4757 - })?; 4111 + ) -> std::result::Result<tonic::Response<super::GetTrackInfoResponse>, tonic::Status> 4112 + { 4113 + self.inner.ready().await.map_err(|e| { 4114 + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 4115 + })?; 4758 4116 let codec = tonic::codec::ProstCodec::default(); 4759 4117 let path = http::uri::PathAndQuery::from_static( 4760 4118 "/rockbox.v1alpha1.PlaylistService/GetTrackInfo", 4761 4119 ); 4762 4120 let mut req = request.into_request(); 4763 - req.extensions_mut() 4764 - .insert( 4765 - GrpcMethod::new("rockbox.v1alpha1.PlaylistService", "GetTrackInfo"), 4766 - ); 4121 + req.extensions_mut().insert(GrpcMethod::new( 4122 + "rockbox.v1alpha1.PlaylistService", 4123 + "GetTrackInfo", 4124 + )); 4767 4125 self.inner.unary(req, path, codec).await 4768 4126 } 4769 4127 pub async fn get_first_index( 4770 4128 &mut self, 4771 4129 request: impl tonic::IntoRequest<super::GetFirstIndexRequest>, 4772 - ) -> std::result::Result< 4773 - tonic::Response<super::GetFirstIndexResponse>, 4774 - tonic::Status, 4775 - > { 4776 - self.inner 4777 - .ready() 4778 - .await 4779 - .map_err(|e| { 4780 - tonic::Status::unknown( 4781 - format!("Service was not ready: {}", e.into()), 4782 - ) 4783 - })?; 4130 + ) -> std::result::Result<tonic::Response<super::GetFirstIndexResponse>, tonic::Status> 4131 + { 4132 + self.inner.ready().await.map_err(|e| { 4133 + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 4134 + })?; 4784 4135 let codec = tonic::codec::ProstCodec::default(); 4785 4136 let path = http::uri::PathAndQuery::from_static( 4786 4137 "/rockbox.v1alpha1.PlaylistService/GetFirstIndex", 4787 4138 ); 4788 4139 let mut req = request.into_request(); 4789 - req.extensions_mut() 4790 - .insert( 4791 - GrpcMethod::new("rockbox.v1alpha1.PlaylistService", "GetFirstIndex"), 4792 - ); 4140 + req.extensions_mut().insert(GrpcMethod::new( 4141 + "rockbox.v1alpha1.PlaylistService", 4142 + "GetFirstIndex", 4143 + )); 4793 4144 self.inner.unary(req, path, codec).await 4794 4145 } 4795 4146 pub async fn get_display_index( 4796 4147 &mut self, 4797 4148 request: impl tonic::IntoRequest<super::GetDisplayIndexRequest>, 4798 - ) -> std::result::Result< 4799 - tonic::Response<super::GetDisplayIndexResponse>, 4800 - tonic::Status, 4801 - > { 4802 - self.inner 4803 - .ready() 4804 - .await 4805 - .map_err(|e| { 4806 - tonic::Status::unknown( 4807 - format!("Service was not ready: {}", e.into()), 4808 - ) 4809 - })?; 4149 + ) -> std::result::Result<tonic::Response<super::GetDisplayIndexResponse>, tonic::Status> 4150 + { 4151 + self.inner.ready().await.map_err(|e| { 4152 + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 4153 + })?; 4810 4154 let codec = tonic::codec::ProstCodec::default(); 4811 4155 let path = http::uri::PathAndQuery::from_static( 4812 4156 "/rockbox.v1alpha1.PlaylistService/GetDisplayIndex", 4813 4157 ); 4814 4158 let mut req = request.into_request(); 4815 - req.extensions_mut() 4816 - .insert( 4817 - GrpcMethod::new( 4818 - "rockbox.v1alpha1.PlaylistService", 4819 - "GetDisplayIndex", 4820 - ), 4821 - ); 4159 + req.extensions_mut().insert(GrpcMethod::new( 4160 + "rockbox.v1alpha1.PlaylistService", 4161 + "GetDisplayIndex", 4162 + )); 4822 4163 self.inner.unary(req, path, codec).await 4823 4164 } 4824 4165 pub async fn amount( 4825 4166 &mut self, 4826 4167 request: impl tonic::IntoRequest<super::AmountRequest>, 4827 4168 ) -> std::result::Result<tonic::Response<super::AmountResponse>, tonic::Status> { 4828 - self.inner 4829 - .ready() 4830 - .await 4831 - .map_err(|e| { 4832 - tonic::Status::unknown( 4833 - format!("Service was not ready: {}", e.into()), 4834 - ) 4835 - })?; 4169 + self.inner.ready().await.map_err(|e| { 4170 + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 4171 + })?; 4836 4172 let codec = tonic::codec::ProstCodec::default(); 4837 - let path = http::uri::PathAndQuery::from_static( 4838 - "/rockbox.v1alpha1.PlaylistService/Amount", 4839 - ); 4173 + let path = 4174 + http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.PlaylistService/Amount"); 4840 4175 let mut req = request.into_request(); 4841 - req.extensions_mut() 4842 - .insert(GrpcMethod::new("rockbox.v1alpha1.PlaylistService", "Amount")); 4176 + req.extensions_mut().insert(GrpcMethod::new( 4177 + "rockbox.v1alpha1.PlaylistService", 4178 + "Amount", 4179 + )); 4843 4180 self.inner.unary(req, path, codec).await 4844 4181 } 4845 4182 pub async fn playlist_resume( 4846 4183 &mut self, 4847 4184 request: impl tonic::IntoRequest<super::PlaylistResumeRequest>, 4848 - ) -> std::result::Result< 4849 - tonic::Response<super::PlaylistResumeResponse>, 4850 - tonic::Status, 4851 - > { 4852 - self.inner 4853 - .ready() 4854 - .await 4855 - .map_err(|e| { 4856 - tonic::Status::unknown( 4857 - format!("Service was not ready: {}", e.into()), 4858 - ) 4859 - })?; 4185 + ) -> std::result::Result<tonic::Response<super::PlaylistResumeResponse>, tonic::Status> 4186 + { 4187 + self.inner.ready().await.map_err(|e| { 4188 + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 4189 + })?; 4860 4190 let codec = tonic::codec::ProstCodec::default(); 4861 4191 let path = http::uri::PathAndQuery::from_static( 4862 4192 "/rockbox.v1alpha1.PlaylistService/PlaylistResume", 4863 4193 ); 4864 4194 let mut req = request.into_request(); 4865 - req.extensions_mut() 4866 - .insert( 4867 - GrpcMethod::new("rockbox.v1alpha1.PlaylistService", "PlaylistResume"), 4868 - ); 4195 + req.extensions_mut().insert(GrpcMethod::new( 4196 + "rockbox.v1alpha1.PlaylistService", 4197 + "PlaylistResume", 4198 + )); 4869 4199 self.inner.unary(req, path, codec).await 4870 4200 } 4871 4201 pub async fn resume_track( 4872 4202 &mut self, 4873 4203 request: impl tonic::IntoRequest<super::ResumeTrackRequest>, 4874 - ) -> std::result::Result< 4875 - tonic::Response<super::ResumeTrackResponse>, 4876 - tonic::Status, 4877 - > { 4878 - self.inner 4879 - .ready() 4880 - .await 4881 - .map_err(|e| { 4882 - tonic::Status::unknown( 4883 - format!("Service was not ready: {}", e.into()), 4884 - ) 4885 - })?; 4204 + ) -> std::result::Result<tonic::Response<super::ResumeTrackResponse>, tonic::Status> 4205 + { 4206 + self.inner.ready().await.map_err(|e| { 4207 + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 4208 + })?; 4886 4209 let codec = tonic::codec::ProstCodec::default(); 4887 4210 let path = http::uri::PathAndQuery::from_static( 4888 4211 "/rockbox.v1alpha1.PlaylistService/ResumeTrack", 4889 4212 ); 4890 4213 let mut req = request.into_request(); 4891 - req.extensions_mut() 4892 - .insert( 4893 - GrpcMethod::new("rockbox.v1alpha1.PlaylistService", "ResumeTrack"), 4894 - ); 4214 + req.extensions_mut().insert(GrpcMethod::new( 4215 + "rockbox.v1alpha1.PlaylistService", 4216 + "ResumeTrack", 4217 + )); 4895 4218 self.inner.unary(req, path, codec).await 4896 4219 } 4897 4220 pub async fn set_modified( 4898 4221 &mut self, 4899 4222 request: impl tonic::IntoRequest<super::SetModifiedRequest>, 4900 - ) -> std::result::Result< 4901 - tonic::Response<super::SetModifiedResponse>, 4902 - tonic::Status, 4903 - > { 4904 - self.inner 4905 - .ready() 4906 - .await 4907 - .map_err(|e| { 4908 - tonic::Status::unknown( 4909 - format!("Service was not ready: {}", e.into()), 4910 - ) 4911 - })?; 4223 + ) -> std::result::Result<tonic::Response<super::SetModifiedResponse>, tonic::Status> 4224 + { 4225 + self.inner.ready().await.map_err(|e| { 4226 + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 4227 + })?; 4912 4228 let codec = tonic::codec::ProstCodec::default(); 4913 4229 let path = http::uri::PathAndQuery::from_static( 4914 4230 "/rockbox.v1alpha1.PlaylistService/SetModified", 4915 4231 ); 4916 4232 let mut req = request.into_request(); 4917 - req.extensions_mut() 4918 - .insert( 4919 - GrpcMethod::new("rockbox.v1alpha1.PlaylistService", "SetModified"), 4920 - ); 4233 + req.extensions_mut().insert(GrpcMethod::new( 4234 + "rockbox.v1alpha1.PlaylistService", 4235 + "SetModified", 4236 + )); 4921 4237 self.inner.unary(req, path, codec).await 4922 4238 } 4923 4239 pub async fn start( 4924 4240 &mut self, 4925 4241 request: impl tonic::IntoRequest<super::StartRequest>, 4926 4242 ) -> std::result::Result<tonic::Response<super::StartResponse>, tonic::Status> { 4927 - self.inner 4928 - .ready() 4929 - .await 4930 - .map_err(|e| { 4931 - tonic::Status::unknown( 4932 - format!("Service was not ready: {}", e.into()), 4933 - ) 4934 - })?; 4243 + self.inner.ready().await.map_err(|e| { 4244 + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 4245 + })?; 4935 4246 let codec = tonic::codec::ProstCodec::default(); 4936 - let path = http::uri::PathAndQuery::from_static( 4937 - "/rockbox.v1alpha1.PlaylistService/Start", 4938 - ); 4247 + let path = 4248 + http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.PlaylistService/Start"); 4939 4249 let mut req = request.into_request(); 4940 4250 req.extensions_mut() 4941 4251 .insert(GrpcMethod::new("rockbox.v1alpha1.PlaylistService", "Start")); ··· 4945 4255 &mut self, 4946 4256 request: impl tonic::IntoRequest<super::SyncRequest>, 4947 4257 ) -> std::result::Result<tonic::Response<super::SyncResponse>, tonic::Status> { 4948 - self.inner 4949 - .ready() 4950 - .await 4951 - .map_err(|e| { 4952 - tonic::Status::unknown( 4953 - format!("Service was not ready: {}", e.into()), 4954 - ) 4955 - })?; 4258 + self.inner.ready().await.map_err(|e| { 4259 + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 4260 + })?; 4956 4261 let codec = tonic::codec::ProstCodec::default(); 4957 - let path = http::uri::PathAndQuery::from_static( 4958 - "/rockbox.v1alpha1.PlaylistService/Sync", 4959 - ); 4262 + let path = 4263 + http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.PlaylistService/Sync"); 4960 4264 let mut req = request.into_request(); 4961 4265 req.extensions_mut() 4962 4266 .insert(GrpcMethod::new("rockbox.v1alpha1.PlaylistService", "Sync")); ··· 4965 4269 pub async fn remove_all_tracks( 4966 4270 &mut self, 4967 4271 request: impl tonic::IntoRequest<super::RemoveAllTracksRequest>, 4968 - ) -> std::result::Result< 4969 - tonic::Response<super::RemoveAllTracksResponse>, 4970 - tonic::Status, 4971 - > { 4972 - self.inner 4973 - .ready() 4974 - .await 4975 - .map_err(|e| { 4976 - tonic::Status::unknown( 4977 - format!("Service was not ready: {}", e.into()), 4978 - ) 4979 - })?; 4272 + ) -> std::result::Result<tonic::Response<super::RemoveAllTracksResponse>, tonic::Status> 4273 + { 4274 + self.inner.ready().await.map_err(|e| { 4275 + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 4276 + })?; 4980 4277 let codec = tonic::codec::ProstCodec::default(); 4981 4278 let path = http::uri::PathAndQuery::from_static( 4982 4279 "/rockbox.v1alpha1.PlaylistService/RemoveAllTracks", 4983 4280 ); 4984 4281 let mut req = request.into_request(); 4985 - req.extensions_mut() 4986 - .insert( 4987 - GrpcMethod::new( 4988 - "rockbox.v1alpha1.PlaylistService", 4989 - "RemoveAllTracks", 4990 - ), 4991 - ); 4282 + req.extensions_mut().insert(GrpcMethod::new( 4283 + "rockbox.v1alpha1.PlaylistService", 4284 + "RemoveAllTracks", 4285 + )); 4992 4286 self.inner.unary(req, path, codec).await 4993 4287 } 4994 4288 pub async fn remove_tracks( 4995 4289 &mut self, 4996 4290 request: impl tonic::IntoRequest<super::RemoveTracksRequest>, 4997 - ) -> std::result::Result< 4998 - tonic::Response<super::RemoveTracksResponse>, 4999 - tonic::Status, 5000 - > { 5001 - self.inner 5002 - .ready() 5003 - .await 5004 - .map_err(|e| { 5005 - tonic::Status::unknown( 5006 - format!("Service was not ready: {}", e.into()), 5007 - ) 5008 - })?; 4291 + ) -> std::result::Result<tonic::Response<super::RemoveTracksResponse>, tonic::Status> 4292 + { 4293 + self.inner.ready().await.map_err(|e| { 4294 + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 4295 + })?; 5009 4296 let codec = tonic::codec::ProstCodec::default(); 5010 4297 let path = http::uri::PathAndQuery::from_static( 5011 4298 "/rockbox.v1alpha1.PlaylistService/RemoveTracks", 5012 4299 ); 5013 4300 let mut req = request.into_request(); 5014 - req.extensions_mut() 5015 - .insert( 5016 - GrpcMethod::new("rockbox.v1alpha1.PlaylistService", "RemoveTracks"), 5017 - ); 4301 + req.extensions_mut().insert(GrpcMethod::new( 4302 + "rockbox.v1alpha1.PlaylistService", 4303 + "RemoveTracks", 4304 + )); 5018 4305 self.inner.unary(req, path, codec).await 5019 4306 } 5020 4307 pub async fn create_playlist( 5021 4308 &mut self, 5022 4309 request: impl tonic::IntoRequest<super::CreatePlaylistRequest>, 5023 - ) -> std::result::Result< 5024 - tonic::Response<super::CreatePlaylistResponse>, 5025 - tonic::Status, 5026 - > { 5027 - self.inner 5028 - .ready() 5029 - .await 5030 - .map_err(|e| { 5031 - tonic::Status::unknown( 5032 - format!("Service was not ready: {}", e.into()), 5033 - ) 5034 - })?; 4310 + ) -> std::result::Result<tonic::Response<super::CreatePlaylistResponse>, tonic::Status> 4311 + { 4312 + self.inner.ready().await.map_err(|e| { 4313 + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 4314 + })?; 5035 4315 let codec = tonic::codec::ProstCodec::default(); 5036 4316 let path = http::uri::PathAndQuery::from_static( 5037 4317 "/rockbox.v1alpha1.PlaylistService/CreatePlaylist", 5038 4318 ); 5039 4319 let mut req = request.into_request(); 5040 - req.extensions_mut() 5041 - .insert( 5042 - GrpcMethod::new("rockbox.v1alpha1.PlaylistService", "CreatePlaylist"), 5043 - ); 4320 + req.extensions_mut().insert(GrpcMethod::new( 4321 + "rockbox.v1alpha1.PlaylistService", 4322 + "CreatePlaylist", 4323 + )); 5044 4324 self.inner.unary(req, path, codec).await 5045 4325 } 5046 4326 pub async fn insert_tracks( 5047 4327 &mut self, 5048 4328 request: impl tonic::IntoRequest<super::InsertTracksRequest>, 5049 - ) -> std::result::Result< 5050 - tonic::Response<super::InsertTracksResponse>, 5051 - tonic::Status, 5052 - > { 5053 - self.inner 5054 - .ready() 5055 - .await 5056 - .map_err(|e| { 5057 - tonic::Status::unknown( 5058 - format!("Service was not ready: {}", e.into()), 5059 - ) 5060 - })?; 4329 + ) -> std::result::Result<tonic::Response<super::InsertTracksResponse>, tonic::Status> 4330 + { 4331 + self.inner.ready().await.map_err(|e| { 4332 + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 4333 + })?; 5061 4334 let codec = tonic::codec::ProstCodec::default(); 5062 4335 let path = http::uri::PathAndQuery::from_static( 5063 4336 "/rockbox.v1alpha1.PlaylistService/InsertTracks", 5064 4337 ); 5065 4338 let mut req = request.into_request(); 5066 - req.extensions_mut() 5067 - .insert( 5068 - GrpcMethod::new("rockbox.v1alpha1.PlaylistService", "InsertTracks"), 5069 - ); 4339 + req.extensions_mut().insert(GrpcMethod::new( 4340 + "rockbox.v1alpha1.PlaylistService", 4341 + "InsertTracks", 4342 + )); 5070 4343 self.inner.unary(req, path, codec).await 5071 4344 } 5072 4345 pub async fn insert_directory( 5073 4346 &mut self, 5074 4347 request: impl tonic::IntoRequest<super::InsertDirectoryRequest>, 5075 - ) -> std::result::Result< 5076 - tonic::Response<super::InsertDirectoryResponse>, 5077 - tonic::Status, 5078 - > { 5079 - self.inner 5080 - .ready() 5081 - .await 5082 - .map_err(|e| { 5083 - tonic::Status::unknown( 5084 - format!("Service was not ready: {}", e.into()), 5085 - ) 5086 - })?; 4348 + ) -> std::result::Result<tonic::Response<super::InsertDirectoryResponse>, tonic::Status> 4349 + { 4350 + self.inner.ready().await.map_err(|e| { 4351 + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 4352 + })?; 5087 4353 let codec = tonic::codec::ProstCodec::default(); 5088 4354 let path = http::uri::PathAndQuery::from_static( 5089 4355 "/rockbox.v1alpha1.PlaylistService/InsertDirectory", 5090 4356 ); 5091 4357 let mut req = request.into_request(); 5092 - req.extensions_mut() 5093 - .insert( 5094 - GrpcMethod::new( 5095 - "rockbox.v1alpha1.PlaylistService", 5096 - "InsertDirectory", 5097 - ), 5098 - ); 4358 + req.extensions_mut().insert(GrpcMethod::new( 4359 + "rockbox.v1alpha1.PlaylistService", 4360 + "InsertDirectory", 4361 + )); 5099 4362 self.inner.unary(req, path, codec).await 5100 4363 } 5101 4364 pub async fn insert_playlist( 5102 4365 &mut self, 5103 4366 request: impl tonic::IntoRequest<super::InsertPlaylistRequest>, 5104 - ) -> std::result::Result< 5105 - tonic::Response<super::InsertPlaylistResponse>, 5106 - tonic::Status, 5107 - > { 5108 - self.inner 5109 - .ready() 5110 - .await 5111 - .map_err(|e| { 5112 - tonic::Status::unknown( 5113 - format!("Service was not ready: {}", e.into()), 5114 - ) 5115 - })?; 4367 + ) -> std::result::Result<tonic::Response<super::InsertPlaylistResponse>, tonic::Status> 4368 + { 4369 + self.inner.ready().await.map_err(|e| { 4370 + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 4371 + })?; 5116 4372 let codec = tonic::codec::ProstCodec::default(); 5117 4373 let path = http::uri::PathAndQuery::from_static( 5118 4374 "/rockbox.v1alpha1.PlaylistService/InsertPlaylist", 5119 4375 ); 5120 4376 let mut req = request.into_request(); 5121 - req.extensions_mut() 5122 - .insert( 5123 - GrpcMethod::new("rockbox.v1alpha1.PlaylistService", "InsertPlaylist"), 5124 - ); 4377 + req.extensions_mut().insert(GrpcMethod::new( 4378 + "rockbox.v1alpha1.PlaylistService", 4379 + "InsertPlaylist", 4380 + )); 5125 4381 self.inner.unary(req, path, codec).await 5126 4382 } 5127 4383 pub async fn insert_album( 5128 4384 &mut self, 5129 4385 request: impl tonic::IntoRequest<super::InsertAlbumRequest>, 5130 - ) -> std::result::Result< 5131 - tonic::Response<super::InsertAlbumResponse>, 5132 - tonic::Status, 5133 - > { 5134 - self.inner 5135 - .ready() 5136 - .await 5137 - .map_err(|e| { 5138 - tonic::Status::unknown( 5139 - format!("Service was not ready: {}", e.into()), 5140 - ) 5141 - })?; 4386 + ) -> std::result::Result<tonic::Response<super::InsertAlbumResponse>, tonic::Status> 4387 + { 4388 + self.inner.ready().await.map_err(|e| { 4389 + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 4390 + })?; 5142 4391 let codec = tonic::codec::ProstCodec::default(); 5143 4392 let path = http::uri::PathAndQuery::from_static( 5144 4393 "/rockbox.v1alpha1.PlaylistService/InsertAlbum", 5145 4394 ); 5146 4395 let mut req = request.into_request(); 5147 - req.extensions_mut() 5148 - .insert( 5149 - GrpcMethod::new("rockbox.v1alpha1.PlaylistService", "InsertAlbum"), 5150 - ); 4396 + req.extensions_mut().insert(GrpcMethod::new( 4397 + "rockbox.v1alpha1.PlaylistService", 4398 + "InsertAlbum", 4399 + )); 5151 4400 self.inner.unary(req, path, codec).await 5152 4401 } 5153 4402 pub async fn insert_artist_tracks( 5154 4403 &mut self, 5155 4404 request: impl tonic::IntoRequest<super::InsertArtistTracksRequest>, 5156 - ) -> std::result::Result< 5157 - tonic::Response<super::InsertArtistTracksResponse>, 5158 - tonic::Status, 5159 - > { 5160 - self.inner 5161 - .ready() 5162 - .await 5163 - .map_err(|e| { 5164 - tonic::Status::unknown( 5165 - format!("Service was not ready: {}", e.into()), 5166 - ) 5167 - })?; 4405 + ) -> std::result::Result<tonic::Response<super::InsertArtistTracksResponse>, tonic::Status> 4406 + { 4407 + self.inner.ready().await.map_err(|e| { 4408 + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 4409 + })?; 5168 4410 let codec = tonic::codec::ProstCodec::default(); 5169 4411 let path = http::uri::PathAndQuery::from_static( 5170 4412 "/rockbox.v1alpha1.PlaylistService/InsertArtistTracks", 5171 4413 ); 5172 4414 let mut req = request.into_request(); 5173 - req.extensions_mut() 5174 - .insert( 5175 - GrpcMethod::new( 5176 - "rockbox.v1alpha1.PlaylistService", 5177 - "InsertArtistTracks", 5178 - ), 5179 - ); 4415 + req.extensions_mut().insert(GrpcMethod::new( 4416 + "rockbox.v1alpha1.PlaylistService", 4417 + "InsertArtistTracks", 4418 + )); 5180 4419 self.inner.unary(req, path, codec).await 5181 4420 } 5182 4421 pub async fn shuffle_playlist( 5183 4422 &mut self, 5184 4423 request: impl tonic::IntoRequest<super::ShufflePlaylistRequest>, 5185 - ) -> std::result::Result< 5186 - tonic::Response<super::ShufflePlaylistResponse>, 5187 - tonic::Status, 5188 - > { 5189 - self.inner 5190 - .ready() 5191 - .await 5192 - .map_err(|e| { 5193 - tonic::Status::unknown( 5194 - format!("Service was not ready: {}", e.into()), 5195 - ) 5196 - })?; 4424 + ) -> std::result::Result<tonic::Response<super::ShufflePlaylistResponse>, tonic::Status> 4425 + { 4426 + self.inner.ready().await.map_err(|e| { 4427 + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 4428 + })?; 5197 4429 let codec = tonic::codec::ProstCodec::default(); 5198 4430 let path = http::uri::PathAndQuery::from_static( 5199 4431 "/rockbox.v1alpha1.PlaylistService/ShufflePlaylist", 5200 4432 ); 5201 4433 let mut req = request.into_request(); 5202 - req.extensions_mut() 5203 - .insert( 5204 - GrpcMethod::new( 5205 - "rockbox.v1alpha1.PlaylistService", 5206 - "ShufflePlaylist", 5207 - ), 5208 - ); 4434 + req.extensions_mut().insert(GrpcMethod::new( 4435 + "rockbox.v1alpha1.PlaylistService", 4436 + "ShufflePlaylist", 4437 + )); 5209 4438 self.inner.unary(req, path, codec).await 5210 4439 } 5211 4440 } ··· 5217 4446 dead_code, 5218 4447 missing_docs, 5219 4448 clippy::wildcard_imports, 5220 - clippy::let_unit_value, 4449 + clippy::let_unit_value 5221 4450 )] 5222 4451 use tonic::codegen::*; 5223 4452 /// Generated trait containing gRPC methods that should be implemented for use with PlaylistServiceServer. ··· 5226 4455 async fn get_current( 5227 4456 &self, 5228 4457 request: tonic::Request<super::GetCurrentRequest>, 5229 - ) -> std::result::Result< 5230 - tonic::Response<super::GetCurrentResponse>, 5231 - tonic::Status, 5232 - >; 4458 + ) -> std::result::Result<tonic::Response<super::GetCurrentResponse>, tonic::Status>; 5233 4459 async fn get_resume_info( 5234 4460 &self, 5235 4461 request: tonic::Request<super::GetResumeInfoRequest>, 5236 - ) -> std::result::Result< 5237 - tonic::Response<super::GetResumeInfoResponse>, 5238 - tonic::Status, 5239 - >; 4462 + ) -> std::result::Result<tonic::Response<super::GetResumeInfoResponse>, tonic::Status>; 5240 4463 async fn get_track_info( 5241 4464 &self, 5242 4465 request: tonic::Request<super::GetTrackInfoRequest>, 5243 - ) -> std::result::Result< 5244 - tonic::Response<super::GetTrackInfoResponse>, 5245 - tonic::Status, 5246 - >; 4466 + ) -> std::result::Result<tonic::Response<super::GetTrackInfoResponse>, tonic::Status>; 5247 4467 async fn get_first_index( 5248 4468 &self, 5249 4469 request: tonic::Request<super::GetFirstIndexRequest>, 5250 - ) -> std::result::Result< 5251 - tonic::Response<super::GetFirstIndexResponse>, 5252 - tonic::Status, 5253 - >; 4470 + ) -> std::result::Result<tonic::Response<super::GetFirstIndexResponse>, tonic::Status>; 5254 4471 async fn get_display_index( 5255 4472 &self, 5256 4473 request: tonic::Request<super::GetDisplayIndexRequest>, 5257 - ) -> std::result::Result< 5258 - tonic::Response<super::GetDisplayIndexResponse>, 5259 - tonic::Status, 5260 - >; 4474 + ) -> std::result::Result<tonic::Response<super::GetDisplayIndexResponse>, tonic::Status>; 5261 4475 async fn amount( 5262 4476 &self, 5263 4477 request: tonic::Request<super::AmountRequest>, ··· 5265 4479 async fn playlist_resume( 5266 4480 &self, 5267 4481 request: tonic::Request<super::PlaylistResumeRequest>, 5268 - ) -> std::result::Result< 5269 - tonic::Response<super::PlaylistResumeResponse>, 5270 - tonic::Status, 5271 - >; 4482 + ) -> std::result::Result<tonic::Response<super::PlaylistResumeResponse>, tonic::Status>; 5272 4483 async fn resume_track( 5273 4484 &self, 5274 4485 request: tonic::Request<super::ResumeTrackRequest>, 5275 - ) -> std::result::Result< 5276 - tonic::Response<super::ResumeTrackResponse>, 5277 - tonic::Status, 5278 - >; 4486 + ) -> std::result::Result<tonic::Response<super::ResumeTrackResponse>, tonic::Status>; 5279 4487 async fn set_modified( 5280 4488 &self, 5281 4489 request: tonic::Request<super::SetModifiedRequest>, 5282 - ) -> std::result::Result< 5283 - tonic::Response<super::SetModifiedResponse>, 5284 - tonic::Status, 5285 - >; 4490 + ) -> std::result::Result<tonic::Response<super::SetModifiedResponse>, tonic::Status>; 5286 4491 async fn start( 5287 4492 &self, 5288 4493 request: tonic::Request<super::StartRequest>, ··· 5294 4499 async fn remove_all_tracks( 5295 4500 &self, 5296 4501 request: tonic::Request<super::RemoveAllTracksRequest>, 5297 - ) -> std::result::Result< 5298 - tonic::Response<super::RemoveAllTracksResponse>, 5299 - tonic::Status, 5300 - >; 4502 + ) -> std::result::Result<tonic::Response<super::RemoveAllTracksResponse>, tonic::Status>; 5301 4503 async fn remove_tracks( 5302 4504 &self, 5303 4505 request: tonic::Request<super::RemoveTracksRequest>, 5304 - ) -> std::result::Result< 5305 - tonic::Response<super::RemoveTracksResponse>, 5306 - tonic::Status, 5307 - >; 4506 + ) -> std::result::Result<tonic::Response<super::RemoveTracksResponse>, tonic::Status>; 5308 4507 async fn create_playlist( 5309 4508 &self, 5310 4509 request: tonic::Request<super::CreatePlaylistRequest>, 5311 - ) -> std::result::Result< 5312 - tonic::Response<super::CreatePlaylistResponse>, 5313 - tonic::Status, 5314 - >; 4510 + ) -> std::result::Result<tonic::Response<super::CreatePlaylistResponse>, tonic::Status>; 5315 4511 async fn insert_tracks( 5316 4512 &self, 5317 4513 request: tonic::Request<super::InsertTracksRequest>, 5318 - ) -> std::result::Result< 5319 - tonic::Response<super::InsertTracksResponse>, 5320 - tonic::Status, 5321 - >; 4514 + ) -> std::result::Result<tonic::Response<super::InsertTracksResponse>, tonic::Status>; 5322 4515 async fn insert_directory( 5323 4516 &self, 5324 4517 request: tonic::Request<super::InsertDirectoryRequest>, 5325 - ) -> std::result::Result< 5326 - tonic::Response<super::InsertDirectoryResponse>, 5327 - tonic::Status, 5328 - >; 4518 + ) -> std::result::Result<tonic::Response<super::InsertDirectoryResponse>, tonic::Status>; 5329 4519 async fn insert_playlist( 5330 4520 &self, 5331 4521 request: tonic::Request<super::InsertPlaylistRequest>, 5332 - ) -> std::result::Result< 5333 - tonic::Response<super::InsertPlaylistResponse>, 5334 - tonic::Status, 5335 - >; 4522 + ) -> std::result::Result<tonic::Response<super::InsertPlaylistResponse>, tonic::Status>; 5336 4523 async fn insert_album( 5337 4524 &self, 5338 4525 request: tonic::Request<super::InsertAlbumRequest>, 5339 - ) -> std::result::Result< 5340 - tonic::Response<super::InsertAlbumResponse>, 5341 - tonic::Status, 5342 - >; 4526 + ) -> std::result::Result<tonic::Response<super::InsertAlbumResponse>, tonic::Status>; 5343 4527 async fn insert_artist_tracks( 5344 4528 &self, 5345 4529 request: tonic::Request<super::InsertArtistTracksRequest>, 5346 - ) -> std::result::Result< 5347 - tonic::Response<super::InsertArtistTracksResponse>, 5348 - tonic::Status, 5349 - >; 4530 + ) -> std::result::Result<tonic::Response<super::InsertArtistTracksResponse>, tonic::Status>; 5350 4531 async fn shuffle_playlist( 5351 4532 &self, 5352 4533 request: tonic::Request<super::ShufflePlaylistRequest>, 5353 - ) -> std::result::Result< 5354 - tonic::Response<super::ShufflePlaylistResponse>, 5355 - tonic::Status, 5356 - >; 4534 + ) -> std::result::Result<tonic::Response<super::ShufflePlaylistResponse>, tonic::Status>; 5357 4535 } 5358 4536 #[derive(Debug)] 5359 4537 pub struct PlaylistServiceServer<T> { ··· 5376 4554 max_encoding_message_size: None, 5377 4555 } 5378 4556 } 5379 - pub fn with_interceptor<F>( 5380 - inner: T, 5381 - interceptor: F, 5382 - ) -> InterceptedService<Self, F> 4557 + pub fn with_interceptor<F>(inner: T, interceptor: F) -> InterceptedService<Self, F> 5383 4558 where 5384 4559 F: tonic::service::Interceptor, 5385 4560 { ··· 5434 4609 "/rockbox.v1alpha1.PlaylistService/GetCurrent" => { 5435 4610 #[allow(non_camel_case_types)] 5436 4611 struct GetCurrentSvc<T: PlaylistService>(pub Arc<T>); 5437 - impl< 5438 - T: PlaylistService, 5439 - > tonic::server::UnaryService<super::GetCurrentRequest> 5440 - for GetCurrentSvc<T> { 4612 + impl<T: PlaylistService> tonic::server::UnaryService<super::GetCurrentRequest> 4613 + for GetCurrentSvc<T> 4614 + { 5441 4615 type Response = super::GetCurrentResponse; 5442 - type Future = BoxFuture< 5443 - tonic::Response<Self::Response>, 5444 - tonic::Status, 5445 - >; 4616 + type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 5446 4617 fn call( 5447 4618 &mut self, 5448 4619 request: tonic::Request<super::GetCurrentRequest>, ··· 5479 4650 "/rockbox.v1alpha1.PlaylistService/GetResumeInfo" => { 5480 4651 #[allow(non_camel_case_types)] 5481 4652 struct GetResumeInfoSvc<T: PlaylistService>(pub Arc<T>); 5482 - impl< 5483 - T: PlaylistService, 5484 - > tonic::server::UnaryService<super::GetResumeInfoRequest> 5485 - for GetResumeInfoSvc<T> { 4653 + impl<T: PlaylistService> 4654 + tonic::server::UnaryService<super::GetResumeInfoRequest> 4655 + for GetResumeInfoSvc<T> 4656 + { 5486 4657 type Response = super::GetResumeInfoResponse; 5487 - type Future = BoxFuture< 5488 - tonic::Response<Self::Response>, 5489 - tonic::Status, 5490 - >; 4658 + type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 5491 4659 fn call( 5492 4660 &mut self, 5493 4661 request: tonic::Request<super::GetResumeInfoRequest>, 5494 4662 ) -> Self::Future { 5495 4663 let inner = Arc::clone(&self.0); 5496 4664 let fut = async move { 5497 - <T as PlaylistService>::get_resume_info(&inner, request) 5498 - .await 4665 + <T as PlaylistService>::get_resume_info(&inner, request).await 5499 4666 }; 5500 4667 Box::pin(fut) 5501 4668 } ··· 5525 4692 "/rockbox.v1alpha1.PlaylistService/GetTrackInfo" => { 5526 4693 #[allow(non_camel_case_types)] 5527 4694 struct GetTrackInfoSvc<T: PlaylistService>(pub Arc<T>); 5528 - impl< 5529 - T: PlaylistService, 5530 - > tonic::server::UnaryService<super::GetTrackInfoRequest> 5531 - for GetTrackInfoSvc<T> { 4695 + impl<T: PlaylistService> tonic::server::UnaryService<super::GetTrackInfoRequest> 4696 + for GetTrackInfoSvc<T> 4697 + { 5532 4698 type Response = super::GetTrackInfoResponse; 5533 - type Future = BoxFuture< 5534 - tonic::Response<Self::Response>, 5535 - tonic::Status, 5536 - >; 4699 + type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 5537 4700 fn call( 5538 4701 &mut self, 5539 4702 request: tonic::Request<super::GetTrackInfoRequest>, 5540 4703 ) -> Self::Future { 5541 4704 let inner = Arc::clone(&self.0); 5542 4705 let fut = async move { 5543 - <T as PlaylistService>::get_track_info(&inner, request) 5544 - .await 4706 + <T as PlaylistService>::get_track_info(&inner, request).await 5545 4707 }; 5546 4708 Box::pin(fut) 5547 4709 } ··· 5571 4733 "/rockbox.v1alpha1.PlaylistService/GetFirstIndex" => { 5572 4734 #[allow(non_camel_case_types)] 5573 4735 struct GetFirstIndexSvc<T: PlaylistService>(pub Arc<T>); 5574 - impl< 5575 - T: PlaylistService, 5576 - > tonic::server::UnaryService<super::GetFirstIndexRequest> 5577 - for GetFirstIndexSvc<T> { 4736 + impl<T: PlaylistService> 4737 + tonic::server::UnaryService<super::GetFirstIndexRequest> 4738 + for GetFirstIndexSvc<T> 4739 + { 5578 4740 type Response = super::GetFirstIndexResponse; 5579 - type Future = BoxFuture< 5580 - tonic::Response<Self::Response>, 5581 - tonic::Status, 5582 - >; 4741 + type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 5583 4742 fn call( 5584 4743 &mut self, 5585 4744 request: tonic::Request<super::GetFirstIndexRequest>, 5586 4745 ) -> Self::Future { 5587 4746 let inner = Arc::clone(&self.0); 5588 4747 let fut = async move { 5589 - <T as PlaylistService>::get_first_index(&inner, request) 5590 - .await 4748 + <T as PlaylistService>::get_first_index(&inner, request).await 5591 4749 }; 5592 4750 Box::pin(fut) 5593 4751 } ··· 5617 4775 "/rockbox.v1alpha1.PlaylistService/GetDisplayIndex" => { 5618 4776 #[allow(non_camel_case_types)] 5619 4777 struct GetDisplayIndexSvc<T: PlaylistService>(pub Arc<T>); 5620 - impl< 5621 - T: PlaylistService, 5622 - > tonic::server::UnaryService<super::GetDisplayIndexRequest> 5623 - for GetDisplayIndexSvc<T> { 4778 + impl<T: PlaylistService> 4779 + tonic::server::UnaryService<super::GetDisplayIndexRequest> 4780 + for GetDisplayIndexSvc<T> 4781 + { 5624 4782 type Response = super::GetDisplayIndexResponse; 5625 - type Future = BoxFuture< 5626 - tonic::Response<Self::Response>, 5627 - tonic::Status, 5628 - >; 4783 + type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 5629 4784 fn call( 5630 4785 &mut self, 5631 4786 request: tonic::Request<super::GetDisplayIndexRequest>, 5632 4787 ) -> Self::Future { 5633 4788 let inner = Arc::clone(&self.0); 5634 4789 let fut = async move { 5635 - <T as PlaylistService>::get_display_index(&inner, request) 5636 - .await 4790 + <T as PlaylistService>::get_display_index(&inner, request).await 5637 4791 }; 5638 4792 Box::pin(fut) 5639 4793 } ··· 5663 4817 "/rockbox.v1alpha1.PlaylistService/Amount" => { 5664 4818 #[allow(non_camel_case_types)] 5665 4819 struct AmountSvc<T: PlaylistService>(pub Arc<T>); 5666 - impl< 5667 - T: PlaylistService, 5668 - > tonic::server::UnaryService<super::AmountRequest> 5669 - for AmountSvc<T> { 4820 + impl<T: PlaylistService> tonic::server::UnaryService<super::AmountRequest> for AmountSvc<T> { 5670 4821 type Response = super::AmountResponse; 5671 - type Future = BoxFuture< 5672 - tonic::Response<Self::Response>, 5673 - tonic::Status, 5674 - >; 4822 + type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 5675 4823 fn call( 5676 4824 &mut self, 5677 4825 request: tonic::Request<super::AmountRequest>, ··· 5708 4856 "/rockbox.v1alpha1.PlaylistService/PlaylistResume" => { 5709 4857 #[allow(non_camel_case_types)] 5710 4858 struct PlaylistResumeSvc<T: PlaylistService>(pub Arc<T>); 5711 - impl< 5712 - T: PlaylistService, 5713 - > tonic::server::UnaryService<super::PlaylistResumeRequest> 5714 - for PlaylistResumeSvc<T> { 4859 + impl<T: PlaylistService> 4860 + tonic::server::UnaryService<super::PlaylistResumeRequest> 4861 + for PlaylistResumeSvc<T> 4862 + { 5715 4863 type Response = super::PlaylistResumeResponse; 5716 - type Future = BoxFuture< 5717 - tonic::Response<Self::Response>, 5718 - tonic::Status, 5719 - >; 4864 + type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 5720 4865 fn call( 5721 4866 &mut self, 5722 4867 request: tonic::Request<super::PlaylistResumeRequest>, 5723 4868 ) -> Self::Future { 5724 4869 let inner = Arc::clone(&self.0); 5725 4870 let fut = async move { 5726 - <T as PlaylistService>::playlist_resume(&inner, request) 5727 - .await 4871 + <T as PlaylistService>::playlist_resume(&inner, request).await 5728 4872 }; 5729 4873 Box::pin(fut) 5730 4874 } ··· 5754 4898 "/rockbox.v1alpha1.PlaylistService/ResumeTrack" => { 5755 4899 #[allow(non_camel_case_types)] 5756 4900 struct ResumeTrackSvc<T: PlaylistService>(pub Arc<T>); 5757 - impl< 5758 - T: PlaylistService, 5759 - > tonic::server::UnaryService<super::ResumeTrackRequest> 5760 - for ResumeTrackSvc<T> { 4901 + impl<T: PlaylistService> tonic::server::UnaryService<super::ResumeTrackRequest> 4902 + for ResumeTrackSvc<T> 4903 + { 5761 4904 type Response = super::ResumeTrackResponse; 5762 - type Future = BoxFuture< 5763 - tonic::Response<Self::Response>, 5764 - tonic::Status, 5765 - >; 4905 + type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 5766 4906 fn call( 5767 4907 &mut self, 5768 4908 request: tonic::Request<super::ResumeTrackRequest>, ··· 5799 4939 "/rockbox.v1alpha1.PlaylistService/SetModified" => { 5800 4940 #[allow(non_camel_case_types)] 5801 4941 struct SetModifiedSvc<T: PlaylistService>(pub Arc<T>); 5802 - impl< 5803 - T: PlaylistService, 5804 - > tonic::server::UnaryService<super::SetModifiedRequest> 5805 - for SetModifiedSvc<T> { 4942 + impl<T: PlaylistService> tonic::server::UnaryService<super::SetModifiedRequest> 4943 + for SetModifiedSvc<T> 4944 + { 5806 4945 type Response = super::SetModifiedResponse; 5807 - type Future = BoxFuture< 5808 - tonic::Response<Self::Response>, 5809 - tonic::Status, 5810 - >; 4946 + type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 5811 4947 fn call( 5812 4948 &mut self, 5813 4949 request: tonic::Request<super::SetModifiedRequest>, ··· 5844 4980 "/rockbox.v1alpha1.PlaylistService/Start" => { 5845 4981 #[allow(non_camel_case_types)] 5846 4982 struct StartSvc<T: PlaylistService>(pub Arc<T>); 5847 - impl< 5848 - T: PlaylistService, 5849 - > tonic::server::UnaryService<super::StartRequest> for StartSvc<T> { 4983 + impl<T: PlaylistService> tonic::server::UnaryService<super::StartRequest> for StartSvc<T> { 5850 4984 type Response = super::StartResponse; 5851 - type Future = BoxFuture< 5852 - tonic::Response<Self::Response>, 5853 - tonic::Status, 5854 - >; 4985 + type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 5855 4986 fn call( 5856 4987 &mut self, 5857 4988 request: tonic::Request<super::StartRequest>, 5858 4989 ) -> Self::Future { 5859 4990 let inner = Arc::clone(&self.0); 5860 - let fut = async move { 5861 - <T as PlaylistService>::start(&inner, request).await 5862 - }; 4991 + let fut = 4992 + async move { <T as PlaylistService>::start(&inner, request).await }; 5863 4993 Box::pin(fut) 5864 4994 } 5865 4995 } ··· 5888 5018 "/rockbox.v1alpha1.PlaylistService/Sync" => { 5889 5019 #[allow(non_camel_case_types)] 5890 5020 struct SyncSvc<T: PlaylistService>(pub Arc<T>); 5891 - impl< 5892 - T: PlaylistService, 5893 - > tonic::server::UnaryService<super::SyncRequest> for SyncSvc<T> { 5021 + impl<T: PlaylistService> tonic::server::UnaryService<super::SyncRequest> for SyncSvc<T> { 5894 5022 type Response = super::SyncResponse; 5895 - type Future = BoxFuture< 5896 - tonic::Response<Self::Response>, 5897 - tonic::Status, 5898 - >; 5023 + type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 5899 5024 fn call( 5900 5025 &mut self, 5901 5026 request: tonic::Request<super::SyncRequest>, 5902 5027 ) -> Self::Future { 5903 5028 let inner = Arc::clone(&self.0); 5904 - let fut = async move { 5905 - <T as PlaylistService>::sync(&inner, request).await 5906 - }; 5029 + let fut = 5030 + async move { <T as PlaylistService>::sync(&inner, request).await }; 5907 5031 Box::pin(fut) 5908 5032 } 5909 5033 } ··· 5932 5056 "/rockbox.v1alpha1.PlaylistService/RemoveAllTracks" => { 5933 5057 #[allow(non_camel_case_types)] 5934 5058 struct RemoveAllTracksSvc<T: PlaylistService>(pub Arc<T>); 5935 - impl< 5936 - T: PlaylistService, 5937 - > tonic::server::UnaryService<super::RemoveAllTracksRequest> 5938 - for RemoveAllTracksSvc<T> { 5059 + impl<T: PlaylistService> 5060 + tonic::server::UnaryService<super::RemoveAllTracksRequest> 5061 + for RemoveAllTracksSvc<T> 5062 + { 5939 5063 type Response = super::RemoveAllTracksResponse; 5940 - type Future = BoxFuture< 5941 - tonic::Response<Self::Response>, 5942 - tonic::Status, 5943 - >; 5064 + type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 5944 5065 fn call( 5945 5066 &mut self, 5946 5067 request: tonic::Request<super::RemoveAllTracksRequest>, 5947 5068 ) -> Self::Future { 5948 5069 let inner = Arc::clone(&self.0); 5949 5070 let fut = async move { 5950 - <T as PlaylistService>::remove_all_tracks(&inner, request) 5951 - .await 5071 + <T as PlaylistService>::remove_all_tracks(&inner, request).await 5952 5072 }; 5953 5073 Box::pin(fut) 5954 5074 } ··· 5978 5098 "/rockbox.v1alpha1.PlaylistService/RemoveTracks" => { 5979 5099 #[allow(non_camel_case_types)] 5980 5100 struct RemoveTracksSvc<T: PlaylistService>(pub Arc<T>); 5981 - impl< 5982 - T: PlaylistService, 5983 - > tonic::server::UnaryService<super::RemoveTracksRequest> 5984 - for RemoveTracksSvc<T> { 5101 + impl<T: PlaylistService> tonic::server::UnaryService<super::RemoveTracksRequest> 5102 + for RemoveTracksSvc<T> 5103 + { 5985 5104 type Response = super::RemoveTracksResponse; 5986 - type Future = BoxFuture< 5987 - tonic::Response<Self::Response>, 5988 - tonic::Status, 5989 - >; 5105 + type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 5990 5106 fn call( 5991 5107 &mut self, 5992 5108 request: tonic::Request<super::RemoveTracksRequest>, ··· 6023 5139 "/rockbox.v1alpha1.PlaylistService/CreatePlaylist" => { 6024 5140 #[allow(non_camel_case_types)] 6025 5141 struct CreatePlaylistSvc<T: PlaylistService>(pub Arc<T>); 6026 - impl< 6027 - T: PlaylistService, 6028 - > tonic::server::UnaryService<super::CreatePlaylistRequest> 6029 - for CreatePlaylistSvc<T> { 5142 + impl<T: PlaylistService> 5143 + tonic::server::UnaryService<super::CreatePlaylistRequest> 5144 + for CreatePlaylistSvc<T> 5145 + { 6030 5146 type Response = super::CreatePlaylistResponse; 6031 - type Future = BoxFuture< 6032 - tonic::Response<Self::Response>, 6033 - tonic::Status, 6034 - >; 5147 + type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 6035 5148 fn call( 6036 5149 &mut self, 6037 5150 request: tonic::Request<super::CreatePlaylistRequest>, 6038 5151 ) -> Self::Future { 6039 5152 let inner = Arc::clone(&self.0); 6040 5153 let fut = async move { 6041 - <T as PlaylistService>::create_playlist(&inner, request) 6042 - .await 5154 + <T as PlaylistService>::create_playlist(&inner, request).await 6043 5155 }; 6044 5156 Box::pin(fut) 6045 5157 } ··· 6069 5181 "/rockbox.v1alpha1.PlaylistService/InsertTracks" => { 6070 5182 #[allow(non_camel_case_types)] 6071 5183 struct InsertTracksSvc<T: PlaylistService>(pub Arc<T>); 6072 - impl< 6073 - T: PlaylistService, 6074 - > tonic::server::UnaryService<super::InsertTracksRequest> 6075 - for InsertTracksSvc<T> { 5184 + impl<T: PlaylistService> tonic::server::UnaryService<super::InsertTracksRequest> 5185 + for InsertTracksSvc<T> 5186 + { 6076 5187 type Response = super::InsertTracksResponse; 6077 - type Future = BoxFuture< 6078 - tonic::Response<Self::Response>, 6079 - tonic::Status, 6080 - >; 5188 + type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 6081 5189 fn call( 6082 5190 &mut self, 6083 5191 request: tonic::Request<super::InsertTracksRequest>, ··· 6114 5222 "/rockbox.v1alpha1.PlaylistService/InsertDirectory" => { 6115 5223 #[allow(non_camel_case_types)] 6116 5224 struct InsertDirectorySvc<T: PlaylistService>(pub Arc<T>); 6117 - impl< 6118 - T: PlaylistService, 6119 - > tonic::server::UnaryService<super::InsertDirectoryRequest> 6120 - for InsertDirectorySvc<T> { 5225 + impl<T: PlaylistService> 5226 + tonic::server::UnaryService<super::InsertDirectoryRequest> 5227 + for InsertDirectorySvc<T> 5228 + { 6121 5229 type Response = super::InsertDirectoryResponse; 6122 - type Future = BoxFuture< 6123 - tonic::Response<Self::Response>, 6124 - tonic::Status, 6125 - >; 5230 + type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 6126 5231 fn call( 6127 5232 &mut self, 6128 5233 request: tonic::Request<super::InsertDirectoryRequest>, 6129 5234 ) -> Self::Future { 6130 5235 let inner = Arc::clone(&self.0); 6131 5236 let fut = async move { 6132 - <T as PlaylistService>::insert_directory(&inner, request) 6133 - .await 5237 + <T as PlaylistService>::insert_directory(&inner, request).await 6134 5238 }; 6135 5239 Box::pin(fut) 6136 5240 } ··· 6160 5264 "/rockbox.v1alpha1.PlaylistService/InsertPlaylist" => { 6161 5265 #[allow(non_camel_case_types)] 6162 5266 struct InsertPlaylistSvc<T: PlaylistService>(pub Arc<T>); 6163 - impl< 6164 - T: PlaylistService, 6165 - > tonic::server::UnaryService<super::InsertPlaylistRequest> 6166 - for InsertPlaylistSvc<T> { 5267 + impl<T: PlaylistService> 5268 + tonic::server::UnaryService<super::InsertPlaylistRequest> 5269 + for InsertPlaylistSvc<T> 5270 + { 6167 5271 type Response = super::InsertPlaylistResponse; 6168 - type Future = BoxFuture< 6169 - tonic::Response<Self::Response>, 6170 - tonic::Status, 6171 - >; 5272 + type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 6172 5273 fn call( 6173 5274 &mut self, 6174 5275 request: tonic::Request<super::InsertPlaylistRequest>, 6175 5276 ) -> Self::Future { 6176 5277 let inner = Arc::clone(&self.0); 6177 5278 let fut = async move { 6178 - <T as PlaylistService>::insert_playlist(&inner, request) 6179 - .await 5279 + <T as PlaylistService>::insert_playlist(&inner, request).await 6180 5280 }; 6181 5281 Box::pin(fut) 6182 5282 } ··· 6206 5306 "/rockbox.v1alpha1.PlaylistService/InsertAlbum" => { 6207 5307 #[allow(non_camel_case_types)] 6208 5308 struct InsertAlbumSvc<T: PlaylistService>(pub Arc<T>); 6209 - impl< 6210 - T: PlaylistService, 6211 - > tonic::server::UnaryService<super::InsertAlbumRequest> 6212 - for InsertAlbumSvc<T> { 5309 + impl<T: PlaylistService> tonic::server::UnaryService<super::InsertAlbumRequest> 5310 + for InsertAlbumSvc<T> 5311 + { 6213 5312 type Response = super::InsertAlbumResponse; 6214 - type Future = BoxFuture< 6215 - tonic::Response<Self::Response>, 6216 - tonic::Status, 6217 - >; 5313 + type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 6218 5314 fn call( 6219 5315 &mut self, 6220 5316 request: tonic::Request<super::InsertAlbumRequest>, ··· 6251 5347 "/rockbox.v1alpha1.PlaylistService/InsertArtistTracks" => { 6252 5348 #[allow(non_camel_case_types)] 6253 5349 struct InsertArtistTracksSvc<T: PlaylistService>(pub Arc<T>); 6254 - impl< 6255 - T: PlaylistService, 6256 - > tonic::server::UnaryService<super::InsertArtistTracksRequest> 6257 - for InsertArtistTracksSvc<T> { 5350 + impl<T: PlaylistService> 5351 + tonic::server::UnaryService<super::InsertArtistTracksRequest> 5352 + for InsertArtistTracksSvc<T> 5353 + { 6258 5354 type Response = super::InsertArtistTracksResponse; 6259 - type Future = BoxFuture< 6260 - tonic::Response<Self::Response>, 6261 - tonic::Status, 6262 - >; 5355 + type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 6263 5356 fn call( 6264 5357 &mut self, 6265 5358 request: tonic::Request<super::InsertArtistTracksRequest>, 6266 5359 ) -> Self::Future { 6267 5360 let inner = Arc::clone(&self.0); 6268 5361 let fut = async move { 6269 - <T as PlaylistService>::insert_artist_tracks( 6270 - &inner, 6271 - request, 6272 - ) 6273 - .await 5362 + <T as PlaylistService>::insert_artist_tracks(&inner, request).await 6274 5363 }; 6275 5364 Box::pin(fut) 6276 5365 } ··· 6300 5389 "/rockbox.v1alpha1.PlaylistService/ShufflePlaylist" => { 6301 5390 #[allow(non_camel_case_types)] 6302 5391 struct ShufflePlaylistSvc<T: PlaylistService>(pub Arc<T>); 6303 - impl< 6304 - T: PlaylistService, 6305 - > tonic::server::UnaryService<super::ShufflePlaylistRequest> 6306 - for ShufflePlaylistSvc<T> { 5392 + impl<T: PlaylistService> 5393 + tonic::server::UnaryService<super::ShufflePlaylistRequest> 5394 + for ShufflePlaylistSvc<T> 5395 + { 6307 5396 type Response = super::ShufflePlaylistResponse; 6308 - type Future = BoxFuture< 6309 - tonic::Response<Self::Response>, 6310 - tonic::Status, 6311 - >; 5397 + type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 6312 5398 fn call( 6313 5399 &mut self, 6314 5400 request: tonic::Request<super::ShufflePlaylistRequest>, 6315 5401 ) -> Self::Future { 6316 5402 let inner = Arc::clone(&self.0); 6317 5403 let fut = async move { 6318 - <T as PlaylistService>::shuffle_playlist(&inner, request) 6319 - .await 5404 + <T as PlaylistService>::shuffle_playlist(&inner, request).await 6320 5405 }; 6321 5406 Box::pin(fut) 6322 5407 } ··· 6343 5428 }; 6344 5429 Box::pin(fut) 6345 5430 } 6346 - _ => { 6347 - Box::pin(async move { 6348 - let mut response = http::Response::new(empty_body()); 6349 - let headers = response.headers_mut(); 6350 - headers 6351 - .insert( 6352 - tonic::Status::GRPC_STATUS, 6353 - (tonic::Code::Unimplemented as i32).into(), 6354 - ); 6355 - headers 6356 - .insert( 6357 - http::header::CONTENT_TYPE, 6358 - tonic::metadata::GRPC_CONTENT_TYPE, 6359 - ); 6360 - Ok(response) 6361 - }) 6362 - } 5431 + _ => Box::pin(async move { 5432 + let mut response = http::Response::new(empty_body()); 5433 + let headers = response.headers_mut(); 5434 + headers.insert( 5435 + tonic::Status::GRPC_STATUS, 5436 + (tonic::Code::Unimplemented as i32).into(), 5437 + ); 5438 + headers.insert( 5439 + http::header::CONTENT_TYPE, 5440 + tonic::metadata::GRPC_CONTENT_TYPE, 5441 + ); 5442 + Ok(response) 5443 + }), 6363 5444 } 6364 5445 } 6365 5446 } ··· 6867 5948 dead_code, 6868 5949 missing_docs, 6869 5950 clippy::wildcard_imports, 6870 - clippy::let_unit_value, 5951 + clippy::let_unit_value 6871 5952 )] 6872 - use tonic::codegen::*; 6873 5953 use tonic::codegen::http::Uri; 5954 + use tonic::codegen::*; 6874 5955 #[derive(Debug, Clone)] 6875 5956 pub struct SettingsServiceClient<T> { 6876 5957 inner: tonic::client::Grpc<T>, ··· 6914 5995 <T as tonic::client::GrpcService<tonic::body::BoxBody>>::ResponseBody, 6915 5996 >, 6916 5997 >, 6917 - <T as tonic::codegen::Service< 6918 - http::Request<tonic::body::BoxBody>, 6919 - >>::Error: Into<StdError> + std::marker::Send + std::marker::Sync, 5998 + <T as tonic::codegen::Service<http::Request<tonic::body::BoxBody>>>::Error: 5999 + Into<StdError> + std::marker::Send + std::marker::Sync, 6920 6000 { 6921 6001 SettingsServiceClient::new(InterceptedService::new(inner, interceptor)) 6922 6002 } ··· 6954 6034 pub async fn get_settings_list( 6955 6035 &mut self, 6956 6036 request: impl tonic::IntoRequest<super::GetSettingsListRequest>, 6957 - ) -> std::result::Result< 6958 - tonic::Response<super::GetSettingsListResponse>, 6959 - tonic::Status, 6960 - > { 6961 - self.inner 6962 - .ready() 6963 - .await 6964 - .map_err(|e| { 6965 - tonic::Status::unknown( 6966 - format!("Service was not ready: {}", e.into()), 6967 - ) 6968 - })?; 6037 + ) -> std::result::Result<tonic::Response<super::GetSettingsListResponse>, tonic::Status> 6038 + { 6039 + self.inner.ready().await.map_err(|e| { 6040 + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 6041 + })?; 6969 6042 let codec = tonic::codec::ProstCodec::default(); 6970 6043 let path = http::uri::PathAndQuery::from_static( 6971 6044 "/rockbox.v1alpha1.SettingsService/GetSettingsList", 6972 6045 ); 6973 6046 let mut req = request.into_request(); 6974 - req.extensions_mut() 6975 - .insert( 6976 - GrpcMethod::new( 6977 - "rockbox.v1alpha1.SettingsService", 6978 - "GetSettingsList", 6979 - ), 6980 - ); 6047 + req.extensions_mut().insert(GrpcMethod::new( 6048 + "rockbox.v1alpha1.SettingsService", 6049 + "GetSettingsList", 6050 + )); 6981 6051 self.inner.unary(req, path, codec).await 6982 6052 } 6983 6053 pub async fn get_global_settings( 6984 6054 &mut self, 6985 6055 request: impl tonic::IntoRequest<super::GetGlobalSettingsRequest>, 6986 - ) -> std::result::Result< 6987 - tonic::Response<super::GetGlobalSettingsResponse>, 6988 - tonic::Status, 6989 - > { 6990 - self.inner 6991 - .ready() 6992 - .await 6993 - .map_err(|e| { 6994 - tonic::Status::unknown( 6995 - format!("Service was not ready: {}", e.into()), 6996 - ) 6997 - })?; 6056 + ) -> std::result::Result<tonic::Response<super::GetGlobalSettingsResponse>, tonic::Status> 6057 + { 6058 + self.inner.ready().await.map_err(|e| { 6059 + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 6060 + })?; 6998 6061 let codec = tonic::codec::ProstCodec::default(); 6999 6062 let path = http::uri::PathAndQuery::from_static( 7000 6063 "/rockbox.v1alpha1.SettingsService/GetGlobalSettings", 7001 6064 ); 7002 6065 let mut req = request.into_request(); 7003 - req.extensions_mut() 7004 - .insert( 7005 - GrpcMethod::new( 7006 - "rockbox.v1alpha1.SettingsService", 7007 - "GetGlobalSettings", 7008 - ), 7009 - ); 6066 + req.extensions_mut().insert(GrpcMethod::new( 6067 + "rockbox.v1alpha1.SettingsService", 6068 + "GetGlobalSettings", 6069 + )); 7010 6070 self.inner.unary(req, path, codec).await 7011 6071 } 7012 6072 pub async fn save_settings( 7013 6073 &mut self, 7014 6074 request: impl tonic::IntoRequest<super::SaveSettingsRequest>, 7015 - ) -> std::result::Result< 7016 - tonic::Response<super::SaveSettingsResponse>, 7017 - tonic::Status, 7018 - > { 7019 - self.inner 7020 - .ready() 7021 - .await 7022 - .map_err(|e| { 7023 - tonic::Status::unknown( 7024 - format!("Service was not ready: {}", e.into()), 7025 - ) 7026 - })?; 6075 + ) -> std::result::Result<tonic::Response<super::SaveSettingsResponse>, tonic::Status> 6076 + { 6077 + self.inner.ready().await.map_err(|e| { 6078 + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 6079 + })?; 7027 6080 let codec = tonic::codec::ProstCodec::default(); 7028 6081 let path = http::uri::PathAndQuery::from_static( 7029 6082 "/rockbox.v1alpha1.SettingsService/SaveSettings", 7030 6083 ); 7031 6084 let mut req = request.into_request(); 7032 - req.extensions_mut() 7033 - .insert( 7034 - GrpcMethod::new("rockbox.v1alpha1.SettingsService", "SaveSettings"), 7035 - ); 6085 + req.extensions_mut().insert(GrpcMethod::new( 6086 + "rockbox.v1alpha1.SettingsService", 6087 + "SaveSettings", 6088 + )); 7036 6089 self.inner.unary(req, path, codec).await 7037 6090 } 7038 6091 } ··· 7044 6097 dead_code, 7045 6098 missing_docs, 7046 6099 clippy::wildcard_imports, 7047 - clippy::let_unit_value, 6100 + clippy::let_unit_value 7048 6101 )] 7049 6102 use tonic::codegen::*; 7050 6103 /// Generated trait containing gRPC methods that should be implemented for use with SettingsServiceServer. ··· 7053 6106 async fn get_settings_list( 7054 6107 &self, 7055 6108 request: tonic::Request<super::GetSettingsListRequest>, 7056 - ) -> std::result::Result< 7057 - tonic::Response<super::GetSettingsListResponse>, 7058 - tonic::Status, 7059 - >; 6109 + ) -> std::result::Result<tonic::Response<super::GetSettingsListResponse>, tonic::Status>; 7060 6110 async fn get_global_settings( 7061 6111 &self, 7062 6112 request: tonic::Request<super::GetGlobalSettingsRequest>, 7063 - ) -> std::result::Result< 7064 - tonic::Response<super::GetGlobalSettingsResponse>, 7065 - tonic::Status, 7066 - >; 6113 + ) -> std::result::Result<tonic::Response<super::GetGlobalSettingsResponse>, tonic::Status>; 7067 6114 async fn save_settings( 7068 6115 &self, 7069 6116 request: tonic::Request<super::SaveSettingsRequest>, 7070 - ) -> std::result::Result< 7071 - tonic::Response<super::SaveSettingsResponse>, 7072 - tonic::Status, 7073 - >; 6117 + ) -> std::result::Result<tonic::Response<super::SaveSettingsResponse>, tonic::Status>; 7074 6118 } 7075 6119 #[derive(Debug)] 7076 6120 pub struct SettingsServiceServer<T> { ··· 7093 6137 max_encoding_message_size: None, 7094 6138 } 7095 6139 } 7096 - pub fn with_interceptor<F>( 7097 - inner: T, 7098 - interceptor: F, 7099 - ) -> InterceptedService<Self, F> 6140 + pub fn with_interceptor<F>(inner: T, interceptor: F) -> InterceptedService<Self, F> 7100 6141 where 7101 6142 F: tonic::service::Interceptor, 7102 6143 { ··· 7151 6192 "/rockbox.v1alpha1.SettingsService/GetSettingsList" => { 7152 6193 #[allow(non_camel_case_types)] 7153 6194 struct GetSettingsListSvc<T: SettingsService>(pub Arc<T>); 7154 - impl< 7155 - T: SettingsService, 7156 - > tonic::server::UnaryService<super::GetSettingsListRequest> 7157 - for GetSettingsListSvc<T> { 6195 + impl<T: SettingsService> 6196 + tonic::server::UnaryService<super::GetSettingsListRequest> 6197 + for GetSettingsListSvc<T> 6198 + { 7158 6199 type Response = super::GetSettingsListResponse; 7159 - type Future = BoxFuture< 7160 - tonic::Response<Self::Response>, 7161 - tonic::Status, 7162 - >; 6200 + type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 7163 6201 fn call( 7164 6202 &mut self, 7165 6203 request: tonic::Request<super::GetSettingsListRequest>, 7166 6204 ) -> Self::Future { 7167 6205 let inner = Arc::clone(&self.0); 7168 6206 let fut = async move { 7169 - <T as SettingsService>::get_settings_list(&inner, request) 7170 - .await 6207 + <T as SettingsService>::get_settings_list(&inner, request).await 7171 6208 }; 7172 6209 Box::pin(fut) 7173 6210 } ··· 7197 6234 "/rockbox.v1alpha1.SettingsService/GetGlobalSettings" => { 7198 6235 #[allow(non_camel_case_types)] 7199 6236 struct GetGlobalSettingsSvc<T: SettingsService>(pub Arc<T>); 7200 - impl< 7201 - T: SettingsService, 7202 - > tonic::server::UnaryService<super::GetGlobalSettingsRequest> 7203 - for GetGlobalSettingsSvc<T> { 6237 + impl<T: SettingsService> 6238 + tonic::server::UnaryService<super::GetGlobalSettingsRequest> 6239 + for GetGlobalSettingsSvc<T> 6240 + { 7204 6241 type Response = super::GetGlobalSettingsResponse; 7205 - type Future = BoxFuture< 7206 - tonic::Response<Self::Response>, 7207 - tonic::Status, 7208 - >; 6242 + type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 7209 6243 fn call( 7210 6244 &mut self, 7211 6245 request: tonic::Request<super::GetGlobalSettingsRequest>, 7212 6246 ) -> Self::Future { 7213 6247 let inner = Arc::clone(&self.0); 7214 6248 let fut = async move { 7215 - <T as SettingsService>::get_global_settings(&inner, request) 7216 - .await 6249 + <T as SettingsService>::get_global_settings(&inner, request).await 7217 6250 }; 7218 6251 Box::pin(fut) 7219 6252 } ··· 7243 6276 "/rockbox.v1alpha1.SettingsService/SaveSettings" => { 7244 6277 #[allow(non_camel_case_types)] 7245 6278 struct SaveSettingsSvc<T: SettingsService>(pub Arc<T>); 7246 - impl< 7247 - T: SettingsService, 7248 - > tonic::server::UnaryService<super::SaveSettingsRequest> 7249 - for SaveSettingsSvc<T> { 6279 + impl<T: SettingsService> tonic::server::UnaryService<super::SaveSettingsRequest> 6280 + for SaveSettingsSvc<T> 6281 + { 7250 6282 type Response = super::SaveSettingsResponse; 7251 - type Future = BoxFuture< 7252 - tonic::Response<Self::Response>, 7253 - tonic::Status, 7254 - >; 6283 + type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 7255 6284 fn call( 7256 6285 &mut self, 7257 6286 request: tonic::Request<super::SaveSettingsRequest>, ··· 7285 6314 }; 7286 6315 Box::pin(fut) 7287 6316 } 7288 - _ => { 7289 - Box::pin(async move { 7290 - let mut response = http::Response::new(empty_body()); 7291 - let headers = response.headers_mut(); 7292 - headers 7293 - .insert( 7294 - tonic::Status::GRPC_STATUS, 7295 - (tonic::Code::Unimplemented as i32).into(), 7296 - ); 7297 - headers 7298 - .insert( 7299 - http::header::CONTENT_TYPE, 7300 - tonic::metadata::GRPC_CONTENT_TYPE, 7301 - ); 7302 - Ok(response) 7303 - }) 7304 - } 6317 + _ => Box::pin(async move { 6318 + let mut response = http::Response::new(empty_body()); 6319 + let headers = response.headers_mut(); 6320 + headers.insert( 6321 + tonic::Status::GRPC_STATUS, 6322 + (tonic::Code::Unimplemented as i32).into(), 6323 + ); 6324 + headers.insert( 6325 + http::header::CONTENT_TYPE, 6326 + tonic::metadata::GRPC_CONTENT_TYPE, 6327 + ); 6328 + Ok(response) 6329 + }), 7305 6330 } 7306 6331 } 7307 6332 } ··· 7459 6484 dead_code, 7460 6485 missing_docs, 7461 6486 clippy::wildcard_imports, 7462 - clippy::let_unit_value, 6487 + clippy::let_unit_value 7463 6488 )] 7464 - use tonic::codegen::*; 7465 6489 use tonic::codegen::http::Uri; 6490 + use tonic::codegen::*; 7466 6491 #[derive(Debug, Clone)] 7467 6492 pub struct SoundServiceClient<T> { 7468 6493 inner: tonic::client::Grpc<T>, ··· 7506 6531 <T as tonic::client::GrpcService<tonic::body::BoxBody>>::ResponseBody, 7507 6532 >, 7508 6533 >, 7509 - <T as tonic::codegen::Service< 7510 - http::Request<tonic::body::BoxBody>, 7511 - >>::Error: Into<StdError> + std::marker::Send + std::marker::Sync, 6534 + <T as tonic::codegen::Service<http::Request<tonic::body::BoxBody>>>::Error: 6535 + Into<StdError> + std::marker::Send + std::marker::Sync, 7512 6536 { 7513 6537 SoundServiceClient::new(InterceptedService::new(inner, interceptor)) 7514 6538 } ··· 7546 6570 pub async fn adjust_volume( 7547 6571 &mut self, 7548 6572 request: impl tonic::IntoRequest<super::AdjustVolumeRequest>, 7549 - ) -> std::result::Result< 7550 - tonic::Response<super::AdjustVolumeResponse>, 7551 - tonic::Status, 7552 - > { 7553 - self.inner 7554 - .ready() 7555 - .await 7556 - .map_err(|e| { 7557 - tonic::Status::unknown( 7558 - format!("Service was not ready: {}", e.into()), 7559 - ) 7560 - })?; 6573 + ) -> std::result::Result<tonic::Response<super::AdjustVolumeResponse>, tonic::Status> 6574 + { 6575 + self.inner.ready().await.map_err(|e| { 6576 + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 6577 + })?; 7561 6578 let codec = tonic::codec::ProstCodec::default(); 7562 - let path = http::uri::PathAndQuery::from_static( 7563 - "/rockbox.v1alpha1.SoundService/AdjustVolume", 7564 - ); 6579 + let path = 6580 + http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.SoundService/AdjustVolume"); 7565 6581 let mut req = request.into_request(); 7566 - req.extensions_mut() 7567 - .insert( 7568 - GrpcMethod::new("rockbox.v1alpha1.SoundService", "AdjustVolume"), 7569 - ); 6582 + req.extensions_mut().insert(GrpcMethod::new( 6583 + "rockbox.v1alpha1.SoundService", 6584 + "AdjustVolume", 6585 + )); 7570 6586 self.inner.unary(req, path, codec).await 7571 6587 } 7572 6588 pub async fn sound_set( 7573 6589 &mut self, 7574 6590 request: impl tonic::IntoRequest<super::SoundSetRequest>, 7575 - ) -> std::result::Result< 7576 - tonic::Response<super::SoundSetResponse>, 7577 - tonic::Status, 7578 - > { 7579 - self.inner 7580 - .ready() 7581 - .await 7582 - .map_err(|e| { 7583 - tonic::Status::unknown( 7584 - format!("Service was not ready: {}", e.into()), 7585 - ) 7586 - })?; 6591 + ) -> std::result::Result<tonic::Response<super::SoundSetResponse>, tonic::Status> { 6592 + self.inner.ready().await.map_err(|e| { 6593 + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 6594 + })?; 7587 6595 let codec = tonic::codec::ProstCodec::default(); 7588 - let path = http::uri::PathAndQuery::from_static( 7589 - "/rockbox.v1alpha1.SoundService/SoundSet", 7590 - ); 6596 + let path = 6597 + http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.SoundService/SoundSet"); 7591 6598 let mut req = request.into_request(); 7592 6599 req.extensions_mut() 7593 6600 .insert(GrpcMethod::new("rockbox.v1alpha1.SoundService", "SoundSet")); ··· 7596 6603 pub async fn sound_current( 7597 6604 &mut self, 7598 6605 request: impl tonic::IntoRequest<super::SoundCurrentRequest>, 7599 - ) -> std::result::Result< 7600 - tonic::Response<super::SoundCurrentResponse>, 7601 - tonic::Status, 7602 - > { 7603 - self.inner 7604 - .ready() 7605 - .await 7606 - .map_err(|e| { 7607 - tonic::Status::unknown( 7608 - format!("Service was not ready: {}", e.into()), 7609 - ) 7610 - })?; 6606 + ) -> std::result::Result<tonic::Response<super::SoundCurrentResponse>, tonic::Status> 6607 + { 6608 + self.inner.ready().await.map_err(|e| { 6609 + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 6610 + })?; 7611 6611 let codec = tonic::codec::ProstCodec::default(); 7612 - let path = http::uri::PathAndQuery::from_static( 7613 - "/rockbox.v1alpha1.SoundService/SoundCurrent", 7614 - ); 6612 + let path = 6613 + http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.SoundService/SoundCurrent"); 7615 6614 let mut req = request.into_request(); 7616 - req.extensions_mut() 7617 - .insert( 7618 - GrpcMethod::new("rockbox.v1alpha1.SoundService", "SoundCurrent"), 7619 - ); 6615 + req.extensions_mut().insert(GrpcMethod::new( 6616 + "rockbox.v1alpha1.SoundService", 6617 + "SoundCurrent", 6618 + )); 7620 6619 self.inner.unary(req, path, codec).await 7621 6620 } 7622 6621 pub async fn sound_default( 7623 6622 &mut self, 7624 6623 request: impl tonic::IntoRequest<super::SoundDefaultRequest>, 7625 - ) -> std::result::Result< 7626 - tonic::Response<super::SoundDefaultResponse>, 7627 - tonic::Status, 7628 - > { 7629 - self.inner 7630 - .ready() 7631 - .await 7632 - .map_err(|e| { 7633 - tonic::Status::unknown( 7634 - format!("Service was not ready: {}", e.into()), 7635 - ) 7636 - })?; 6624 + ) -> std::result::Result<tonic::Response<super::SoundDefaultResponse>, tonic::Status> 6625 + { 6626 + self.inner.ready().await.map_err(|e| { 6627 + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 6628 + })?; 7637 6629 let codec = tonic::codec::ProstCodec::default(); 7638 - let path = http::uri::PathAndQuery::from_static( 7639 - "/rockbox.v1alpha1.SoundService/SoundDefault", 7640 - ); 6630 + let path = 6631 + http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.SoundService/SoundDefault"); 7641 6632 let mut req = request.into_request(); 7642 - req.extensions_mut() 7643 - .insert( 7644 - GrpcMethod::new("rockbox.v1alpha1.SoundService", "SoundDefault"), 7645 - ); 6633 + req.extensions_mut().insert(GrpcMethod::new( 6634 + "rockbox.v1alpha1.SoundService", 6635 + "SoundDefault", 6636 + )); 7646 6637 self.inner.unary(req, path, codec).await 7647 6638 } 7648 6639 pub async fn sound_min( 7649 6640 &mut self, 7650 6641 request: impl tonic::IntoRequest<super::SoundMinRequest>, 7651 - ) -> std::result::Result< 7652 - tonic::Response<super::SoundMinResponse>, 7653 - tonic::Status, 7654 - > { 7655 - self.inner 7656 - .ready() 7657 - .await 7658 - .map_err(|e| { 7659 - tonic::Status::unknown( 7660 - format!("Service was not ready: {}", e.into()), 7661 - ) 7662 - })?; 6642 + ) -> std::result::Result<tonic::Response<super::SoundMinResponse>, tonic::Status> { 6643 + self.inner.ready().await.map_err(|e| { 6644 + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 6645 + })?; 7663 6646 let codec = tonic::codec::ProstCodec::default(); 7664 - let path = http::uri::PathAndQuery::from_static( 7665 - "/rockbox.v1alpha1.SoundService/SoundMin", 7666 - ); 6647 + let path = 6648 + http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.SoundService/SoundMin"); 7667 6649 let mut req = request.into_request(); 7668 6650 req.extensions_mut() 7669 6651 .insert(GrpcMethod::new("rockbox.v1alpha1.SoundService", "SoundMin")); ··· 7672 6654 pub async fn sound_max( 7673 6655 &mut self, 7674 6656 request: impl tonic::IntoRequest<super::SoundMaxRequest>, 7675 - ) -> std::result::Result< 7676 - tonic::Response<super::SoundMaxResponse>, 7677 - tonic::Status, 7678 - > { 7679 - self.inner 7680 - .ready() 7681 - .await 7682 - .map_err(|e| { 7683 - tonic::Status::unknown( 7684 - format!("Service was not ready: {}", e.into()), 7685 - ) 7686 - })?; 6657 + ) -> std::result::Result<tonic::Response<super::SoundMaxResponse>, tonic::Status> { 6658 + self.inner.ready().await.map_err(|e| { 6659 + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 6660 + })?; 7687 6661 let codec = tonic::codec::ProstCodec::default(); 7688 - let path = http::uri::PathAndQuery::from_static( 7689 - "/rockbox.v1alpha1.SoundService/SoundMax", 7690 - ); 6662 + let path = 6663 + http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.SoundService/SoundMax"); 7691 6664 let mut req = request.into_request(); 7692 6665 req.extensions_mut() 7693 6666 .insert(GrpcMethod::new("rockbox.v1alpha1.SoundService", "SoundMax")); ··· 7696 6669 pub async fn sound_unit( 7697 6670 &mut self, 7698 6671 request: impl tonic::IntoRequest<super::SoundUnitRequest>, 7699 - ) -> std::result::Result< 7700 - tonic::Response<super::SoundUnitResponse>, 7701 - tonic::Status, 7702 - > { 7703 - self.inner 7704 - .ready() 7705 - .await 7706 - .map_err(|e| { 7707 - tonic::Status::unknown( 7708 - format!("Service was not ready: {}", e.into()), 7709 - ) 7710 - })?; 6672 + ) -> std::result::Result<tonic::Response<super::SoundUnitResponse>, tonic::Status> { 6673 + self.inner.ready().await.map_err(|e| { 6674 + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 6675 + })?; 7711 6676 let codec = tonic::codec::ProstCodec::default(); 7712 - let path = http::uri::PathAndQuery::from_static( 7713 - "/rockbox.v1alpha1.SoundService/SoundUnit", 7714 - ); 6677 + let path = 6678 + http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.SoundService/SoundUnit"); 7715 6679 let mut req = request.into_request(); 7716 - req.extensions_mut() 7717 - .insert(GrpcMethod::new("rockbox.v1alpha1.SoundService", "SoundUnit")); 6680 + req.extensions_mut().insert(GrpcMethod::new( 6681 + "rockbox.v1alpha1.SoundService", 6682 + "SoundUnit", 6683 + )); 7718 6684 self.inner.unary(req, path, codec).await 7719 6685 } 7720 6686 pub async fn sound_val2_phys( 7721 6687 &mut self, 7722 6688 request: impl tonic::IntoRequest<super::SoundVal2PhysRequest>, 7723 - ) -> std::result::Result< 7724 - tonic::Response<super::SoundVal2PhysResponse>, 7725 - tonic::Status, 7726 - > { 7727 - self.inner 7728 - .ready() 7729 - .await 7730 - .map_err(|e| { 7731 - tonic::Status::unknown( 7732 - format!("Service was not ready: {}", e.into()), 7733 - ) 7734 - })?; 6689 + ) -> std::result::Result<tonic::Response<super::SoundVal2PhysResponse>, tonic::Status> 6690 + { 6691 + self.inner.ready().await.map_err(|e| { 6692 + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 6693 + })?; 7735 6694 let codec = tonic::codec::ProstCodec::default(); 7736 6695 let path = http::uri::PathAndQuery::from_static( 7737 6696 "/rockbox.v1alpha1.SoundService/SoundVal2Phys", 7738 6697 ); 7739 6698 let mut req = request.into_request(); 7740 - req.extensions_mut() 7741 - .insert( 7742 - GrpcMethod::new("rockbox.v1alpha1.SoundService", "SoundVal2Phys"), 7743 - ); 6699 + req.extensions_mut().insert(GrpcMethod::new( 6700 + "rockbox.v1alpha1.SoundService", 6701 + "SoundVal2Phys", 6702 + )); 7744 6703 self.inner.unary(req, path, codec).await 7745 6704 } 7746 6705 pub async fn get_pitch( 7747 6706 &mut self, 7748 6707 request: impl tonic::IntoRequest<super::GetPitchRequest>, 7749 - ) -> std::result::Result< 7750 - tonic::Response<super::GetPitchResponse>, 7751 - tonic::Status, 7752 - > { 7753 - self.inner 7754 - .ready() 7755 - .await 7756 - .map_err(|e| { 7757 - tonic::Status::unknown( 7758 - format!("Service was not ready: {}", e.into()), 7759 - ) 7760 - })?; 6708 + ) -> std::result::Result<tonic::Response<super::GetPitchResponse>, tonic::Status> { 6709 + self.inner.ready().await.map_err(|e| { 6710 + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 6711 + })?; 7761 6712 let codec = tonic::codec::ProstCodec::default(); 7762 - let path = http::uri::PathAndQuery::from_static( 7763 - "/rockbox.v1alpha1.SoundService/GetPitch", 7764 - ); 6713 + let path = 6714 + http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.SoundService/GetPitch"); 7765 6715 let mut req = request.into_request(); 7766 6716 req.extensions_mut() 7767 6717 .insert(GrpcMethod::new("rockbox.v1alpha1.SoundService", "GetPitch")); ··· 7770 6720 pub async fn set_pitch( 7771 6721 &mut self, 7772 6722 request: impl tonic::IntoRequest<super::SetPitchRequest>, 7773 - ) -> std::result::Result< 7774 - tonic::Response<super::SetPitchResponse>, 7775 - tonic::Status, 7776 - > { 7777 - self.inner 7778 - .ready() 7779 - .await 7780 - .map_err(|e| { 7781 - tonic::Status::unknown( 7782 - format!("Service was not ready: {}", e.into()), 7783 - ) 7784 - })?; 6723 + ) -> std::result::Result<tonic::Response<super::SetPitchResponse>, tonic::Status> { 6724 + self.inner.ready().await.map_err(|e| { 6725 + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 6726 + })?; 7785 6727 let codec = tonic::codec::ProstCodec::default(); 7786 - let path = http::uri::PathAndQuery::from_static( 7787 - "/rockbox.v1alpha1.SoundService/SetPitch", 7788 - ); 6728 + let path = 6729 + http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.SoundService/SetPitch"); 7789 6730 let mut req = request.into_request(); 7790 6731 req.extensions_mut() 7791 6732 .insert(GrpcMethod::new("rockbox.v1alpha1.SoundService", "SetPitch")); ··· 7794 6735 pub async fn beep_play( 7795 6736 &mut self, 7796 6737 request: impl tonic::IntoRequest<super::BeepPlayRequest>, 7797 - ) -> std::result::Result< 7798 - tonic::Response<super::BeepPlayResponse>, 7799 - tonic::Status, 7800 - > { 7801 - self.inner 7802 - .ready() 7803 - .await 7804 - .map_err(|e| { 7805 - tonic::Status::unknown( 7806 - format!("Service was not ready: {}", e.into()), 7807 - ) 7808 - })?; 6738 + ) -> std::result::Result<tonic::Response<super::BeepPlayResponse>, tonic::Status> { 6739 + self.inner.ready().await.map_err(|e| { 6740 + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 6741 + })?; 7809 6742 let codec = tonic::codec::ProstCodec::default(); 7810 - let path = http::uri::PathAndQuery::from_static( 7811 - "/rockbox.v1alpha1.SoundService/BeepPlay", 7812 - ); 6743 + let path = 6744 + http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.SoundService/BeepPlay"); 7813 6745 let mut req = request.into_request(); 7814 6746 req.extensions_mut() 7815 6747 .insert(GrpcMethod::new("rockbox.v1alpha1.SoundService", "BeepPlay")); ··· 7818 6750 pub async fn pcmbuf_fade( 7819 6751 &mut self, 7820 6752 request: impl tonic::IntoRequest<super::PcmbufFadeRequest>, 7821 - ) -> std::result::Result< 7822 - tonic::Response<super::PcmbufFadeResponse>, 7823 - tonic::Status, 7824 - > { 7825 - self.inner 7826 - .ready() 7827 - .await 7828 - .map_err(|e| { 7829 - tonic::Status::unknown( 7830 - format!("Service was not ready: {}", e.into()), 7831 - ) 7832 - })?; 6753 + ) -> std::result::Result<tonic::Response<super::PcmbufFadeResponse>, tonic::Status> 6754 + { 6755 + self.inner.ready().await.map_err(|e| { 6756 + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 6757 + })?; 7833 6758 let codec = tonic::codec::ProstCodec::default(); 7834 - let path = http::uri::PathAndQuery::from_static( 7835 - "/rockbox.v1alpha1.SoundService/PcmbufFade", 7836 - ); 6759 + let path = 6760 + http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.SoundService/PcmbufFade"); 7837 6761 let mut req = request.into_request(); 7838 - req.extensions_mut() 7839 - .insert(GrpcMethod::new("rockbox.v1alpha1.SoundService", "PcmbufFade")); 6762 + req.extensions_mut().insert(GrpcMethod::new( 6763 + "rockbox.v1alpha1.SoundService", 6764 + "PcmbufFade", 6765 + )); 7840 6766 self.inner.unary(req, path, codec).await 7841 6767 } 7842 6768 pub async fn pcmbuf_set_low_latency( 7843 6769 &mut self, 7844 6770 request: impl tonic::IntoRequest<super::PcmbufSetLowLatencyRequest>, 7845 - ) -> std::result::Result< 7846 - tonic::Response<super::PcmbufSetLowLatencyResponse>, 7847 - tonic::Status, 7848 - > { 7849 - self.inner 7850 - .ready() 7851 - .await 7852 - .map_err(|e| { 7853 - tonic::Status::unknown( 7854 - format!("Service was not ready: {}", e.into()), 7855 - ) 7856 - })?; 6771 + ) -> std::result::Result<tonic::Response<super::PcmbufSetLowLatencyResponse>, tonic::Status> 6772 + { 6773 + self.inner.ready().await.map_err(|e| { 6774 + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 6775 + })?; 7857 6776 let codec = tonic::codec::ProstCodec::default(); 7858 6777 let path = http::uri::PathAndQuery::from_static( 7859 6778 "/rockbox.v1alpha1.SoundService/PcmbufSetLowLatency", 7860 6779 ); 7861 6780 let mut req = request.into_request(); 7862 - req.extensions_mut() 7863 - .insert( 7864 - GrpcMethod::new( 7865 - "rockbox.v1alpha1.SoundService", 7866 - "PcmbufSetLowLatency", 7867 - ), 7868 - ); 6781 + req.extensions_mut().insert(GrpcMethod::new( 6782 + "rockbox.v1alpha1.SoundService", 6783 + "PcmbufSetLowLatency", 6784 + )); 7869 6785 self.inner.unary(req, path, codec).await 7870 6786 } 7871 6787 pub async fn system_sound_play( 7872 6788 &mut self, 7873 6789 request: impl tonic::IntoRequest<super::SystemSoundPlayRequest>, 7874 - ) -> std::result::Result< 7875 - tonic::Response<super::SystemSoundPlayResponse>, 7876 - tonic::Status, 7877 - > { 7878 - self.inner 7879 - .ready() 7880 - .await 7881 - .map_err(|e| { 7882 - tonic::Status::unknown( 7883 - format!("Service was not ready: {}", e.into()), 7884 - ) 7885 - })?; 6790 + ) -> std::result::Result<tonic::Response<super::SystemSoundPlayResponse>, tonic::Status> 6791 + { 6792 + self.inner.ready().await.map_err(|e| { 6793 + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 6794 + })?; 7886 6795 let codec = tonic::codec::ProstCodec::default(); 7887 6796 let path = http::uri::PathAndQuery::from_static( 7888 6797 "/rockbox.v1alpha1.SoundService/SystemSoundPlay", 7889 6798 ); 7890 6799 let mut req = request.into_request(); 7891 - req.extensions_mut() 7892 - .insert( 7893 - GrpcMethod::new("rockbox.v1alpha1.SoundService", "SystemSoundPlay"), 7894 - ); 6800 + req.extensions_mut().insert(GrpcMethod::new( 6801 + "rockbox.v1alpha1.SoundService", 6802 + "SystemSoundPlay", 6803 + )); 7895 6804 self.inner.unary(req, path, codec).await 7896 6805 } 7897 6806 pub async fn keyclick_click( 7898 6807 &mut self, 7899 6808 request: impl tonic::IntoRequest<super::KeyclickClickRequest>, 7900 - ) -> std::result::Result< 7901 - tonic::Response<super::KeyclickClickResponse>, 7902 - tonic::Status, 7903 - > { 7904 - self.inner 7905 - .ready() 7906 - .await 7907 - .map_err(|e| { 7908 - tonic::Status::unknown( 7909 - format!("Service was not ready: {}", e.into()), 7910 - ) 7911 - })?; 6809 + ) -> std::result::Result<tonic::Response<super::KeyclickClickResponse>, tonic::Status> 6810 + { 6811 + self.inner.ready().await.map_err(|e| { 6812 + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 6813 + })?; 7912 6814 let codec = tonic::codec::ProstCodec::default(); 7913 6815 let path = http::uri::PathAndQuery::from_static( 7914 6816 "/rockbox.v1alpha1.SoundService/KeyclickClick", 7915 6817 ); 7916 6818 let mut req = request.into_request(); 7917 - req.extensions_mut() 7918 - .insert( 7919 - GrpcMethod::new("rockbox.v1alpha1.SoundService", "KeyclickClick"), 7920 - ); 6819 + req.extensions_mut().insert(GrpcMethod::new( 6820 + "rockbox.v1alpha1.SoundService", 6821 + "KeyclickClick", 6822 + )); 7921 6823 self.inner.unary(req, path, codec).await 7922 6824 } 7923 6825 } ··· 7929 6831 dead_code, 7930 6832 missing_docs, 7931 6833 clippy::wildcard_imports, 7932 - clippy::let_unit_value, 6834 + clippy::let_unit_value 7933 6835 )] 7934 6836 use tonic::codegen::*; 7935 6837 /// Generated trait containing gRPC methods that should be implemented for use with SoundServiceServer. ··· 7938 6840 async fn adjust_volume( 7939 6841 &self, 7940 6842 request: tonic::Request<super::AdjustVolumeRequest>, 7941 - ) -> std::result::Result< 7942 - tonic::Response<super::AdjustVolumeResponse>, 7943 - tonic::Status, 7944 - >; 6843 + ) -> std::result::Result<tonic::Response<super::AdjustVolumeResponse>, tonic::Status>; 7945 6844 async fn sound_set( 7946 6845 &self, 7947 6846 request: tonic::Request<super::SoundSetRequest>, 7948 - ) -> std::result::Result< 7949 - tonic::Response<super::SoundSetResponse>, 7950 - tonic::Status, 7951 - >; 6847 + ) -> std::result::Result<tonic::Response<super::SoundSetResponse>, tonic::Status>; 7952 6848 async fn sound_current( 7953 6849 &self, 7954 6850 request: tonic::Request<super::SoundCurrentRequest>, 7955 - ) -> std::result::Result< 7956 - tonic::Response<super::SoundCurrentResponse>, 7957 - tonic::Status, 7958 - >; 6851 + ) -> std::result::Result<tonic::Response<super::SoundCurrentResponse>, tonic::Status>; 7959 6852 async fn sound_default( 7960 6853 &self, 7961 6854 request: tonic::Request<super::SoundDefaultRequest>, 7962 - ) -> std::result::Result< 7963 - tonic::Response<super::SoundDefaultResponse>, 7964 - tonic::Status, 7965 - >; 6855 + ) -> std::result::Result<tonic::Response<super::SoundDefaultResponse>, tonic::Status>; 7966 6856 async fn sound_min( 7967 6857 &self, 7968 6858 request: tonic::Request<super::SoundMinRequest>, 7969 - ) -> std::result::Result< 7970 - tonic::Response<super::SoundMinResponse>, 7971 - tonic::Status, 7972 - >; 6859 + ) -> std::result::Result<tonic::Response<super::SoundMinResponse>, tonic::Status>; 7973 6860 async fn sound_max( 7974 6861 &self, 7975 6862 request: tonic::Request<super::SoundMaxRequest>, 7976 - ) -> std::result::Result< 7977 - tonic::Response<super::SoundMaxResponse>, 7978 - tonic::Status, 7979 - >; 6863 + ) -> std::result::Result<tonic::Response<super::SoundMaxResponse>, tonic::Status>; 7980 6864 async fn sound_unit( 7981 6865 &self, 7982 6866 request: tonic::Request<super::SoundUnitRequest>, 7983 - ) -> std::result::Result< 7984 - tonic::Response<super::SoundUnitResponse>, 7985 - tonic::Status, 7986 - >; 6867 + ) -> std::result::Result<tonic::Response<super::SoundUnitResponse>, tonic::Status>; 7987 6868 async fn sound_val2_phys( 7988 6869 &self, 7989 6870 request: tonic::Request<super::SoundVal2PhysRequest>, 7990 - ) -> std::result::Result< 7991 - tonic::Response<super::SoundVal2PhysResponse>, 7992 - tonic::Status, 7993 - >; 6871 + ) -> std::result::Result<tonic::Response<super::SoundVal2PhysResponse>, tonic::Status>; 7994 6872 async fn get_pitch( 7995 6873 &self, 7996 6874 request: tonic::Request<super::GetPitchRequest>, 7997 - ) -> std::result::Result< 7998 - tonic::Response<super::GetPitchResponse>, 7999 - tonic::Status, 8000 - >; 6875 + ) -> std::result::Result<tonic::Response<super::GetPitchResponse>, tonic::Status>; 8001 6876 async fn set_pitch( 8002 6877 &self, 8003 6878 request: tonic::Request<super::SetPitchRequest>, 8004 - ) -> std::result::Result< 8005 - tonic::Response<super::SetPitchResponse>, 8006 - tonic::Status, 8007 - >; 6879 + ) -> std::result::Result<tonic::Response<super::SetPitchResponse>, tonic::Status>; 8008 6880 async fn beep_play( 8009 6881 &self, 8010 6882 request: tonic::Request<super::BeepPlayRequest>, 8011 - ) -> std::result::Result< 8012 - tonic::Response<super::BeepPlayResponse>, 8013 - tonic::Status, 8014 - >; 6883 + ) -> std::result::Result<tonic::Response<super::BeepPlayResponse>, tonic::Status>; 8015 6884 async fn pcmbuf_fade( 8016 6885 &self, 8017 6886 request: tonic::Request<super::PcmbufFadeRequest>, 8018 - ) -> std::result::Result< 8019 - tonic::Response<super::PcmbufFadeResponse>, 8020 - tonic::Status, 8021 - >; 6887 + ) -> std::result::Result<tonic::Response<super::PcmbufFadeResponse>, tonic::Status>; 8022 6888 async fn pcmbuf_set_low_latency( 8023 6889 &self, 8024 6890 request: tonic::Request<super::PcmbufSetLowLatencyRequest>, 8025 - ) -> std::result::Result< 8026 - tonic::Response<super::PcmbufSetLowLatencyResponse>, 8027 - tonic::Status, 8028 - >; 6891 + ) -> std::result::Result<tonic::Response<super::PcmbufSetLowLatencyResponse>, tonic::Status>; 8029 6892 async fn system_sound_play( 8030 6893 &self, 8031 6894 request: tonic::Request<super::SystemSoundPlayRequest>, 8032 - ) -> std::result::Result< 8033 - tonic::Response<super::SystemSoundPlayResponse>, 8034 - tonic::Status, 8035 - >; 6895 + ) -> std::result::Result<tonic::Response<super::SystemSoundPlayResponse>, tonic::Status>; 8036 6896 async fn keyclick_click( 8037 6897 &self, 8038 6898 request: tonic::Request<super::KeyclickClickRequest>, 8039 - ) -> std::result::Result< 8040 - tonic::Response<super::KeyclickClickResponse>, 8041 - tonic::Status, 8042 - >; 6899 + ) -> std::result::Result<tonic::Response<super::KeyclickClickResponse>, tonic::Status>; 8043 6900 } 8044 6901 #[derive(Debug)] 8045 6902 pub struct SoundServiceServer<T> { ··· 8062 6919 max_encoding_message_size: None, 8063 6920 } 8064 6921 } 8065 - pub fn with_interceptor<F>( 8066 - inner: T, 8067 - interceptor: F, 8068 - ) -> InterceptedService<Self, F> 6922 + pub fn with_interceptor<F>(inner: T, interceptor: F) -> InterceptedService<Self, F> 8069 6923 where 8070 6924 F: tonic::service::Interceptor, 8071 6925 { ··· 8120 6974 "/rockbox.v1alpha1.SoundService/AdjustVolume" => { 8121 6975 #[allow(non_camel_case_types)] 8122 6976 struct AdjustVolumeSvc<T: SoundService>(pub Arc<T>); 8123 - impl< 8124 - T: SoundService, 8125 - > tonic::server::UnaryService<super::AdjustVolumeRequest> 8126 - for AdjustVolumeSvc<T> { 6977 + impl<T: SoundService> tonic::server::UnaryService<super::AdjustVolumeRequest> 6978 + for AdjustVolumeSvc<T> 6979 + { 8127 6980 type Response = super::AdjustVolumeResponse; 8128 - type Future = BoxFuture< 8129 - tonic::Response<Self::Response>, 8130 - tonic::Status, 8131 - >; 6981 + type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 8132 6982 fn call( 8133 6983 &mut self, 8134 6984 request: tonic::Request<super::AdjustVolumeRequest>, ··· 8165 7015 "/rockbox.v1alpha1.SoundService/SoundSet" => { 8166 7016 #[allow(non_camel_case_types)] 8167 7017 struct SoundSetSvc<T: SoundService>(pub Arc<T>); 8168 - impl< 8169 - T: SoundService, 8170 - > tonic::server::UnaryService<super::SoundSetRequest> 8171 - for SoundSetSvc<T> { 7018 + impl<T: SoundService> tonic::server::UnaryService<super::SoundSetRequest> for SoundSetSvc<T> { 8172 7019 type Response = super::SoundSetResponse; 8173 - type Future = BoxFuture< 8174 - tonic::Response<Self::Response>, 8175 - tonic::Status, 8176 - >; 7020 + type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 8177 7021 fn call( 8178 7022 &mut self, 8179 7023 request: tonic::Request<super::SoundSetRequest>, ··· 8210 7054 "/rockbox.v1alpha1.SoundService/SoundCurrent" => { 8211 7055 #[allow(non_camel_case_types)] 8212 7056 struct SoundCurrentSvc<T: SoundService>(pub Arc<T>); 8213 - impl< 8214 - T: SoundService, 8215 - > tonic::server::UnaryService<super::SoundCurrentRequest> 8216 - for SoundCurrentSvc<T> { 7057 + impl<T: SoundService> tonic::server::UnaryService<super::SoundCurrentRequest> 7058 + for SoundCurrentSvc<T> 7059 + { 8217 7060 type Response = super::SoundCurrentResponse; 8218 - type Future = BoxFuture< 8219 - tonic::Response<Self::Response>, 8220 - tonic::Status, 8221 - >; 7061 + type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 8222 7062 fn call( 8223 7063 &mut self, 8224 7064 request: tonic::Request<super::SoundCurrentRequest>, ··· 8255 7095 "/rockbox.v1alpha1.SoundService/SoundDefault" => { 8256 7096 #[allow(non_camel_case_types)] 8257 7097 struct SoundDefaultSvc<T: SoundService>(pub Arc<T>); 8258 - impl< 8259 - T: SoundService, 8260 - > tonic::server::UnaryService<super::SoundDefaultRequest> 8261 - for SoundDefaultSvc<T> { 7098 + impl<T: SoundService> tonic::server::UnaryService<super::SoundDefaultRequest> 7099 + for SoundDefaultSvc<T> 7100 + { 8262 7101 type Response = super::SoundDefaultResponse; 8263 - type Future = BoxFuture< 8264 - tonic::Response<Self::Response>, 8265 - tonic::Status, 8266 - >; 7102 + type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 8267 7103 fn call( 8268 7104 &mut self, 8269 7105 request: tonic::Request<super::SoundDefaultRequest>, ··· 8300 7136 "/rockbox.v1alpha1.SoundService/SoundMin" => { 8301 7137 #[allow(non_camel_case_types)] 8302 7138 struct SoundMinSvc<T: SoundService>(pub Arc<T>); 8303 - impl< 8304 - T: SoundService, 8305 - > tonic::server::UnaryService<super::SoundMinRequest> 8306 - for SoundMinSvc<T> { 7139 + impl<T: SoundService> tonic::server::UnaryService<super::SoundMinRequest> for SoundMinSvc<T> { 8307 7140 type Response = super::SoundMinResponse; 8308 - type Future = BoxFuture< 8309 - tonic::Response<Self::Response>, 8310 - tonic::Status, 8311 - >; 7141 + type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 8312 7142 fn call( 8313 7143 &mut self, 8314 7144 request: tonic::Request<super::SoundMinRequest>, ··· 8345 7175 "/rockbox.v1alpha1.SoundService/SoundMax" => { 8346 7176 #[allow(non_camel_case_types)] 8347 7177 struct SoundMaxSvc<T: SoundService>(pub Arc<T>); 8348 - impl< 8349 - T: SoundService, 8350 - > tonic::server::UnaryService<super::SoundMaxRequest> 8351 - for SoundMaxSvc<T> { 7178 + impl<T: SoundService> tonic::server::UnaryService<super::SoundMaxRequest> for SoundMaxSvc<T> { 8352 7179 type Response = super::SoundMaxResponse; 8353 - type Future = BoxFuture< 8354 - tonic::Response<Self::Response>, 8355 - tonic::Status, 8356 - >; 7180 + type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 8357 7181 fn call( 8358 7182 &mut self, 8359 7183 request: tonic::Request<super::SoundMaxRequest>, ··· 8390 7214 "/rockbox.v1alpha1.SoundService/SoundUnit" => { 8391 7215 #[allow(non_camel_case_types)] 8392 7216 struct SoundUnitSvc<T: SoundService>(pub Arc<T>); 8393 - impl< 8394 - T: SoundService, 8395 - > tonic::server::UnaryService<super::SoundUnitRequest> 8396 - for SoundUnitSvc<T> { 7217 + impl<T: SoundService> tonic::server::UnaryService<super::SoundUnitRequest> for SoundUnitSvc<T> { 8397 7218 type Response = super::SoundUnitResponse; 8398 - type Future = BoxFuture< 8399 - tonic::Response<Self::Response>, 8400 - tonic::Status, 8401 - >; 7219 + type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 8402 7220 fn call( 8403 7221 &mut self, 8404 7222 request: tonic::Request<super::SoundUnitRequest>, ··· 8435 7253 "/rockbox.v1alpha1.SoundService/SoundVal2Phys" => { 8436 7254 #[allow(non_camel_case_types)] 8437 7255 struct SoundVal2PhysSvc<T: SoundService>(pub Arc<T>); 8438 - impl< 8439 - T: SoundService, 8440 - > tonic::server::UnaryService<super::SoundVal2PhysRequest> 8441 - for SoundVal2PhysSvc<T> { 7256 + impl<T: SoundService> tonic::server::UnaryService<super::SoundVal2PhysRequest> 7257 + for SoundVal2PhysSvc<T> 7258 + { 8442 7259 type Response = super::SoundVal2PhysResponse; 8443 - type Future = BoxFuture< 8444 - tonic::Response<Self::Response>, 8445 - tonic::Status, 8446 - >; 7260 + type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 8447 7261 fn call( 8448 7262 &mut self, 8449 7263 request: tonic::Request<super::SoundVal2PhysRequest>, ··· 8480 7294 "/rockbox.v1alpha1.SoundService/GetPitch" => { 8481 7295 #[allow(non_camel_case_types)] 8482 7296 struct GetPitchSvc<T: SoundService>(pub Arc<T>); 8483 - impl< 8484 - T: SoundService, 8485 - > tonic::server::UnaryService<super::GetPitchRequest> 8486 - for GetPitchSvc<T> { 7297 + impl<T: SoundService> tonic::server::UnaryService<super::GetPitchRequest> for GetPitchSvc<T> { 8487 7298 type Response = super::GetPitchResponse; 8488 - type Future = BoxFuture< 8489 - tonic::Response<Self::Response>, 8490 - tonic::Status, 8491 - >; 7299 + type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 8492 7300 fn call( 8493 7301 &mut self, 8494 7302 request: tonic::Request<super::GetPitchRequest>, ··· 8525 7333 "/rockbox.v1alpha1.SoundService/SetPitch" => { 8526 7334 #[allow(non_camel_case_types)] 8527 7335 struct SetPitchSvc<T: SoundService>(pub Arc<T>); 8528 - impl< 8529 - T: SoundService, 8530 - > tonic::server::UnaryService<super::SetPitchRequest> 8531 - for SetPitchSvc<T> { 7336 + impl<T: SoundService> tonic::server::UnaryService<super::SetPitchRequest> for SetPitchSvc<T> { 8532 7337 type Response = super::SetPitchResponse; 8533 - type Future = BoxFuture< 8534 - tonic::Response<Self::Response>, 8535 - tonic::Status, 8536 - >; 7338 + type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 8537 7339 fn call( 8538 7340 &mut self, 8539 7341 request: tonic::Request<super::SetPitchRequest>, ··· 8570 7372 "/rockbox.v1alpha1.SoundService/BeepPlay" => { 8571 7373 #[allow(non_camel_case_types)] 8572 7374 struct BeepPlaySvc<T: SoundService>(pub Arc<T>); 8573 - impl< 8574 - T: SoundService, 8575 - > tonic::server::UnaryService<super::BeepPlayRequest> 8576 - for BeepPlaySvc<T> { 7375 + impl<T: SoundService> tonic::server::UnaryService<super::BeepPlayRequest> for BeepPlaySvc<T> { 8577 7376 type Response = super::BeepPlayResponse; 8578 - type Future = BoxFuture< 8579 - tonic::Response<Self::Response>, 8580 - tonic::Status, 8581 - >; 7377 + type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 8582 7378 fn call( 8583 7379 &mut self, 8584 7380 request: tonic::Request<super::BeepPlayRequest>, ··· 8615 7411 "/rockbox.v1alpha1.SoundService/PcmbufFade" => { 8616 7412 #[allow(non_camel_case_types)] 8617 7413 struct PcmbufFadeSvc<T: SoundService>(pub Arc<T>); 8618 - impl< 8619 - T: SoundService, 8620 - > tonic::server::UnaryService<super::PcmbufFadeRequest> 8621 - for PcmbufFadeSvc<T> { 7414 + impl<T: SoundService> tonic::server::UnaryService<super::PcmbufFadeRequest> for PcmbufFadeSvc<T> { 8622 7415 type Response = super::PcmbufFadeResponse; 8623 - type Future = BoxFuture< 8624 - tonic::Response<Self::Response>, 8625 - tonic::Status, 8626 - >; 7416 + type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 8627 7417 fn call( 8628 7418 &mut self, 8629 7419 request: tonic::Request<super::PcmbufFadeRequest>, ··· 8660 7450 "/rockbox.v1alpha1.SoundService/PcmbufSetLowLatency" => { 8661 7451 #[allow(non_camel_case_types)] 8662 7452 struct PcmbufSetLowLatencySvc<T: SoundService>(pub Arc<T>); 8663 - impl< 8664 - T: SoundService, 8665 - > tonic::server::UnaryService<super::PcmbufSetLowLatencyRequest> 8666 - for PcmbufSetLowLatencySvc<T> { 7453 + impl<T: SoundService> 7454 + tonic::server::UnaryService<super::PcmbufSetLowLatencyRequest> 7455 + for PcmbufSetLowLatencySvc<T> 7456 + { 8667 7457 type Response = super::PcmbufSetLowLatencyResponse; 8668 - type Future = BoxFuture< 8669 - tonic::Response<Self::Response>, 8670 - tonic::Status, 8671 - >; 7458 + type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 8672 7459 fn call( 8673 7460 &mut self, 8674 7461 request: tonic::Request<super::PcmbufSetLowLatencyRequest>, 8675 7462 ) -> Self::Future { 8676 7463 let inner = Arc::clone(&self.0); 8677 7464 let fut = async move { 8678 - <T as SoundService>::pcmbuf_set_low_latency(&inner, request) 8679 - .await 7465 + <T as SoundService>::pcmbuf_set_low_latency(&inner, request).await 8680 7466 }; 8681 7467 Box::pin(fut) 8682 7468 } ··· 8706 7492 "/rockbox.v1alpha1.SoundService/SystemSoundPlay" => { 8707 7493 #[allow(non_camel_case_types)] 8708 7494 struct SystemSoundPlaySvc<T: SoundService>(pub Arc<T>); 8709 - impl< 8710 - T: SoundService, 8711 - > tonic::server::UnaryService<super::SystemSoundPlayRequest> 8712 - for SystemSoundPlaySvc<T> { 7495 + impl<T: SoundService> tonic::server::UnaryService<super::SystemSoundPlayRequest> 7496 + for SystemSoundPlaySvc<T> 7497 + { 8713 7498 type Response = super::SystemSoundPlayResponse; 8714 - type Future = BoxFuture< 8715 - tonic::Response<Self::Response>, 8716 - tonic::Status, 8717 - >; 7499 + type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 8718 7500 fn call( 8719 7501 &mut self, 8720 7502 request: tonic::Request<super::SystemSoundPlayRequest>, 8721 7503 ) -> Self::Future { 8722 7504 let inner = Arc::clone(&self.0); 8723 7505 let fut = async move { 8724 - <T as SoundService>::system_sound_play(&inner, request) 8725 - .await 7506 + <T as SoundService>::system_sound_play(&inner, request).await 8726 7507 }; 8727 7508 Box::pin(fut) 8728 7509 } ··· 8752 7533 "/rockbox.v1alpha1.SoundService/KeyclickClick" => { 8753 7534 #[allow(non_camel_case_types)] 8754 7535 struct KeyclickClickSvc<T: SoundService>(pub Arc<T>); 8755 - impl< 8756 - T: SoundService, 8757 - > tonic::server::UnaryService<super::KeyclickClickRequest> 8758 - for KeyclickClickSvc<T> { 7536 + impl<T: SoundService> tonic::server::UnaryService<super::KeyclickClickRequest> 7537 + for KeyclickClickSvc<T> 7538 + { 8759 7539 type Response = super::KeyclickClickResponse; 8760 - type Future = BoxFuture< 8761 - tonic::Response<Self::Response>, 8762 - tonic::Status, 8763 - >; 7540 + type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 8764 7541 fn call( 8765 7542 &mut self, 8766 7543 request: tonic::Request<super::KeyclickClickRequest>, ··· 8794 7571 }; 8795 7572 Box::pin(fut) 8796 7573 } 8797 - _ => { 8798 - Box::pin(async move { 8799 - let mut response = http::Response::new(empty_body()); 8800 - let headers = response.headers_mut(); 8801 - headers 8802 - .insert( 8803 - tonic::Status::GRPC_STATUS, 8804 - (tonic::Code::Unimplemented as i32).into(), 8805 - ); 8806 - headers 8807 - .insert( 8808 - http::header::CONTENT_TYPE, 8809 - tonic::metadata::GRPC_CONTENT_TYPE, 8810 - ); 8811 - Ok(response) 8812 - }) 8813 - } 7574 + _ => Box::pin(async move { 7575 + let mut response = http::Response::new(empty_body()); 7576 + let headers = response.headers_mut(); 7577 + headers.insert( 7578 + tonic::Status::GRPC_STATUS, 7579 + (tonic::Code::Unimplemented as i32).into(), 7580 + ); 7581 + headers.insert( 7582 + http::header::CONTENT_TYPE, 7583 + tonic::metadata::GRPC_CONTENT_TYPE, 7584 + ); 7585 + Ok(response) 7586 + }), 8814 7587 } 8815 7588 } 8816 7589 } ··· 8871 7644 dead_code, 8872 7645 missing_docs, 8873 7646 clippy::wildcard_imports, 8874 - clippy::let_unit_value, 7647 + clippy::let_unit_value 8875 7648 )] 7649 + use tonic::codegen::http::Uri; 8876 7650 use tonic::codegen::*; 8877 - use tonic::codegen::http::Uri; 8878 7651 #[derive(Debug, Clone)] 8879 7652 pub struct SystemServiceClient<T> { 8880 7653 inner: tonic::client::Grpc<T>, ··· 8918 7691 <T as tonic::client::GrpcService<tonic::body::BoxBody>>::ResponseBody, 8919 7692 >, 8920 7693 >, 8921 - <T as tonic::codegen::Service< 8922 - http::Request<tonic::body::BoxBody>, 8923 - >>::Error: Into<StdError> + std::marker::Send + std::marker::Sync, 7694 + <T as tonic::codegen::Service<http::Request<tonic::body::BoxBody>>>::Error: 7695 + Into<StdError> + std::marker::Send + std::marker::Sync, 8924 7696 { 8925 7697 SystemServiceClient::new(InterceptedService::new(inner, interceptor)) 8926 7698 } ··· 8958 7730 pub async fn get_rockbox_version( 8959 7731 &mut self, 8960 7732 request: impl tonic::IntoRequest<super::GetRockboxVersionRequest>, 8961 - ) -> std::result::Result< 8962 - tonic::Response<super::GetRockboxVersionResponse>, 8963 - tonic::Status, 8964 - > { 8965 - self.inner 8966 - .ready() 8967 - .await 8968 - .map_err(|e| { 8969 - tonic::Status::unknown( 8970 - format!("Service was not ready: {}", e.into()), 8971 - ) 8972 - })?; 7733 + ) -> std::result::Result<tonic::Response<super::GetRockboxVersionResponse>, tonic::Status> 7734 + { 7735 + self.inner.ready().await.map_err(|e| { 7736 + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 7737 + })?; 8973 7738 let codec = tonic::codec::ProstCodec::default(); 8974 7739 let path = http::uri::PathAndQuery::from_static( 8975 7740 "/rockbox.v1alpha1.SystemService/GetRockboxVersion", 8976 7741 ); 8977 7742 let mut req = request.into_request(); 8978 - req.extensions_mut() 8979 - .insert( 8980 - GrpcMethod::new( 8981 - "rockbox.v1alpha1.SystemService", 8982 - "GetRockboxVersion", 8983 - ), 8984 - ); 7743 + req.extensions_mut().insert(GrpcMethod::new( 7744 + "rockbox.v1alpha1.SystemService", 7745 + "GetRockboxVersion", 7746 + )); 8985 7747 self.inner.unary(req, path, codec).await 8986 7748 } 8987 7749 pub async fn get_global_status( 8988 7750 &mut self, 8989 7751 request: impl tonic::IntoRequest<super::GetGlobalStatusRequest>, 8990 - ) -> std::result::Result< 8991 - tonic::Response<super::GetGlobalStatusResponse>, 8992 - tonic::Status, 8993 - > { 8994 - self.inner 8995 - .ready() 8996 - .await 8997 - .map_err(|e| { 8998 - tonic::Status::unknown( 8999 - format!("Service was not ready: {}", e.into()), 9000 - ) 9001 - })?; 7752 + ) -> std::result::Result<tonic::Response<super::GetGlobalStatusResponse>, tonic::Status> 7753 + { 7754 + self.inner.ready().await.map_err(|e| { 7755 + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 7756 + })?; 9002 7757 let codec = tonic::codec::ProstCodec::default(); 9003 7758 let path = http::uri::PathAndQuery::from_static( 9004 7759 "/rockbox.v1alpha1.SystemService/GetGlobalStatus", 9005 7760 ); 9006 7761 let mut req = request.into_request(); 9007 - req.extensions_mut() 9008 - .insert( 9009 - GrpcMethod::new("rockbox.v1alpha1.SystemService", "GetGlobalStatus"), 9010 - ); 7762 + req.extensions_mut().insert(GrpcMethod::new( 7763 + "rockbox.v1alpha1.SystemService", 7764 + "GetGlobalStatus", 7765 + )); 9011 7766 self.inner.unary(req, path, codec).await 9012 7767 } 9013 7768 } ··· 9019 7774 dead_code, 9020 7775 missing_docs, 9021 7776 clippy::wildcard_imports, 9022 - clippy::let_unit_value, 7777 + clippy::let_unit_value 9023 7778 )] 9024 7779 use tonic::codegen::*; 9025 7780 /// Generated trait containing gRPC methods that should be implemented for use with SystemServiceServer. ··· 9028 7783 async fn get_rockbox_version( 9029 7784 &self, 9030 7785 request: tonic::Request<super::GetRockboxVersionRequest>, 9031 - ) -> std::result::Result< 9032 - tonic::Response<super::GetRockboxVersionResponse>, 9033 - tonic::Status, 9034 - >; 7786 + ) -> std::result::Result<tonic::Response<super::GetRockboxVersionResponse>, tonic::Status>; 9035 7787 async fn get_global_status( 9036 7788 &self, 9037 7789 request: tonic::Request<super::GetGlobalStatusRequest>, 9038 - ) -> std::result::Result< 9039 - tonic::Response<super::GetGlobalStatusResponse>, 9040 - tonic::Status, 9041 - >; 7790 + ) -> std::result::Result<tonic::Response<super::GetGlobalStatusResponse>, tonic::Status>; 9042 7791 } 9043 7792 #[derive(Debug)] 9044 7793 pub struct SystemServiceServer<T> { ··· 9061 7810 max_encoding_message_size: None, 9062 7811 } 9063 7812 } 9064 - pub fn with_interceptor<F>( 9065 - inner: T, 9066 - interceptor: F, 9067 - ) -> InterceptedService<Self, F> 7813 + pub fn with_interceptor<F>(inner: T, interceptor: F) -> InterceptedService<Self, F> 9068 7814 where 9069 7815 F: tonic::service::Interceptor, 9070 7816 { ··· 9119 7865 "/rockbox.v1alpha1.SystemService/GetRockboxVersion" => { 9120 7866 #[allow(non_camel_case_types)] 9121 7867 struct GetRockboxVersionSvc<T: SystemService>(pub Arc<T>); 9122 - impl< 9123 - T: SystemService, 9124 - > tonic::server::UnaryService<super::GetRockboxVersionRequest> 9125 - for GetRockboxVersionSvc<T> { 7868 + impl<T: SystemService> 7869 + tonic::server::UnaryService<super::GetRockboxVersionRequest> 7870 + for GetRockboxVersionSvc<T> 7871 + { 9126 7872 type Response = super::GetRockboxVersionResponse; 9127 - type Future = BoxFuture< 9128 - tonic::Response<Self::Response>, 9129 - tonic::Status, 9130 - >; 7873 + type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 9131 7874 fn call( 9132 7875 &mut self, 9133 7876 request: tonic::Request<super::GetRockboxVersionRequest>, 9134 7877 ) -> Self::Future { 9135 7878 let inner = Arc::clone(&self.0); 9136 7879 let fut = async move { 9137 - <T as SystemService>::get_rockbox_version(&inner, request) 9138 - .await 7880 + <T as SystemService>::get_rockbox_version(&inner, request).await 9139 7881 }; 9140 7882 Box::pin(fut) 9141 7883 } ··· 9165 7907 "/rockbox.v1alpha1.SystemService/GetGlobalStatus" => { 9166 7908 #[allow(non_camel_case_types)] 9167 7909 struct GetGlobalStatusSvc<T: SystemService>(pub Arc<T>); 9168 - impl< 9169 - T: SystemService, 9170 - > tonic::server::UnaryService<super::GetGlobalStatusRequest> 9171 - for GetGlobalStatusSvc<T> { 7910 + impl<T: SystemService> 7911 + tonic::server::UnaryService<super::GetGlobalStatusRequest> 7912 + for GetGlobalStatusSvc<T> 7913 + { 9172 7914 type Response = super::GetGlobalStatusResponse; 9173 - type Future = BoxFuture< 9174 - tonic::Response<Self::Response>, 9175 - tonic::Status, 9176 - >; 7915 + type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 9177 7916 fn call( 9178 7917 &mut self, 9179 7918 request: tonic::Request<super::GetGlobalStatusRequest>, 9180 7919 ) -> Self::Future { 9181 7920 let inner = Arc::clone(&self.0); 9182 7921 let fut = async move { 9183 - <T as SystemService>::get_global_status(&inner, request) 9184 - .await 7922 + <T as SystemService>::get_global_status(&inner, request).await 9185 7923 }; 9186 7924 Box::pin(fut) 9187 7925 } ··· 9208 7946 }; 9209 7947 Box::pin(fut) 9210 7948 } 9211 - _ => { 9212 - Box::pin(async move { 9213 - let mut response = http::Response::new(empty_body()); 9214 - let headers = response.headers_mut(); 9215 - headers 9216 - .insert( 9217 - tonic::Status::GRPC_STATUS, 9218 - (tonic::Code::Unimplemented as i32).into(), 9219 - ); 9220 - headers 9221 - .insert( 9222 - http::header::CONTENT_TYPE, 9223 - tonic::metadata::GRPC_CONTENT_TYPE, 9224 - ); 9225 - Ok(response) 9226 - }) 9227 - } 7949 + _ => Box::pin(async move { 7950 + let mut response = http::Response::new(empty_body()); 7951 + let headers = response.headers_mut(); 7952 + headers.insert( 7953 + tonic::Status::GRPC_STATUS, 7954 + (tonic::Code::Unimplemented as i32).into(), 7955 + ); 7956 + headers.insert( 7957 + http::header::CONTENT_TYPE, 7958 + tonic::metadata::GRPC_CONTENT_TYPE, 7959 + ); 7960 + Ok(response) 7961 + }), 9228 7962 } 9229 7963 } 9230 7964 }
+1210 -2442
gtk/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 } ··· 542 519 dead_code, 543 520 missing_docs, 544 521 clippy::wildcard_imports, 545 - clippy::let_unit_value, 522 + clippy::let_unit_value 546 523 )] 547 - use tonic::codegen::*; 548 524 use tonic::codegen::http::Uri; 525 + use tonic::codegen::*; 549 526 #[derive(Debug, Clone)] 550 527 pub struct LibraryServiceClient<T> { 551 528 inner: tonic::client::Grpc<T>, ··· 589 566 <T as tonic::client::GrpcService<tonic::body::BoxBody>>::ResponseBody, 590 567 >, 591 568 >, 592 - <T as tonic::codegen::Service< 593 - http::Request<tonic::body::BoxBody>, 594 - >>::Error: Into<StdError> + std::marker::Send + std::marker::Sync, 569 + <T as tonic::codegen::Service<http::Request<tonic::body::BoxBody>>>::Error: 570 + Into<StdError> + std::marker::Send + std::marker::Sync, 595 571 { 596 572 LibraryServiceClient::new(InterceptedService::new(inner, interceptor)) 597 573 } ··· 629 605 pub async fn get_albums( 630 606 &mut self, 631 607 request: impl tonic::IntoRequest<super::GetAlbumsRequest>, 632 - ) -> std::result::Result< 633 - tonic::Response<super::GetAlbumsResponse>, 634 - tonic::Status, 635 - > { 636 - self.inner 637 - .ready() 638 - .await 639 - .map_err(|e| { 640 - tonic::Status::unknown( 641 - format!("Service was not ready: {}", e.into()), 642 - ) 643 - })?; 608 + ) -> std::result::Result<tonic::Response<super::GetAlbumsResponse>, tonic::Status> { 609 + self.inner.ready().await.map_err(|e| { 610 + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 611 + })?; 644 612 let codec = tonic::codec::ProstCodec::default(); 645 - let path = http::uri::PathAndQuery::from_static( 646 - "/rockbox.v1alpha1.LibraryService/GetAlbums", 647 - ); 613 + let path = 614 + http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.LibraryService/GetAlbums"); 648 615 let mut req = request.into_request(); 649 - req.extensions_mut() 650 - .insert(GrpcMethod::new("rockbox.v1alpha1.LibraryService", "GetAlbums")); 616 + req.extensions_mut().insert(GrpcMethod::new( 617 + "rockbox.v1alpha1.LibraryService", 618 + "GetAlbums", 619 + )); 651 620 self.inner.unary(req, path, codec).await 652 621 } 653 622 pub async fn get_artists( 654 623 &mut self, 655 624 request: impl tonic::IntoRequest<super::GetArtistsRequest>, 656 - ) -> std::result::Result< 657 - tonic::Response<super::GetArtistsResponse>, 658 - tonic::Status, 659 - > { 660 - self.inner 661 - .ready() 662 - .await 663 - .map_err(|e| { 664 - tonic::Status::unknown( 665 - format!("Service was not ready: {}", e.into()), 666 - ) 667 - })?; 625 + ) -> std::result::Result<tonic::Response<super::GetArtistsResponse>, tonic::Status> 626 + { 627 + self.inner.ready().await.map_err(|e| { 628 + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 629 + })?; 668 630 let codec = tonic::codec::ProstCodec::default(); 669 - let path = http::uri::PathAndQuery::from_static( 670 - "/rockbox.v1alpha1.LibraryService/GetArtists", 671 - ); 631 + let path = 632 + http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.LibraryService/GetArtists"); 672 633 let mut req = request.into_request(); 673 - req.extensions_mut() 674 - .insert( 675 - GrpcMethod::new("rockbox.v1alpha1.LibraryService", "GetArtists"), 676 - ); 634 + req.extensions_mut().insert(GrpcMethod::new( 635 + "rockbox.v1alpha1.LibraryService", 636 + "GetArtists", 637 + )); 677 638 self.inner.unary(req, path, codec).await 678 639 } 679 640 pub async fn get_tracks( 680 641 &mut self, 681 642 request: impl tonic::IntoRequest<super::GetTracksRequest>, 682 - ) -> std::result::Result< 683 - tonic::Response<super::GetTracksResponse>, 684 - tonic::Status, 685 - > { 686 - self.inner 687 - .ready() 688 - .await 689 - .map_err(|e| { 690 - tonic::Status::unknown( 691 - format!("Service was not ready: {}", e.into()), 692 - ) 693 - })?; 643 + ) -> std::result::Result<tonic::Response<super::GetTracksResponse>, tonic::Status> { 644 + self.inner.ready().await.map_err(|e| { 645 + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 646 + })?; 694 647 let codec = tonic::codec::ProstCodec::default(); 695 - let path = http::uri::PathAndQuery::from_static( 696 - "/rockbox.v1alpha1.LibraryService/GetTracks", 697 - ); 648 + let path = 649 + http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.LibraryService/GetTracks"); 698 650 let mut req = request.into_request(); 699 - req.extensions_mut() 700 - .insert(GrpcMethod::new("rockbox.v1alpha1.LibraryService", "GetTracks")); 651 + req.extensions_mut().insert(GrpcMethod::new( 652 + "rockbox.v1alpha1.LibraryService", 653 + "GetTracks", 654 + )); 701 655 self.inner.unary(req, path, codec).await 702 656 } 703 657 pub async fn get_album( 704 658 &mut self, 705 659 request: impl tonic::IntoRequest<super::GetAlbumRequest>, 706 - ) -> std::result::Result< 707 - tonic::Response<super::GetAlbumResponse>, 708 - tonic::Status, 709 - > { 710 - self.inner 711 - .ready() 712 - .await 713 - .map_err(|e| { 714 - tonic::Status::unknown( 715 - format!("Service was not ready: {}", e.into()), 716 - ) 717 - })?; 660 + ) -> std::result::Result<tonic::Response<super::GetAlbumResponse>, tonic::Status> { 661 + self.inner.ready().await.map_err(|e| { 662 + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 663 + })?; 718 664 let codec = tonic::codec::ProstCodec::default(); 719 - let path = http::uri::PathAndQuery::from_static( 720 - "/rockbox.v1alpha1.LibraryService/GetAlbum", 721 - ); 665 + let path = 666 + http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.LibraryService/GetAlbum"); 722 667 let mut req = request.into_request(); 723 - req.extensions_mut() 724 - .insert(GrpcMethod::new("rockbox.v1alpha1.LibraryService", "GetAlbum")); 668 + req.extensions_mut().insert(GrpcMethod::new( 669 + "rockbox.v1alpha1.LibraryService", 670 + "GetAlbum", 671 + )); 725 672 self.inner.unary(req, path, codec).await 726 673 } 727 674 pub async fn get_artist( 728 675 &mut self, 729 676 request: impl tonic::IntoRequest<super::GetArtistRequest>, 730 - ) -> std::result::Result< 731 - tonic::Response<super::GetArtistResponse>, 732 - tonic::Status, 733 - > { 734 - self.inner 735 - .ready() 736 - .await 737 - .map_err(|e| { 738 - tonic::Status::unknown( 739 - format!("Service was not ready: {}", e.into()), 740 - ) 741 - })?; 677 + ) -> std::result::Result<tonic::Response<super::GetArtistResponse>, tonic::Status> { 678 + self.inner.ready().await.map_err(|e| { 679 + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 680 + })?; 742 681 let codec = tonic::codec::ProstCodec::default(); 743 - let path = http::uri::PathAndQuery::from_static( 744 - "/rockbox.v1alpha1.LibraryService/GetArtist", 745 - ); 682 + let path = 683 + http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.LibraryService/GetArtist"); 746 684 let mut req = request.into_request(); 747 - req.extensions_mut() 748 - .insert(GrpcMethod::new("rockbox.v1alpha1.LibraryService", "GetArtist")); 685 + req.extensions_mut().insert(GrpcMethod::new( 686 + "rockbox.v1alpha1.LibraryService", 687 + "GetArtist", 688 + )); 749 689 self.inner.unary(req, path, codec).await 750 690 } 751 691 pub async fn get_track( 752 692 &mut self, 753 693 request: impl tonic::IntoRequest<super::GetTrackRequest>, 754 - ) -> std::result::Result< 755 - tonic::Response<super::GetTrackResponse>, 756 - tonic::Status, 757 - > { 758 - self.inner 759 - .ready() 760 - .await 761 - .map_err(|e| { 762 - tonic::Status::unknown( 763 - format!("Service was not ready: {}", e.into()), 764 - ) 765 - })?; 694 + ) -> std::result::Result<tonic::Response<super::GetTrackResponse>, tonic::Status> { 695 + self.inner.ready().await.map_err(|e| { 696 + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 697 + })?; 766 698 let codec = tonic::codec::ProstCodec::default(); 767 - let path = http::uri::PathAndQuery::from_static( 768 - "/rockbox.v1alpha1.LibraryService/GetTrack", 769 - ); 699 + let path = 700 + http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.LibraryService/GetTrack"); 770 701 let mut req = request.into_request(); 771 - req.extensions_mut() 772 - .insert(GrpcMethod::new("rockbox.v1alpha1.LibraryService", "GetTrack")); 702 + req.extensions_mut().insert(GrpcMethod::new( 703 + "rockbox.v1alpha1.LibraryService", 704 + "GetTrack", 705 + )); 773 706 self.inner.unary(req, path, codec).await 774 707 } 775 708 pub async fn like_track( 776 709 &mut self, 777 710 request: impl tonic::IntoRequest<super::LikeTrackRequest>, 778 - ) -> std::result::Result< 779 - tonic::Response<super::LikeTrackResponse>, 780 - tonic::Status, 781 - > { 782 - self.inner 783 - .ready() 784 - .await 785 - .map_err(|e| { 786 - tonic::Status::unknown( 787 - format!("Service was not ready: {}", e.into()), 788 - ) 789 - })?; 711 + ) -> std::result::Result<tonic::Response<super::LikeTrackResponse>, tonic::Status> { 712 + self.inner.ready().await.map_err(|e| { 713 + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 714 + })?; 790 715 let codec = tonic::codec::ProstCodec::default(); 791 - let path = http::uri::PathAndQuery::from_static( 792 - "/rockbox.v1alpha1.LibraryService/LikeTrack", 793 - ); 716 + let path = 717 + http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.LibraryService/LikeTrack"); 794 718 let mut req = request.into_request(); 795 - req.extensions_mut() 796 - .insert(GrpcMethod::new("rockbox.v1alpha1.LibraryService", "LikeTrack")); 719 + req.extensions_mut().insert(GrpcMethod::new( 720 + "rockbox.v1alpha1.LibraryService", 721 + "LikeTrack", 722 + )); 797 723 self.inner.unary(req, path, codec).await 798 724 } 799 725 pub async fn unlike_track( 800 726 &mut self, 801 727 request: impl tonic::IntoRequest<super::UnlikeTrackRequest>, 802 - ) -> std::result::Result< 803 - tonic::Response<super::UnlikeTrackResponse>, 804 - tonic::Status, 805 - > { 806 - self.inner 807 - .ready() 808 - .await 809 - .map_err(|e| { 810 - tonic::Status::unknown( 811 - format!("Service was not ready: {}", e.into()), 812 - ) 813 - })?; 728 + ) -> std::result::Result<tonic::Response<super::UnlikeTrackResponse>, tonic::Status> 729 + { 730 + self.inner.ready().await.map_err(|e| { 731 + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 732 + })?; 814 733 let codec = tonic::codec::ProstCodec::default(); 815 734 let path = http::uri::PathAndQuery::from_static( 816 735 "/rockbox.v1alpha1.LibraryService/UnlikeTrack", 817 736 ); 818 737 let mut req = request.into_request(); 819 - req.extensions_mut() 820 - .insert( 821 - GrpcMethod::new("rockbox.v1alpha1.LibraryService", "UnlikeTrack"), 822 - ); 738 + req.extensions_mut().insert(GrpcMethod::new( 739 + "rockbox.v1alpha1.LibraryService", 740 + "UnlikeTrack", 741 + )); 823 742 self.inner.unary(req, path, codec).await 824 743 } 825 744 pub async fn like_album( 826 745 &mut self, 827 746 request: impl tonic::IntoRequest<super::LikeAlbumRequest>, 828 - ) -> std::result::Result< 829 - tonic::Response<super::LikeAlbumResponse>, 830 - tonic::Status, 831 - > { 832 - self.inner 833 - .ready() 834 - .await 835 - .map_err(|e| { 836 - tonic::Status::unknown( 837 - format!("Service was not ready: {}", e.into()), 838 - ) 839 - })?; 747 + ) -> std::result::Result<tonic::Response<super::LikeAlbumResponse>, tonic::Status> { 748 + self.inner.ready().await.map_err(|e| { 749 + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 750 + })?; 840 751 let codec = tonic::codec::ProstCodec::default(); 841 - let path = http::uri::PathAndQuery::from_static( 842 - "/rockbox.v1alpha1.LibraryService/LikeAlbum", 843 - ); 752 + let path = 753 + http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.LibraryService/LikeAlbum"); 844 754 let mut req = request.into_request(); 845 - req.extensions_mut() 846 - .insert(GrpcMethod::new("rockbox.v1alpha1.LibraryService", "LikeAlbum")); 755 + req.extensions_mut().insert(GrpcMethod::new( 756 + "rockbox.v1alpha1.LibraryService", 757 + "LikeAlbum", 758 + )); 847 759 self.inner.unary(req, path, codec).await 848 760 } 849 761 pub async fn unlike_album( 850 762 &mut self, 851 763 request: impl tonic::IntoRequest<super::UnlikeAlbumRequest>, 852 - ) -> std::result::Result< 853 - tonic::Response<super::UnlikeAlbumResponse>, 854 - tonic::Status, 855 - > { 856 - self.inner 857 - .ready() 858 - .await 859 - .map_err(|e| { 860 - tonic::Status::unknown( 861 - format!("Service was not ready: {}", e.into()), 862 - ) 863 - })?; 764 + ) -> std::result::Result<tonic::Response<super::UnlikeAlbumResponse>, tonic::Status> 765 + { 766 + self.inner.ready().await.map_err(|e| { 767 + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 768 + })?; 864 769 let codec = tonic::codec::ProstCodec::default(); 865 770 let path = http::uri::PathAndQuery::from_static( 866 771 "/rockbox.v1alpha1.LibraryService/UnlikeAlbum", 867 772 ); 868 773 let mut req = request.into_request(); 869 - req.extensions_mut() 870 - .insert( 871 - GrpcMethod::new("rockbox.v1alpha1.LibraryService", "UnlikeAlbum"), 872 - ); 774 + req.extensions_mut().insert(GrpcMethod::new( 775 + "rockbox.v1alpha1.LibraryService", 776 + "UnlikeAlbum", 777 + )); 873 778 self.inner.unary(req, path, codec).await 874 779 } 875 780 pub async fn get_liked_tracks( 876 781 &mut self, 877 782 request: impl tonic::IntoRequest<super::GetLikedTracksRequest>, 878 - ) -> std::result::Result< 879 - tonic::Response<super::GetLikedTracksResponse>, 880 - tonic::Status, 881 - > { 882 - self.inner 883 - .ready() 884 - .await 885 - .map_err(|e| { 886 - tonic::Status::unknown( 887 - format!("Service was not ready: {}", e.into()), 888 - ) 889 - })?; 783 + ) -> std::result::Result<tonic::Response<super::GetLikedTracksResponse>, tonic::Status> 784 + { 785 + self.inner.ready().await.map_err(|e| { 786 + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 787 + })?; 890 788 let codec = tonic::codec::ProstCodec::default(); 891 789 let path = http::uri::PathAndQuery::from_static( 892 790 "/rockbox.v1alpha1.LibraryService/GetLikedTracks", 893 791 ); 894 792 let mut req = request.into_request(); 895 - req.extensions_mut() 896 - .insert( 897 - GrpcMethod::new("rockbox.v1alpha1.LibraryService", "GetLikedTracks"), 898 - ); 793 + req.extensions_mut().insert(GrpcMethod::new( 794 + "rockbox.v1alpha1.LibraryService", 795 + "GetLikedTracks", 796 + )); 899 797 self.inner.unary(req, path, codec).await 900 798 } 901 799 pub async fn get_liked_albums( 902 800 &mut self, 903 801 request: impl tonic::IntoRequest<super::GetLikedAlbumsRequest>, 904 - ) -> std::result::Result< 905 - tonic::Response<super::GetLikedAlbumsResponse>, 906 - tonic::Status, 907 - > { 908 - self.inner 909 - .ready() 910 - .await 911 - .map_err(|e| { 912 - tonic::Status::unknown( 913 - format!("Service was not ready: {}", e.into()), 914 - ) 915 - })?; 802 + ) -> std::result::Result<tonic::Response<super::GetLikedAlbumsResponse>, tonic::Status> 803 + { 804 + self.inner.ready().await.map_err(|e| { 805 + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 806 + })?; 916 807 let codec = tonic::codec::ProstCodec::default(); 917 808 let path = http::uri::PathAndQuery::from_static( 918 809 "/rockbox.v1alpha1.LibraryService/GetLikedAlbums", 919 810 ); 920 811 let mut req = request.into_request(); 921 - req.extensions_mut() 922 - .insert( 923 - GrpcMethod::new("rockbox.v1alpha1.LibraryService", "GetLikedAlbums"), 924 - ); 812 + req.extensions_mut().insert(GrpcMethod::new( 813 + "rockbox.v1alpha1.LibraryService", 814 + "GetLikedAlbums", 815 + )); 925 816 self.inner.unary(req, path, codec).await 926 817 } 927 818 pub async fn scan_library( 928 819 &mut self, 929 820 request: impl tonic::IntoRequest<super::ScanLibraryRequest>, 930 - ) -> std::result::Result< 931 - tonic::Response<super::ScanLibraryResponse>, 932 - tonic::Status, 933 - > { 934 - self.inner 935 - .ready() 936 - .await 937 - .map_err(|e| { 938 - tonic::Status::unknown( 939 - format!("Service was not ready: {}", e.into()), 940 - ) 941 - })?; 821 + ) -> std::result::Result<tonic::Response<super::ScanLibraryResponse>, tonic::Status> 822 + { 823 + self.inner.ready().await.map_err(|e| { 824 + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 825 + })?; 942 826 let codec = tonic::codec::ProstCodec::default(); 943 827 let path = http::uri::PathAndQuery::from_static( 944 828 "/rockbox.v1alpha1.LibraryService/ScanLibrary", 945 829 ); 946 830 let mut req = request.into_request(); 947 - req.extensions_mut() 948 - .insert( 949 - GrpcMethod::new("rockbox.v1alpha1.LibraryService", "ScanLibrary"), 950 - ); 831 + req.extensions_mut().insert(GrpcMethod::new( 832 + "rockbox.v1alpha1.LibraryService", 833 + "ScanLibrary", 834 + )); 951 835 self.inner.unary(req, path, codec).await 952 836 } 953 837 pub async fn search( 954 838 &mut self, 955 839 request: impl tonic::IntoRequest<super::SearchRequest>, 956 840 ) -> std::result::Result<tonic::Response<super::SearchResponse>, tonic::Status> { 957 - self.inner 958 - .ready() 959 - .await 960 - .map_err(|e| { 961 - tonic::Status::unknown( 962 - format!("Service was not ready: {}", e.into()), 963 - ) 964 - })?; 841 + self.inner.ready().await.map_err(|e| { 842 + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 843 + })?; 965 844 let codec = tonic::codec::ProstCodec::default(); 966 - let path = http::uri::PathAndQuery::from_static( 967 - "/rockbox.v1alpha1.LibraryService/Search", 968 - ); 845 + let path = 846 + http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.LibraryService/Search"); 969 847 let mut req = request.into_request(); 970 848 req.extensions_mut() 971 849 .insert(GrpcMethod::new("rockbox.v1alpha1.LibraryService", "Search")); ··· 980 858 dead_code, 981 859 missing_docs, 982 860 clippy::wildcard_imports, 983 - clippy::let_unit_value, 861 + clippy::let_unit_value 984 862 )] 985 863 use tonic::codegen::*; 986 864 /// Generated trait containing gRPC methods that should be implemented for use with LibraryServiceServer. ··· 989 867 async fn get_albums( 990 868 &self, 991 869 request: tonic::Request<super::GetAlbumsRequest>, 992 - ) -> std::result::Result< 993 - tonic::Response<super::GetAlbumsResponse>, 994 - tonic::Status, 995 - >; 870 + ) -> std::result::Result<tonic::Response<super::GetAlbumsResponse>, tonic::Status>; 996 871 async fn get_artists( 997 872 &self, 998 873 request: tonic::Request<super::GetArtistsRequest>, 999 - ) -> std::result::Result< 1000 - tonic::Response<super::GetArtistsResponse>, 1001 - tonic::Status, 1002 - >; 874 + ) -> std::result::Result<tonic::Response<super::GetArtistsResponse>, tonic::Status>; 1003 875 async fn get_tracks( 1004 876 &self, 1005 877 request: tonic::Request<super::GetTracksRequest>, 1006 - ) -> std::result::Result< 1007 - tonic::Response<super::GetTracksResponse>, 1008 - tonic::Status, 1009 - >; 878 + ) -> std::result::Result<tonic::Response<super::GetTracksResponse>, tonic::Status>; 1010 879 async fn get_album( 1011 880 &self, 1012 881 request: tonic::Request<super::GetAlbumRequest>, 1013 - ) -> std::result::Result< 1014 - tonic::Response<super::GetAlbumResponse>, 1015 - tonic::Status, 1016 - >; 882 + ) -> std::result::Result<tonic::Response<super::GetAlbumResponse>, tonic::Status>; 1017 883 async fn get_artist( 1018 884 &self, 1019 885 request: tonic::Request<super::GetArtistRequest>, 1020 - ) -> std::result::Result< 1021 - tonic::Response<super::GetArtistResponse>, 1022 - tonic::Status, 1023 - >; 886 + ) -> std::result::Result<tonic::Response<super::GetArtistResponse>, tonic::Status>; 1024 887 async fn get_track( 1025 888 &self, 1026 889 request: tonic::Request<super::GetTrackRequest>, 1027 - ) -> std::result::Result< 1028 - tonic::Response<super::GetTrackResponse>, 1029 - tonic::Status, 1030 - >; 890 + ) -> std::result::Result<tonic::Response<super::GetTrackResponse>, tonic::Status>; 1031 891 async fn like_track( 1032 892 &self, 1033 893 request: tonic::Request<super::LikeTrackRequest>, 1034 - ) -> std::result::Result< 1035 - tonic::Response<super::LikeTrackResponse>, 1036 - tonic::Status, 1037 - >; 894 + ) -> std::result::Result<tonic::Response<super::LikeTrackResponse>, tonic::Status>; 1038 895 async fn unlike_track( 1039 896 &self, 1040 897 request: tonic::Request<super::UnlikeTrackRequest>, 1041 - ) -> std::result::Result< 1042 - tonic::Response<super::UnlikeTrackResponse>, 1043 - tonic::Status, 1044 - >; 898 + ) -> std::result::Result<tonic::Response<super::UnlikeTrackResponse>, tonic::Status>; 1045 899 async fn like_album( 1046 900 &self, 1047 901 request: tonic::Request<super::LikeAlbumRequest>, 1048 - ) -> std::result::Result< 1049 - tonic::Response<super::LikeAlbumResponse>, 1050 - tonic::Status, 1051 - >; 902 + ) -> std::result::Result<tonic::Response<super::LikeAlbumResponse>, tonic::Status>; 1052 903 async fn unlike_album( 1053 904 &self, 1054 905 request: tonic::Request<super::UnlikeAlbumRequest>, 1055 - ) -> std::result::Result< 1056 - tonic::Response<super::UnlikeAlbumResponse>, 1057 - tonic::Status, 1058 - >; 906 + ) -> std::result::Result<tonic::Response<super::UnlikeAlbumResponse>, tonic::Status>; 1059 907 async fn get_liked_tracks( 1060 908 &self, 1061 909 request: tonic::Request<super::GetLikedTracksRequest>, 1062 - ) -> std::result::Result< 1063 - tonic::Response<super::GetLikedTracksResponse>, 1064 - tonic::Status, 1065 - >; 910 + ) -> std::result::Result<tonic::Response<super::GetLikedTracksResponse>, tonic::Status>; 1066 911 async fn get_liked_albums( 1067 912 &self, 1068 913 request: tonic::Request<super::GetLikedAlbumsRequest>, 1069 - ) -> std::result::Result< 1070 - tonic::Response<super::GetLikedAlbumsResponse>, 1071 - tonic::Status, 1072 - >; 914 + ) -> std::result::Result<tonic::Response<super::GetLikedAlbumsResponse>, tonic::Status>; 1073 915 async fn scan_library( 1074 916 &self, 1075 917 request: tonic::Request<super::ScanLibraryRequest>, 1076 - ) -> std::result::Result< 1077 - tonic::Response<super::ScanLibraryResponse>, 1078 - tonic::Status, 1079 - >; 918 + ) -> std::result::Result<tonic::Response<super::ScanLibraryResponse>, tonic::Status>; 1080 919 async fn search( 1081 920 &self, 1082 921 request: tonic::Request<super::SearchRequest>, ··· 1103 942 max_encoding_message_size: None, 1104 943 } 1105 944 } 1106 - pub fn with_interceptor<F>( 1107 - inner: T, 1108 - interceptor: F, 1109 - ) -> InterceptedService<Self, F> 945 + pub fn with_interceptor<F>(inner: T, interceptor: F) -> InterceptedService<Self, F> 1110 946 where 1111 947 F: tonic::service::Interceptor, 1112 948 { ··· 1161 997 "/rockbox.v1alpha1.LibraryService/GetAlbums" => { 1162 998 #[allow(non_camel_case_types)] 1163 999 struct GetAlbumsSvc<T: LibraryService>(pub Arc<T>); 1164 - impl< 1165 - T: LibraryService, 1166 - > tonic::server::UnaryService<super::GetAlbumsRequest> 1167 - for GetAlbumsSvc<T> { 1000 + impl<T: LibraryService> tonic::server::UnaryService<super::GetAlbumsRequest> for GetAlbumsSvc<T> { 1168 1001 type Response = super::GetAlbumsResponse; 1169 - type Future = BoxFuture< 1170 - tonic::Response<Self::Response>, 1171 - tonic::Status, 1172 - >; 1002 + type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 1173 1003 fn call( 1174 1004 &mut self, 1175 1005 request: tonic::Request<super::GetAlbumsRequest>, ··· 1206 1036 "/rockbox.v1alpha1.LibraryService/GetArtists" => { 1207 1037 #[allow(non_camel_case_types)] 1208 1038 struct GetArtistsSvc<T: LibraryService>(pub Arc<T>); 1209 - impl< 1210 - T: LibraryService, 1211 - > tonic::server::UnaryService<super::GetArtistsRequest> 1212 - for GetArtistsSvc<T> { 1039 + impl<T: LibraryService> tonic::server::UnaryService<super::GetArtistsRequest> for GetArtistsSvc<T> { 1213 1040 type Response = super::GetArtistsResponse; 1214 - type Future = BoxFuture< 1215 - tonic::Response<Self::Response>, 1216 - tonic::Status, 1217 - >; 1041 + type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 1218 1042 fn call( 1219 1043 &mut self, 1220 1044 request: tonic::Request<super::GetArtistsRequest>, ··· 1251 1075 "/rockbox.v1alpha1.LibraryService/GetTracks" => { 1252 1076 #[allow(non_camel_case_types)] 1253 1077 struct GetTracksSvc<T: LibraryService>(pub Arc<T>); 1254 - impl< 1255 - T: LibraryService, 1256 - > tonic::server::UnaryService<super::GetTracksRequest> 1257 - for GetTracksSvc<T> { 1078 + impl<T: LibraryService> tonic::server::UnaryService<super::GetTracksRequest> for GetTracksSvc<T> { 1258 1079 type Response = super::GetTracksResponse; 1259 - type Future = BoxFuture< 1260 - tonic::Response<Self::Response>, 1261 - tonic::Status, 1262 - >; 1080 + type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 1263 1081 fn call( 1264 1082 &mut self, 1265 1083 request: tonic::Request<super::GetTracksRequest>, ··· 1296 1114 "/rockbox.v1alpha1.LibraryService/GetAlbum" => { 1297 1115 #[allow(non_camel_case_types)] 1298 1116 struct GetAlbumSvc<T: LibraryService>(pub Arc<T>); 1299 - impl< 1300 - T: LibraryService, 1301 - > tonic::server::UnaryService<super::GetAlbumRequest> 1302 - for GetAlbumSvc<T> { 1117 + impl<T: LibraryService> tonic::server::UnaryService<super::GetAlbumRequest> for GetAlbumSvc<T> { 1303 1118 type Response = super::GetAlbumResponse; 1304 - type Future = BoxFuture< 1305 - tonic::Response<Self::Response>, 1306 - tonic::Status, 1307 - >; 1119 + type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 1308 1120 fn call( 1309 1121 &mut self, 1310 1122 request: tonic::Request<super::GetAlbumRequest>, ··· 1341 1153 "/rockbox.v1alpha1.LibraryService/GetArtist" => { 1342 1154 #[allow(non_camel_case_types)] 1343 1155 struct GetArtistSvc<T: LibraryService>(pub Arc<T>); 1344 - impl< 1345 - T: LibraryService, 1346 - > tonic::server::UnaryService<super::GetArtistRequest> 1347 - for GetArtistSvc<T> { 1156 + impl<T: LibraryService> tonic::server::UnaryService<super::GetArtistRequest> for GetArtistSvc<T> { 1348 1157 type Response = super::GetArtistResponse; 1349 - type Future = BoxFuture< 1350 - tonic::Response<Self::Response>, 1351 - tonic::Status, 1352 - >; 1158 + type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 1353 1159 fn call( 1354 1160 &mut self, 1355 1161 request: tonic::Request<super::GetArtistRequest>, ··· 1386 1192 "/rockbox.v1alpha1.LibraryService/GetTrack" => { 1387 1193 #[allow(non_camel_case_types)] 1388 1194 struct GetTrackSvc<T: LibraryService>(pub Arc<T>); 1389 - impl< 1390 - T: LibraryService, 1391 - > tonic::server::UnaryService<super::GetTrackRequest> 1392 - for GetTrackSvc<T> { 1195 + impl<T: LibraryService> tonic::server::UnaryService<super::GetTrackRequest> for GetTrackSvc<T> { 1393 1196 type Response = super::GetTrackResponse; 1394 - type Future = BoxFuture< 1395 - tonic::Response<Self::Response>, 1396 - tonic::Status, 1397 - >; 1197 + type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 1398 1198 fn call( 1399 1199 &mut self, 1400 1200 request: tonic::Request<super::GetTrackRequest>, ··· 1431 1231 "/rockbox.v1alpha1.LibraryService/LikeTrack" => { 1432 1232 #[allow(non_camel_case_types)] 1433 1233 struct LikeTrackSvc<T: LibraryService>(pub Arc<T>); 1434 - impl< 1435 - T: LibraryService, 1436 - > tonic::server::UnaryService<super::LikeTrackRequest> 1437 - for LikeTrackSvc<T> { 1234 + impl<T: LibraryService> tonic::server::UnaryService<super::LikeTrackRequest> for LikeTrackSvc<T> { 1438 1235 type Response = super::LikeTrackResponse; 1439 - type Future = BoxFuture< 1440 - tonic::Response<Self::Response>, 1441 - tonic::Status, 1442 - >; 1236 + type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 1443 1237 fn call( 1444 1238 &mut self, 1445 1239 request: tonic::Request<super::LikeTrackRequest>, ··· 1476 1270 "/rockbox.v1alpha1.LibraryService/UnlikeTrack" => { 1477 1271 #[allow(non_camel_case_types)] 1478 1272 struct UnlikeTrackSvc<T: LibraryService>(pub Arc<T>); 1479 - impl< 1480 - T: LibraryService, 1481 - > tonic::server::UnaryService<super::UnlikeTrackRequest> 1482 - for UnlikeTrackSvc<T> { 1273 + impl<T: LibraryService> tonic::server::UnaryService<super::UnlikeTrackRequest> 1274 + for UnlikeTrackSvc<T> 1275 + { 1483 1276 type Response = super::UnlikeTrackResponse; 1484 - type Future = BoxFuture< 1485 - tonic::Response<Self::Response>, 1486 - tonic::Status, 1487 - >; 1277 + type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 1488 1278 fn call( 1489 1279 &mut self, 1490 1280 request: tonic::Request<super::UnlikeTrackRequest>, ··· 1521 1311 "/rockbox.v1alpha1.LibraryService/LikeAlbum" => { 1522 1312 #[allow(non_camel_case_types)] 1523 1313 struct LikeAlbumSvc<T: LibraryService>(pub Arc<T>); 1524 - impl< 1525 - T: LibraryService, 1526 - > tonic::server::UnaryService<super::LikeAlbumRequest> 1527 - for LikeAlbumSvc<T> { 1314 + impl<T: LibraryService> tonic::server::UnaryService<super::LikeAlbumRequest> for LikeAlbumSvc<T> { 1528 1315 type Response = super::LikeAlbumResponse; 1529 - type Future = BoxFuture< 1530 - tonic::Response<Self::Response>, 1531 - tonic::Status, 1532 - >; 1316 + type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 1533 1317 fn call( 1534 1318 &mut self, 1535 1319 request: tonic::Request<super::LikeAlbumRequest>, ··· 1566 1350 "/rockbox.v1alpha1.LibraryService/UnlikeAlbum" => { 1567 1351 #[allow(non_camel_case_types)] 1568 1352 struct UnlikeAlbumSvc<T: LibraryService>(pub Arc<T>); 1569 - impl< 1570 - T: LibraryService, 1571 - > tonic::server::UnaryService<super::UnlikeAlbumRequest> 1572 - for UnlikeAlbumSvc<T> { 1353 + impl<T: LibraryService> tonic::server::UnaryService<super::UnlikeAlbumRequest> 1354 + for UnlikeAlbumSvc<T> 1355 + { 1573 1356 type Response = super::UnlikeAlbumResponse; 1574 - type Future = BoxFuture< 1575 - tonic::Response<Self::Response>, 1576 - tonic::Status, 1577 - >; 1357 + type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 1578 1358 fn call( 1579 1359 &mut self, 1580 1360 request: tonic::Request<super::UnlikeAlbumRequest>, ··· 1611 1391 "/rockbox.v1alpha1.LibraryService/GetLikedTracks" => { 1612 1392 #[allow(non_camel_case_types)] 1613 1393 struct GetLikedTracksSvc<T: LibraryService>(pub Arc<T>); 1614 - impl< 1615 - T: LibraryService, 1616 - > tonic::server::UnaryService<super::GetLikedTracksRequest> 1617 - for GetLikedTracksSvc<T> { 1394 + impl<T: LibraryService> 1395 + tonic::server::UnaryService<super::GetLikedTracksRequest> 1396 + for GetLikedTracksSvc<T> 1397 + { 1618 1398 type Response = super::GetLikedTracksResponse; 1619 - type Future = BoxFuture< 1620 - tonic::Response<Self::Response>, 1621 - tonic::Status, 1622 - >; 1399 + type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 1623 1400 fn call( 1624 1401 &mut self, 1625 1402 request: tonic::Request<super::GetLikedTracksRequest>, 1626 1403 ) -> Self::Future { 1627 1404 let inner = Arc::clone(&self.0); 1628 1405 let fut = async move { 1629 - <T as LibraryService>::get_liked_tracks(&inner, request) 1630 - .await 1406 + <T as LibraryService>::get_liked_tracks(&inner, request).await 1631 1407 }; 1632 1408 Box::pin(fut) 1633 1409 } ··· 1657 1433 "/rockbox.v1alpha1.LibraryService/GetLikedAlbums" => { 1658 1434 #[allow(non_camel_case_types)] 1659 1435 struct GetLikedAlbumsSvc<T: LibraryService>(pub Arc<T>); 1660 - impl< 1661 - T: LibraryService, 1662 - > tonic::server::UnaryService<super::GetLikedAlbumsRequest> 1663 - for GetLikedAlbumsSvc<T> { 1436 + impl<T: LibraryService> 1437 + tonic::server::UnaryService<super::GetLikedAlbumsRequest> 1438 + for GetLikedAlbumsSvc<T> 1439 + { 1664 1440 type Response = super::GetLikedAlbumsResponse; 1665 - type Future = BoxFuture< 1666 - tonic::Response<Self::Response>, 1667 - tonic::Status, 1668 - >; 1441 + type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 1669 1442 fn call( 1670 1443 &mut self, 1671 1444 request: tonic::Request<super::GetLikedAlbumsRequest>, 1672 1445 ) -> Self::Future { 1673 1446 let inner = Arc::clone(&self.0); 1674 1447 let fut = async move { 1675 - <T as LibraryService>::get_liked_albums(&inner, request) 1676 - .await 1448 + <T as LibraryService>::get_liked_albums(&inner, request).await 1677 1449 }; 1678 1450 Box::pin(fut) 1679 1451 } ··· 1703 1475 "/rockbox.v1alpha1.LibraryService/ScanLibrary" => { 1704 1476 #[allow(non_camel_case_types)] 1705 1477 struct ScanLibrarySvc<T: LibraryService>(pub Arc<T>); 1706 - impl< 1707 - T: LibraryService, 1708 - > tonic::server::UnaryService<super::ScanLibraryRequest> 1709 - for ScanLibrarySvc<T> { 1478 + impl<T: LibraryService> tonic::server::UnaryService<super::ScanLibraryRequest> 1479 + for ScanLibrarySvc<T> 1480 + { 1710 1481 type Response = super::ScanLibraryResponse; 1711 - type Future = BoxFuture< 1712 - tonic::Response<Self::Response>, 1713 - tonic::Status, 1714 - >; 1482 + type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 1715 1483 fn call( 1716 1484 &mut self, 1717 1485 request: tonic::Request<super::ScanLibraryRequest>, ··· 1748 1516 "/rockbox.v1alpha1.LibraryService/Search" => { 1749 1517 #[allow(non_camel_case_types)] 1750 1518 struct SearchSvc<T: LibraryService>(pub Arc<T>); 1751 - impl< 1752 - T: LibraryService, 1753 - > tonic::server::UnaryService<super::SearchRequest> 1754 - for SearchSvc<T> { 1519 + impl<T: LibraryService> tonic::server::UnaryService<super::SearchRequest> for SearchSvc<T> { 1755 1520 type Response = super::SearchResponse; 1756 - type Future = BoxFuture< 1757 - tonic::Response<Self::Response>, 1758 - tonic::Status, 1759 - >; 1521 + type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 1760 1522 fn call( 1761 1523 &mut self, 1762 1524 request: tonic::Request<super::SearchRequest>, 1763 1525 ) -> Self::Future { 1764 1526 let inner = Arc::clone(&self.0); 1765 - let fut = async move { 1766 - <T as LibraryService>::search(&inner, request).await 1767 - }; 1527 + let fut = 1528 + async move { <T as LibraryService>::search(&inner, request).await }; 1768 1529 Box::pin(fut) 1769 1530 } 1770 1531 } ··· 1790 1551 }; 1791 1552 Box::pin(fut) 1792 1553 } 1793 - _ => { 1794 - Box::pin(async move { 1795 - let mut response = http::Response::new(empty_body()); 1796 - let headers = response.headers_mut(); 1797 - headers 1798 - .insert( 1799 - tonic::Status::GRPC_STATUS, 1800 - (tonic::Code::Unimplemented as i32).into(), 1801 - ); 1802 - headers 1803 - .insert( 1804 - http::header::CONTENT_TYPE, 1805 - tonic::metadata::GRPC_CONTENT_TYPE, 1806 - ); 1807 - Ok(response) 1808 - }) 1809 - } 1554 + _ => Box::pin(async move { 1555 + let mut response = http::Response::new(empty_body()); 1556 + let headers = response.headers_mut(); 1557 + headers.insert( 1558 + tonic::Status::GRPC_STATUS, 1559 + (tonic::Code::Unimplemented as i32).into(), 1560 + ); 1561 + headers.insert( 1562 + http::header::CONTENT_TYPE, 1563 + tonic::metadata::GRPC_CONTENT_TYPE, 1564 + ); 1565 + Ok(response) 1566 + }), 1810 1567 } 1811 1568 } 1812 1569 } ··· 1835 1592 dead_code, 1836 1593 missing_docs, 1837 1594 clippy::wildcard_imports, 1838 - clippy::let_unit_value, 1595 + clippy::let_unit_value 1839 1596 )] 1840 - use tonic::codegen::*; 1841 1597 use tonic::codegen::http::Uri; 1598 + use tonic::codegen::*; 1842 1599 #[derive(Debug, Clone)] 1843 1600 pub struct MetadataServiceClient<T> { 1844 1601 inner: tonic::client::Grpc<T>, ··· 1882 1639 <T as tonic::client::GrpcService<tonic::body::BoxBody>>::ResponseBody, 1883 1640 >, 1884 1641 >, 1885 - <T as tonic::codegen::Service< 1886 - http::Request<tonic::body::BoxBody>, 1887 - >>::Error: Into<StdError> + std::marker::Send + std::marker::Sync, 1642 + <T as tonic::codegen::Service<http::Request<tonic::body::BoxBody>>>::Error: 1643 + Into<StdError> + std::marker::Send + std::marker::Sync, 1888 1644 { 1889 1645 MetadataServiceClient::new(InterceptedService::new(inner, interceptor)) 1890 1646 } ··· 1928 1684 dead_code, 1929 1685 missing_docs, 1930 1686 clippy::wildcard_imports, 1931 - clippy::let_unit_value, 1687 + clippy::let_unit_value 1932 1688 )] 1933 1689 use tonic::codegen::*; 1934 1690 /// Generated trait containing gRPC methods that should be implemented for use with MetadataServiceServer. ··· 1955 1711 max_encoding_message_size: None, 1956 1712 } 1957 1713 } 1958 - pub fn with_interceptor<F>( 1959 - inner: T, 1960 - interceptor: F, 1961 - ) -> InterceptedService<Self, F> 1714 + pub fn with_interceptor<F>(inner: T, interceptor: F) -> InterceptedService<Self, F> 1962 1715 where 1963 1716 F: tonic::service::Interceptor, 1964 1717 { ··· 2010 1763 } 2011 1764 fn call(&mut self, req: http::Request<B>) -> Self::Future { 2012 1765 match req.uri().path() { 2013 - _ => { 2014 - Box::pin(async move { 2015 - let mut response = http::Response::new(empty_body()); 2016 - let headers = response.headers_mut(); 2017 - headers 2018 - .insert( 2019 - tonic::Status::GRPC_STATUS, 2020 - (tonic::Code::Unimplemented as i32).into(), 2021 - ); 2022 - headers 2023 - .insert( 2024 - http::header::CONTENT_TYPE, 2025 - tonic::metadata::GRPC_CONTENT_TYPE, 2026 - ); 2027 - Ok(response) 2028 - }) 2029 - } 1766 + _ => Box::pin(async move { 1767 + let mut response = http::Response::new(empty_body()); 1768 + let headers = response.headers_mut(); 1769 + headers.insert( 1770 + tonic::Status::GRPC_STATUS, 1771 + (tonic::Code::Unimplemented as i32).into(), 1772 + ); 1773 + headers.insert( 1774 + http::header::CONTENT_TYPE, 1775 + tonic::metadata::GRPC_CONTENT_TYPE, 1776 + ); 1777 + Ok(response) 1778 + }), 2030 1779 } 2031 1780 } 2032 1781 } ··· 2295 2044 dead_code, 2296 2045 missing_docs, 2297 2046 clippy::wildcard_imports, 2298 - clippy::let_unit_value, 2047 + clippy::let_unit_value 2299 2048 )] 2300 - use tonic::codegen::*; 2301 2049 use tonic::codegen::http::Uri; 2050 + use tonic::codegen::*; 2302 2051 #[derive(Debug, Clone)] 2303 2052 pub struct PlaybackServiceClient<T> { 2304 2053 inner: tonic::client::Grpc<T>, ··· 2342 2091 <T as tonic::client::GrpcService<tonic::body::BoxBody>>::ResponseBody, 2343 2092 >, 2344 2093 >, 2345 - <T as tonic::codegen::Service< 2346 - http::Request<tonic::body::BoxBody>, 2347 - >>::Error: Into<StdError> + std::marker::Send + std::marker::Sync, 2094 + <T as tonic::codegen::Service<http::Request<tonic::body::BoxBody>>>::Error: 2095 + Into<StdError> + std::marker::Send + std::marker::Sync, 2348 2096 { 2349 2097 PlaybackServiceClient::new(InterceptedService::new(inner, interceptor)) 2350 2098 } ··· 2383 2131 &mut self, 2384 2132 request: impl tonic::IntoRequest<super::PlayRequest>, 2385 2133 ) -> std::result::Result<tonic::Response<super::PlayResponse>, tonic::Status> { 2386 - self.inner 2387 - .ready() 2388 - .await 2389 - .map_err(|e| { 2390 - tonic::Status::unknown( 2391 - format!("Service was not ready: {}", e.into()), 2392 - ) 2393 - })?; 2134 + self.inner.ready().await.map_err(|e| { 2135 + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 2136 + })?; 2394 2137 let codec = tonic::codec::ProstCodec::default(); 2395 - let path = http::uri::PathAndQuery::from_static( 2396 - "/rockbox.v1alpha1.PlaybackService/Play", 2397 - ); 2138 + let path = 2139 + http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.PlaybackService/Play"); 2398 2140 let mut req = request.into_request(); 2399 2141 req.extensions_mut() 2400 2142 .insert(GrpcMethod::new("rockbox.v1alpha1.PlaybackService", "Play")); ··· 2404 2146 &mut self, 2405 2147 request: impl tonic::IntoRequest<super::PauseRequest>, 2406 2148 ) -> std::result::Result<tonic::Response<super::PauseResponse>, tonic::Status> { 2407 - self.inner 2408 - .ready() 2409 - .await 2410 - .map_err(|e| { 2411 - tonic::Status::unknown( 2412 - format!("Service was not ready: {}", e.into()), 2413 - ) 2414 - })?; 2149 + self.inner.ready().await.map_err(|e| { 2150 + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 2151 + })?; 2415 2152 let codec = tonic::codec::ProstCodec::default(); 2416 - let path = http::uri::PathAndQuery::from_static( 2417 - "/rockbox.v1alpha1.PlaybackService/Pause", 2418 - ); 2153 + let path = 2154 + http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.PlaybackService/Pause"); 2419 2155 let mut req = request.into_request(); 2420 2156 req.extensions_mut() 2421 2157 .insert(GrpcMethod::new("rockbox.v1alpha1.PlaybackService", "Pause")); ··· 2425 2161 &mut self, 2426 2162 request: impl tonic::IntoRequest<super::ResumeRequest>, 2427 2163 ) -> std::result::Result<tonic::Response<super::ResumeResponse>, tonic::Status> { 2428 - self.inner 2429 - .ready() 2430 - .await 2431 - .map_err(|e| { 2432 - tonic::Status::unknown( 2433 - format!("Service was not ready: {}", e.into()), 2434 - ) 2435 - })?; 2164 + self.inner.ready().await.map_err(|e| { 2165 + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 2166 + })?; 2436 2167 let codec = tonic::codec::ProstCodec::default(); 2437 - let path = http::uri::PathAndQuery::from_static( 2438 - "/rockbox.v1alpha1.PlaybackService/Resume", 2439 - ); 2168 + let path = 2169 + http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.PlaybackService/Resume"); 2440 2170 let mut req = request.into_request(); 2441 - req.extensions_mut() 2442 - .insert(GrpcMethod::new("rockbox.v1alpha1.PlaybackService", "Resume")); 2171 + req.extensions_mut().insert(GrpcMethod::new( 2172 + "rockbox.v1alpha1.PlaybackService", 2173 + "Resume", 2174 + )); 2443 2175 self.inner.unary(req, path, codec).await 2444 2176 } 2445 2177 pub async fn next( 2446 2178 &mut self, 2447 2179 request: impl tonic::IntoRequest<super::NextRequest>, 2448 2180 ) -> std::result::Result<tonic::Response<super::NextResponse>, tonic::Status> { 2449 - self.inner 2450 - .ready() 2451 - .await 2452 - .map_err(|e| { 2453 - tonic::Status::unknown( 2454 - format!("Service was not ready: {}", e.into()), 2455 - ) 2456 - })?; 2181 + self.inner.ready().await.map_err(|e| { 2182 + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 2183 + })?; 2457 2184 let codec = tonic::codec::ProstCodec::default(); 2458 - let path = http::uri::PathAndQuery::from_static( 2459 - "/rockbox.v1alpha1.PlaybackService/Next", 2460 - ); 2185 + let path = 2186 + http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.PlaybackService/Next"); 2461 2187 let mut req = request.into_request(); 2462 2188 req.extensions_mut() 2463 2189 .insert(GrpcMethod::new("rockbox.v1alpha1.PlaybackService", "Next")); ··· 2466 2192 pub async fn previous( 2467 2193 &mut self, 2468 2194 request: impl tonic::IntoRequest<super::PreviousRequest>, 2469 - ) -> std::result::Result< 2470 - tonic::Response<super::PreviousResponse>, 2471 - tonic::Status, 2472 - > { 2473 - self.inner 2474 - .ready() 2475 - .await 2476 - .map_err(|e| { 2477 - tonic::Status::unknown( 2478 - format!("Service was not ready: {}", e.into()), 2479 - ) 2480 - })?; 2195 + ) -> std::result::Result<tonic::Response<super::PreviousResponse>, tonic::Status> { 2196 + self.inner.ready().await.map_err(|e| { 2197 + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 2198 + })?; 2481 2199 let codec = tonic::codec::ProstCodec::default(); 2482 - let path = http::uri::PathAndQuery::from_static( 2483 - "/rockbox.v1alpha1.PlaybackService/Previous", 2484 - ); 2200 + let path = 2201 + http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.PlaybackService/Previous"); 2485 2202 let mut req = request.into_request(); 2486 - req.extensions_mut() 2487 - .insert(GrpcMethod::new("rockbox.v1alpha1.PlaybackService", "Previous")); 2203 + req.extensions_mut().insert(GrpcMethod::new( 2204 + "rockbox.v1alpha1.PlaybackService", 2205 + "Previous", 2206 + )); 2488 2207 self.inner.unary(req, path, codec).await 2489 2208 } 2490 2209 pub async fn fast_forward_rewind( 2491 2210 &mut self, 2492 2211 request: impl tonic::IntoRequest<super::FastForwardRewindRequest>, 2493 - ) -> std::result::Result< 2494 - tonic::Response<super::FastForwardRewindResponse>, 2495 - tonic::Status, 2496 - > { 2497 - self.inner 2498 - .ready() 2499 - .await 2500 - .map_err(|e| { 2501 - tonic::Status::unknown( 2502 - format!("Service was not ready: {}", e.into()), 2503 - ) 2504 - })?; 2212 + ) -> std::result::Result<tonic::Response<super::FastForwardRewindResponse>, tonic::Status> 2213 + { 2214 + self.inner.ready().await.map_err(|e| { 2215 + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 2216 + })?; 2505 2217 let codec = tonic::codec::ProstCodec::default(); 2506 2218 let path = http::uri::PathAndQuery::from_static( 2507 2219 "/rockbox.v1alpha1.PlaybackService/FastForwardRewind", 2508 2220 ); 2509 2221 let mut req = request.into_request(); 2510 - req.extensions_mut() 2511 - .insert( 2512 - GrpcMethod::new( 2513 - "rockbox.v1alpha1.PlaybackService", 2514 - "FastForwardRewind", 2515 - ), 2516 - ); 2222 + req.extensions_mut().insert(GrpcMethod::new( 2223 + "rockbox.v1alpha1.PlaybackService", 2224 + "FastForwardRewind", 2225 + )); 2517 2226 self.inner.unary(req, path, codec).await 2518 2227 } 2519 2228 pub async fn status( 2520 2229 &mut self, 2521 2230 request: impl tonic::IntoRequest<super::StatusRequest>, 2522 2231 ) -> std::result::Result<tonic::Response<super::StatusResponse>, tonic::Status> { 2523 - self.inner 2524 - .ready() 2525 - .await 2526 - .map_err(|e| { 2527 - tonic::Status::unknown( 2528 - format!("Service was not ready: {}", e.into()), 2529 - ) 2530 - })?; 2232 + self.inner.ready().await.map_err(|e| { 2233 + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 2234 + })?; 2531 2235 let codec = tonic::codec::ProstCodec::default(); 2532 - let path = http::uri::PathAndQuery::from_static( 2533 - "/rockbox.v1alpha1.PlaybackService/Status", 2534 - ); 2236 + let path = 2237 + http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.PlaybackService/Status"); 2535 2238 let mut req = request.into_request(); 2536 - req.extensions_mut() 2537 - .insert(GrpcMethod::new("rockbox.v1alpha1.PlaybackService", "Status")); 2239 + req.extensions_mut().insert(GrpcMethod::new( 2240 + "rockbox.v1alpha1.PlaybackService", 2241 + "Status", 2242 + )); 2538 2243 self.inner.unary(req, path, codec).await 2539 2244 } 2540 2245 pub async fn current_track( 2541 2246 &mut self, 2542 2247 request: impl tonic::IntoRequest<super::CurrentTrackRequest>, 2543 - ) -> std::result::Result< 2544 - tonic::Response<super::CurrentTrackResponse>, 2545 - tonic::Status, 2546 - > { 2547 - self.inner 2548 - .ready() 2549 - .await 2550 - .map_err(|e| { 2551 - tonic::Status::unknown( 2552 - format!("Service was not ready: {}", e.into()), 2553 - ) 2554 - })?; 2248 + ) -> std::result::Result<tonic::Response<super::CurrentTrackResponse>, tonic::Status> 2249 + { 2250 + self.inner.ready().await.map_err(|e| { 2251 + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 2252 + })?; 2555 2253 let codec = tonic::codec::ProstCodec::default(); 2556 2254 let path = http::uri::PathAndQuery::from_static( 2557 2255 "/rockbox.v1alpha1.PlaybackService/CurrentTrack", 2558 2256 ); 2559 2257 let mut req = request.into_request(); 2560 - req.extensions_mut() 2561 - .insert( 2562 - GrpcMethod::new("rockbox.v1alpha1.PlaybackService", "CurrentTrack"), 2563 - ); 2258 + req.extensions_mut().insert(GrpcMethod::new( 2259 + "rockbox.v1alpha1.PlaybackService", 2260 + "CurrentTrack", 2261 + )); 2564 2262 self.inner.unary(req, path, codec).await 2565 2263 } 2566 2264 pub async fn next_track( 2567 2265 &mut self, 2568 2266 request: impl tonic::IntoRequest<super::NextTrackRequest>, 2569 - ) -> std::result::Result< 2570 - tonic::Response<super::NextTrackResponse>, 2571 - tonic::Status, 2572 - > { 2573 - self.inner 2574 - .ready() 2575 - .await 2576 - .map_err(|e| { 2577 - tonic::Status::unknown( 2578 - format!("Service was not ready: {}", e.into()), 2579 - ) 2580 - })?; 2267 + ) -> std::result::Result<tonic::Response<super::NextTrackResponse>, tonic::Status> { 2268 + self.inner.ready().await.map_err(|e| { 2269 + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 2270 + })?; 2581 2271 let codec = tonic::codec::ProstCodec::default(); 2582 - let path = http::uri::PathAndQuery::from_static( 2583 - "/rockbox.v1alpha1.PlaybackService/NextTrack", 2584 - ); 2272 + let path = 2273 + http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.PlaybackService/NextTrack"); 2585 2274 let mut req = request.into_request(); 2586 - req.extensions_mut() 2587 - .insert( 2588 - GrpcMethod::new("rockbox.v1alpha1.PlaybackService", "NextTrack"), 2589 - ); 2275 + req.extensions_mut().insert(GrpcMethod::new( 2276 + "rockbox.v1alpha1.PlaybackService", 2277 + "NextTrack", 2278 + )); 2590 2279 self.inner.unary(req, path, codec).await 2591 2280 } 2592 2281 pub async fn flush_and_reload_tracks( 2593 2282 &mut self, 2594 2283 request: impl tonic::IntoRequest<super::FlushAndReloadTracksRequest>, 2595 - ) -> std::result::Result< 2596 - tonic::Response<super::FlushAndReloadTracksResponse>, 2597 - tonic::Status, 2598 - > { 2599 - self.inner 2600 - .ready() 2601 - .await 2602 - .map_err(|e| { 2603 - tonic::Status::unknown( 2604 - format!("Service was not ready: {}", e.into()), 2605 - ) 2606 - })?; 2284 + ) -> std::result::Result<tonic::Response<super::FlushAndReloadTracksResponse>, tonic::Status> 2285 + { 2286 + self.inner.ready().await.map_err(|e| { 2287 + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 2288 + })?; 2607 2289 let codec = tonic::codec::ProstCodec::default(); 2608 2290 let path = http::uri::PathAndQuery::from_static( 2609 2291 "/rockbox.v1alpha1.PlaybackService/FlushAndReloadTracks", 2610 2292 ); 2611 2293 let mut req = request.into_request(); 2612 - req.extensions_mut() 2613 - .insert( 2614 - GrpcMethod::new( 2615 - "rockbox.v1alpha1.PlaybackService", 2616 - "FlushAndReloadTracks", 2617 - ), 2618 - ); 2294 + req.extensions_mut().insert(GrpcMethod::new( 2295 + "rockbox.v1alpha1.PlaybackService", 2296 + "FlushAndReloadTracks", 2297 + )); 2619 2298 self.inner.unary(req, path, codec).await 2620 2299 } 2621 2300 pub async fn get_file_position( 2622 2301 &mut self, 2623 2302 request: impl tonic::IntoRequest<super::GetFilePositionRequest>, 2624 - ) -> std::result::Result< 2625 - tonic::Response<super::GetFilePositionResponse>, 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 - })?; 2303 + ) -> std::result::Result<tonic::Response<super::GetFilePositionResponse>, tonic::Status> 2304 + { 2305 + self.inner.ready().await.map_err(|e| { 2306 + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 2307 + })?; 2636 2308 let codec = tonic::codec::ProstCodec::default(); 2637 2309 let path = http::uri::PathAndQuery::from_static( 2638 2310 "/rockbox.v1alpha1.PlaybackService/GetFilePosition", 2639 2311 ); 2640 2312 let mut req = request.into_request(); 2641 - req.extensions_mut() 2642 - .insert( 2643 - GrpcMethod::new( 2644 - "rockbox.v1alpha1.PlaybackService", 2645 - "GetFilePosition", 2646 - ), 2647 - ); 2313 + req.extensions_mut().insert(GrpcMethod::new( 2314 + "rockbox.v1alpha1.PlaybackService", 2315 + "GetFilePosition", 2316 + )); 2648 2317 self.inner.unary(req, path, codec).await 2649 2318 } 2650 2319 pub async fn hard_stop( 2651 2320 &mut self, 2652 2321 request: impl tonic::IntoRequest<super::HardStopRequest>, 2653 - ) -> std::result::Result< 2654 - tonic::Response<super::HardStopResponse>, 2655 - tonic::Status, 2656 - > { 2657 - self.inner 2658 - .ready() 2659 - .await 2660 - .map_err(|e| { 2661 - tonic::Status::unknown( 2662 - format!("Service was not ready: {}", e.into()), 2663 - ) 2664 - })?; 2322 + ) -> std::result::Result<tonic::Response<super::HardStopResponse>, tonic::Status> { 2323 + self.inner.ready().await.map_err(|e| { 2324 + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 2325 + })?; 2665 2326 let codec = tonic::codec::ProstCodec::default(); 2666 - let path = http::uri::PathAndQuery::from_static( 2667 - "/rockbox.v1alpha1.PlaybackService/HardStop", 2668 - ); 2327 + let path = 2328 + http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.PlaybackService/HardStop"); 2669 2329 let mut req = request.into_request(); 2670 - req.extensions_mut() 2671 - .insert(GrpcMethod::new("rockbox.v1alpha1.PlaybackService", "HardStop")); 2330 + req.extensions_mut().insert(GrpcMethod::new( 2331 + "rockbox.v1alpha1.PlaybackService", 2332 + "HardStop", 2333 + )); 2672 2334 self.inner.unary(req, path, codec).await 2673 2335 } 2674 2336 pub async fn play_album( 2675 2337 &mut self, 2676 2338 request: impl tonic::IntoRequest<super::PlayAlbumRequest>, 2677 - ) -> std::result::Result< 2678 - tonic::Response<super::PlayAlbumResponse>, 2679 - tonic::Status, 2680 - > { 2681 - self.inner 2682 - .ready() 2683 - .await 2684 - .map_err(|e| { 2685 - tonic::Status::unknown( 2686 - format!("Service was not ready: {}", e.into()), 2687 - ) 2688 - })?; 2339 + ) -> std::result::Result<tonic::Response<super::PlayAlbumResponse>, tonic::Status> { 2340 + self.inner.ready().await.map_err(|e| { 2341 + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 2342 + })?; 2689 2343 let codec = tonic::codec::ProstCodec::default(); 2690 - let path = http::uri::PathAndQuery::from_static( 2691 - "/rockbox.v1alpha1.PlaybackService/PlayAlbum", 2692 - ); 2344 + let path = 2345 + http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.PlaybackService/PlayAlbum"); 2693 2346 let mut req = request.into_request(); 2694 - req.extensions_mut() 2695 - .insert( 2696 - GrpcMethod::new("rockbox.v1alpha1.PlaybackService", "PlayAlbum"), 2697 - ); 2347 + req.extensions_mut().insert(GrpcMethod::new( 2348 + "rockbox.v1alpha1.PlaybackService", 2349 + "PlayAlbum", 2350 + )); 2698 2351 self.inner.unary(req, path, codec).await 2699 2352 } 2700 2353 pub async fn play_artist_tracks( 2701 2354 &mut self, 2702 2355 request: impl tonic::IntoRequest<super::PlayArtistTracksRequest>, 2703 - ) -> std::result::Result< 2704 - tonic::Response<super::PlayArtistTracksResponse>, 2705 - tonic::Status, 2706 - > { 2707 - self.inner 2708 - .ready() 2709 - .await 2710 - .map_err(|e| { 2711 - tonic::Status::unknown( 2712 - format!("Service was not ready: {}", e.into()), 2713 - ) 2714 - })?; 2356 + ) -> std::result::Result<tonic::Response<super::PlayArtistTracksResponse>, tonic::Status> 2357 + { 2358 + self.inner.ready().await.map_err(|e| { 2359 + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 2360 + })?; 2715 2361 let codec = tonic::codec::ProstCodec::default(); 2716 2362 let path = http::uri::PathAndQuery::from_static( 2717 2363 "/rockbox.v1alpha1.PlaybackService/PlayArtistTracks", 2718 2364 ); 2719 2365 let mut req = request.into_request(); 2720 - req.extensions_mut() 2721 - .insert( 2722 - GrpcMethod::new( 2723 - "rockbox.v1alpha1.PlaybackService", 2724 - "PlayArtistTracks", 2725 - ), 2726 - ); 2366 + req.extensions_mut().insert(GrpcMethod::new( 2367 + "rockbox.v1alpha1.PlaybackService", 2368 + "PlayArtistTracks", 2369 + )); 2727 2370 self.inner.unary(req, path, codec).await 2728 2371 } 2729 2372 pub async fn play_playlist( 2730 2373 &mut self, 2731 2374 request: impl tonic::IntoRequest<super::PlayPlaylistRequest>, 2732 - ) -> std::result::Result< 2733 - tonic::Response<super::PlayPlaylistResponse>, 2734 - tonic::Status, 2735 - > { 2736 - self.inner 2737 - .ready() 2738 - .await 2739 - .map_err(|e| { 2740 - tonic::Status::unknown( 2741 - format!("Service was not ready: {}", e.into()), 2742 - ) 2743 - })?; 2375 + ) -> std::result::Result<tonic::Response<super::PlayPlaylistResponse>, tonic::Status> 2376 + { 2377 + self.inner.ready().await.map_err(|e| { 2378 + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 2379 + })?; 2744 2380 let codec = tonic::codec::ProstCodec::default(); 2745 2381 let path = http::uri::PathAndQuery::from_static( 2746 2382 "/rockbox.v1alpha1.PlaybackService/PlayPlaylist", 2747 2383 ); 2748 2384 let mut req = request.into_request(); 2749 - req.extensions_mut() 2750 - .insert( 2751 - GrpcMethod::new("rockbox.v1alpha1.PlaybackService", "PlayPlaylist"), 2752 - ); 2385 + req.extensions_mut().insert(GrpcMethod::new( 2386 + "rockbox.v1alpha1.PlaybackService", 2387 + "PlayPlaylist", 2388 + )); 2753 2389 self.inner.unary(req, path, codec).await 2754 2390 } 2755 2391 pub async fn play_directory( 2756 2392 &mut self, 2757 2393 request: impl tonic::IntoRequest<super::PlayDirectoryRequest>, 2758 - ) -> std::result::Result< 2759 - tonic::Response<super::PlayDirectoryResponse>, 2760 - tonic::Status, 2761 - > { 2762 - self.inner 2763 - .ready() 2764 - .await 2765 - .map_err(|e| { 2766 - tonic::Status::unknown( 2767 - format!("Service was not ready: {}", e.into()), 2768 - ) 2769 - })?; 2394 + ) -> std::result::Result<tonic::Response<super::PlayDirectoryResponse>, tonic::Status> 2395 + { 2396 + self.inner.ready().await.map_err(|e| { 2397 + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 2398 + })?; 2770 2399 let codec = tonic::codec::ProstCodec::default(); 2771 2400 let path = http::uri::PathAndQuery::from_static( 2772 2401 "/rockbox.v1alpha1.PlaybackService/PlayDirectory", 2773 2402 ); 2774 2403 let mut req = request.into_request(); 2775 - req.extensions_mut() 2776 - .insert( 2777 - GrpcMethod::new("rockbox.v1alpha1.PlaybackService", "PlayDirectory"), 2778 - ); 2404 + req.extensions_mut().insert(GrpcMethod::new( 2405 + "rockbox.v1alpha1.PlaybackService", 2406 + "PlayDirectory", 2407 + )); 2779 2408 self.inner.unary(req, path, codec).await 2780 2409 } 2781 2410 pub async fn play_track( 2782 2411 &mut self, 2783 2412 request: impl tonic::IntoRequest<super::PlayTrackRequest>, 2784 - ) -> std::result::Result< 2785 - tonic::Response<super::PlayTrackResponse>, 2786 - tonic::Status, 2787 - > { 2788 - self.inner 2789 - .ready() 2790 - .await 2791 - .map_err(|e| { 2792 - tonic::Status::unknown( 2793 - format!("Service was not ready: {}", e.into()), 2794 - ) 2795 - })?; 2413 + ) -> std::result::Result<tonic::Response<super::PlayTrackResponse>, tonic::Status> { 2414 + self.inner.ready().await.map_err(|e| { 2415 + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 2416 + })?; 2796 2417 let codec = tonic::codec::ProstCodec::default(); 2797 - let path = http::uri::PathAndQuery::from_static( 2798 - "/rockbox.v1alpha1.PlaybackService/PlayTrack", 2799 - ); 2418 + let path = 2419 + http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.PlaybackService/PlayTrack"); 2800 2420 let mut req = request.into_request(); 2801 - req.extensions_mut() 2802 - .insert( 2803 - GrpcMethod::new("rockbox.v1alpha1.PlaybackService", "PlayTrack"), 2804 - ); 2421 + req.extensions_mut().insert(GrpcMethod::new( 2422 + "rockbox.v1alpha1.PlaybackService", 2423 + "PlayTrack", 2424 + )); 2805 2425 self.inner.unary(req, path, codec).await 2806 2426 } 2807 2427 pub async fn play_liked_tracks( 2808 2428 &mut self, 2809 2429 request: impl tonic::IntoRequest<super::PlayLikedTracksRequest>, 2810 - ) -> std::result::Result< 2811 - tonic::Response<super::PlayLikedTracksResponse>, 2812 - tonic::Status, 2813 - > { 2814 - self.inner 2815 - .ready() 2816 - .await 2817 - .map_err(|e| { 2818 - tonic::Status::unknown( 2819 - format!("Service was not ready: {}", e.into()), 2820 - ) 2821 - })?; 2430 + ) -> std::result::Result<tonic::Response<super::PlayLikedTracksResponse>, tonic::Status> 2431 + { 2432 + self.inner.ready().await.map_err(|e| { 2433 + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 2434 + })?; 2822 2435 let codec = tonic::codec::ProstCodec::default(); 2823 2436 let path = http::uri::PathAndQuery::from_static( 2824 2437 "/rockbox.v1alpha1.PlaybackService/PlayLikedTracks", 2825 2438 ); 2826 2439 let mut req = request.into_request(); 2827 - req.extensions_mut() 2828 - .insert( 2829 - GrpcMethod::new( 2830 - "rockbox.v1alpha1.PlaybackService", 2831 - "PlayLikedTracks", 2832 - ), 2833 - ); 2440 + req.extensions_mut().insert(GrpcMethod::new( 2441 + "rockbox.v1alpha1.PlaybackService", 2442 + "PlayLikedTracks", 2443 + )); 2834 2444 self.inner.unary(req, path, codec).await 2835 2445 } 2836 2446 pub async fn play_all_tracks( 2837 2447 &mut self, 2838 2448 request: impl tonic::IntoRequest<super::PlayAllTracksRequest>, 2839 - ) -> std::result::Result< 2840 - tonic::Response<super::PlayAllTracksResponse>, 2841 - tonic::Status, 2842 - > { 2843 - self.inner 2844 - .ready() 2845 - .await 2846 - .map_err(|e| { 2847 - tonic::Status::unknown( 2848 - format!("Service was not ready: {}", e.into()), 2849 - ) 2850 - })?; 2449 + ) -> std::result::Result<tonic::Response<super::PlayAllTracksResponse>, tonic::Status> 2450 + { 2451 + self.inner.ready().await.map_err(|e| { 2452 + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 2453 + })?; 2851 2454 let codec = tonic::codec::ProstCodec::default(); 2852 2455 let path = http::uri::PathAndQuery::from_static( 2853 2456 "/rockbox.v1alpha1.PlaybackService/PlayAllTracks", 2854 2457 ); 2855 2458 let mut req = request.into_request(); 2856 - req.extensions_mut() 2857 - .insert( 2858 - GrpcMethod::new("rockbox.v1alpha1.PlaybackService", "PlayAllTracks"), 2859 - ); 2459 + req.extensions_mut().insert(GrpcMethod::new( 2460 + "rockbox.v1alpha1.PlaybackService", 2461 + "PlayAllTracks", 2462 + )); 2860 2463 self.inner.unary(req, path, codec).await 2861 2464 } 2862 2465 pub async fn stream_current_track( ··· 2866 2469 tonic::Response<tonic::codec::Streaming<super::CurrentTrackResponse>>, 2867 2470 tonic::Status, 2868 2471 > { 2869 - self.inner 2870 - .ready() 2871 - .await 2872 - .map_err(|e| { 2873 - tonic::Status::unknown( 2874 - format!("Service was not ready: {}", e.into()), 2875 - ) 2876 - })?; 2472 + self.inner.ready().await.map_err(|e| { 2473 + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 2474 + })?; 2877 2475 let codec = tonic::codec::ProstCodec::default(); 2878 2476 let path = http::uri::PathAndQuery::from_static( 2879 2477 "/rockbox.v1alpha1.PlaybackService/StreamCurrentTrack", 2880 2478 ); 2881 2479 let mut req = request.into_request(); 2882 - req.extensions_mut() 2883 - .insert( 2884 - GrpcMethod::new( 2885 - "rockbox.v1alpha1.PlaybackService", 2886 - "StreamCurrentTrack", 2887 - ), 2888 - ); 2480 + req.extensions_mut().insert(GrpcMethod::new( 2481 + "rockbox.v1alpha1.PlaybackService", 2482 + "StreamCurrentTrack", 2483 + )); 2889 2484 self.inner.server_streaming(req, path, codec).await 2890 2485 } 2891 2486 pub async fn stream_status( ··· 2895 2490 tonic::Response<tonic::codec::Streaming<super::StatusResponse>>, 2896 2491 tonic::Status, 2897 2492 > { 2898 - self.inner 2899 - .ready() 2900 - .await 2901 - .map_err(|e| { 2902 - tonic::Status::unknown( 2903 - format!("Service was not ready: {}", e.into()), 2904 - ) 2905 - })?; 2493 + self.inner.ready().await.map_err(|e| { 2494 + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 2495 + })?; 2906 2496 let codec = tonic::codec::ProstCodec::default(); 2907 2497 let path = http::uri::PathAndQuery::from_static( 2908 2498 "/rockbox.v1alpha1.PlaybackService/StreamStatus", 2909 2499 ); 2910 2500 let mut req = request.into_request(); 2911 - req.extensions_mut() 2912 - .insert( 2913 - GrpcMethod::new("rockbox.v1alpha1.PlaybackService", "StreamStatus"), 2914 - ); 2501 + req.extensions_mut().insert(GrpcMethod::new( 2502 + "rockbox.v1alpha1.PlaybackService", 2503 + "StreamStatus", 2504 + )); 2915 2505 self.inner.server_streaming(req, path, codec).await 2916 2506 } 2917 2507 pub async fn stream_playlist( ··· 2921 2511 tonic::Response<tonic::codec::Streaming<super::PlaylistResponse>>, 2922 2512 tonic::Status, 2923 2513 > { 2924 - self.inner 2925 - .ready() 2926 - .await 2927 - .map_err(|e| { 2928 - tonic::Status::unknown( 2929 - format!("Service was not ready: {}", e.into()), 2930 - ) 2931 - })?; 2514 + self.inner.ready().await.map_err(|e| { 2515 + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 2516 + })?; 2932 2517 let codec = tonic::codec::ProstCodec::default(); 2933 2518 let path = http::uri::PathAndQuery::from_static( 2934 2519 "/rockbox.v1alpha1.PlaybackService/StreamPlaylist", 2935 2520 ); 2936 2521 let mut req = request.into_request(); 2937 - req.extensions_mut() 2938 - .insert( 2939 - GrpcMethod::new("rockbox.v1alpha1.PlaybackService", "StreamPlaylist"), 2940 - ); 2522 + req.extensions_mut().insert(GrpcMethod::new( 2523 + "rockbox.v1alpha1.PlaybackService", 2524 + "StreamPlaylist", 2525 + )); 2941 2526 self.inner.server_streaming(req, path, codec).await 2942 2527 } 2943 2528 } ··· 2949 2534 dead_code, 2950 2535 missing_docs, 2951 2536 clippy::wildcard_imports, 2952 - clippy::let_unit_value, 2537 + clippy::let_unit_value 2953 2538 )] 2954 2539 use tonic::codegen::*; 2955 2540 /// Generated trait containing gRPC methods that should be implemented for use with PlaybackServiceServer. ··· 2974 2559 async fn previous( 2975 2560 &self, 2976 2561 request: tonic::Request<super::PreviousRequest>, 2977 - ) -> std::result::Result< 2978 - tonic::Response<super::PreviousResponse>, 2979 - tonic::Status, 2980 - >; 2562 + ) -> std::result::Result<tonic::Response<super::PreviousResponse>, tonic::Status>; 2981 2563 async fn fast_forward_rewind( 2982 2564 &self, 2983 2565 request: tonic::Request<super::FastForwardRewindRequest>, 2984 - ) -> std::result::Result< 2985 - tonic::Response<super::FastForwardRewindResponse>, 2986 - tonic::Status, 2987 - >; 2566 + ) -> std::result::Result<tonic::Response<super::FastForwardRewindResponse>, tonic::Status>; 2988 2567 async fn status( 2989 2568 &self, 2990 2569 request: tonic::Request<super::StatusRequest>, ··· 2992 2571 async fn current_track( 2993 2572 &self, 2994 2573 request: tonic::Request<super::CurrentTrackRequest>, 2995 - ) -> std::result::Result< 2996 - tonic::Response<super::CurrentTrackResponse>, 2997 - tonic::Status, 2998 - >; 2574 + ) -> std::result::Result<tonic::Response<super::CurrentTrackResponse>, tonic::Status>; 2999 2575 async fn next_track( 3000 2576 &self, 3001 2577 request: tonic::Request<super::NextTrackRequest>, 3002 - ) -> std::result::Result< 3003 - tonic::Response<super::NextTrackResponse>, 3004 - tonic::Status, 3005 - >; 2578 + ) -> std::result::Result<tonic::Response<super::NextTrackResponse>, tonic::Status>; 3006 2579 async fn flush_and_reload_tracks( 3007 2580 &self, 3008 2581 request: tonic::Request<super::FlushAndReloadTracksRequest>, 3009 - ) -> std::result::Result< 3010 - tonic::Response<super::FlushAndReloadTracksResponse>, 3011 - tonic::Status, 3012 - >; 2582 + ) -> std::result::Result<tonic::Response<super::FlushAndReloadTracksResponse>, tonic::Status>; 3013 2583 async fn get_file_position( 3014 2584 &self, 3015 2585 request: tonic::Request<super::GetFilePositionRequest>, 3016 - ) -> std::result::Result< 3017 - tonic::Response<super::GetFilePositionResponse>, 3018 - tonic::Status, 3019 - >; 2586 + ) -> std::result::Result<tonic::Response<super::GetFilePositionResponse>, tonic::Status>; 3020 2587 async fn hard_stop( 3021 2588 &self, 3022 2589 request: tonic::Request<super::HardStopRequest>, 3023 - ) -> std::result::Result< 3024 - tonic::Response<super::HardStopResponse>, 3025 - tonic::Status, 3026 - >; 2590 + ) -> std::result::Result<tonic::Response<super::HardStopResponse>, tonic::Status>; 3027 2591 async fn play_album( 3028 2592 &self, 3029 2593 request: tonic::Request<super::PlayAlbumRequest>, 3030 - ) -> std::result::Result< 3031 - tonic::Response<super::PlayAlbumResponse>, 3032 - tonic::Status, 3033 - >; 2594 + ) -> std::result::Result<tonic::Response<super::PlayAlbumResponse>, tonic::Status>; 3034 2595 async fn play_artist_tracks( 3035 2596 &self, 3036 2597 request: tonic::Request<super::PlayArtistTracksRequest>, 3037 - ) -> std::result::Result< 3038 - tonic::Response<super::PlayArtistTracksResponse>, 3039 - tonic::Status, 3040 - >; 2598 + ) -> std::result::Result<tonic::Response<super::PlayArtistTracksResponse>, tonic::Status>; 3041 2599 async fn play_playlist( 3042 2600 &self, 3043 2601 request: tonic::Request<super::PlayPlaylistRequest>, 3044 - ) -> std::result::Result< 3045 - tonic::Response<super::PlayPlaylistResponse>, 3046 - tonic::Status, 3047 - >; 2602 + ) -> std::result::Result<tonic::Response<super::PlayPlaylistResponse>, tonic::Status>; 3048 2603 async fn play_directory( 3049 2604 &self, 3050 2605 request: tonic::Request<super::PlayDirectoryRequest>, 3051 - ) -> std::result::Result< 3052 - tonic::Response<super::PlayDirectoryResponse>, 3053 - tonic::Status, 3054 - >; 2606 + ) -> std::result::Result<tonic::Response<super::PlayDirectoryResponse>, tonic::Status>; 3055 2607 async fn play_track( 3056 2608 &self, 3057 2609 request: tonic::Request<super::PlayTrackRequest>, 3058 - ) -> std::result::Result< 3059 - tonic::Response<super::PlayTrackResponse>, 3060 - tonic::Status, 3061 - >; 2610 + ) -> std::result::Result<tonic::Response<super::PlayTrackResponse>, tonic::Status>; 3062 2611 async fn play_liked_tracks( 3063 2612 &self, 3064 2613 request: tonic::Request<super::PlayLikedTracksRequest>, 3065 - ) -> std::result::Result< 3066 - tonic::Response<super::PlayLikedTracksResponse>, 3067 - tonic::Status, 3068 - >; 2614 + ) -> std::result::Result<tonic::Response<super::PlayLikedTracksResponse>, tonic::Status>; 3069 2615 async fn play_all_tracks( 3070 2616 &self, 3071 2617 request: tonic::Request<super::PlayAllTracksRequest>, 3072 - ) -> std::result::Result< 3073 - tonic::Response<super::PlayAllTracksResponse>, 3074 - tonic::Status, 3075 - >; 2618 + ) -> std::result::Result<tonic::Response<super::PlayAllTracksResponse>, tonic::Status>; 3076 2619 /// Server streaming response type for the StreamCurrentTrack method. 3077 2620 type StreamCurrentTrackStream: tonic::codegen::tokio_stream::Stream< 3078 2621 Item = std::result::Result<super::CurrentTrackResponse, tonic::Status>, 3079 - > 3080 - + std::marker::Send 2622 + > + std::marker::Send 3081 2623 + 'static; 3082 2624 async fn stream_current_track( 3083 2625 &self, 3084 2626 request: tonic::Request<super::StreamCurrentTrackRequest>, 3085 - ) -> std::result::Result< 3086 - tonic::Response<Self::StreamCurrentTrackStream>, 3087 - tonic::Status, 3088 - >; 2627 + ) -> std::result::Result<tonic::Response<Self::StreamCurrentTrackStream>, tonic::Status>; 3089 2628 /// Server streaming response type for the StreamStatus method. 3090 2629 type StreamStatusStream: tonic::codegen::tokio_stream::Stream< 3091 2630 Item = std::result::Result<super::StatusResponse, tonic::Status>, 3092 - > 3093 - + std::marker::Send 2631 + > + std::marker::Send 3094 2632 + 'static; 3095 2633 async fn stream_status( 3096 2634 &self, 3097 2635 request: tonic::Request<super::StreamStatusRequest>, 3098 - ) -> std::result::Result< 3099 - tonic::Response<Self::StreamStatusStream>, 3100 - tonic::Status, 3101 - >; 2636 + ) -> std::result::Result<tonic::Response<Self::StreamStatusStream>, tonic::Status>; 3102 2637 /// Server streaming response type for the StreamPlaylist method. 3103 2638 type StreamPlaylistStream: tonic::codegen::tokio_stream::Stream< 3104 2639 Item = std::result::Result<super::PlaylistResponse, tonic::Status>, 3105 - > 3106 - + std::marker::Send 2640 + > + std::marker::Send 3107 2641 + 'static; 3108 2642 async fn stream_playlist( 3109 2643 &self, 3110 2644 request: tonic::Request<super::StreamPlaylistRequest>, 3111 - ) -> std::result::Result< 3112 - tonic::Response<Self::StreamPlaylistStream>, 3113 - tonic::Status, 3114 - >; 2645 + ) -> std::result::Result<tonic::Response<Self::StreamPlaylistStream>, tonic::Status>; 3115 2646 } 3116 2647 #[derive(Debug)] 3117 2648 pub struct PlaybackServiceServer<T> { ··· 3134 2665 max_encoding_message_size: None, 3135 2666 } 3136 2667 } 3137 - pub fn with_interceptor<F>( 3138 - inner: T, 3139 - interceptor: F, 3140 - ) -> InterceptedService<Self, F> 2668 + pub fn with_interceptor<F>(inner: T, interceptor: F) -> InterceptedService<Self, F> 3141 2669 where 3142 2670 F: tonic::service::Interceptor, 3143 2671 { ··· 3192 2720 "/rockbox.v1alpha1.PlaybackService/Play" => { 3193 2721 #[allow(non_camel_case_types)] 3194 2722 struct PlaySvc<T: PlaybackService>(pub Arc<T>); 3195 - impl< 3196 - T: PlaybackService, 3197 - > tonic::server::UnaryService<super::PlayRequest> for PlaySvc<T> { 2723 + impl<T: PlaybackService> tonic::server::UnaryService<super::PlayRequest> for PlaySvc<T> { 3198 2724 type Response = super::PlayResponse; 3199 - type Future = BoxFuture< 3200 - tonic::Response<Self::Response>, 3201 - tonic::Status, 3202 - >; 2725 + type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 3203 2726 fn call( 3204 2727 &mut self, 3205 2728 request: tonic::Request<super::PlayRequest>, 3206 2729 ) -> Self::Future { 3207 2730 let inner = Arc::clone(&self.0); 3208 - let fut = async move { 3209 - <T as PlaybackService>::play(&inner, request).await 3210 - }; 2731 + let fut = 2732 + async move { <T as PlaybackService>::play(&inner, request).await }; 3211 2733 Box::pin(fut) 3212 2734 } 3213 2735 } ··· 3236 2758 "/rockbox.v1alpha1.PlaybackService/Pause" => { 3237 2759 #[allow(non_camel_case_types)] 3238 2760 struct PauseSvc<T: PlaybackService>(pub Arc<T>); 3239 - impl< 3240 - T: PlaybackService, 3241 - > tonic::server::UnaryService<super::PauseRequest> for PauseSvc<T> { 2761 + impl<T: PlaybackService> tonic::server::UnaryService<super::PauseRequest> for PauseSvc<T> { 3242 2762 type Response = super::PauseResponse; 3243 - type Future = BoxFuture< 3244 - tonic::Response<Self::Response>, 3245 - tonic::Status, 3246 - >; 2763 + type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 3247 2764 fn call( 3248 2765 &mut self, 3249 2766 request: tonic::Request<super::PauseRequest>, 3250 2767 ) -> Self::Future { 3251 2768 let inner = Arc::clone(&self.0); 3252 - let fut = async move { 3253 - <T as PlaybackService>::pause(&inner, request).await 3254 - }; 2769 + let fut = 2770 + async move { <T as PlaybackService>::pause(&inner, request).await }; 3255 2771 Box::pin(fut) 3256 2772 } 3257 2773 } ··· 3280 2796 "/rockbox.v1alpha1.PlaybackService/Resume" => { 3281 2797 #[allow(non_camel_case_types)] 3282 2798 struct ResumeSvc<T: PlaybackService>(pub Arc<T>); 3283 - impl< 3284 - T: PlaybackService, 3285 - > tonic::server::UnaryService<super::ResumeRequest> 3286 - for ResumeSvc<T> { 2799 + impl<T: PlaybackService> tonic::server::UnaryService<super::ResumeRequest> for ResumeSvc<T> { 3287 2800 type Response = super::ResumeResponse; 3288 - type Future = BoxFuture< 3289 - tonic::Response<Self::Response>, 3290 - tonic::Status, 3291 - >; 2801 + type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 3292 2802 fn call( 3293 2803 &mut self, 3294 2804 request: tonic::Request<super::ResumeRequest>, ··· 3325 2835 "/rockbox.v1alpha1.PlaybackService/Next" => { 3326 2836 #[allow(non_camel_case_types)] 3327 2837 struct NextSvc<T: PlaybackService>(pub Arc<T>); 3328 - impl< 3329 - T: PlaybackService, 3330 - > tonic::server::UnaryService<super::NextRequest> for NextSvc<T> { 2838 + impl<T: PlaybackService> tonic::server::UnaryService<super::NextRequest> for NextSvc<T> { 3331 2839 type Response = super::NextResponse; 3332 - type Future = BoxFuture< 3333 - tonic::Response<Self::Response>, 3334 - tonic::Status, 3335 - >; 2840 + type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 3336 2841 fn call( 3337 2842 &mut self, 3338 2843 request: tonic::Request<super::NextRequest>, 3339 2844 ) -> Self::Future { 3340 2845 let inner = Arc::clone(&self.0); 3341 - let fut = async move { 3342 - <T as PlaybackService>::next(&inner, request).await 3343 - }; 2846 + let fut = 2847 + async move { <T as PlaybackService>::next(&inner, request).await }; 3344 2848 Box::pin(fut) 3345 2849 } 3346 2850 } ··· 3369 2873 "/rockbox.v1alpha1.PlaybackService/Previous" => { 3370 2874 #[allow(non_camel_case_types)] 3371 2875 struct PreviousSvc<T: PlaybackService>(pub Arc<T>); 3372 - impl< 3373 - T: PlaybackService, 3374 - > tonic::server::UnaryService<super::PreviousRequest> 3375 - for PreviousSvc<T> { 2876 + impl<T: PlaybackService> tonic::server::UnaryService<super::PreviousRequest> for PreviousSvc<T> { 3376 2877 type Response = super::PreviousResponse; 3377 - type Future = BoxFuture< 3378 - tonic::Response<Self::Response>, 3379 - tonic::Status, 3380 - >; 2878 + type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 3381 2879 fn call( 3382 2880 &mut self, 3383 2881 request: tonic::Request<super::PreviousRequest>, ··· 3414 2912 "/rockbox.v1alpha1.PlaybackService/FastForwardRewind" => { 3415 2913 #[allow(non_camel_case_types)] 3416 2914 struct FastForwardRewindSvc<T: PlaybackService>(pub Arc<T>); 3417 - impl< 3418 - T: PlaybackService, 3419 - > tonic::server::UnaryService<super::FastForwardRewindRequest> 3420 - for FastForwardRewindSvc<T> { 2915 + impl<T: PlaybackService> 2916 + tonic::server::UnaryService<super::FastForwardRewindRequest> 2917 + for FastForwardRewindSvc<T> 2918 + { 3421 2919 type Response = super::FastForwardRewindResponse; 3422 - type Future = BoxFuture< 3423 - tonic::Response<Self::Response>, 3424 - tonic::Status, 3425 - >; 2920 + type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 3426 2921 fn call( 3427 2922 &mut self, 3428 2923 request: tonic::Request<super::FastForwardRewindRequest>, 3429 2924 ) -> Self::Future { 3430 2925 let inner = Arc::clone(&self.0); 3431 2926 let fut = async move { 3432 - <T as PlaybackService>::fast_forward_rewind(&inner, request) 3433 - .await 2927 + <T as PlaybackService>::fast_forward_rewind(&inner, request).await 3434 2928 }; 3435 2929 Box::pin(fut) 3436 2930 } ··· 3460 2954 "/rockbox.v1alpha1.PlaybackService/Status" => { 3461 2955 #[allow(non_camel_case_types)] 3462 2956 struct StatusSvc<T: PlaybackService>(pub Arc<T>); 3463 - impl< 3464 - T: PlaybackService, 3465 - > tonic::server::UnaryService<super::StatusRequest> 3466 - for StatusSvc<T> { 2957 + impl<T: PlaybackService> tonic::server::UnaryService<super::StatusRequest> for StatusSvc<T> { 3467 2958 type Response = super::StatusResponse; 3468 - type Future = BoxFuture< 3469 - tonic::Response<Self::Response>, 3470 - tonic::Status, 3471 - >; 2959 + type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 3472 2960 fn call( 3473 2961 &mut self, 3474 2962 request: tonic::Request<super::StatusRequest>, ··· 3505 2993 "/rockbox.v1alpha1.PlaybackService/CurrentTrack" => { 3506 2994 #[allow(non_camel_case_types)] 3507 2995 struct CurrentTrackSvc<T: PlaybackService>(pub Arc<T>); 3508 - impl< 3509 - T: PlaybackService, 3510 - > tonic::server::UnaryService<super::CurrentTrackRequest> 3511 - for CurrentTrackSvc<T> { 2996 + impl<T: PlaybackService> tonic::server::UnaryService<super::CurrentTrackRequest> 2997 + for CurrentTrackSvc<T> 2998 + { 3512 2999 type Response = super::CurrentTrackResponse; 3513 - type Future = BoxFuture< 3514 - tonic::Response<Self::Response>, 3515 - tonic::Status, 3516 - >; 3000 + type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 3517 3001 fn call( 3518 3002 &mut self, 3519 3003 request: tonic::Request<super::CurrentTrackRequest>, ··· 3550 3034 "/rockbox.v1alpha1.PlaybackService/NextTrack" => { 3551 3035 #[allow(non_camel_case_types)] 3552 3036 struct NextTrackSvc<T: PlaybackService>(pub Arc<T>); 3553 - impl< 3554 - T: PlaybackService, 3555 - > tonic::server::UnaryService<super::NextTrackRequest> 3556 - for NextTrackSvc<T> { 3037 + impl<T: PlaybackService> tonic::server::UnaryService<super::NextTrackRequest> for NextTrackSvc<T> { 3557 3038 type Response = super::NextTrackResponse; 3558 - type Future = BoxFuture< 3559 - tonic::Response<Self::Response>, 3560 - tonic::Status, 3561 - >; 3039 + type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 3562 3040 fn call( 3563 3041 &mut self, 3564 3042 request: tonic::Request<super::NextTrackRequest>, ··· 3595 3073 "/rockbox.v1alpha1.PlaybackService/FlushAndReloadTracks" => { 3596 3074 #[allow(non_camel_case_types)] 3597 3075 struct FlushAndReloadTracksSvc<T: PlaybackService>(pub Arc<T>); 3598 - impl< 3599 - T: PlaybackService, 3600 - > tonic::server::UnaryService<super::FlushAndReloadTracksRequest> 3601 - for FlushAndReloadTracksSvc<T> { 3076 + impl<T: PlaybackService> 3077 + tonic::server::UnaryService<super::FlushAndReloadTracksRequest> 3078 + for FlushAndReloadTracksSvc<T> 3079 + { 3602 3080 type Response = super::FlushAndReloadTracksResponse; 3603 - type Future = BoxFuture< 3604 - tonic::Response<Self::Response>, 3605 - tonic::Status, 3606 - >; 3081 + type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 3607 3082 fn call( 3608 3083 &mut self, 3609 3084 request: tonic::Request<super::FlushAndReloadTracksRequest>, 3610 3085 ) -> Self::Future { 3611 3086 let inner = Arc::clone(&self.0); 3612 3087 let fut = async move { 3613 - <T as PlaybackService>::flush_and_reload_tracks( 3614 - &inner, 3615 - request, 3616 - ) 3088 + <T as PlaybackService>::flush_and_reload_tracks(&inner, request) 3617 3089 .await 3618 3090 }; 3619 3091 Box::pin(fut) ··· 3644 3116 "/rockbox.v1alpha1.PlaybackService/GetFilePosition" => { 3645 3117 #[allow(non_camel_case_types)] 3646 3118 struct GetFilePositionSvc<T: PlaybackService>(pub Arc<T>); 3647 - impl< 3648 - T: PlaybackService, 3649 - > tonic::server::UnaryService<super::GetFilePositionRequest> 3650 - for GetFilePositionSvc<T> { 3119 + impl<T: PlaybackService> 3120 + tonic::server::UnaryService<super::GetFilePositionRequest> 3121 + for GetFilePositionSvc<T> 3122 + { 3651 3123 type Response = super::GetFilePositionResponse; 3652 - type Future = BoxFuture< 3653 - tonic::Response<Self::Response>, 3654 - tonic::Status, 3655 - >; 3124 + type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 3656 3125 fn call( 3657 3126 &mut self, 3658 3127 request: tonic::Request<super::GetFilePositionRequest>, 3659 3128 ) -> Self::Future { 3660 3129 let inner = Arc::clone(&self.0); 3661 3130 let fut = async move { 3662 - <T as PlaybackService>::get_file_position(&inner, request) 3663 - .await 3131 + <T as PlaybackService>::get_file_position(&inner, request).await 3664 3132 }; 3665 3133 Box::pin(fut) 3666 3134 } ··· 3690 3158 "/rockbox.v1alpha1.PlaybackService/HardStop" => { 3691 3159 #[allow(non_camel_case_types)] 3692 3160 struct HardStopSvc<T: PlaybackService>(pub Arc<T>); 3693 - impl< 3694 - T: PlaybackService, 3695 - > tonic::server::UnaryService<super::HardStopRequest> 3696 - for HardStopSvc<T> { 3161 + impl<T: PlaybackService> tonic::server::UnaryService<super::HardStopRequest> for HardStopSvc<T> { 3697 3162 type Response = super::HardStopResponse; 3698 - type Future = BoxFuture< 3699 - tonic::Response<Self::Response>, 3700 - tonic::Status, 3701 - >; 3163 + type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 3702 3164 fn call( 3703 3165 &mut self, 3704 3166 request: tonic::Request<super::HardStopRequest>, ··· 3735 3197 "/rockbox.v1alpha1.PlaybackService/PlayAlbum" => { 3736 3198 #[allow(non_camel_case_types)] 3737 3199 struct PlayAlbumSvc<T: PlaybackService>(pub Arc<T>); 3738 - impl< 3739 - T: PlaybackService, 3740 - > tonic::server::UnaryService<super::PlayAlbumRequest> 3741 - for PlayAlbumSvc<T> { 3200 + impl<T: PlaybackService> tonic::server::UnaryService<super::PlayAlbumRequest> for PlayAlbumSvc<T> { 3742 3201 type Response = super::PlayAlbumResponse; 3743 - type Future = BoxFuture< 3744 - tonic::Response<Self::Response>, 3745 - tonic::Status, 3746 - >; 3202 + type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 3747 3203 fn call( 3748 3204 &mut self, 3749 3205 request: tonic::Request<super::PlayAlbumRequest>, ··· 3780 3236 "/rockbox.v1alpha1.PlaybackService/PlayArtistTracks" => { 3781 3237 #[allow(non_camel_case_types)] 3782 3238 struct PlayArtistTracksSvc<T: PlaybackService>(pub Arc<T>); 3783 - impl< 3784 - T: PlaybackService, 3785 - > tonic::server::UnaryService<super::PlayArtistTracksRequest> 3786 - for PlayArtistTracksSvc<T> { 3239 + impl<T: PlaybackService> 3240 + tonic::server::UnaryService<super::PlayArtistTracksRequest> 3241 + for PlayArtistTracksSvc<T> 3242 + { 3787 3243 type Response = super::PlayArtistTracksResponse; 3788 - type Future = BoxFuture< 3789 - tonic::Response<Self::Response>, 3790 - tonic::Status, 3791 - >; 3244 + type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 3792 3245 fn call( 3793 3246 &mut self, 3794 3247 request: tonic::Request<super::PlayArtistTracksRequest>, 3795 3248 ) -> Self::Future { 3796 3249 let inner = Arc::clone(&self.0); 3797 3250 let fut = async move { 3798 - <T as PlaybackService>::play_artist_tracks(&inner, request) 3799 - .await 3251 + <T as PlaybackService>::play_artist_tracks(&inner, request).await 3800 3252 }; 3801 3253 Box::pin(fut) 3802 3254 } ··· 3826 3278 "/rockbox.v1alpha1.PlaybackService/PlayPlaylist" => { 3827 3279 #[allow(non_camel_case_types)] 3828 3280 struct PlayPlaylistSvc<T: PlaybackService>(pub Arc<T>); 3829 - impl< 3830 - T: PlaybackService, 3831 - > tonic::server::UnaryService<super::PlayPlaylistRequest> 3832 - for PlayPlaylistSvc<T> { 3281 + impl<T: PlaybackService> tonic::server::UnaryService<super::PlayPlaylistRequest> 3282 + for PlayPlaylistSvc<T> 3283 + { 3833 3284 type Response = super::PlayPlaylistResponse; 3834 - type Future = BoxFuture< 3835 - tonic::Response<Self::Response>, 3836 - tonic::Status, 3837 - >; 3285 + type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 3838 3286 fn call( 3839 3287 &mut self, 3840 3288 request: tonic::Request<super::PlayPlaylistRequest>, ··· 3871 3319 "/rockbox.v1alpha1.PlaybackService/PlayDirectory" => { 3872 3320 #[allow(non_camel_case_types)] 3873 3321 struct PlayDirectorySvc<T: PlaybackService>(pub Arc<T>); 3874 - impl< 3875 - T: PlaybackService, 3876 - > tonic::server::UnaryService<super::PlayDirectoryRequest> 3877 - for PlayDirectorySvc<T> { 3322 + impl<T: PlaybackService> 3323 + tonic::server::UnaryService<super::PlayDirectoryRequest> 3324 + for PlayDirectorySvc<T> 3325 + { 3878 3326 type Response = super::PlayDirectoryResponse; 3879 - type Future = BoxFuture< 3880 - tonic::Response<Self::Response>, 3881 - tonic::Status, 3882 - >; 3327 + type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 3883 3328 fn call( 3884 3329 &mut self, 3885 3330 request: tonic::Request<super::PlayDirectoryRequest>, 3886 3331 ) -> Self::Future { 3887 3332 let inner = Arc::clone(&self.0); 3888 3333 let fut = async move { 3889 - <T as PlaybackService>::play_directory(&inner, request) 3890 - .await 3334 + <T as PlaybackService>::play_directory(&inner, request).await 3891 3335 }; 3892 3336 Box::pin(fut) 3893 3337 } ··· 3917 3361 "/rockbox.v1alpha1.PlaybackService/PlayTrack" => { 3918 3362 #[allow(non_camel_case_types)] 3919 3363 struct PlayTrackSvc<T: PlaybackService>(pub Arc<T>); 3920 - impl< 3921 - T: PlaybackService, 3922 - > tonic::server::UnaryService<super::PlayTrackRequest> 3923 - for PlayTrackSvc<T> { 3364 + impl<T: PlaybackService> tonic::server::UnaryService<super::PlayTrackRequest> for PlayTrackSvc<T> { 3924 3365 type Response = super::PlayTrackResponse; 3925 - type Future = BoxFuture< 3926 - tonic::Response<Self::Response>, 3927 - tonic::Status, 3928 - >; 3366 + type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 3929 3367 fn call( 3930 3368 &mut self, 3931 3369 request: tonic::Request<super::PlayTrackRequest>, ··· 3962 3400 "/rockbox.v1alpha1.PlaybackService/PlayLikedTracks" => { 3963 3401 #[allow(non_camel_case_types)] 3964 3402 struct PlayLikedTracksSvc<T: PlaybackService>(pub Arc<T>); 3965 - impl< 3966 - T: PlaybackService, 3967 - > tonic::server::UnaryService<super::PlayLikedTracksRequest> 3968 - for PlayLikedTracksSvc<T> { 3403 + impl<T: PlaybackService> 3404 + tonic::server::UnaryService<super::PlayLikedTracksRequest> 3405 + for PlayLikedTracksSvc<T> 3406 + { 3969 3407 type Response = super::PlayLikedTracksResponse; 3970 - type Future = BoxFuture< 3971 - tonic::Response<Self::Response>, 3972 - tonic::Status, 3973 - >; 3408 + type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 3974 3409 fn call( 3975 3410 &mut self, 3976 3411 request: tonic::Request<super::PlayLikedTracksRequest>, 3977 3412 ) -> Self::Future { 3978 3413 let inner = Arc::clone(&self.0); 3979 3414 let fut = async move { 3980 - <T as PlaybackService>::play_liked_tracks(&inner, request) 3981 - .await 3415 + <T as PlaybackService>::play_liked_tracks(&inner, request).await 3982 3416 }; 3983 3417 Box::pin(fut) 3984 3418 } ··· 4008 3442 "/rockbox.v1alpha1.PlaybackService/PlayAllTracks" => { 4009 3443 #[allow(non_camel_case_types)] 4010 3444 struct PlayAllTracksSvc<T: PlaybackService>(pub Arc<T>); 4011 - impl< 4012 - T: PlaybackService, 4013 - > tonic::server::UnaryService<super::PlayAllTracksRequest> 4014 - for PlayAllTracksSvc<T> { 3445 + impl<T: PlaybackService> 3446 + tonic::server::UnaryService<super::PlayAllTracksRequest> 3447 + for PlayAllTracksSvc<T> 3448 + { 4015 3449 type Response = super::PlayAllTracksResponse; 4016 - type Future = BoxFuture< 4017 - tonic::Response<Self::Response>, 4018 - tonic::Status, 4019 - >; 3450 + type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 4020 3451 fn call( 4021 3452 &mut self, 4022 3453 request: tonic::Request<super::PlayAllTracksRequest>, 4023 3454 ) -> Self::Future { 4024 3455 let inner = Arc::clone(&self.0); 4025 3456 let fut = async move { 4026 - <T as PlaybackService>::play_all_tracks(&inner, request) 4027 - .await 3457 + <T as PlaybackService>::play_all_tracks(&inner, request).await 4028 3458 }; 4029 3459 Box::pin(fut) 4030 3460 } ··· 4054 3484 "/rockbox.v1alpha1.PlaybackService/StreamCurrentTrack" => { 4055 3485 #[allow(non_camel_case_types)] 4056 3486 struct StreamCurrentTrackSvc<T: PlaybackService>(pub Arc<T>); 4057 - impl< 4058 - T: PlaybackService, 4059 - > tonic::server::ServerStreamingService< 4060 - super::StreamCurrentTrackRequest, 4061 - > for StreamCurrentTrackSvc<T> { 3487 + impl<T: PlaybackService> 3488 + tonic::server::ServerStreamingService<super::StreamCurrentTrackRequest> 3489 + for StreamCurrentTrackSvc<T> 3490 + { 4062 3491 type Response = super::CurrentTrackResponse; 4063 3492 type ResponseStream = T::StreamCurrentTrackStream; 4064 - type Future = BoxFuture< 4065 - tonic::Response<Self::ResponseStream>, 4066 - tonic::Status, 4067 - >; 3493 + type Future = 3494 + BoxFuture<tonic::Response<Self::ResponseStream>, tonic::Status>; 4068 3495 fn call( 4069 3496 &mut self, 4070 3497 request: tonic::Request<super::StreamCurrentTrackRequest>, 4071 3498 ) -> Self::Future { 4072 3499 let inner = Arc::clone(&self.0); 4073 3500 let fut = async move { 4074 - <T as PlaybackService>::stream_current_track( 4075 - &inner, 4076 - request, 4077 - ) 4078 - .await 3501 + <T as PlaybackService>::stream_current_track(&inner, request).await 4079 3502 }; 4080 3503 Box::pin(fut) 4081 3504 } ··· 4105 3528 "/rockbox.v1alpha1.PlaybackService/StreamStatus" => { 4106 3529 #[allow(non_camel_case_types)] 4107 3530 struct StreamStatusSvc<T: PlaybackService>(pub Arc<T>); 4108 - impl< 4109 - T: PlaybackService, 4110 - > tonic::server::ServerStreamingService<super::StreamStatusRequest> 4111 - for StreamStatusSvc<T> { 3531 + impl<T: PlaybackService> 3532 + tonic::server::ServerStreamingService<super::StreamStatusRequest> 3533 + for StreamStatusSvc<T> 3534 + { 4112 3535 type Response = super::StatusResponse; 4113 3536 type ResponseStream = T::StreamStatusStream; 4114 - type Future = BoxFuture< 4115 - tonic::Response<Self::ResponseStream>, 4116 - tonic::Status, 4117 - >; 3537 + type Future = 3538 + BoxFuture<tonic::Response<Self::ResponseStream>, tonic::Status>; 4118 3539 fn call( 4119 3540 &mut self, 4120 3541 request: tonic::Request<super::StreamStatusRequest>, ··· 4151 3572 "/rockbox.v1alpha1.PlaybackService/StreamPlaylist" => { 4152 3573 #[allow(non_camel_case_types)] 4153 3574 struct StreamPlaylistSvc<T: PlaybackService>(pub Arc<T>); 4154 - impl< 4155 - T: PlaybackService, 4156 - > tonic::server::ServerStreamingService<super::StreamPlaylistRequest> 4157 - for StreamPlaylistSvc<T> { 3575 + impl<T: PlaybackService> 3576 + tonic::server::ServerStreamingService<super::StreamPlaylistRequest> 3577 + for StreamPlaylistSvc<T> 3578 + { 4158 3579 type Response = super::PlaylistResponse; 4159 3580 type ResponseStream = T::StreamPlaylistStream; 4160 - type Future = BoxFuture< 4161 - tonic::Response<Self::ResponseStream>, 4162 - tonic::Status, 4163 - >; 3581 + type Future = 3582 + BoxFuture<tonic::Response<Self::ResponseStream>, tonic::Status>; 4164 3583 fn call( 4165 3584 &mut self, 4166 3585 request: tonic::Request<super::StreamPlaylistRequest>, 4167 3586 ) -> Self::Future { 4168 3587 let inner = Arc::clone(&self.0); 4169 3588 let fut = async move { 4170 - <T as PlaybackService>::stream_playlist(&inner, request) 4171 - .await 3589 + <T as PlaybackService>::stream_playlist(&inner, request).await 4172 3590 }; 4173 3591 Box::pin(fut) 4174 3592 } ··· 4195 3613 }; 4196 3614 Box::pin(fut) 4197 3615 } 4198 - _ => { 4199 - Box::pin(async move { 4200 - let mut response = http::Response::new(empty_body()); 4201 - let headers = response.headers_mut(); 4202 - headers 4203 - .insert( 4204 - tonic::Status::GRPC_STATUS, 4205 - (tonic::Code::Unimplemented as i32).into(), 4206 - ); 4207 - headers 4208 - .insert( 4209 - http::header::CONTENT_TYPE, 4210 - tonic::metadata::GRPC_CONTENT_TYPE, 4211 - ); 4212 - Ok(response) 4213 - }) 4214 - } 3616 + _ => Box::pin(async move { 3617 + let mut response = http::Response::new(empty_body()); 3618 + let headers = response.headers_mut(); 3619 + headers.insert( 3620 + tonic::Status::GRPC_STATUS, 3621 + (tonic::Code::Unimplemented as i32).into(), 3622 + ); 3623 + headers.insert( 3624 + http::header::CONTENT_TYPE, 3625 + tonic::metadata::GRPC_CONTENT_TYPE, 3626 + ); 3627 + Ok(response) 3628 + }), 4215 3629 } 4216 3630 } 4217 3631 } ··· 4416 3830 dead_code, 4417 3831 missing_docs, 4418 3832 clippy::wildcard_imports, 4419 - clippy::let_unit_value, 3833 + clippy::let_unit_value 4420 3834 )] 4421 - use tonic::codegen::*; 4422 3835 use tonic::codegen::http::Uri; 3836 + use tonic::codegen::*; 4423 3837 #[derive(Debug, Clone)] 4424 3838 pub struct PlaylistServiceClient<T> { 4425 3839 inner: tonic::client::Grpc<T>, ··· 4463 3877 <T as tonic::client::GrpcService<tonic::body::BoxBody>>::ResponseBody, 4464 3878 >, 4465 3879 >, 4466 - <T as tonic::codegen::Service< 4467 - http::Request<tonic::body::BoxBody>, 4468 - >>::Error: Into<StdError> + std::marker::Send + std::marker::Sync, 3880 + <T as tonic::codegen::Service<http::Request<tonic::body::BoxBody>>>::Error: 3881 + Into<StdError> + std::marker::Send + std::marker::Sync, 4469 3882 { 4470 3883 PlaylistServiceClient::new(InterceptedService::new(inner, interceptor)) 4471 3884 } ··· 4503 3916 pub async fn get_current( 4504 3917 &mut self, 4505 3918 request: impl tonic::IntoRequest<super::GetCurrentRequest>, 4506 - ) -> std::result::Result< 4507 - tonic::Response<super::GetCurrentResponse>, 4508 - tonic::Status, 4509 - > { 4510 - self.inner 4511 - .ready() 4512 - .await 4513 - .map_err(|e| { 4514 - tonic::Status::unknown( 4515 - format!("Service was not ready: {}", e.into()), 4516 - ) 4517 - })?; 3919 + ) -> std::result::Result<tonic::Response<super::GetCurrentResponse>, tonic::Status> 3920 + { 3921 + self.inner.ready().await.map_err(|e| { 3922 + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 3923 + })?; 4518 3924 let codec = tonic::codec::ProstCodec::default(); 4519 3925 let path = http::uri::PathAndQuery::from_static( 4520 3926 "/rockbox.v1alpha1.PlaylistService/GetCurrent", 4521 3927 ); 4522 3928 let mut req = request.into_request(); 4523 - req.extensions_mut() 4524 - .insert( 4525 - GrpcMethod::new("rockbox.v1alpha1.PlaylistService", "GetCurrent"), 4526 - ); 3929 + req.extensions_mut().insert(GrpcMethod::new( 3930 + "rockbox.v1alpha1.PlaylistService", 3931 + "GetCurrent", 3932 + )); 4527 3933 self.inner.unary(req, path, codec).await 4528 3934 } 4529 3935 pub async fn get_resume_info( 4530 3936 &mut self, 4531 3937 request: impl tonic::IntoRequest<super::GetResumeInfoRequest>, 4532 - ) -> std::result::Result< 4533 - tonic::Response<super::GetResumeInfoResponse>, 4534 - tonic::Status, 4535 - > { 4536 - self.inner 4537 - .ready() 4538 - .await 4539 - .map_err(|e| { 4540 - tonic::Status::unknown( 4541 - format!("Service was not ready: {}", e.into()), 4542 - ) 4543 - })?; 3938 + ) -> std::result::Result<tonic::Response<super::GetResumeInfoResponse>, tonic::Status> 3939 + { 3940 + self.inner.ready().await.map_err(|e| { 3941 + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 3942 + })?; 4544 3943 let codec = tonic::codec::ProstCodec::default(); 4545 3944 let path = http::uri::PathAndQuery::from_static( 4546 3945 "/rockbox.v1alpha1.PlaylistService/GetResumeInfo", 4547 3946 ); 4548 3947 let mut req = request.into_request(); 4549 - req.extensions_mut() 4550 - .insert( 4551 - GrpcMethod::new("rockbox.v1alpha1.PlaylistService", "GetResumeInfo"), 4552 - ); 3948 + req.extensions_mut().insert(GrpcMethod::new( 3949 + "rockbox.v1alpha1.PlaylistService", 3950 + "GetResumeInfo", 3951 + )); 4553 3952 self.inner.unary(req, path, codec).await 4554 3953 } 4555 3954 pub async fn get_track_info( 4556 3955 &mut self, 4557 3956 request: impl tonic::IntoRequest<super::GetTrackInfoRequest>, 4558 - ) -> std::result::Result< 4559 - tonic::Response<super::GetTrackInfoResponse>, 4560 - tonic::Status, 4561 - > { 4562 - self.inner 4563 - .ready() 4564 - .await 4565 - .map_err(|e| { 4566 - tonic::Status::unknown( 4567 - format!("Service was not ready: {}", e.into()), 4568 - ) 4569 - })?; 3957 + ) -> std::result::Result<tonic::Response<super::GetTrackInfoResponse>, tonic::Status> 3958 + { 3959 + self.inner.ready().await.map_err(|e| { 3960 + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 3961 + })?; 4570 3962 let codec = tonic::codec::ProstCodec::default(); 4571 3963 let path = http::uri::PathAndQuery::from_static( 4572 3964 "/rockbox.v1alpha1.PlaylistService/GetTrackInfo", 4573 3965 ); 4574 3966 let mut req = request.into_request(); 4575 - req.extensions_mut() 4576 - .insert( 4577 - GrpcMethod::new("rockbox.v1alpha1.PlaylistService", "GetTrackInfo"), 4578 - ); 3967 + req.extensions_mut().insert(GrpcMethod::new( 3968 + "rockbox.v1alpha1.PlaylistService", 3969 + "GetTrackInfo", 3970 + )); 4579 3971 self.inner.unary(req, path, codec).await 4580 3972 } 4581 3973 pub async fn get_first_index( 4582 3974 &mut self, 4583 3975 request: impl tonic::IntoRequest<super::GetFirstIndexRequest>, 4584 - ) -> std::result::Result< 4585 - tonic::Response<super::GetFirstIndexResponse>, 4586 - tonic::Status, 4587 - > { 4588 - self.inner 4589 - .ready() 4590 - .await 4591 - .map_err(|e| { 4592 - tonic::Status::unknown( 4593 - format!("Service was not ready: {}", e.into()), 4594 - ) 4595 - })?; 3976 + ) -> std::result::Result<tonic::Response<super::GetFirstIndexResponse>, tonic::Status> 3977 + { 3978 + self.inner.ready().await.map_err(|e| { 3979 + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 3980 + })?; 4596 3981 let codec = tonic::codec::ProstCodec::default(); 4597 3982 let path = http::uri::PathAndQuery::from_static( 4598 3983 "/rockbox.v1alpha1.PlaylistService/GetFirstIndex", 4599 3984 ); 4600 3985 let mut req = request.into_request(); 4601 - req.extensions_mut() 4602 - .insert( 4603 - GrpcMethod::new("rockbox.v1alpha1.PlaylistService", "GetFirstIndex"), 4604 - ); 3986 + req.extensions_mut().insert(GrpcMethod::new( 3987 + "rockbox.v1alpha1.PlaylistService", 3988 + "GetFirstIndex", 3989 + )); 4605 3990 self.inner.unary(req, path, codec).await 4606 3991 } 4607 3992 pub async fn get_display_index( 4608 3993 &mut self, 4609 3994 request: impl tonic::IntoRequest<super::GetDisplayIndexRequest>, 4610 - ) -> std::result::Result< 4611 - tonic::Response<super::GetDisplayIndexResponse>, 4612 - tonic::Status, 4613 - > { 4614 - self.inner 4615 - .ready() 4616 - .await 4617 - .map_err(|e| { 4618 - tonic::Status::unknown( 4619 - format!("Service was not ready: {}", e.into()), 4620 - ) 4621 - })?; 3995 + ) -> std::result::Result<tonic::Response<super::GetDisplayIndexResponse>, tonic::Status> 3996 + { 3997 + self.inner.ready().await.map_err(|e| { 3998 + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 3999 + })?; 4622 4000 let codec = tonic::codec::ProstCodec::default(); 4623 4001 let path = http::uri::PathAndQuery::from_static( 4624 4002 "/rockbox.v1alpha1.PlaylistService/GetDisplayIndex", 4625 4003 ); 4626 4004 let mut req = request.into_request(); 4627 - req.extensions_mut() 4628 - .insert( 4629 - GrpcMethod::new( 4630 - "rockbox.v1alpha1.PlaylistService", 4631 - "GetDisplayIndex", 4632 - ), 4633 - ); 4005 + req.extensions_mut().insert(GrpcMethod::new( 4006 + "rockbox.v1alpha1.PlaylistService", 4007 + "GetDisplayIndex", 4008 + )); 4634 4009 self.inner.unary(req, path, codec).await 4635 4010 } 4636 4011 pub async fn amount( 4637 4012 &mut self, 4638 4013 request: impl tonic::IntoRequest<super::AmountRequest>, 4639 4014 ) -> std::result::Result<tonic::Response<super::AmountResponse>, tonic::Status> { 4640 - self.inner 4641 - .ready() 4642 - .await 4643 - .map_err(|e| { 4644 - tonic::Status::unknown( 4645 - format!("Service was not ready: {}", e.into()), 4646 - ) 4647 - })?; 4015 + self.inner.ready().await.map_err(|e| { 4016 + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 4017 + })?; 4648 4018 let codec = tonic::codec::ProstCodec::default(); 4649 - let path = http::uri::PathAndQuery::from_static( 4650 - "/rockbox.v1alpha1.PlaylistService/Amount", 4651 - ); 4019 + let path = 4020 + http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.PlaylistService/Amount"); 4652 4021 let mut req = request.into_request(); 4653 - req.extensions_mut() 4654 - .insert(GrpcMethod::new("rockbox.v1alpha1.PlaylistService", "Amount")); 4022 + req.extensions_mut().insert(GrpcMethod::new( 4023 + "rockbox.v1alpha1.PlaylistService", 4024 + "Amount", 4025 + )); 4655 4026 self.inner.unary(req, path, codec).await 4656 4027 } 4657 4028 pub async fn playlist_resume( 4658 4029 &mut self, 4659 4030 request: impl tonic::IntoRequest<super::PlaylistResumeRequest>, 4660 - ) -> std::result::Result< 4661 - tonic::Response<super::PlaylistResumeResponse>, 4662 - tonic::Status, 4663 - > { 4664 - self.inner 4665 - .ready() 4666 - .await 4667 - .map_err(|e| { 4668 - tonic::Status::unknown( 4669 - format!("Service was not ready: {}", e.into()), 4670 - ) 4671 - })?; 4031 + ) -> std::result::Result<tonic::Response<super::PlaylistResumeResponse>, tonic::Status> 4032 + { 4033 + self.inner.ready().await.map_err(|e| { 4034 + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 4035 + })?; 4672 4036 let codec = tonic::codec::ProstCodec::default(); 4673 4037 let path = http::uri::PathAndQuery::from_static( 4674 4038 "/rockbox.v1alpha1.PlaylistService/PlaylistResume", 4675 4039 ); 4676 4040 let mut req = request.into_request(); 4677 - req.extensions_mut() 4678 - .insert( 4679 - GrpcMethod::new("rockbox.v1alpha1.PlaylistService", "PlaylistResume"), 4680 - ); 4041 + req.extensions_mut().insert(GrpcMethod::new( 4042 + "rockbox.v1alpha1.PlaylistService", 4043 + "PlaylistResume", 4044 + )); 4681 4045 self.inner.unary(req, path, codec).await 4682 4046 } 4683 4047 pub async fn resume_track( 4684 4048 &mut self, 4685 4049 request: impl tonic::IntoRequest<super::ResumeTrackRequest>, 4686 - ) -> std::result::Result< 4687 - tonic::Response<super::ResumeTrackResponse>, 4688 - tonic::Status, 4689 - > { 4690 - self.inner 4691 - .ready() 4692 - .await 4693 - .map_err(|e| { 4694 - tonic::Status::unknown( 4695 - format!("Service was not ready: {}", e.into()), 4696 - ) 4697 - })?; 4050 + ) -> std::result::Result<tonic::Response<super::ResumeTrackResponse>, tonic::Status> 4051 + { 4052 + self.inner.ready().await.map_err(|e| { 4053 + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 4054 + })?; 4698 4055 let codec = tonic::codec::ProstCodec::default(); 4699 4056 let path = http::uri::PathAndQuery::from_static( 4700 4057 "/rockbox.v1alpha1.PlaylistService/ResumeTrack", 4701 4058 ); 4702 4059 let mut req = request.into_request(); 4703 - req.extensions_mut() 4704 - .insert( 4705 - GrpcMethod::new("rockbox.v1alpha1.PlaylistService", "ResumeTrack"), 4706 - ); 4060 + req.extensions_mut().insert(GrpcMethod::new( 4061 + "rockbox.v1alpha1.PlaylistService", 4062 + "ResumeTrack", 4063 + )); 4707 4064 self.inner.unary(req, path, codec).await 4708 4065 } 4709 4066 pub async fn set_modified( 4710 4067 &mut self, 4711 4068 request: impl tonic::IntoRequest<super::SetModifiedRequest>, 4712 - ) -> std::result::Result< 4713 - tonic::Response<super::SetModifiedResponse>, 4714 - tonic::Status, 4715 - > { 4716 - self.inner 4717 - .ready() 4718 - .await 4719 - .map_err(|e| { 4720 - tonic::Status::unknown( 4721 - format!("Service was not ready: {}", e.into()), 4722 - ) 4723 - })?; 4069 + ) -> std::result::Result<tonic::Response<super::SetModifiedResponse>, tonic::Status> 4070 + { 4071 + self.inner.ready().await.map_err(|e| { 4072 + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 4073 + })?; 4724 4074 let codec = tonic::codec::ProstCodec::default(); 4725 4075 let path = http::uri::PathAndQuery::from_static( 4726 4076 "/rockbox.v1alpha1.PlaylistService/SetModified", 4727 4077 ); 4728 4078 let mut req = request.into_request(); 4729 - req.extensions_mut() 4730 - .insert( 4731 - GrpcMethod::new("rockbox.v1alpha1.PlaylistService", "SetModified"), 4732 - ); 4079 + req.extensions_mut().insert(GrpcMethod::new( 4080 + "rockbox.v1alpha1.PlaylistService", 4081 + "SetModified", 4082 + )); 4733 4083 self.inner.unary(req, path, codec).await 4734 4084 } 4735 4085 pub async fn start( 4736 4086 &mut self, 4737 4087 request: impl tonic::IntoRequest<super::StartRequest>, 4738 4088 ) -> std::result::Result<tonic::Response<super::StartResponse>, tonic::Status> { 4739 - self.inner 4740 - .ready() 4741 - .await 4742 - .map_err(|e| { 4743 - tonic::Status::unknown( 4744 - format!("Service was not ready: {}", e.into()), 4745 - ) 4746 - })?; 4089 + self.inner.ready().await.map_err(|e| { 4090 + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 4091 + })?; 4747 4092 let codec = tonic::codec::ProstCodec::default(); 4748 - let path = http::uri::PathAndQuery::from_static( 4749 - "/rockbox.v1alpha1.PlaylistService/Start", 4750 - ); 4093 + let path = 4094 + http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.PlaylistService/Start"); 4751 4095 let mut req = request.into_request(); 4752 4096 req.extensions_mut() 4753 4097 .insert(GrpcMethod::new("rockbox.v1alpha1.PlaylistService", "Start")); ··· 4757 4101 &mut self, 4758 4102 request: impl tonic::IntoRequest<super::SyncRequest>, 4759 4103 ) -> std::result::Result<tonic::Response<super::SyncResponse>, tonic::Status> { 4760 - self.inner 4761 - .ready() 4762 - .await 4763 - .map_err(|e| { 4764 - tonic::Status::unknown( 4765 - format!("Service was not ready: {}", e.into()), 4766 - ) 4767 - })?; 4104 + self.inner.ready().await.map_err(|e| { 4105 + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 4106 + })?; 4768 4107 let codec = tonic::codec::ProstCodec::default(); 4769 - let path = http::uri::PathAndQuery::from_static( 4770 - "/rockbox.v1alpha1.PlaylistService/Sync", 4771 - ); 4108 + let path = 4109 + http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.PlaylistService/Sync"); 4772 4110 let mut req = request.into_request(); 4773 4111 req.extensions_mut() 4774 4112 .insert(GrpcMethod::new("rockbox.v1alpha1.PlaylistService", "Sync")); ··· 4777 4115 pub async fn remove_all_tracks( 4778 4116 &mut self, 4779 4117 request: impl tonic::IntoRequest<super::RemoveAllTracksRequest>, 4780 - ) -> std::result::Result< 4781 - tonic::Response<super::RemoveAllTracksResponse>, 4782 - tonic::Status, 4783 - > { 4784 - self.inner 4785 - .ready() 4786 - .await 4787 - .map_err(|e| { 4788 - tonic::Status::unknown( 4789 - format!("Service was not ready: {}", e.into()), 4790 - ) 4791 - })?; 4118 + ) -> std::result::Result<tonic::Response<super::RemoveAllTracksResponse>, tonic::Status> 4119 + { 4120 + self.inner.ready().await.map_err(|e| { 4121 + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 4122 + })?; 4792 4123 let codec = tonic::codec::ProstCodec::default(); 4793 4124 let path = http::uri::PathAndQuery::from_static( 4794 4125 "/rockbox.v1alpha1.PlaylistService/RemoveAllTracks", 4795 4126 ); 4796 4127 let mut req = request.into_request(); 4797 - req.extensions_mut() 4798 - .insert( 4799 - GrpcMethod::new( 4800 - "rockbox.v1alpha1.PlaylistService", 4801 - "RemoveAllTracks", 4802 - ), 4803 - ); 4128 + req.extensions_mut().insert(GrpcMethod::new( 4129 + "rockbox.v1alpha1.PlaylistService", 4130 + "RemoveAllTracks", 4131 + )); 4804 4132 self.inner.unary(req, path, codec).await 4805 4133 } 4806 4134 pub async fn remove_tracks( 4807 4135 &mut self, 4808 4136 request: impl tonic::IntoRequest<super::RemoveTracksRequest>, 4809 - ) -> std::result::Result< 4810 - tonic::Response<super::RemoveTracksResponse>, 4811 - tonic::Status, 4812 - > { 4813 - self.inner 4814 - .ready() 4815 - .await 4816 - .map_err(|e| { 4817 - tonic::Status::unknown( 4818 - format!("Service was not ready: {}", e.into()), 4819 - ) 4820 - })?; 4137 + ) -> std::result::Result<tonic::Response<super::RemoveTracksResponse>, tonic::Status> 4138 + { 4139 + self.inner.ready().await.map_err(|e| { 4140 + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 4141 + })?; 4821 4142 let codec = tonic::codec::ProstCodec::default(); 4822 4143 let path = http::uri::PathAndQuery::from_static( 4823 4144 "/rockbox.v1alpha1.PlaylistService/RemoveTracks", 4824 4145 ); 4825 4146 let mut req = request.into_request(); 4826 - req.extensions_mut() 4827 - .insert( 4828 - GrpcMethod::new("rockbox.v1alpha1.PlaylistService", "RemoveTracks"), 4829 - ); 4147 + req.extensions_mut().insert(GrpcMethod::new( 4148 + "rockbox.v1alpha1.PlaylistService", 4149 + "RemoveTracks", 4150 + )); 4830 4151 self.inner.unary(req, path, codec).await 4831 4152 } 4832 4153 pub async fn create_playlist( 4833 4154 &mut self, 4834 4155 request: impl tonic::IntoRequest<super::CreatePlaylistRequest>, 4835 - ) -> std::result::Result< 4836 - tonic::Response<super::CreatePlaylistResponse>, 4837 - tonic::Status, 4838 - > { 4839 - self.inner 4840 - .ready() 4841 - .await 4842 - .map_err(|e| { 4843 - tonic::Status::unknown( 4844 - format!("Service was not ready: {}", e.into()), 4845 - ) 4846 - })?; 4156 + ) -> std::result::Result<tonic::Response<super::CreatePlaylistResponse>, tonic::Status> 4157 + { 4158 + self.inner.ready().await.map_err(|e| { 4159 + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 4160 + })?; 4847 4161 let codec = tonic::codec::ProstCodec::default(); 4848 4162 let path = http::uri::PathAndQuery::from_static( 4849 4163 "/rockbox.v1alpha1.PlaylistService/CreatePlaylist", 4850 4164 ); 4851 4165 let mut req = request.into_request(); 4852 - req.extensions_mut() 4853 - .insert( 4854 - GrpcMethod::new("rockbox.v1alpha1.PlaylistService", "CreatePlaylist"), 4855 - ); 4166 + req.extensions_mut().insert(GrpcMethod::new( 4167 + "rockbox.v1alpha1.PlaylistService", 4168 + "CreatePlaylist", 4169 + )); 4856 4170 self.inner.unary(req, path, codec).await 4857 4171 } 4858 4172 pub async fn insert_tracks( 4859 4173 &mut self, 4860 4174 request: impl tonic::IntoRequest<super::InsertTracksRequest>, 4861 - ) -> std::result::Result< 4862 - tonic::Response<super::InsertTracksResponse>, 4863 - tonic::Status, 4864 - > { 4865 - self.inner 4866 - .ready() 4867 - .await 4868 - .map_err(|e| { 4869 - tonic::Status::unknown( 4870 - format!("Service was not ready: {}", e.into()), 4871 - ) 4872 - })?; 4175 + ) -> std::result::Result<tonic::Response<super::InsertTracksResponse>, tonic::Status> 4176 + { 4177 + self.inner.ready().await.map_err(|e| { 4178 + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 4179 + })?; 4873 4180 let codec = tonic::codec::ProstCodec::default(); 4874 4181 let path = http::uri::PathAndQuery::from_static( 4875 4182 "/rockbox.v1alpha1.PlaylistService/InsertTracks", 4876 4183 ); 4877 4184 let mut req = request.into_request(); 4878 - req.extensions_mut() 4879 - .insert( 4880 - GrpcMethod::new("rockbox.v1alpha1.PlaylistService", "InsertTracks"), 4881 - ); 4185 + req.extensions_mut().insert(GrpcMethod::new( 4186 + "rockbox.v1alpha1.PlaylistService", 4187 + "InsertTracks", 4188 + )); 4882 4189 self.inner.unary(req, path, codec).await 4883 4190 } 4884 4191 pub async fn insert_directory( 4885 4192 &mut self, 4886 4193 request: impl tonic::IntoRequest<super::InsertDirectoryRequest>, 4887 - ) -> std::result::Result< 4888 - tonic::Response<super::InsertDirectoryResponse>, 4889 - tonic::Status, 4890 - > { 4891 - self.inner 4892 - .ready() 4893 - .await 4894 - .map_err(|e| { 4895 - tonic::Status::unknown( 4896 - format!("Service was not ready: {}", e.into()), 4897 - ) 4898 - })?; 4194 + ) -> std::result::Result<tonic::Response<super::InsertDirectoryResponse>, tonic::Status> 4195 + { 4196 + self.inner.ready().await.map_err(|e| { 4197 + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 4198 + })?; 4899 4199 let codec = tonic::codec::ProstCodec::default(); 4900 4200 let path = http::uri::PathAndQuery::from_static( 4901 4201 "/rockbox.v1alpha1.PlaylistService/InsertDirectory", 4902 4202 ); 4903 4203 let mut req = request.into_request(); 4904 - req.extensions_mut() 4905 - .insert( 4906 - GrpcMethod::new( 4907 - "rockbox.v1alpha1.PlaylistService", 4908 - "InsertDirectory", 4909 - ), 4910 - ); 4204 + req.extensions_mut().insert(GrpcMethod::new( 4205 + "rockbox.v1alpha1.PlaylistService", 4206 + "InsertDirectory", 4207 + )); 4911 4208 self.inner.unary(req, path, codec).await 4912 4209 } 4913 4210 pub async fn insert_playlist( 4914 4211 &mut self, 4915 4212 request: impl tonic::IntoRequest<super::InsertPlaylistRequest>, 4916 - ) -> std::result::Result< 4917 - tonic::Response<super::InsertPlaylistResponse>, 4918 - tonic::Status, 4919 - > { 4920 - self.inner 4921 - .ready() 4922 - .await 4923 - .map_err(|e| { 4924 - tonic::Status::unknown( 4925 - format!("Service was not ready: {}", e.into()), 4926 - ) 4927 - })?; 4213 + ) -> std::result::Result<tonic::Response<super::InsertPlaylistResponse>, tonic::Status> 4214 + { 4215 + self.inner.ready().await.map_err(|e| { 4216 + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 4217 + })?; 4928 4218 let codec = tonic::codec::ProstCodec::default(); 4929 4219 let path = http::uri::PathAndQuery::from_static( 4930 4220 "/rockbox.v1alpha1.PlaylistService/InsertPlaylist", 4931 4221 ); 4932 4222 let mut req = request.into_request(); 4933 - req.extensions_mut() 4934 - .insert( 4935 - GrpcMethod::new("rockbox.v1alpha1.PlaylistService", "InsertPlaylist"), 4936 - ); 4223 + req.extensions_mut().insert(GrpcMethod::new( 4224 + "rockbox.v1alpha1.PlaylistService", 4225 + "InsertPlaylist", 4226 + )); 4937 4227 self.inner.unary(req, path, codec).await 4938 4228 } 4939 4229 pub async fn insert_album( 4940 4230 &mut self, 4941 4231 request: impl tonic::IntoRequest<super::InsertAlbumRequest>, 4942 - ) -> std::result::Result< 4943 - tonic::Response<super::InsertAlbumResponse>, 4944 - tonic::Status, 4945 - > { 4946 - self.inner 4947 - .ready() 4948 - .await 4949 - .map_err(|e| { 4950 - tonic::Status::unknown( 4951 - format!("Service was not ready: {}", e.into()), 4952 - ) 4953 - })?; 4232 + ) -> std::result::Result<tonic::Response<super::InsertAlbumResponse>, tonic::Status> 4233 + { 4234 + self.inner.ready().await.map_err(|e| { 4235 + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 4236 + })?; 4954 4237 let codec = tonic::codec::ProstCodec::default(); 4955 4238 let path = http::uri::PathAndQuery::from_static( 4956 4239 "/rockbox.v1alpha1.PlaylistService/InsertAlbum", 4957 4240 ); 4958 4241 let mut req = request.into_request(); 4959 - req.extensions_mut() 4960 - .insert( 4961 - GrpcMethod::new("rockbox.v1alpha1.PlaylistService", "InsertAlbum"), 4962 - ); 4242 + req.extensions_mut().insert(GrpcMethod::new( 4243 + "rockbox.v1alpha1.PlaylistService", 4244 + "InsertAlbum", 4245 + )); 4963 4246 self.inner.unary(req, path, codec).await 4964 4247 } 4965 4248 pub async fn insert_artist_tracks( 4966 4249 &mut self, 4967 4250 request: impl tonic::IntoRequest<super::InsertArtistTracksRequest>, 4968 - ) -> std::result::Result< 4969 - tonic::Response<super::InsertArtistTracksResponse>, 4970 - tonic::Status, 4971 - > { 4972 - self.inner 4973 - .ready() 4974 - .await 4975 - .map_err(|e| { 4976 - tonic::Status::unknown( 4977 - format!("Service was not ready: {}", e.into()), 4978 - ) 4979 - })?; 4251 + ) -> std::result::Result<tonic::Response<super::InsertArtistTracksResponse>, tonic::Status> 4252 + { 4253 + self.inner.ready().await.map_err(|e| { 4254 + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 4255 + })?; 4980 4256 let codec = tonic::codec::ProstCodec::default(); 4981 4257 let path = http::uri::PathAndQuery::from_static( 4982 4258 "/rockbox.v1alpha1.PlaylistService/InsertArtistTracks", 4983 4259 ); 4984 4260 let mut req = request.into_request(); 4985 - req.extensions_mut() 4986 - .insert( 4987 - GrpcMethod::new( 4988 - "rockbox.v1alpha1.PlaylistService", 4989 - "InsertArtistTracks", 4990 - ), 4991 - ); 4261 + req.extensions_mut().insert(GrpcMethod::new( 4262 + "rockbox.v1alpha1.PlaylistService", 4263 + "InsertArtistTracks", 4264 + )); 4992 4265 self.inner.unary(req, path, codec).await 4993 4266 } 4994 4267 pub async fn shuffle_playlist( 4995 4268 &mut self, 4996 4269 request: impl tonic::IntoRequest<super::ShufflePlaylistRequest>, 4997 - ) -> std::result::Result< 4998 - tonic::Response<super::ShufflePlaylistResponse>, 4999 - tonic::Status, 5000 - > { 5001 - self.inner 5002 - .ready() 5003 - .await 5004 - .map_err(|e| { 5005 - tonic::Status::unknown( 5006 - format!("Service was not ready: {}", e.into()), 5007 - ) 5008 - })?; 4270 + ) -> std::result::Result<tonic::Response<super::ShufflePlaylistResponse>, tonic::Status> 4271 + { 4272 + self.inner.ready().await.map_err(|e| { 4273 + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 4274 + })?; 5009 4275 let codec = tonic::codec::ProstCodec::default(); 5010 4276 let path = http::uri::PathAndQuery::from_static( 5011 4277 "/rockbox.v1alpha1.PlaylistService/ShufflePlaylist", 5012 4278 ); 5013 4279 let mut req = request.into_request(); 5014 - req.extensions_mut() 5015 - .insert( 5016 - GrpcMethod::new( 5017 - "rockbox.v1alpha1.PlaylistService", 5018 - "ShufflePlaylist", 5019 - ), 5020 - ); 4280 + req.extensions_mut().insert(GrpcMethod::new( 4281 + "rockbox.v1alpha1.PlaylistService", 4282 + "ShufflePlaylist", 4283 + )); 5021 4284 self.inner.unary(req, path, codec).await 5022 4285 } 5023 4286 } ··· 5029 4292 dead_code, 5030 4293 missing_docs, 5031 4294 clippy::wildcard_imports, 5032 - clippy::let_unit_value, 4295 + clippy::let_unit_value 5033 4296 )] 5034 4297 use tonic::codegen::*; 5035 4298 /// Generated trait containing gRPC methods that should be implemented for use with PlaylistServiceServer. ··· 5038 4301 async fn get_current( 5039 4302 &self, 5040 4303 request: tonic::Request<super::GetCurrentRequest>, 5041 - ) -> std::result::Result< 5042 - tonic::Response<super::GetCurrentResponse>, 5043 - tonic::Status, 5044 - >; 4304 + ) -> std::result::Result<tonic::Response<super::GetCurrentResponse>, tonic::Status>; 5045 4305 async fn get_resume_info( 5046 4306 &self, 5047 4307 request: tonic::Request<super::GetResumeInfoRequest>, 5048 - ) -> std::result::Result< 5049 - tonic::Response<super::GetResumeInfoResponse>, 5050 - tonic::Status, 5051 - >; 4308 + ) -> std::result::Result<tonic::Response<super::GetResumeInfoResponse>, tonic::Status>; 5052 4309 async fn get_track_info( 5053 4310 &self, 5054 4311 request: tonic::Request<super::GetTrackInfoRequest>, 5055 - ) -> std::result::Result< 5056 - tonic::Response<super::GetTrackInfoResponse>, 5057 - tonic::Status, 5058 - >; 4312 + ) -> std::result::Result<tonic::Response<super::GetTrackInfoResponse>, tonic::Status>; 5059 4313 async fn get_first_index( 5060 4314 &self, 5061 4315 request: tonic::Request<super::GetFirstIndexRequest>, 5062 - ) -> std::result::Result< 5063 - tonic::Response<super::GetFirstIndexResponse>, 5064 - tonic::Status, 5065 - >; 4316 + ) -> std::result::Result<tonic::Response<super::GetFirstIndexResponse>, tonic::Status>; 5066 4317 async fn get_display_index( 5067 4318 &self, 5068 4319 request: tonic::Request<super::GetDisplayIndexRequest>, 5069 - ) -> std::result::Result< 5070 - tonic::Response<super::GetDisplayIndexResponse>, 5071 - tonic::Status, 5072 - >; 4320 + ) -> std::result::Result<tonic::Response<super::GetDisplayIndexResponse>, tonic::Status>; 5073 4321 async fn amount( 5074 4322 &self, 5075 4323 request: tonic::Request<super::AmountRequest>, ··· 5077 4325 async fn playlist_resume( 5078 4326 &self, 5079 4327 request: tonic::Request<super::PlaylistResumeRequest>, 5080 - ) -> std::result::Result< 5081 - tonic::Response<super::PlaylistResumeResponse>, 5082 - tonic::Status, 5083 - >; 4328 + ) -> std::result::Result<tonic::Response<super::PlaylistResumeResponse>, tonic::Status>; 5084 4329 async fn resume_track( 5085 4330 &self, 5086 4331 request: tonic::Request<super::ResumeTrackRequest>, 5087 - ) -> std::result::Result< 5088 - tonic::Response<super::ResumeTrackResponse>, 5089 - tonic::Status, 5090 - >; 4332 + ) -> std::result::Result<tonic::Response<super::ResumeTrackResponse>, tonic::Status>; 5091 4333 async fn set_modified( 5092 4334 &self, 5093 4335 request: tonic::Request<super::SetModifiedRequest>, 5094 - ) -> std::result::Result< 5095 - tonic::Response<super::SetModifiedResponse>, 5096 - tonic::Status, 5097 - >; 4336 + ) -> std::result::Result<tonic::Response<super::SetModifiedResponse>, tonic::Status>; 5098 4337 async fn start( 5099 4338 &self, 5100 4339 request: tonic::Request<super::StartRequest>, ··· 5106 4345 async fn remove_all_tracks( 5107 4346 &self, 5108 4347 request: tonic::Request<super::RemoveAllTracksRequest>, 5109 - ) -> std::result::Result< 5110 - tonic::Response<super::RemoveAllTracksResponse>, 5111 - tonic::Status, 5112 - >; 4348 + ) -> std::result::Result<tonic::Response<super::RemoveAllTracksResponse>, tonic::Status>; 5113 4349 async fn remove_tracks( 5114 4350 &self, 5115 4351 request: tonic::Request<super::RemoveTracksRequest>, 5116 - ) -> std::result::Result< 5117 - tonic::Response<super::RemoveTracksResponse>, 5118 - tonic::Status, 5119 - >; 4352 + ) -> std::result::Result<tonic::Response<super::RemoveTracksResponse>, tonic::Status>; 5120 4353 async fn create_playlist( 5121 4354 &self, 5122 4355 request: tonic::Request<super::CreatePlaylistRequest>, 5123 - ) -> std::result::Result< 5124 - tonic::Response<super::CreatePlaylistResponse>, 5125 - tonic::Status, 5126 - >; 4356 + ) -> std::result::Result<tonic::Response<super::CreatePlaylistResponse>, tonic::Status>; 5127 4357 async fn insert_tracks( 5128 4358 &self, 5129 4359 request: tonic::Request<super::InsertTracksRequest>, 5130 - ) -> std::result::Result< 5131 - tonic::Response<super::InsertTracksResponse>, 5132 - tonic::Status, 5133 - >; 4360 + ) -> std::result::Result<tonic::Response<super::InsertTracksResponse>, tonic::Status>; 5134 4361 async fn insert_directory( 5135 4362 &self, 5136 4363 request: tonic::Request<super::InsertDirectoryRequest>, 5137 - ) -> std::result::Result< 5138 - tonic::Response<super::InsertDirectoryResponse>, 5139 - tonic::Status, 5140 - >; 4364 + ) -> std::result::Result<tonic::Response<super::InsertDirectoryResponse>, tonic::Status>; 5141 4365 async fn insert_playlist( 5142 4366 &self, 5143 4367 request: tonic::Request<super::InsertPlaylistRequest>, 5144 - ) -> std::result::Result< 5145 - tonic::Response<super::InsertPlaylistResponse>, 5146 - tonic::Status, 5147 - >; 4368 + ) -> std::result::Result<tonic::Response<super::InsertPlaylistResponse>, tonic::Status>; 5148 4369 async fn insert_album( 5149 4370 &self, 5150 4371 request: tonic::Request<super::InsertAlbumRequest>, 5151 - ) -> std::result::Result< 5152 - tonic::Response<super::InsertAlbumResponse>, 5153 - tonic::Status, 5154 - >; 4372 + ) -> std::result::Result<tonic::Response<super::InsertAlbumResponse>, tonic::Status>; 5155 4373 async fn insert_artist_tracks( 5156 4374 &self, 5157 4375 request: tonic::Request<super::InsertArtistTracksRequest>, 5158 - ) -> std::result::Result< 5159 - tonic::Response<super::InsertArtistTracksResponse>, 5160 - tonic::Status, 5161 - >; 4376 + ) -> std::result::Result<tonic::Response<super::InsertArtistTracksResponse>, tonic::Status>; 5162 4377 async fn shuffle_playlist( 5163 4378 &self, 5164 4379 request: tonic::Request<super::ShufflePlaylistRequest>, 5165 - ) -> std::result::Result< 5166 - tonic::Response<super::ShufflePlaylistResponse>, 5167 - tonic::Status, 5168 - >; 4380 + ) -> std::result::Result<tonic::Response<super::ShufflePlaylistResponse>, tonic::Status>; 5169 4381 } 5170 4382 #[derive(Debug)] 5171 4383 pub struct PlaylistServiceServer<T> { ··· 5188 4400 max_encoding_message_size: None, 5189 4401 } 5190 4402 } 5191 - pub fn with_interceptor<F>( 5192 - inner: T, 5193 - interceptor: F, 5194 - ) -> InterceptedService<Self, F> 4403 + pub fn with_interceptor<F>(inner: T, interceptor: F) -> InterceptedService<Self, F> 5195 4404 where 5196 4405 F: tonic::service::Interceptor, 5197 4406 { ··· 5246 4455 "/rockbox.v1alpha1.PlaylistService/GetCurrent" => { 5247 4456 #[allow(non_camel_case_types)] 5248 4457 struct GetCurrentSvc<T: PlaylistService>(pub Arc<T>); 5249 - impl< 5250 - T: PlaylistService, 5251 - > tonic::server::UnaryService<super::GetCurrentRequest> 5252 - for GetCurrentSvc<T> { 4458 + impl<T: PlaylistService> tonic::server::UnaryService<super::GetCurrentRequest> 4459 + for GetCurrentSvc<T> 4460 + { 5253 4461 type Response = super::GetCurrentResponse; 5254 - type Future = BoxFuture< 5255 - tonic::Response<Self::Response>, 5256 - tonic::Status, 5257 - >; 4462 + type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 5258 4463 fn call( 5259 4464 &mut self, 5260 4465 request: tonic::Request<super::GetCurrentRequest>, ··· 5291 4496 "/rockbox.v1alpha1.PlaylistService/GetResumeInfo" => { 5292 4497 #[allow(non_camel_case_types)] 5293 4498 struct GetResumeInfoSvc<T: PlaylistService>(pub Arc<T>); 5294 - impl< 5295 - T: PlaylistService, 5296 - > tonic::server::UnaryService<super::GetResumeInfoRequest> 5297 - for GetResumeInfoSvc<T> { 4499 + impl<T: PlaylistService> 4500 + tonic::server::UnaryService<super::GetResumeInfoRequest> 4501 + for GetResumeInfoSvc<T> 4502 + { 5298 4503 type Response = super::GetResumeInfoResponse; 5299 - type Future = BoxFuture< 5300 - tonic::Response<Self::Response>, 5301 - tonic::Status, 5302 - >; 4504 + type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 5303 4505 fn call( 5304 4506 &mut self, 5305 4507 request: tonic::Request<super::GetResumeInfoRequest>, 5306 4508 ) -> Self::Future { 5307 4509 let inner = Arc::clone(&self.0); 5308 4510 let fut = async move { 5309 - <T as PlaylistService>::get_resume_info(&inner, request) 5310 - .await 4511 + <T as PlaylistService>::get_resume_info(&inner, request).await 5311 4512 }; 5312 4513 Box::pin(fut) 5313 4514 } ··· 5337 4538 "/rockbox.v1alpha1.PlaylistService/GetTrackInfo" => { 5338 4539 #[allow(non_camel_case_types)] 5339 4540 struct GetTrackInfoSvc<T: PlaylistService>(pub Arc<T>); 5340 - impl< 5341 - T: PlaylistService, 5342 - > tonic::server::UnaryService<super::GetTrackInfoRequest> 5343 - for GetTrackInfoSvc<T> { 4541 + impl<T: PlaylistService> tonic::server::UnaryService<super::GetTrackInfoRequest> 4542 + for GetTrackInfoSvc<T> 4543 + { 5344 4544 type Response = super::GetTrackInfoResponse; 5345 - type Future = BoxFuture< 5346 - tonic::Response<Self::Response>, 5347 - tonic::Status, 5348 - >; 4545 + type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 5349 4546 fn call( 5350 4547 &mut self, 5351 4548 request: tonic::Request<super::GetTrackInfoRequest>, 5352 4549 ) -> Self::Future { 5353 4550 let inner = Arc::clone(&self.0); 5354 4551 let fut = async move { 5355 - <T as PlaylistService>::get_track_info(&inner, request) 5356 - .await 4552 + <T as PlaylistService>::get_track_info(&inner, request).await 5357 4553 }; 5358 4554 Box::pin(fut) 5359 4555 } ··· 5383 4579 "/rockbox.v1alpha1.PlaylistService/GetFirstIndex" => { 5384 4580 #[allow(non_camel_case_types)] 5385 4581 struct GetFirstIndexSvc<T: PlaylistService>(pub Arc<T>); 5386 - impl< 5387 - T: PlaylistService, 5388 - > tonic::server::UnaryService<super::GetFirstIndexRequest> 5389 - for GetFirstIndexSvc<T> { 4582 + impl<T: PlaylistService> 4583 + tonic::server::UnaryService<super::GetFirstIndexRequest> 4584 + for GetFirstIndexSvc<T> 4585 + { 5390 4586 type Response = super::GetFirstIndexResponse; 5391 - type Future = BoxFuture< 5392 - tonic::Response<Self::Response>, 5393 - tonic::Status, 5394 - >; 4587 + type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 5395 4588 fn call( 5396 4589 &mut self, 5397 4590 request: tonic::Request<super::GetFirstIndexRequest>, 5398 4591 ) -> Self::Future { 5399 4592 let inner = Arc::clone(&self.0); 5400 4593 let fut = async move { 5401 - <T as PlaylistService>::get_first_index(&inner, request) 5402 - .await 4594 + <T as PlaylistService>::get_first_index(&inner, request).await 5403 4595 }; 5404 4596 Box::pin(fut) 5405 4597 } ··· 5429 4621 "/rockbox.v1alpha1.PlaylistService/GetDisplayIndex" => { 5430 4622 #[allow(non_camel_case_types)] 5431 4623 struct GetDisplayIndexSvc<T: PlaylistService>(pub Arc<T>); 5432 - impl< 5433 - T: PlaylistService, 5434 - > tonic::server::UnaryService<super::GetDisplayIndexRequest> 5435 - for GetDisplayIndexSvc<T> { 4624 + impl<T: PlaylistService> 4625 + tonic::server::UnaryService<super::GetDisplayIndexRequest> 4626 + for GetDisplayIndexSvc<T> 4627 + { 5436 4628 type Response = super::GetDisplayIndexResponse; 5437 - type Future = BoxFuture< 5438 - tonic::Response<Self::Response>, 5439 - tonic::Status, 5440 - >; 4629 + type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 5441 4630 fn call( 5442 4631 &mut self, 5443 4632 request: tonic::Request<super::GetDisplayIndexRequest>, 5444 4633 ) -> Self::Future { 5445 4634 let inner = Arc::clone(&self.0); 5446 4635 let fut = async move { 5447 - <T as PlaylistService>::get_display_index(&inner, request) 5448 - .await 4636 + <T as PlaylistService>::get_display_index(&inner, request).await 5449 4637 }; 5450 4638 Box::pin(fut) 5451 4639 } ··· 5475 4663 "/rockbox.v1alpha1.PlaylistService/Amount" => { 5476 4664 #[allow(non_camel_case_types)] 5477 4665 struct AmountSvc<T: PlaylistService>(pub Arc<T>); 5478 - impl< 5479 - T: PlaylistService, 5480 - > tonic::server::UnaryService<super::AmountRequest> 5481 - for AmountSvc<T> { 4666 + impl<T: PlaylistService> tonic::server::UnaryService<super::AmountRequest> for AmountSvc<T> { 5482 4667 type Response = super::AmountResponse; 5483 - type Future = BoxFuture< 5484 - tonic::Response<Self::Response>, 5485 - tonic::Status, 5486 - >; 4668 + type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 5487 4669 fn call( 5488 4670 &mut self, 5489 4671 request: tonic::Request<super::AmountRequest>, ··· 5520 4702 "/rockbox.v1alpha1.PlaylistService/PlaylistResume" => { 5521 4703 #[allow(non_camel_case_types)] 5522 4704 struct PlaylistResumeSvc<T: PlaylistService>(pub Arc<T>); 5523 - impl< 5524 - T: PlaylistService, 5525 - > tonic::server::UnaryService<super::PlaylistResumeRequest> 5526 - for PlaylistResumeSvc<T> { 4705 + impl<T: PlaylistService> 4706 + tonic::server::UnaryService<super::PlaylistResumeRequest> 4707 + for PlaylistResumeSvc<T> 4708 + { 5527 4709 type Response = super::PlaylistResumeResponse; 5528 - type Future = BoxFuture< 5529 - tonic::Response<Self::Response>, 5530 - tonic::Status, 5531 - >; 4710 + type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 5532 4711 fn call( 5533 4712 &mut self, 5534 4713 request: tonic::Request<super::PlaylistResumeRequest>, 5535 4714 ) -> Self::Future { 5536 4715 let inner = Arc::clone(&self.0); 5537 4716 let fut = async move { 5538 - <T as PlaylistService>::playlist_resume(&inner, request) 5539 - .await 4717 + <T as PlaylistService>::playlist_resume(&inner, request).await 5540 4718 }; 5541 4719 Box::pin(fut) 5542 4720 } ··· 5566 4744 "/rockbox.v1alpha1.PlaylistService/ResumeTrack" => { 5567 4745 #[allow(non_camel_case_types)] 5568 4746 struct ResumeTrackSvc<T: PlaylistService>(pub Arc<T>); 5569 - impl< 5570 - T: PlaylistService, 5571 - > tonic::server::UnaryService<super::ResumeTrackRequest> 5572 - for ResumeTrackSvc<T> { 4747 + impl<T: PlaylistService> tonic::server::UnaryService<super::ResumeTrackRequest> 4748 + for ResumeTrackSvc<T> 4749 + { 5573 4750 type Response = super::ResumeTrackResponse; 5574 - type Future = BoxFuture< 5575 - tonic::Response<Self::Response>, 5576 - tonic::Status, 5577 - >; 4751 + type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 5578 4752 fn call( 5579 4753 &mut self, 5580 4754 request: tonic::Request<super::ResumeTrackRequest>, ··· 5611 4785 "/rockbox.v1alpha1.PlaylistService/SetModified" => { 5612 4786 #[allow(non_camel_case_types)] 5613 4787 struct SetModifiedSvc<T: PlaylistService>(pub Arc<T>); 5614 - impl< 5615 - T: PlaylistService, 5616 - > tonic::server::UnaryService<super::SetModifiedRequest> 5617 - for SetModifiedSvc<T> { 4788 + impl<T: PlaylistService> tonic::server::UnaryService<super::SetModifiedRequest> 4789 + for SetModifiedSvc<T> 4790 + { 5618 4791 type Response = super::SetModifiedResponse; 5619 - type Future = BoxFuture< 5620 - tonic::Response<Self::Response>, 5621 - tonic::Status, 5622 - >; 4792 + type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 5623 4793 fn call( 5624 4794 &mut self, 5625 4795 request: tonic::Request<super::SetModifiedRequest>, ··· 5656 4826 "/rockbox.v1alpha1.PlaylistService/Start" => { 5657 4827 #[allow(non_camel_case_types)] 5658 4828 struct StartSvc<T: PlaylistService>(pub Arc<T>); 5659 - impl< 5660 - T: PlaylistService, 5661 - > tonic::server::UnaryService<super::StartRequest> for StartSvc<T> { 4829 + impl<T: PlaylistService> tonic::server::UnaryService<super::StartRequest> for StartSvc<T> { 5662 4830 type Response = super::StartResponse; 5663 - type Future = BoxFuture< 5664 - tonic::Response<Self::Response>, 5665 - tonic::Status, 5666 - >; 4831 + type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 5667 4832 fn call( 5668 4833 &mut self, 5669 4834 request: tonic::Request<super::StartRequest>, 5670 4835 ) -> Self::Future { 5671 4836 let inner = Arc::clone(&self.0); 5672 - let fut = async move { 5673 - <T as PlaylistService>::start(&inner, request).await 5674 - }; 4837 + let fut = 4838 + async move { <T as PlaylistService>::start(&inner, request).await }; 5675 4839 Box::pin(fut) 5676 4840 } 5677 4841 } ··· 5700 4864 "/rockbox.v1alpha1.PlaylistService/Sync" => { 5701 4865 #[allow(non_camel_case_types)] 5702 4866 struct SyncSvc<T: PlaylistService>(pub Arc<T>); 5703 - impl< 5704 - T: PlaylistService, 5705 - > tonic::server::UnaryService<super::SyncRequest> for SyncSvc<T> { 4867 + impl<T: PlaylistService> tonic::server::UnaryService<super::SyncRequest> for SyncSvc<T> { 5706 4868 type Response = super::SyncResponse; 5707 - type Future = BoxFuture< 5708 - tonic::Response<Self::Response>, 5709 - tonic::Status, 5710 - >; 4869 + type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 5711 4870 fn call( 5712 4871 &mut self, 5713 4872 request: tonic::Request<super::SyncRequest>, 5714 4873 ) -> Self::Future { 5715 4874 let inner = Arc::clone(&self.0); 5716 - let fut = async move { 5717 - <T as PlaylistService>::sync(&inner, request).await 5718 - }; 4875 + let fut = 4876 + async move { <T as PlaylistService>::sync(&inner, request).await }; 5719 4877 Box::pin(fut) 5720 4878 } 5721 4879 } ··· 5744 4902 "/rockbox.v1alpha1.PlaylistService/RemoveAllTracks" => { 5745 4903 #[allow(non_camel_case_types)] 5746 4904 struct RemoveAllTracksSvc<T: PlaylistService>(pub Arc<T>); 5747 - impl< 5748 - T: PlaylistService, 5749 - > tonic::server::UnaryService<super::RemoveAllTracksRequest> 5750 - for RemoveAllTracksSvc<T> { 4905 + impl<T: PlaylistService> 4906 + tonic::server::UnaryService<super::RemoveAllTracksRequest> 4907 + for RemoveAllTracksSvc<T> 4908 + { 5751 4909 type Response = super::RemoveAllTracksResponse; 5752 - type Future = BoxFuture< 5753 - tonic::Response<Self::Response>, 5754 - tonic::Status, 5755 - >; 4910 + type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 5756 4911 fn call( 5757 4912 &mut self, 5758 4913 request: tonic::Request<super::RemoveAllTracksRequest>, 5759 4914 ) -> Self::Future { 5760 4915 let inner = Arc::clone(&self.0); 5761 4916 let fut = async move { 5762 - <T as PlaylistService>::remove_all_tracks(&inner, request) 5763 - .await 4917 + <T as PlaylistService>::remove_all_tracks(&inner, request).await 5764 4918 }; 5765 4919 Box::pin(fut) 5766 4920 } ··· 5790 4944 "/rockbox.v1alpha1.PlaylistService/RemoveTracks" => { 5791 4945 #[allow(non_camel_case_types)] 5792 4946 struct RemoveTracksSvc<T: PlaylistService>(pub Arc<T>); 5793 - impl< 5794 - T: PlaylistService, 5795 - > tonic::server::UnaryService<super::RemoveTracksRequest> 5796 - for RemoveTracksSvc<T> { 4947 + impl<T: PlaylistService> tonic::server::UnaryService<super::RemoveTracksRequest> 4948 + for RemoveTracksSvc<T> 4949 + { 5797 4950 type Response = super::RemoveTracksResponse; 5798 - type Future = BoxFuture< 5799 - tonic::Response<Self::Response>, 5800 - tonic::Status, 5801 - >; 4951 + type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 5802 4952 fn call( 5803 4953 &mut self, 5804 4954 request: tonic::Request<super::RemoveTracksRequest>, ··· 5835 4985 "/rockbox.v1alpha1.PlaylistService/CreatePlaylist" => { 5836 4986 #[allow(non_camel_case_types)] 5837 4987 struct CreatePlaylistSvc<T: PlaylistService>(pub Arc<T>); 5838 - impl< 5839 - T: PlaylistService, 5840 - > tonic::server::UnaryService<super::CreatePlaylistRequest> 5841 - for CreatePlaylistSvc<T> { 4988 + impl<T: PlaylistService> 4989 + tonic::server::UnaryService<super::CreatePlaylistRequest> 4990 + for CreatePlaylistSvc<T> 4991 + { 5842 4992 type Response = super::CreatePlaylistResponse; 5843 - type Future = BoxFuture< 5844 - tonic::Response<Self::Response>, 5845 - tonic::Status, 5846 - >; 4993 + type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 5847 4994 fn call( 5848 4995 &mut self, 5849 4996 request: tonic::Request<super::CreatePlaylistRequest>, 5850 4997 ) -> Self::Future { 5851 4998 let inner = Arc::clone(&self.0); 5852 4999 let fut = async move { 5853 - <T as PlaylistService>::create_playlist(&inner, request) 5854 - .await 5000 + <T as PlaylistService>::create_playlist(&inner, request).await 5855 5001 }; 5856 5002 Box::pin(fut) 5857 5003 } ··· 5881 5027 "/rockbox.v1alpha1.PlaylistService/InsertTracks" => { 5882 5028 #[allow(non_camel_case_types)] 5883 5029 struct InsertTracksSvc<T: PlaylistService>(pub Arc<T>); 5884 - impl< 5885 - T: PlaylistService, 5886 - > tonic::server::UnaryService<super::InsertTracksRequest> 5887 - for InsertTracksSvc<T> { 5030 + impl<T: PlaylistService> tonic::server::UnaryService<super::InsertTracksRequest> 5031 + for InsertTracksSvc<T> 5032 + { 5888 5033 type Response = super::InsertTracksResponse; 5889 - type Future = BoxFuture< 5890 - tonic::Response<Self::Response>, 5891 - tonic::Status, 5892 - >; 5034 + type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 5893 5035 fn call( 5894 5036 &mut self, 5895 5037 request: tonic::Request<super::InsertTracksRequest>, ··· 5926 5068 "/rockbox.v1alpha1.PlaylistService/InsertDirectory" => { 5927 5069 #[allow(non_camel_case_types)] 5928 5070 struct InsertDirectorySvc<T: PlaylistService>(pub Arc<T>); 5929 - impl< 5930 - T: PlaylistService, 5931 - > tonic::server::UnaryService<super::InsertDirectoryRequest> 5932 - for InsertDirectorySvc<T> { 5071 + impl<T: PlaylistService> 5072 + tonic::server::UnaryService<super::InsertDirectoryRequest> 5073 + for InsertDirectorySvc<T> 5074 + { 5933 5075 type Response = super::InsertDirectoryResponse; 5934 - type Future = BoxFuture< 5935 - tonic::Response<Self::Response>, 5936 - tonic::Status, 5937 - >; 5076 + type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 5938 5077 fn call( 5939 5078 &mut self, 5940 5079 request: tonic::Request<super::InsertDirectoryRequest>, 5941 5080 ) -> Self::Future { 5942 5081 let inner = Arc::clone(&self.0); 5943 5082 let fut = async move { 5944 - <T as PlaylistService>::insert_directory(&inner, request) 5945 - .await 5083 + <T as PlaylistService>::insert_directory(&inner, request).await 5946 5084 }; 5947 5085 Box::pin(fut) 5948 5086 } ··· 5972 5110 "/rockbox.v1alpha1.PlaylistService/InsertPlaylist" => { 5973 5111 #[allow(non_camel_case_types)] 5974 5112 struct InsertPlaylistSvc<T: PlaylistService>(pub Arc<T>); 5975 - impl< 5976 - T: PlaylistService, 5977 - > tonic::server::UnaryService<super::InsertPlaylistRequest> 5978 - for InsertPlaylistSvc<T> { 5113 + impl<T: PlaylistService> 5114 + tonic::server::UnaryService<super::InsertPlaylistRequest> 5115 + for InsertPlaylistSvc<T> 5116 + { 5979 5117 type Response = super::InsertPlaylistResponse; 5980 - type Future = BoxFuture< 5981 - tonic::Response<Self::Response>, 5982 - tonic::Status, 5983 - >; 5118 + type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 5984 5119 fn call( 5985 5120 &mut self, 5986 5121 request: tonic::Request<super::InsertPlaylistRequest>, 5987 5122 ) -> Self::Future { 5988 5123 let inner = Arc::clone(&self.0); 5989 5124 let fut = async move { 5990 - <T as PlaylistService>::insert_playlist(&inner, request) 5991 - .await 5125 + <T as PlaylistService>::insert_playlist(&inner, request).await 5992 5126 }; 5993 5127 Box::pin(fut) 5994 5128 } ··· 6018 5152 "/rockbox.v1alpha1.PlaylistService/InsertAlbum" => { 6019 5153 #[allow(non_camel_case_types)] 6020 5154 struct InsertAlbumSvc<T: PlaylistService>(pub Arc<T>); 6021 - impl< 6022 - T: PlaylistService, 6023 - > tonic::server::UnaryService<super::InsertAlbumRequest> 6024 - for InsertAlbumSvc<T> { 5155 + impl<T: PlaylistService> tonic::server::UnaryService<super::InsertAlbumRequest> 5156 + for InsertAlbumSvc<T> 5157 + { 6025 5158 type Response = super::InsertAlbumResponse; 6026 - type Future = BoxFuture< 6027 - tonic::Response<Self::Response>, 6028 - tonic::Status, 6029 - >; 5159 + type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 6030 5160 fn call( 6031 5161 &mut self, 6032 5162 request: tonic::Request<super::InsertAlbumRequest>, ··· 6063 5193 "/rockbox.v1alpha1.PlaylistService/InsertArtistTracks" => { 6064 5194 #[allow(non_camel_case_types)] 6065 5195 struct InsertArtistTracksSvc<T: PlaylistService>(pub Arc<T>); 6066 - impl< 6067 - T: PlaylistService, 6068 - > tonic::server::UnaryService<super::InsertArtistTracksRequest> 6069 - for InsertArtistTracksSvc<T> { 5196 + impl<T: PlaylistService> 5197 + tonic::server::UnaryService<super::InsertArtistTracksRequest> 5198 + for InsertArtistTracksSvc<T> 5199 + { 6070 5200 type Response = super::InsertArtistTracksResponse; 6071 - type Future = BoxFuture< 6072 - tonic::Response<Self::Response>, 6073 - tonic::Status, 6074 - >; 5201 + type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 6075 5202 fn call( 6076 5203 &mut self, 6077 5204 request: tonic::Request<super::InsertArtistTracksRequest>, 6078 5205 ) -> Self::Future { 6079 5206 let inner = Arc::clone(&self.0); 6080 5207 let fut = async move { 6081 - <T as PlaylistService>::insert_artist_tracks( 6082 - &inner, 6083 - request, 6084 - ) 6085 - .await 5208 + <T as PlaylistService>::insert_artist_tracks(&inner, request).await 6086 5209 }; 6087 5210 Box::pin(fut) 6088 5211 } ··· 6112 5235 "/rockbox.v1alpha1.PlaylistService/ShufflePlaylist" => { 6113 5236 #[allow(non_camel_case_types)] 6114 5237 struct ShufflePlaylistSvc<T: PlaylistService>(pub Arc<T>); 6115 - impl< 6116 - T: PlaylistService, 6117 - > tonic::server::UnaryService<super::ShufflePlaylistRequest> 6118 - for ShufflePlaylistSvc<T> { 5238 + impl<T: PlaylistService> 5239 + tonic::server::UnaryService<super::ShufflePlaylistRequest> 5240 + for ShufflePlaylistSvc<T> 5241 + { 6119 5242 type Response = super::ShufflePlaylistResponse; 6120 - type Future = BoxFuture< 6121 - tonic::Response<Self::Response>, 6122 - tonic::Status, 6123 - >; 5243 + type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 6124 5244 fn call( 6125 5245 &mut self, 6126 5246 request: tonic::Request<super::ShufflePlaylistRequest>, 6127 5247 ) -> Self::Future { 6128 5248 let inner = Arc::clone(&self.0); 6129 5249 let fut = async move { 6130 - <T as PlaylistService>::shuffle_playlist(&inner, request) 6131 - .await 5250 + <T as PlaylistService>::shuffle_playlist(&inner, request).await 6132 5251 }; 6133 5252 Box::pin(fut) 6134 5253 } ··· 6155 5274 }; 6156 5275 Box::pin(fut) 6157 5276 } 6158 - _ => { 6159 - Box::pin(async move { 6160 - let mut response = http::Response::new(empty_body()); 6161 - let headers = response.headers_mut(); 6162 - headers 6163 - .insert( 6164 - tonic::Status::GRPC_STATUS, 6165 - (tonic::Code::Unimplemented as i32).into(), 6166 - ); 6167 - headers 6168 - .insert( 6169 - http::header::CONTENT_TYPE, 6170 - tonic::metadata::GRPC_CONTENT_TYPE, 6171 - ); 6172 - Ok(response) 6173 - }) 6174 - } 5277 + _ => Box::pin(async move { 5278 + let mut response = http::Response::new(empty_body()); 5279 + let headers = response.headers_mut(); 5280 + headers.insert( 5281 + tonic::Status::GRPC_STATUS, 5282 + (tonic::Code::Unimplemented as i32).into(), 5283 + ); 5284 + headers.insert( 5285 + http::header::CONTENT_TYPE, 5286 + tonic::metadata::GRPC_CONTENT_TYPE, 5287 + ); 5288 + Ok(response) 5289 + }), 6175 5290 } 6176 5291 } 6177 5292 } ··· 6679 5794 dead_code, 6680 5795 missing_docs, 6681 5796 clippy::wildcard_imports, 6682 - clippy::let_unit_value, 5797 + clippy::let_unit_value 6683 5798 )] 6684 - use tonic::codegen::*; 6685 5799 use tonic::codegen::http::Uri; 5800 + use tonic::codegen::*; 6686 5801 #[derive(Debug, Clone)] 6687 5802 pub struct SettingsServiceClient<T> { 6688 5803 inner: tonic::client::Grpc<T>, ··· 6726 5841 <T as tonic::client::GrpcService<tonic::body::BoxBody>>::ResponseBody, 6727 5842 >, 6728 5843 >, 6729 - <T as tonic::codegen::Service< 6730 - http::Request<tonic::body::BoxBody>, 6731 - >>::Error: Into<StdError> + std::marker::Send + std::marker::Sync, 5844 + <T as tonic::codegen::Service<http::Request<tonic::body::BoxBody>>>::Error: 5845 + Into<StdError> + std::marker::Send + std::marker::Sync, 6732 5846 { 6733 5847 SettingsServiceClient::new(InterceptedService::new(inner, interceptor)) 6734 5848 } ··· 6766 5880 pub async fn get_settings_list( 6767 5881 &mut self, 6768 5882 request: impl tonic::IntoRequest<super::GetSettingsListRequest>, 6769 - ) -> std::result::Result< 6770 - tonic::Response<super::GetSettingsListResponse>, 6771 - tonic::Status, 6772 - > { 6773 - self.inner 6774 - .ready() 6775 - .await 6776 - .map_err(|e| { 6777 - tonic::Status::unknown( 6778 - format!("Service was not ready: {}", e.into()), 6779 - ) 6780 - })?; 5883 + ) -> std::result::Result<tonic::Response<super::GetSettingsListResponse>, tonic::Status> 5884 + { 5885 + self.inner.ready().await.map_err(|e| { 5886 + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 5887 + })?; 6781 5888 let codec = tonic::codec::ProstCodec::default(); 6782 5889 let path = http::uri::PathAndQuery::from_static( 6783 5890 "/rockbox.v1alpha1.SettingsService/GetSettingsList", 6784 5891 ); 6785 5892 let mut req = request.into_request(); 6786 - req.extensions_mut() 6787 - .insert( 6788 - GrpcMethod::new( 6789 - "rockbox.v1alpha1.SettingsService", 6790 - "GetSettingsList", 6791 - ), 6792 - ); 5893 + req.extensions_mut().insert(GrpcMethod::new( 5894 + "rockbox.v1alpha1.SettingsService", 5895 + "GetSettingsList", 5896 + )); 6793 5897 self.inner.unary(req, path, codec).await 6794 5898 } 6795 5899 pub async fn get_global_settings( 6796 5900 &mut self, 6797 5901 request: impl tonic::IntoRequest<super::GetGlobalSettingsRequest>, 6798 - ) -> std::result::Result< 6799 - tonic::Response<super::GetGlobalSettingsResponse>, 6800 - tonic::Status, 6801 - > { 6802 - self.inner 6803 - .ready() 6804 - .await 6805 - .map_err(|e| { 6806 - tonic::Status::unknown( 6807 - format!("Service was not ready: {}", e.into()), 6808 - ) 6809 - })?; 5902 + ) -> std::result::Result<tonic::Response<super::GetGlobalSettingsResponse>, tonic::Status> 5903 + { 5904 + self.inner.ready().await.map_err(|e| { 5905 + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 5906 + })?; 6810 5907 let codec = tonic::codec::ProstCodec::default(); 6811 5908 let path = http::uri::PathAndQuery::from_static( 6812 5909 "/rockbox.v1alpha1.SettingsService/GetGlobalSettings", 6813 5910 ); 6814 5911 let mut req = request.into_request(); 6815 - req.extensions_mut() 6816 - .insert( 6817 - GrpcMethod::new( 6818 - "rockbox.v1alpha1.SettingsService", 6819 - "GetGlobalSettings", 6820 - ), 6821 - ); 5912 + req.extensions_mut().insert(GrpcMethod::new( 5913 + "rockbox.v1alpha1.SettingsService", 5914 + "GetGlobalSettings", 5915 + )); 6822 5916 self.inner.unary(req, path, codec).await 6823 5917 } 6824 5918 pub async fn save_settings( 6825 5919 &mut self, 6826 5920 request: impl tonic::IntoRequest<super::SaveSettingsRequest>, 6827 - ) -> std::result::Result< 6828 - tonic::Response<super::SaveSettingsResponse>, 6829 - tonic::Status, 6830 - > { 6831 - self.inner 6832 - .ready() 6833 - .await 6834 - .map_err(|e| { 6835 - tonic::Status::unknown( 6836 - format!("Service was not ready: {}", e.into()), 6837 - ) 6838 - })?; 5921 + ) -> std::result::Result<tonic::Response<super::SaveSettingsResponse>, tonic::Status> 5922 + { 5923 + self.inner.ready().await.map_err(|e| { 5924 + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 5925 + })?; 6839 5926 let codec = tonic::codec::ProstCodec::default(); 6840 5927 let path = http::uri::PathAndQuery::from_static( 6841 5928 "/rockbox.v1alpha1.SettingsService/SaveSettings", 6842 5929 ); 6843 5930 let mut req = request.into_request(); 6844 - req.extensions_mut() 6845 - .insert( 6846 - GrpcMethod::new("rockbox.v1alpha1.SettingsService", "SaveSettings"), 6847 - ); 5931 + req.extensions_mut().insert(GrpcMethod::new( 5932 + "rockbox.v1alpha1.SettingsService", 5933 + "SaveSettings", 5934 + )); 6848 5935 self.inner.unary(req, path, codec).await 6849 5936 } 6850 5937 } ··· 6856 5943 dead_code, 6857 5944 missing_docs, 6858 5945 clippy::wildcard_imports, 6859 - clippy::let_unit_value, 5946 + clippy::let_unit_value 6860 5947 )] 6861 5948 use tonic::codegen::*; 6862 5949 /// Generated trait containing gRPC methods that should be implemented for use with SettingsServiceServer. ··· 6865 5952 async fn get_settings_list( 6866 5953 &self, 6867 5954 request: tonic::Request<super::GetSettingsListRequest>, 6868 - ) -> std::result::Result< 6869 - tonic::Response<super::GetSettingsListResponse>, 6870 - tonic::Status, 6871 - >; 5955 + ) -> std::result::Result<tonic::Response<super::GetSettingsListResponse>, tonic::Status>; 6872 5956 async fn get_global_settings( 6873 5957 &self, 6874 5958 request: tonic::Request<super::GetGlobalSettingsRequest>, 6875 - ) -> std::result::Result< 6876 - tonic::Response<super::GetGlobalSettingsResponse>, 6877 - tonic::Status, 6878 - >; 5959 + ) -> std::result::Result<tonic::Response<super::GetGlobalSettingsResponse>, tonic::Status>; 6879 5960 async fn save_settings( 6880 5961 &self, 6881 5962 request: tonic::Request<super::SaveSettingsRequest>, 6882 - ) -> std::result::Result< 6883 - tonic::Response<super::SaveSettingsResponse>, 6884 - tonic::Status, 6885 - >; 5963 + ) -> std::result::Result<tonic::Response<super::SaveSettingsResponse>, tonic::Status>; 6886 5964 } 6887 5965 #[derive(Debug)] 6888 5966 pub struct SettingsServiceServer<T> { ··· 6905 5983 max_encoding_message_size: None, 6906 5984 } 6907 5985 } 6908 - pub fn with_interceptor<F>( 6909 - inner: T, 6910 - interceptor: F, 6911 - ) -> InterceptedService<Self, F> 5986 + pub fn with_interceptor<F>(inner: T, interceptor: F) -> InterceptedService<Self, F> 6912 5987 where 6913 5988 F: tonic::service::Interceptor, 6914 5989 { ··· 6963 6038 "/rockbox.v1alpha1.SettingsService/GetSettingsList" => { 6964 6039 #[allow(non_camel_case_types)] 6965 6040 struct GetSettingsListSvc<T: SettingsService>(pub Arc<T>); 6966 - impl< 6967 - T: SettingsService, 6968 - > tonic::server::UnaryService<super::GetSettingsListRequest> 6969 - for GetSettingsListSvc<T> { 6041 + impl<T: SettingsService> 6042 + tonic::server::UnaryService<super::GetSettingsListRequest> 6043 + for GetSettingsListSvc<T> 6044 + { 6970 6045 type Response = super::GetSettingsListResponse; 6971 - type Future = BoxFuture< 6972 - tonic::Response<Self::Response>, 6973 - tonic::Status, 6974 - >; 6046 + type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 6975 6047 fn call( 6976 6048 &mut self, 6977 6049 request: tonic::Request<super::GetSettingsListRequest>, 6978 6050 ) -> Self::Future { 6979 6051 let inner = Arc::clone(&self.0); 6980 6052 let fut = async move { 6981 - <T as SettingsService>::get_settings_list(&inner, request) 6982 - .await 6053 + <T as SettingsService>::get_settings_list(&inner, request).await 6983 6054 }; 6984 6055 Box::pin(fut) 6985 6056 } ··· 7009 6080 "/rockbox.v1alpha1.SettingsService/GetGlobalSettings" => { 7010 6081 #[allow(non_camel_case_types)] 7011 6082 struct GetGlobalSettingsSvc<T: SettingsService>(pub Arc<T>); 7012 - impl< 7013 - T: SettingsService, 7014 - > tonic::server::UnaryService<super::GetGlobalSettingsRequest> 7015 - for GetGlobalSettingsSvc<T> { 6083 + impl<T: SettingsService> 6084 + tonic::server::UnaryService<super::GetGlobalSettingsRequest> 6085 + for GetGlobalSettingsSvc<T> 6086 + { 7016 6087 type Response = super::GetGlobalSettingsResponse; 7017 - type Future = BoxFuture< 7018 - tonic::Response<Self::Response>, 7019 - tonic::Status, 7020 - >; 6088 + type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 7021 6089 fn call( 7022 6090 &mut self, 7023 6091 request: tonic::Request<super::GetGlobalSettingsRequest>, 7024 6092 ) -> Self::Future { 7025 6093 let inner = Arc::clone(&self.0); 7026 6094 let fut = async move { 7027 - <T as SettingsService>::get_global_settings(&inner, request) 7028 - .await 6095 + <T as SettingsService>::get_global_settings(&inner, request).await 7029 6096 }; 7030 6097 Box::pin(fut) 7031 6098 } ··· 7055 6122 "/rockbox.v1alpha1.SettingsService/SaveSettings" => { 7056 6123 #[allow(non_camel_case_types)] 7057 6124 struct SaveSettingsSvc<T: SettingsService>(pub Arc<T>); 7058 - impl< 7059 - T: SettingsService, 7060 - > tonic::server::UnaryService<super::SaveSettingsRequest> 7061 - for SaveSettingsSvc<T> { 6125 + impl<T: SettingsService> tonic::server::UnaryService<super::SaveSettingsRequest> 6126 + for SaveSettingsSvc<T> 6127 + { 7062 6128 type Response = super::SaveSettingsResponse; 7063 - type Future = BoxFuture< 7064 - tonic::Response<Self::Response>, 7065 - tonic::Status, 7066 - >; 6129 + type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 7067 6130 fn call( 7068 6131 &mut self, 7069 6132 request: tonic::Request<super::SaveSettingsRequest>, ··· 7097 6160 }; 7098 6161 Box::pin(fut) 7099 6162 } 7100 - _ => { 7101 - Box::pin(async move { 7102 - let mut response = http::Response::new(empty_body()); 7103 - let headers = response.headers_mut(); 7104 - headers 7105 - .insert( 7106 - tonic::Status::GRPC_STATUS, 7107 - (tonic::Code::Unimplemented as i32).into(), 7108 - ); 7109 - headers 7110 - .insert( 7111 - http::header::CONTENT_TYPE, 7112 - tonic::metadata::GRPC_CONTENT_TYPE, 7113 - ); 7114 - Ok(response) 7115 - }) 7116 - } 6163 + _ => Box::pin(async move { 6164 + let mut response = http::Response::new(empty_body()); 6165 + let headers = response.headers_mut(); 6166 + headers.insert( 6167 + tonic::Status::GRPC_STATUS, 6168 + (tonic::Code::Unimplemented as i32).into(), 6169 + ); 6170 + headers.insert( 6171 + http::header::CONTENT_TYPE, 6172 + tonic::metadata::GRPC_CONTENT_TYPE, 6173 + ); 6174 + Ok(response) 6175 + }), 7117 6176 } 7118 6177 } 7119 6178 } ··· 7271 6330 dead_code, 7272 6331 missing_docs, 7273 6332 clippy::wildcard_imports, 7274 - clippy::let_unit_value, 6333 + clippy::let_unit_value 7275 6334 )] 7276 - use tonic::codegen::*; 7277 6335 use tonic::codegen::http::Uri; 6336 + use tonic::codegen::*; 7278 6337 #[derive(Debug, Clone)] 7279 6338 pub struct SoundServiceClient<T> { 7280 6339 inner: tonic::client::Grpc<T>, ··· 7318 6377 <T as tonic::client::GrpcService<tonic::body::BoxBody>>::ResponseBody, 7319 6378 >, 7320 6379 >, 7321 - <T as tonic::codegen::Service< 7322 - http::Request<tonic::body::BoxBody>, 7323 - >>::Error: Into<StdError> + std::marker::Send + std::marker::Sync, 6380 + <T as tonic::codegen::Service<http::Request<tonic::body::BoxBody>>>::Error: 6381 + Into<StdError> + std::marker::Send + std::marker::Sync, 7324 6382 { 7325 6383 SoundServiceClient::new(InterceptedService::new(inner, interceptor)) 7326 6384 } ··· 7358 6416 pub async fn adjust_volume( 7359 6417 &mut self, 7360 6418 request: impl tonic::IntoRequest<super::AdjustVolumeRequest>, 7361 - ) -> std::result::Result< 7362 - tonic::Response<super::AdjustVolumeResponse>, 7363 - tonic::Status, 7364 - > { 7365 - self.inner 7366 - .ready() 7367 - .await 7368 - .map_err(|e| { 7369 - tonic::Status::unknown( 7370 - format!("Service was not ready: {}", e.into()), 7371 - ) 7372 - })?; 6419 + ) -> std::result::Result<tonic::Response<super::AdjustVolumeResponse>, tonic::Status> 6420 + { 6421 + self.inner.ready().await.map_err(|e| { 6422 + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 6423 + })?; 7373 6424 let codec = tonic::codec::ProstCodec::default(); 7374 - let path = http::uri::PathAndQuery::from_static( 7375 - "/rockbox.v1alpha1.SoundService/AdjustVolume", 7376 - ); 6425 + let path = 6426 + http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.SoundService/AdjustVolume"); 7377 6427 let mut req = request.into_request(); 7378 - req.extensions_mut() 7379 - .insert( 7380 - GrpcMethod::new("rockbox.v1alpha1.SoundService", "AdjustVolume"), 7381 - ); 6428 + req.extensions_mut().insert(GrpcMethod::new( 6429 + "rockbox.v1alpha1.SoundService", 6430 + "AdjustVolume", 6431 + )); 7382 6432 self.inner.unary(req, path, codec).await 7383 6433 } 7384 6434 pub async fn sound_set( 7385 6435 &mut self, 7386 6436 request: impl tonic::IntoRequest<super::SoundSetRequest>, 7387 - ) -> std::result::Result< 7388 - tonic::Response<super::SoundSetResponse>, 7389 - tonic::Status, 7390 - > { 7391 - self.inner 7392 - .ready() 7393 - .await 7394 - .map_err(|e| { 7395 - tonic::Status::unknown( 7396 - format!("Service was not ready: {}", e.into()), 7397 - ) 7398 - })?; 6437 + ) -> std::result::Result<tonic::Response<super::SoundSetResponse>, tonic::Status> { 6438 + self.inner.ready().await.map_err(|e| { 6439 + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 6440 + })?; 7399 6441 let codec = tonic::codec::ProstCodec::default(); 7400 - let path = http::uri::PathAndQuery::from_static( 7401 - "/rockbox.v1alpha1.SoundService/SoundSet", 7402 - ); 6442 + let path = 6443 + http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.SoundService/SoundSet"); 7403 6444 let mut req = request.into_request(); 7404 6445 req.extensions_mut() 7405 6446 .insert(GrpcMethod::new("rockbox.v1alpha1.SoundService", "SoundSet")); ··· 7408 6449 pub async fn sound_current( 7409 6450 &mut self, 7410 6451 request: impl tonic::IntoRequest<super::SoundCurrentRequest>, 7411 - ) -> std::result::Result< 7412 - tonic::Response<super::SoundCurrentResponse>, 7413 - tonic::Status, 7414 - > { 7415 - self.inner 7416 - .ready() 7417 - .await 7418 - .map_err(|e| { 7419 - tonic::Status::unknown( 7420 - format!("Service was not ready: {}", e.into()), 7421 - ) 7422 - })?; 6452 + ) -> std::result::Result<tonic::Response<super::SoundCurrentResponse>, tonic::Status> 6453 + { 6454 + self.inner.ready().await.map_err(|e| { 6455 + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 6456 + })?; 7423 6457 let codec = tonic::codec::ProstCodec::default(); 7424 - let path = http::uri::PathAndQuery::from_static( 7425 - "/rockbox.v1alpha1.SoundService/SoundCurrent", 7426 - ); 6458 + let path = 6459 + http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.SoundService/SoundCurrent"); 7427 6460 let mut req = request.into_request(); 7428 - req.extensions_mut() 7429 - .insert( 7430 - GrpcMethod::new("rockbox.v1alpha1.SoundService", "SoundCurrent"), 7431 - ); 6461 + req.extensions_mut().insert(GrpcMethod::new( 6462 + "rockbox.v1alpha1.SoundService", 6463 + "SoundCurrent", 6464 + )); 7432 6465 self.inner.unary(req, path, codec).await 7433 6466 } 7434 6467 pub async fn sound_default( 7435 6468 &mut self, 7436 6469 request: impl tonic::IntoRequest<super::SoundDefaultRequest>, 7437 - ) -> std::result::Result< 7438 - tonic::Response<super::SoundDefaultResponse>, 7439 - tonic::Status, 7440 - > { 7441 - self.inner 7442 - .ready() 7443 - .await 7444 - .map_err(|e| { 7445 - tonic::Status::unknown( 7446 - format!("Service was not ready: {}", e.into()), 7447 - ) 7448 - })?; 6470 + ) -> std::result::Result<tonic::Response<super::SoundDefaultResponse>, tonic::Status> 6471 + { 6472 + self.inner.ready().await.map_err(|e| { 6473 + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 6474 + })?; 7449 6475 let codec = tonic::codec::ProstCodec::default(); 7450 - let path = http::uri::PathAndQuery::from_static( 7451 - "/rockbox.v1alpha1.SoundService/SoundDefault", 7452 - ); 6476 + let path = 6477 + http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.SoundService/SoundDefault"); 7453 6478 let mut req = request.into_request(); 7454 - req.extensions_mut() 7455 - .insert( 7456 - GrpcMethod::new("rockbox.v1alpha1.SoundService", "SoundDefault"), 7457 - ); 6479 + req.extensions_mut().insert(GrpcMethod::new( 6480 + "rockbox.v1alpha1.SoundService", 6481 + "SoundDefault", 6482 + )); 7458 6483 self.inner.unary(req, path, codec).await 7459 6484 } 7460 6485 pub async fn sound_min( 7461 6486 &mut self, 7462 6487 request: impl tonic::IntoRequest<super::SoundMinRequest>, 7463 - ) -> std::result::Result< 7464 - tonic::Response<super::SoundMinResponse>, 7465 - tonic::Status, 7466 - > { 7467 - self.inner 7468 - .ready() 7469 - .await 7470 - .map_err(|e| { 7471 - tonic::Status::unknown( 7472 - format!("Service was not ready: {}", e.into()), 7473 - ) 7474 - })?; 6488 + ) -> std::result::Result<tonic::Response<super::SoundMinResponse>, tonic::Status> { 6489 + self.inner.ready().await.map_err(|e| { 6490 + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 6491 + })?; 7475 6492 let codec = tonic::codec::ProstCodec::default(); 7476 - let path = http::uri::PathAndQuery::from_static( 7477 - "/rockbox.v1alpha1.SoundService/SoundMin", 7478 - ); 6493 + let path = 6494 + http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.SoundService/SoundMin"); 7479 6495 let mut req = request.into_request(); 7480 6496 req.extensions_mut() 7481 6497 .insert(GrpcMethod::new("rockbox.v1alpha1.SoundService", "SoundMin")); ··· 7484 6500 pub async fn sound_max( 7485 6501 &mut self, 7486 6502 request: impl tonic::IntoRequest<super::SoundMaxRequest>, 7487 - ) -> std::result::Result< 7488 - tonic::Response<super::SoundMaxResponse>, 7489 - tonic::Status, 7490 - > { 7491 - self.inner 7492 - .ready() 7493 - .await 7494 - .map_err(|e| { 7495 - tonic::Status::unknown( 7496 - format!("Service was not ready: {}", e.into()), 7497 - ) 7498 - })?; 6503 + ) -> std::result::Result<tonic::Response<super::SoundMaxResponse>, tonic::Status> { 6504 + self.inner.ready().await.map_err(|e| { 6505 + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 6506 + })?; 7499 6507 let codec = tonic::codec::ProstCodec::default(); 7500 - let path = http::uri::PathAndQuery::from_static( 7501 - "/rockbox.v1alpha1.SoundService/SoundMax", 7502 - ); 6508 + let path = 6509 + http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.SoundService/SoundMax"); 7503 6510 let mut req = request.into_request(); 7504 6511 req.extensions_mut() 7505 6512 .insert(GrpcMethod::new("rockbox.v1alpha1.SoundService", "SoundMax")); ··· 7508 6515 pub async fn sound_unit( 7509 6516 &mut self, 7510 6517 request: impl tonic::IntoRequest<super::SoundUnitRequest>, 7511 - ) -> std::result::Result< 7512 - tonic::Response<super::SoundUnitResponse>, 7513 - tonic::Status, 7514 - > { 7515 - self.inner 7516 - .ready() 7517 - .await 7518 - .map_err(|e| { 7519 - tonic::Status::unknown( 7520 - format!("Service was not ready: {}", e.into()), 7521 - ) 7522 - })?; 6518 + ) -> std::result::Result<tonic::Response<super::SoundUnitResponse>, tonic::Status> { 6519 + self.inner.ready().await.map_err(|e| { 6520 + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 6521 + })?; 7523 6522 let codec = tonic::codec::ProstCodec::default(); 7524 - let path = http::uri::PathAndQuery::from_static( 7525 - "/rockbox.v1alpha1.SoundService/SoundUnit", 7526 - ); 6523 + let path = 6524 + http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.SoundService/SoundUnit"); 7527 6525 let mut req = request.into_request(); 7528 - req.extensions_mut() 7529 - .insert(GrpcMethod::new("rockbox.v1alpha1.SoundService", "SoundUnit")); 6526 + req.extensions_mut().insert(GrpcMethod::new( 6527 + "rockbox.v1alpha1.SoundService", 6528 + "SoundUnit", 6529 + )); 7530 6530 self.inner.unary(req, path, codec).await 7531 6531 } 7532 6532 pub async fn sound_val2_phys( 7533 6533 &mut self, 7534 6534 request: impl tonic::IntoRequest<super::SoundVal2PhysRequest>, 7535 - ) -> std::result::Result< 7536 - tonic::Response<super::SoundVal2PhysResponse>, 7537 - tonic::Status, 7538 - > { 7539 - self.inner 7540 - .ready() 7541 - .await 7542 - .map_err(|e| { 7543 - tonic::Status::unknown( 7544 - format!("Service was not ready: {}", e.into()), 7545 - ) 7546 - })?; 6535 + ) -> std::result::Result<tonic::Response<super::SoundVal2PhysResponse>, tonic::Status> 6536 + { 6537 + self.inner.ready().await.map_err(|e| { 6538 + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 6539 + })?; 7547 6540 let codec = tonic::codec::ProstCodec::default(); 7548 6541 let path = http::uri::PathAndQuery::from_static( 7549 6542 "/rockbox.v1alpha1.SoundService/SoundVal2Phys", 7550 6543 ); 7551 6544 let mut req = request.into_request(); 7552 - req.extensions_mut() 7553 - .insert( 7554 - GrpcMethod::new("rockbox.v1alpha1.SoundService", "SoundVal2Phys"), 7555 - ); 6545 + req.extensions_mut().insert(GrpcMethod::new( 6546 + "rockbox.v1alpha1.SoundService", 6547 + "SoundVal2Phys", 6548 + )); 7556 6549 self.inner.unary(req, path, codec).await 7557 6550 } 7558 6551 pub async fn get_pitch( 7559 6552 &mut self, 7560 6553 request: impl tonic::IntoRequest<super::GetPitchRequest>, 7561 - ) -> std::result::Result< 7562 - tonic::Response<super::GetPitchResponse>, 7563 - tonic::Status, 7564 - > { 7565 - self.inner 7566 - .ready() 7567 - .await 7568 - .map_err(|e| { 7569 - tonic::Status::unknown( 7570 - format!("Service was not ready: {}", e.into()), 7571 - ) 7572 - })?; 6554 + ) -> std::result::Result<tonic::Response<super::GetPitchResponse>, tonic::Status> { 6555 + self.inner.ready().await.map_err(|e| { 6556 + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 6557 + })?; 7573 6558 let codec = tonic::codec::ProstCodec::default(); 7574 - let path = http::uri::PathAndQuery::from_static( 7575 - "/rockbox.v1alpha1.SoundService/GetPitch", 7576 - ); 6559 + let path = 6560 + http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.SoundService/GetPitch"); 7577 6561 let mut req = request.into_request(); 7578 6562 req.extensions_mut() 7579 6563 .insert(GrpcMethod::new("rockbox.v1alpha1.SoundService", "GetPitch")); ··· 7582 6566 pub async fn set_pitch( 7583 6567 &mut self, 7584 6568 request: impl tonic::IntoRequest<super::SetPitchRequest>, 7585 - ) -> std::result::Result< 7586 - tonic::Response<super::SetPitchResponse>, 7587 - tonic::Status, 7588 - > { 7589 - self.inner 7590 - .ready() 7591 - .await 7592 - .map_err(|e| { 7593 - tonic::Status::unknown( 7594 - format!("Service was not ready: {}", e.into()), 7595 - ) 7596 - })?; 6569 + ) -> std::result::Result<tonic::Response<super::SetPitchResponse>, tonic::Status> { 6570 + self.inner.ready().await.map_err(|e| { 6571 + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 6572 + })?; 7597 6573 let codec = tonic::codec::ProstCodec::default(); 7598 - let path = http::uri::PathAndQuery::from_static( 7599 - "/rockbox.v1alpha1.SoundService/SetPitch", 7600 - ); 6574 + let path = 6575 + http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.SoundService/SetPitch"); 7601 6576 let mut req = request.into_request(); 7602 6577 req.extensions_mut() 7603 6578 .insert(GrpcMethod::new("rockbox.v1alpha1.SoundService", "SetPitch")); ··· 7606 6581 pub async fn beep_play( 7607 6582 &mut self, 7608 6583 request: impl tonic::IntoRequest<super::BeepPlayRequest>, 7609 - ) -> std::result::Result< 7610 - tonic::Response<super::BeepPlayResponse>, 7611 - tonic::Status, 7612 - > { 7613 - self.inner 7614 - .ready() 7615 - .await 7616 - .map_err(|e| { 7617 - tonic::Status::unknown( 7618 - format!("Service was not ready: {}", e.into()), 7619 - ) 7620 - })?; 6584 + ) -> std::result::Result<tonic::Response<super::BeepPlayResponse>, tonic::Status> { 6585 + self.inner.ready().await.map_err(|e| { 6586 + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 6587 + })?; 7621 6588 let codec = tonic::codec::ProstCodec::default(); 7622 - let path = http::uri::PathAndQuery::from_static( 7623 - "/rockbox.v1alpha1.SoundService/BeepPlay", 7624 - ); 6589 + let path = 6590 + http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.SoundService/BeepPlay"); 7625 6591 let mut req = request.into_request(); 7626 6592 req.extensions_mut() 7627 6593 .insert(GrpcMethod::new("rockbox.v1alpha1.SoundService", "BeepPlay")); ··· 7630 6596 pub async fn pcmbuf_fade( 7631 6597 &mut self, 7632 6598 request: impl tonic::IntoRequest<super::PcmbufFadeRequest>, 7633 - ) -> std::result::Result< 7634 - tonic::Response<super::PcmbufFadeResponse>, 7635 - tonic::Status, 7636 - > { 7637 - self.inner 7638 - .ready() 7639 - .await 7640 - .map_err(|e| { 7641 - tonic::Status::unknown( 7642 - format!("Service was not ready: {}", e.into()), 7643 - ) 7644 - })?; 6599 + ) -> std::result::Result<tonic::Response<super::PcmbufFadeResponse>, tonic::Status> 6600 + { 6601 + self.inner.ready().await.map_err(|e| { 6602 + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 6603 + })?; 7645 6604 let codec = tonic::codec::ProstCodec::default(); 7646 - let path = http::uri::PathAndQuery::from_static( 7647 - "/rockbox.v1alpha1.SoundService/PcmbufFade", 7648 - ); 6605 + let path = 6606 + http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.SoundService/PcmbufFade"); 7649 6607 let mut req = request.into_request(); 7650 - req.extensions_mut() 7651 - .insert(GrpcMethod::new("rockbox.v1alpha1.SoundService", "PcmbufFade")); 6608 + req.extensions_mut().insert(GrpcMethod::new( 6609 + "rockbox.v1alpha1.SoundService", 6610 + "PcmbufFade", 6611 + )); 7652 6612 self.inner.unary(req, path, codec).await 7653 6613 } 7654 6614 pub async fn pcmbuf_set_low_latency( 7655 6615 &mut self, 7656 6616 request: impl tonic::IntoRequest<super::PcmbufSetLowLatencyRequest>, 7657 - ) -> std::result::Result< 7658 - tonic::Response<super::PcmbufSetLowLatencyResponse>, 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 - })?; 6617 + ) -> std::result::Result<tonic::Response<super::PcmbufSetLowLatencyResponse>, tonic::Status> 6618 + { 6619 + self.inner.ready().await.map_err(|e| { 6620 + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 6621 + })?; 7669 6622 let codec = tonic::codec::ProstCodec::default(); 7670 6623 let path = http::uri::PathAndQuery::from_static( 7671 6624 "/rockbox.v1alpha1.SoundService/PcmbufSetLowLatency", 7672 6625 ); 7673 6626 let mut req = request.into_request(); 7674 - req.extensions_mut() 7675 - .insert( 7676 - GrpcMethod::new( 7677 - "rockbox.v1alpha1.SoundService", 7678 - "PcmbufSetLowLatency", 7679 - ), 7680 - ); 6627 + req.extensions_mut().insert(GrpcMethod::new( 6628 + "rockbox.v1alpha1.SoundService", 6629 + "PcmbufSetLowLatency", 6630 + )); 7681 6631 self.inner.unary(req, path, codec).await 7682 6632 } 7683 6633 pub async fn system_sound_play( 7684 6634 &mut self, 7685 6635 request: impl tonic::IntoRequest<super::SystemSoundPlayRequest>, 7686 - ) -> std::result::Result< 7687 - tonic::Response<super::SystemSoundPlayResponse>, 7688 - tonic::Status, 7689 - > { 7690 - self.inner 7691 - .ready() 7692 - .await 7693 - .map_err(|e| { 7694 - tonic::Status::unknown( 7695 - format!("Service was not ready: {}", e.into()), 7696 - ) 7697 - })?; 6636 + ) -> std::result::Result<tonic::Response<super::SystemSoundPlayResponse>, tonic::Status> 6637 + { 6638 + self.inner.ready().await.map_err(|e| { 6639 + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 6640 + })?; 7698 6641 let codec = tonic::codec::ProstCodec::default(); 7699 6642 let path = http::uri::PathAndQuery::from_static( 7700 6643 "/rockbox.v1alpha1.SoundService/SystemSoundPlay", 7701 6644 ); 7702 6645 let mut req = request.into_request(); 7703 - req.extensions_mut() 7704 - .insert( 7705 - GrpcMethod::new("rockbox.v1alpha1.SoundService", "SystemSoundPlay"), 7706 - ); 6646 + req.extensions_mut().insert(GrpcMethod::new( 6647 + "rockbox.v1alpha1.SoundService", 6648 + "SystemSoundPlay", 6649 + )); 7707 6650 self.inner.unary(req, path, codec).await 7708 6651 } 7709 6652 pub async fn keyclick_click( 7710 6653 &mut self, 7711 6654 request: impl tonic::IntoRequest<super::KeyclickClickRequest>, 7712 - ) -> std::result::Result< 7713 - tonic::Response<super::KeyclickClickResponse>, 7714 - tonic::Status, 7715 - > { 7716 - self.inner 7717 - .ready() 7718 - .await 7719 - .map_err(|e| { 7720 - tonic::Status::unknown( 7721 - format!("Service was not ready: {}", e.into()), 7722 - ) 7723 - })?; 6655 + ) -> std::result::Result<tonic::Response<super::KeyclickClickResponse>, tonic::Status> 6656 + { 6657 + self.inner.ready().await.map_err(|e| { 6658 + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 6659 + })?; 7724 6660 let codec = tonic::codec::ProstCodec::default(); 7725 6661 let path = http::uri::PathAndQuery::from_static( 7726 6662 "/rockbox.v1alpha1.SoundService/KeyclickClick", 7727 6663 ); 7728 6664 let mut req = request.into_request(); 7729 - req.extensions_mut() 7730 - .insert( 7731 - GrpcMethod::new("rockbox.v1alpha1.SoundService", "KeyclickClick"), 7732 - ); 6665 + req.extensions_mut().insert(GrpcMethod::new( 6666 + "rockbox.v1alpha1.SoundService", 6667 + "KeyclickClick", 6668 + )); 7733 6669 self.inner.unary(req, path, codec).await 7734 6670 } 7735 6671 } ··· 7741 6677 dead_code, 7742 6678 missing_docs, 7743 6679 clippy::wildcard_imports, 7744 - clippy::let_unit_value, 6680 + clippy::let_unit_value 7745 6681 )] 7746 6682 use tonic::codegen::*; 7747 6683 /// Generated trait containing gRPC methods that should be implemented for use with SoundServiceServer. ··· 7750 6686 async fn adjust_volume( 7751 6687 &self, 7752 6688 request: tonic::Request<super::AdjustVolumeRequest>, 7753 - ) -> std::result::Result< 7754 - tonic::Response<super::AdjustVolumeResponse>, 7755 - tonic::Status, 7756 - >; 6689 + ) -> std::result::Result<tonic::Response<super::AdjustVolumeResponse>, tonic::Status>; 7757 6690 async fn sound_set( 7758 6691 &self, 7759 6692 request: tonic::Request<super::SoundSetRequest>, 7760 - ) -> std::result::Result< 7761 - tonic::Response<super::SoundSetResponse>, 7762 - tonic::Status, 7763 - >; 6693 + ) -> std::result::Result<tonic::Response<super::SoundSetResponse>, tonic::Status>; 7764 6694 async fn sound_current( 7765 6695 &self, 7766 6696 request: tonic::Request<super::SoundCurrentRequest>, 7767 - ) -> std::result::Result< 7768 - tonic::Response<super::SoundCurrentResponse>, 7769 - tonic::Status, 7770 - >; 6697 + ) -> std::result::Result<tonic::Response<super::SoundCurrentResponse>, tonic::Status>; 7771 6698 async fn sound_default( 7772 6699 &self, 7773 6700 request: tonic::Request<super::SoundDefaultRequest>, 7774 - ) -> std::result::Result< 7775 - tonic::Response<super::SoundDefaultResponse>, 7776 - tonic::Status, 7777 - >; 6701 + ) -> std::result::Result<tonic::Response<super::SoundDefaultResponse>, tonic::Status>; 7778 6702 async fn sound_min( 7779 6703 &self, 7780 6704 request: tonic::Request<super::SoundMinRequest>, 7781 - ) -> std::result::Result< 7782 - tonic::Response<super::SoundMinResponse>, 7783 - tonic::Status, 7784 - >; 6705 + ) -> std::result::Result<tonic::Response<super::SoundMinResponse>, tonic::Status>; 7785 6706 async fn sound_max( 7786 6707 &self, 7787 6708 request: tonic::Request<super::SoundMaxRequest>, 7788 - ) -> std::result::Result< 7789 - tonic::Response<super::SoundMaxResponse>, 7790 - tonic::Status, 7791 - >; 6709 + ) -> std::result::Result<tonic::Response<super::SoundMaxResponse>, tonic::Status>; 7792 6710 async fn sound_unit( 7793 6711 &self, 7794 6712 request: tonic::Request<super::SoundUnitRequest>, 7795 - ) -> std::result::Result< 7796 - tonic::Response<super::SoundUnitResponse>, 7797 - tonic::Status, 7798 - >; 6713 + ) -> std::result::Result<tonic::Response<super::SoundUnitResponse>, tonic::Status>; 7799 6714 async fn sound_val2_phys( 7800 6715 &self, 7801 6716 request: tonic::Request<super::SoundVal2PhysRequest>, 7802 - ) -> std::result::Result< 7803 - tonic::Response<super::SoundVal2PhysResponse>, 7804 - tonic::Status, 7805 - >; 6717 + ) -> std::result::Result<tonic::Response<super::SoundVal2PhysResponse>, tonic::Status>; 7806 6718 async fn get_pitch( 7807 6719 &self, 7808 6720 request: tonic::Request<super::GetPitchRequest>, 7809 - ) -> std::result::Result< 7810 - tonic::Response<super::GetPitchResponse>, 7811 - tonic::Status, 7812 - >; 6721 + ) -> std::result::Result<tonic::Response<super::GetPitchResponse>, tonic::Status>; 7813 6722 async fn set_pitch( 7814 6723 &self, 7815 6724 request: tonic::Request<super::SetPitchRequest>, 7816 - ) -> std::result::Result< 7817 - tonic::Response<super::SetPitchResponse>, 7818 - tonic::Status, 7819 - >; 6725 + ) -> std::result::Result<tonic::Response<super::SetPitchResponse>, tonic::Status>; 7820 6726 async fn beep_play( 7821 6727 &self, 7822 6728 request: tonic::Request<super::BeepPlayRequest>, 7823 - ) -> std::result::Result< 7824 - tonic::Response<super::BeepPlayResponse>, 7825 - tonic::Status, 7826 - >; 6729 + ) -> std::result::Result<tonic::Response<super::BeepPlayResponse>, tonic::Status>; 7827 6730 async fn pcmbuf_fade( 7828 6731 &self, 7829 6732 request: tonic::Request<super::PcmbufFadeRequest>, 7830 - ) -> std::result::Result< 7831 - tonic::Response<super::PcmbufFadeResponse>, 7832 - tonic::Status, 7833 - >; 6733 + ) -> std::result::Result<tonic::Response<super::PcmbufFadeResponse>, tonic::Status>; 7834 6734 async fn pcmbuf_set_low_latency( 7835 6735 &self, 7836 6736 request: tonic::Request<super::PcmbufSetLowLatencyRequest>, 7837 - ) -> std::result::Result< 7838 - tonic::Response<super::PcmbufSetLowLatencyResponse>, 7839 - tonic::Status, 7840 - >; 6737 + ) -> std::result::Result<tonic::Response<super::PcmbufSetLowLatencyResponse>, tonic::Status>; 7841 6738 async fn system_sound_play( 7842 6739 &self, 7843 6740 request: tonic::Request<super::SystemSoundPlayRequest>, 7844 - ) -> std::result::Result< 7845 - tonic::Response<super::SystemSoundPlayResponse>, 7846 - tonic::Status, 7847 - >; 6741 + ) -> std::result::Result<tonic::Response<super::SystemSoundPlayResponse>, tonic::Status>; 7848 6742 async fn keyclick_click( 7849 6743 &self, 7850 6744 request: tonic::Request<super::KeyclickClickRequest>, 7851 - ) -> std::result::Result< 7852 - tonic::Response<super::KeyclickClickResponse>, 7853 - tonic::Status, 7854 - >; 6745 + ) -> std::result::Result<tonic::Response<super::KeyclickClickResponse>, tonic::Status>; 7855 6746 } 7856 6747 #[derive(Debug)] 7857 6748 pub struct SoundServiceServer<T> { ··· 7874 6765 max_encoding_message_size: None, 7875 6766 } 7876 6767 } 7877 - pub fn with_interceptor<F>( 7878 - inner: T, 7879 - interceptor: F, 7880 - ) -> InterceptedService<Self, F> 6768 + pub fn with_interceptor<F>(inner: T, interceptor: F) -> InterceptedService<Self, F> 7881 6769 where 7882 6770 F: tonic::service::Interceptor, 7883 6771 { ··· 7932 6820 "/rockbox.v1alpha1.SoundService/AdjustVolume" => { 7933 6821 #[allow(non_camel_case_types)] 7934 6822 struct AdjustVolumeSvc<T: SoundService>(pub Arc<T>); 7935 - impl< 7936 - T: SoundService, 7937 - > tonic::server::UnaryService<super::AdjustVolumeRequest> 7938 - for AdjustVolumeSvc<T> { 6823 + impl<T: SoundService> tonic::server::UnaryService<super::AdjustVolumeRequest> 6824 + for AdjustVolumeSvc<T> 6825 + { 7939 6826 type Response = super::AdjustVolumeResponse; 7940 - type Future = BoxFuture< 7941 - tonic::Response<Self::Response>, 7942 - tonic::Status, 7943 - >; 6827 + type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 7944 6828 fn call( 7945 6829 &mut self, 7946 6830 request: tonic::Request<super::AdjustVolumeRequest>, ··· 7977 6861 "/rockbox.v1alpha1.SoundService/SoundSet" => { 7978 6862 #[allow(non_camel_case_types)] 7979 6863 struct SoundSetSvc<T: SoundService>(pub Arc<T>); 7980 - impl< 7981 - T: SoundService, 7982 - > tonic::server::UnaryService<super::SoundSetRequest> 7983 - for SoundSetSvc<T> { 6864 + impl<T: SoundService> tonic::server::UnaryService<super::SoundSetRequest> for SoundSetSvc<T> { 7984 6865 type Response = super::SoundSetResponse; 7985 - type Future = BoxFuture< 7986 - tonic::Response<Self::Response>, 7987 - tonic::Status, 7988 - >; 6866 + type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 7989 6867 fn call( 7990 6868 &mut self, 7991 6869 request: tonic::Request<super::SoundSetRequest>, ··· 8022 6900 "/rockbox.v1alpha1.SoundService/SoundCurrent" => { 8023 6901 #[allow(non_camel_case_types)] 8024 6902 struct SoundCurrentSvc<T: SoundService>(pub Arc<T>); 8025 - impl< 8026 - T: SoundService, 8027 - > tonic::server::UnaryService<super::SoundCurrentRequest> 8028 - for SoundCurrentSvc<T> { 6903 + impl<T: SoundService> tonic::server::UnaryService<super::SoundCurrentRequest> 6904 + for SoundCurrentSvc<T> 6905 + { 8029 6906 type Response = super::SoundCurrentResponse; 8030 - type Future = BoxFuture< 8031 - tonic::Response<Self::Response>, 8032 - tonic::Status, 8033 - >; 6907 + type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 8034 6908 fn call( 8035 6909 &mut self, 8036 6910 request: tonic::Request<super::SoundCurrentRequest>, ··· 8067 6941 "/rockbox.v1alpha1.SoundService/SoundDefault" => { 8068 6942 #[allow(non_camel_case_types)] 8069 6943 struct SoundDefaultSvc<T: SoundService>(pub Arc<T>); 8070 - impl< 8071 - T: SoundService, 8072 - > tonic::server::UnaryService<super::SoundDefaultRequest> 8073 - for SoundDefaultSvc<T> { 6944 + impl<T: SoundService> tonic::server::UnaryService<super::SoundDefaultRequest> 6945 + for SoundDefaultSvc<T> 6946 + { 8074 6947 type Response = super::SoundDefaultResponse; 8075 - type Future = BoxFuture< 8076 - tonic::Response<Self::Response>, 8077 - tonic::Status, 8078 - >; 6948 + type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 8079 6949 fn call( 8080 6950 &mut self, 8081 6951 request: tonic::Request<super::SoundDefaultRequest>, ··· 8112 6982 "/rockbox.v1alpha1.SoundService/SoundMin" => { 8113 6983 #[allow(non_camel_case_types)] 8114 6984 struct SoundMinSvc<T: SoundService>(pub Arc<T>); 8115 - impl< 8116 - T: SoundService, 8117 - > tonic::server::UnaryService<super::SoundMinRequest> 8118 - for SoundMinSvc<T> { 6985 + impl<T: SoundService> tonic::server::UnaryService<super::SoundMinRequest> for SoundMinSvc<T> { 8119 6986 type Response = super::SoundMinResponse; 8120 - type Future = BoxFuture< 8121 - tonic::Response<Self::Response>, 8122 - tonic::Status, 8123 - >; 6987 + type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 8124 6988 fn call( 8125 6989 &mut self, 8126 6990 request: tonic::Request<super::SoundMinRequest>, ··· 8157 7021 "/rockbox.v1alpha1.SoundService/SoundMax" => { 8158 7022 #[allow(non_camel_case_types)] 8159 7023 struct SoundMaxSvc<T: SoundService>(pub Arc<T>); 8160 - impl< 8161 - T: SoundService, 8162 - > tonic::server::UnaryService<super::SoundMaxRequest> 8163 - for SoundMaxSvc<T> { 7024 + impl<T: SoundService> tonic::server::UnaryService<super::SoundMaxRequest> for SoundMaxSvc<T> { 8164 7025 type Response = super::SoundMaxResponse; 8165 - type Future = BoxFuture< 8166 - tonic::Response<Self::Response>, 8167 - tonic::Status, 8168 - >; 7026 + type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 8169 7027 fn call( 8170 7028 &mut self, 8171 7029 request: tonic::Request<super::SoundMaxRequest>, ··· 8202 7060 "/rockbox.v1alpha1.SoundService/SoundUnit" => { 8203 7061 #[allow(non_camel_case_types)] 8204 7062 struct SoundUnitSvc<T: SoundService>(pub Arc<T>); 8205 - impl< 8206 - T: SoundService, 8207 - > tonic::server::UnaryService<super::SoundUnitRequest> 8208 - for SoundUnitSvc<T> { 7063 + impl<T: SoundService> tonic::server::UnaryService<super::SoundUnitRequest> for SoundUnitSvc<T> { 8209 7064 type Response = super::SoundUnitResponse; 8210 - type Future = BoxFuture< 8211 - tonic::Response<Self::Response>, 8212 - tonic::Status, 8213 - >; 7065 + type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 8214 7066 fn call( 8215 7067 &mut self, 8216 7068 request: tonic::Request<super::SoundUnitRequest>, ··· 8247 7099 "/rockbox.v1alpha1.SoundService/SoundVal2Phys" => { 8248 7100 #[allow(non_camel_case_types)] 8249 7101 struct SoundVal2PhysSvc<T: SoundService>(pub Arc<T>); 8250 - impl< 8251 - T: SoundService, 8252 - > tonic::server::UnaryService<super::SoundVal2PhysRequest> 8253 - for SoundVal2PhysSvc<T> { 7102 + impl<T: SoundService> tonic::server::UnaryService<super::SoundVal2PhysRequest> 7103 + for SoundVal2PhysSvc<T> 7104 + { 8254 7105 type Response = super::SoundVal2PhysResponse; 8255 - type Future = BoxFuture< 8256 - tonic::Response<Self::Response>, 8257 - tonic::Status, 8258 - >; 7106 + type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 8259 7107 fn call( 8260 7108 &mut self, 8261 7109 request: tonic::Request<super::SoundVal2PhysRequest>, ··· 8292 7140 "/rockbox.v1alpha1.SoundService/GetPitch" => { 8293 7141 #[allow(non_camel_case_types)] 8294 7142 struct GetPitchSvc<T: SoundService>(pub Arc<T>); 8295 - impl< 8296 - T: SoundService, 8297 - > tonic::server::UnaryService<super::GetPitchRequest> 8298 - for GetPitchSvc<T> { 7143 + impl<T: SoundService> tonic::server::UnaryService<super::GetPitchRequest> for GetPitchSvc<T> { 8299 7144 type Response = super::GetPitchResponse; 8300 - type Future = BoxFuture< 8301 - tonic::Response<Self::Response>, 8302 - tonic::Status, 8303 - >; 7145 + type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 8304 7146 fn call( 8305 7147 &mut self, 8306 7148 request: tonic::Request<super::GetPitchRequest>, ··· 8337 7179 "/rockbox.v1alpha1.SoundService/SetPitch" => { 8338 7180 #[allow(non_camel_case_types)] 8339 7181 struct SetPitchSvc<T: SoundService>(pub Arc<T>); 8340 - impl< 8341 - T: SoundService, 8342 - > tonic::server::UnaryService<super::SetPitchRequest> 8343 - for SetPitchSvc<T> { 7182 + impl<T: SoundService> tonic::server::UnaryService<super::SetPitchRequest> for SetPitchSvc<T> { 8344 7183 type Response = super::SetPitchResponse; 8345 - type Future = BoxFuture< 8346 - tonic::Response<Self::Response>, 8347 - tonic::Status, 8348 - >; 7184 + type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 8349 7185 fn call( 8350 7186 &mut self, 8351 7187 request: tonic::Request<super::SetPitchRequest>, ··· 8382 7218 "/rockbox.v1alpha1.SoundService/BeepPlay" => { 8383 7219 #[allow(non_camel_case_types)] 8384 7220 struct BeepPlaySvc<T: SoundService>(pub Arc<T>); 8385 - impl< 8386 - T: SoundService, 8387 - > tonic::server::UnaryService<super::BeepPlayRequest> 8388 - for BeepPlaySvc<T> { 7221 + impl<T: SoundService> tonic::server::UnaryService<super::BeepPlayRequest> for BeepPlaySvc<T> { 8389 7222 type Response = super::BeepPlayResponse; 8390 - type Future = BoxFuture< 8391 - tonic::Response<Self::Response>, 8392 - tonic::Status, 8393 - >; 7223 + type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 8394 7224 fn call( 8395 7225 &mut self, 8396 7226 request: tonic::Request<super::BeepPlayRequest>, ··· 8427 7257 "/rockbox.v1alpha1.SoundService/PcmbufFade" => { 8428 7258 #[allow(non_camel_case_types)] 8429 7259 struct PcmbufFadeSvc<T: SoundService>(pub Arc<T>); 8430 - impl< 8431 - T: SoundService, 8432 - > tonic::server::UnaryService<super::PcmbufFadeRequest> 8433 - for PcmbufFadeSvc<T> { 7260 + impl<T: SoundService> tonic::server::UnaryService<super::PcmbufFadeRequest> for PcmbufFadeSvc<T> { 8434 7261 type Response = super::PcmbufFadeResponse; 8435 - type Future = BoxFuture< 8436 - tonic::Response<Self::Response>, 8437 - tonic::Status, 8438 - >; 7262 + type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 8439 7263 fn call( 8440 7264 &mut self, 8441 7265 request: tonic::Request<super::PcmbufFadeRequest>, ··· 8472 7296 "/rockbox.v1alpha1.SoundService/PcmbufSetLowLatency" => { 8473 7297 #[allow(non_camel_case_types)] 8474 7298 struct PcmbufSetLowLatencySvc<T: SoundService>(pub Arc<T>); 8475 - impl< 8476 - T: SoundService, 8477 - > tonic::server::UnaryService<super::PcmbufSetLowLatencyRequest> 8478 - for PcmbufSetLowLatencySvc<T> { 7299 + impl<T: SoundService> 7300 + tonic::server::UnaryService<super::PcmbufSetLowLatencyRequest> 7301 + for PcmbufSetLowLatencySvc<T> 7302 + { 8479 7303 type Response = super::PcmbufSetLowLatencyResponse; 8480 - type Future = BoxFuture< 8481 - tonic::Response<Self::Response>, 8482 - tonic::Status, 8483 - >; 7304 + type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 8484 7305 fn call( 8485 7306 &mut self, 8486 7307 request: tonic::Request<super::PcmbufSetLowLatencyRequest>, 8487 7308 ) -> Self::Future { 8488 7309 let inner = Arc::clone(&self.0); 8489 7310 let fut = async move { 8490 - <T as SoundService>::pcmbuf_set_low_latency(&inner, request) 8491 - .await 7311 + <T as SoundService>::pcmbuf_set_low_latency(&inner, request).await 8492 7312 }; 8493 7313 Box::pin(fut) 8494 7314 } ··· 8518 7338 "/rockbox.v1alpha1.SoundService/SystemSoundPlay" => { 8519 7339 #[allow(non_camel_case_types)] 8520 7340 struct SystemSoundPlaySvc<T: SoundService>(pub Arc<T>); 8521 - impl< 8522 - T: SoundService, 8523 - > tonic::server::UnaryService<super::SystemSoundPlayRequest> 8524 - for SystemSoundPlaySvc<T> { 7341 + impl<T: SoundService> tonic::server::UnaryService<super::SystemSoundPlayRequest> 7342 + for SystemSoundPlaySvc<T> 7343 + { 8525 7344 type Response = super::SystemSoundPlayResponse; 8526 - type Future = BoxFuture< 8527 - tonic::Response<Self::Response>, 8528 - tonic::Status, 8529 - >; 7345 + type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 8530 7346 fn call( 8531 7347 &mut self, 8532 7348 request: tonic::Request<super::SystemSoundPlayRequest>, 8533 7349 ) -> Self::Future { 8534 7350 let inner = Arc::clone(&self.0); 8535 7351 let fut = async move { 8536 - <T as SoundService>::system_sound_play(&inner, request) 8537 - .await 7352 + <T as SoundService>::system_sound_play(&inner, request).await 8538 7353 }; 8539 7354 Box::pin(fut) 8540 7355 } ··· 8564 7379 "/rockbox.v1alpha1.SoundService/KeyclickClick" => { 8565 7380 #[allow(non_camel_case_types)] 8566 7381 struct KeyclickClickSvc<T: SoundService>(pub Arc<T>); 8567 - impl< 8568 - T: SoundService, 8569 - > tonic::server::UnaryService<super::KeyclickClickRequest> 8570 - for KeyclickClickSvc<T> { 7382 + impl<T: SoundService> tonic::server::UnaryService<super::KeyclickClickRequest> 7383 + for KeyclickClickSvc<T> 7384 + { 8571 7385 type Response = super::KeyclickClickResponse; 8572 - type Future = BoxFuture< 8573 - tonic::Response<Self::Response>, 8574 - tonic::Status, 8575 - >; 7386 + type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 8576 7387 fn call( 8577 7388 &mut self, 8578 7389 request: tonic::Request<super::KeyclickClickRequest>, ··· 8606 7417 }; 8607 7418 Box::pin(fut) 8608 7419 } 8609 - _ => { 8610 - Box::pin(async move { 8611 - let mut response = http::Response::new(empty_body()); 8612 - let headers = response.headers_mut(); 8613 - headers 8614 - .insert( 8615 - tonic::Status::GRPC_STATUS, 8616 - (tonic::Code::Unimplemented as i32).into(), 8617 - ); 8618 - headers 8619 - .insert( 8620 - http::header::CONTENT_TYPE, 8621 - tonic::metadata::GRPC_CONTENT_TYPE, 8622 - ); 8623 - Ok(response) 8624 - }) 8625 - } 7420 + _ => Box::pin(async move { 7421 + let mut response = http::Response::new(empty_body()); 7422 + let headers = response.headers_mut(); 7423 + headers.insert( 7424 + tonic::Status::GRPC_STATUS, 7425 + (tonic::Code::Unimplemented as i32).into(), 7426 + ); 7427 + headers.insert( 7428 + http::header::CONTENT_TYPE, 7429 + tonic::metadata::GRPC_CONTENT_TYPE, 7430 + ); 7431 + Ok(response) 7432 + }), 8626 7433 } 8627 7434 } 8628 7435 } ··· 8683 7490 dead_code, 8684 7491 missing_docs, 8685 7492 clippy::wildcard_imports, 8686 - clippy::let_unit_value, 7493 + clippy::let_unit_value 8687 7494 )] 8688 - use tonic::codegen::*; 8689 7495 use tonic::codegen::http::Uri; 7496 + use tonic::codegen::*; 8690 7497 #[derive(Debug, Clone)] 8691 7498 pub struct SystemServiceClient<T> { 8692 7499 inner: tonic::client::Grpc<T>, ··· 8730 7537 <T as tonic::client::GrpcService<tonic::body::BoxBody>>::ResponseBody, 8731 7538 >, 8732 7539 >, 8733 - <T as tonic::codegen::Service< 8734 - http::Request<tonic::body::BoxBody>, 8735 - >>::Error: Into<StdError> + std::marker::Send + std::marker::Sync, 7540 + <T as tonic::codegen::Service<http::Request<tonic::body::BoxBody>>>::Error: 7541 + Into<StdError> + std::marker::Send + std::marker::Sync, 8736 7542 { 8737 7543 SystemServiceClient::new(InterceptedService::new(inner, interceptor)) 8738 7544 } ··· 8770 7576 pub async fn get_rockbox_version( 8771 7577 &mut self, 8772 7578 request: impl tonic::IntoRequest<super::GetRockboxVersionRequest>, 8773 - ) -> std::result::Result< 8774 - tonic::Response<super::GetRockboxVersionResponse>, 8775 - tonic::Status, 8776 - > { 8777 - self.inner 8778 - .ready() 8779 - .await 8780 - .map_err(|e| { 8781 - tonic::Status::unknown( 8782 - format!("Service was not ready: {}", e.into()), 8783 - ) 8784 - })?; 7579 + ) -> std::result::Result<tonic::Response<super::GetRockboxVersionResponse>, tonic::Status> 7580 + { 7581 + self.inner.ready().await.map_err(|e| { 7582 + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 7583 + })?; 8785 7584 let codec = tonic::codec::ProstCodec::default(); 8786 7585 let path = http::uri::PathAndQuery::from_static( 8787 7586 "/rockbox.v1alpha1.SystemService/GetRockboxVersion", 8788 7587 ); 8789 7588 let mut req = request.into_request(); 8790 - req.extensions_mut() 8791 - .insert( 8792 - GrpcMethod::new( 8793 - "rockbox.v1alpha1.SystemService", 8794 - "GetRockboxVersion", 8795 - ), 8796 - ); 7589 + req.extensions_mut().insert(GrpcMethod::new( 7590 + "rockbox.v1alpha1.SystemService", 7591 + "GetRockboxVersion", 7592 + )); 8797 7593 self.inner.unary(req, path, codec).await 8798 7594 } 8799 7595 pub async fn get_global_status( 8800 7596 &mut self, 8801 7597 request: impl tonic::IntoRequest<super::GetGlobalStatusRequest>, 8802 - ) -> std::result::Result< 8803 - tonic::Response<super::GetGlobalStatusResponse>, 8804 - tonic::Status, 8805 - > { 8806 - self.inner 8807 - .ready() 8808 - .await 8809 - .map_err(|e| { 8810 - tonic::Status::unknown( 8811 - format!("Service was not ready: {}", e.into()), 8812 - ) 8813 - })?; 7598 + ) -> std::result::Result<tonic::Response<super::GetGlobalStatusResponse>, tonic::Status> 7599 + { 7600 + self.inner.ready().await.map_err(|e| { 7601 + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 7602 + })?; 8814 7603 let codec = tonic::codec::ProstCodec::default(); 8815 7604 let path = http::uri::PathAndQuery::from_static( 8816 7605 "/rockbox.v1alpha1.SystemService/GetGlobalStatus", 8817 7606 ); 8818 7607 let mut req = request.into_request(); 8819 - req.extensions_mut() 8820 - .insert( 8821 - GrpcMethod::new("rockbox.v1alpha1.SystemService", "GetGlobalStatus"), 8822 - ); 7608 + req.extensions_mut().insert(GrpcMethod::new( 7609 + "rockbox.v1alpha1.SystemService", 7610 + "GetGlobalStatus", 7611 + )); 8823 7612 self.inner.unary(req, path, codec).await 8824 7613 } 8825 7614 } ··· 8831 7620 dead_code, 8832 7621 missing_docs, 8833 7622 clippy::wildcard_imports, 8834 - clippy::let_unit_value, 7623 + clippy::let_unit_value 8835 7624 )] 8836 7625 use tonic::codegen::*; 8837 7626 /// Generated trait containing gRPC methods that should be implemented for use with SystemServiceServer. ··· 8840 7629 async fn get_rockbox_version( 8841 7630 &self, 8842 7631 request: tonic::Request<super::GetRockboxVersionRequest>, 8843 - ) -> std::result::Result< 8844 - tonic::Response<super::GetRockboxVersionResponse>, 8845 - tonic::Status, 8846 - >; 7632 + ) -> std::result::Result<tonic::Response<super::GetRockboxVersionResponse>, tonic::Status>; 8847 7633 async fn get_global_status( 8848 7634 &self, 8849 7635 request: tonic::Request<super::GetGlobalStatusRequest>, 8850 - ) -> std::result::Result< 8851 - tonic::Response<super::GetGlobalStatusResponse>, 8852 - tonic::Status, 8853 - >; 7636 + ) -> std::result::Result<tonic::Response<super::GetGlobalStatusResponse>, tonic::Status>; 8854 7637 } 8855 7638 #[derive(Debug)] 8856 7639 pub struct SystemServiceServer<T> { ··· 8873 7656 max_encoding_message_size: None, 8874 7657 } 8875 7658 } 8876 - pub fn with_interceptor<F>( 8877 - inner: T, 8878 - interceptor: F, 8879 - ) -> InterceptedService<Self, F> 7659 + pub fn with_interceptor<F>(inner: T, interceptor: F) -> InterceptedService<Self, F> 8880 7660 where 8881 7661 F: tonic::service::Interceptor, 8882 7662 { ··· 8931 7711 "/rockbox.v1alpha1.SystemService/GetRockboxVersion" => { 8932 7712 #[allow(non_camel_case_types)] 8933 7713 struct GetRockboxVersionSvc<T: SystemService>(pub Arc<T>); 8934 - impl< 8935 - T: SystemService, 8936 - > tonic::server::UnaryService<super::GetRockboxVersionRequest> 8937 - for GetRockboxVersionSvc<T> { 7714 + impl<T: SystemService> 7715 + tonic::server::UnaryService<super::GetRockboxVersionRequest> 7716 + for GetRockboxVersionSvc<T> 7717 + { 8938 7718 type Response = super::GetRockboxVersionResponse; 8939 - type Future = BoxFuture< 8940 - tonic::Response<Self::Response>, 8941 - tonic::Status, 8942 - >; 7719 + type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 8943 7720 fn call( 8944 7721 &mut self, 8945 7722 request: tonic::Request<super::GetRockboxVersionRequest>, 8946 7723 ) -> Self::Future { 8947 7724 let inner = Arc::clone(&self.0); 8948 7725 let fut = async move { 8949 - <T as SystemService>::get_rockbox_version(&inner, request) 8950 - .await 7726 + <T as SystemService>::get_rockbox_version(&inner, request).await 8951 7727 }; 8952 7728 Box::pin(fut) 8953 7729 } ··· 8977 7753 "/rockbox.v1alpha1.SystemService/GetGlobalStatus" => { 8978 7754 #[allow(non_camel_case_types)] 8979 7755 struct GetGlobalStatusSvc<T: SystemService>(pub Arc<T>); 8980 - impl< 8981 - T: SystemService, 8982 - > tonic::server::UnaryService<super::GetGlobalStatusRequest> 8983 - for GetGlobalStatusSvc<T> { 7756 + impl<T: SystemService> 7757 + tonic::server::UnaryService<super::GetGlobalStatusRequest> 7758 + for GetGlobalStatusSvc<T> 7759 + { 8984 7760 type Response = super::GetGlobalStatusResponse; 8985 - type Future = BoxFuture< 8986 - tonic::Response<Self::Response>, 8987 - tonic::Status, 8988 - >; 7761 + type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 8989 7762 fn call( 8990 7763 &mut self, 8991 7764 request: tonic::Request<super::GetGlobalStatusRequest>, 8992 7765 ) -> Self::Future { 8993 7766 let inner = Arc::clone(&self.0); 8994 7767 let fut = async move { 8995 - <T as SystemService>::get_global_status(&inner, request) 8996 - .await 7768 + <T as SystemService>::get_global_status(&inner, request).await 8997 7769 }; 8998 7770 Box::pin(fut) 8999 7771 } ··· 9020 7792 }; 9021 7793 Box::pin(fut) 9022 7794 } 9023 - _ => { 9024 - Box::pin(async move { 9025 - let mut response = http::Response::new(empty_body()); 9026 - let headers = response.headers_mut(); 9027 - headers 9028 - .insert( 9029 - tonic::Status::GRPC_STATUS, 9030 - (tonic::Code::Unimplemented as i32).into(), 9031 - ); 9032 - headers 9033 - .insert( 9034 - http::header::CONTENT_TYPE, 9035 - tonic::metadata::GRPC_CONTENT_TYPE, 9036 - ); 9037 - Ok(response) 9038 - }) 9039 - } 7795 + _ => Box::pin(async move { 7796 + let mut response = http::Response::new(empty_body()); 7797 + let headers = response.headers_mut(); 7798 + headers.insert( 7799 + tonic::Status::GRPC_STATUS, 7800 + (tonic::Code::Unimplemented as i32).into(), 7801 + ); 7802 + headers.insert( 7803 + http::header::CONTENT_TYPE, 7804 + tonic::metadata::GRPC_CONTENT_TYPE, 7805 + ); 7806 + Ok(response) 7807 + }), 9040 7808 } 9041 7809 } 9042 7810 }