+2532 -1255

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

reviewed

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

+1 -1

dist/debian/amd64/DEBIAN/control

reviewed

··· 1 1 Package: rockbox 2 2 - Version: 2026.04.26 2 2 + Version: 2026.04.27 3 3 Section: user/multimedia 4 4 Priority: optional 5 5 Architecture: amd64

+1 -1

dist/debian/arm64/DEBIAN/control

reviewed

··· 1 1 Package: rockbox 2 2 - Version: 2026.04.26 2 2 + Version: 2026.04.27 3 3 Section: user/multimedia 4 4 Priority: optional 5 5 Architecture: arm64

+1 -1

dist/rpm/amd64/rockbox.spec

reviewed

··· 1 1 Name: rockbox 2 2 - Version: 2026.04.26 2 2 + Version: 2026.04.27 3 3 Release: 1%{?dist} 4 4 Summary: High quality audio player 5 5

+1 -1

dist/rpm/arm64/rockbox.spec

reviewed

··· 1 1 Name: rockbox 2 2 - Version: 2026.04.26 2 2 + Version: 2026.04.27 3 3 Release: 1%{?dist} 4 4 Summary: High quality audio player 5 5