+1240 -2506

cli/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::*; 49 48 use tonic::codegen::http::Uri; 49 49 + use tonic::codegen::*; 50 50 #[derive(Debug, Clone)] 51 51 pub struct BrowseServiceClient<T> { 52 52 inner: tonic::client::Grpc<T>, ··· 90 90 <T as tonic::client::GrpcService<tonic::body::BoxBody>>::ResponseBody, 91 91 >, 92 92 >, 93 93 - <T as tonic::codegen::Service< 94 94 - http::Request<tonic::body::BoxBody>, 95 95 - >>::Error: Into<StdError> + std::marker::Send + std::marker::Sync, 93 93 + <T as tonic::codegen::Service<http::Request<tonic::body::BoxBody>>>::Error: 94 94 + Into<StdError> + std::marker::Send + std::marker::Sync, 96 95 { 97 96 BrowseServiceClient::new(InterceptedService::new(inner, interceptor)) 98 97 } ··· 130 129 pub async fn tree_get_entries( 131 130 &mut self, 132 131 request: impl tonic::IntoRequest<super::TreeGetEntriesRequest>, 133 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 - })?; 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 + })?; 145 137 let codec = tonic::codec::ProstCodec::default(); 146 138 let path = http::uri::PathAndQuery::from_static( 147 139 "/rockbox.v1alpha1.BrowseService/TreeGetEntries", 148 140 ); 149 141 let mut req = request.into_request(); 150 150 - req.extensions_mut() 151 151 - .insert( 152 152 - GrpcMethod::new("rockbox.v1alpha1.BrowseService", "TreeGetEntries"), 153 153 - ); 142 142 + req.extensions_mut().insert(GrpcMethod::new( 143 143 + "rockbox.v1alpha1.BrowseService", 144 144 + "TreeGetEntries", 145 145 + )); 154 146 self.inner.unary(req, path, codec).await 155 147 } 156 148 } ··· 162 154 dead_code, 163 155 missing_docs, 164 156 clippy::wildcard_imports, 165 165 - clippy::let_unit_value, 157 157 + clippy::let_unit_value 166 158 )] 167 159 use tonic::codegen::*; 168 160 /// Generated trait containing gRPC methods that should be implemented for use with BrowseServiceServer. ··· 171 163 async fn tree_get_entries( 172 164 &self, 173 165 request: tonic::Request<super::TreeGetEntriesRequest>, 174 174 - ) -> std::result::Result< 175 175 - tonic::Response<super::TreeGetEntriesResponse>, 176 176 - tonic::Status, 177 177 - >; 166 166 + ) -> std::result::Result<tonic::Response<super::TreeGetEntriesResponse>, tonic::Status>; 178 167 } 179 168 #[derive(Debug)] 180 169 pub struct BrowseServiceServer<T> { ··· 197 186 max_encoding_message_size: None, 198 187 } 199 188 } 200 200 - pub fn with_interceptor<F>( 201 201 - inner: T, 202 202 - interceptor: F, 203 203 - ) -> InterceptedService<Self, F> 189 189 + pub fn with_interceptor<F>(inner: T, interceptor: F) -> InterceptedService<Self, F> 204 190 where 205 191 F: tonic::service::Interceptor, 206 192 { ··· 255 241 "/rockbox.v1alpha1.BrowseService/TreeGetEntries" => { 256 242 #[allow(non_camel_case_types)] 257 243 struct TreeGetEntriesSvc<T: BrowseService>(pub Arc<T>); 258 258 - impl< 259 259 - T: BrowseService, 260 260 - > tonic::server::UnaryService<super::TreeGetEntriesRequest> 261 261 - for TreeGetEntriesSvc<T> { 244 244 + impl<T: BrowseService> tonic::server::UnaryService<super::TreeGetEntriesRequest> 245 245 + for TreeGetEntriesSvc<T> 246 246 + { 262 247 type Response = super::TreeGetEntriesResponse; 263 263 - type Future = BoxFuture< 264 264 - tonic::Response<Self::Response>, 265 265 - tonic::Status, 266 266 - >; 248 248 + type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 267 249 fn call( 268 250 &mut self, 269 251 request: tonic::Request<super::TreeGetEntriesRequest>, 270 252 ) -> Self::Future { 271 253 let inner = Arc::clone(&self.0); 272 254 let fut = async move { 273 273 - <T as BrowseService>::tree_get_entries(&inner, request) 274 274 - .await 255 255 + <T as BrowseService>::tree_get_entries(&inner, request).await 275 256 }; 276 257 Box::pin(fut) 277 258 } ··· 298 279 }; 299 280 Box::pin(fut) 300 281 } 301 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 - } 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 + }), 318 295 } 319 296 } 320 297 } ··· 550 527 dead_code, 551 528 missing_docs, 552 529 clippy::wildcard_imports, 553 553 - clippy::let_unit_value, 530 530 + clippy::let_unit_value 554 531 )] 555 555 - use tonic::codegen::*; 556 532 use tonic::codegen::http::Uri; 533 533 + use tonic::codegen::*; 557 534 #[derive(Debug, Clone)] 558 535 pub struct LibraryServiceClient<T> { 559 536 inner: tonic::client::Grpc<T>, ··· 597 574 <T as tonic::client::GrpcService<tonic::body::BoxBody>>::ResponseBody, 598 575 >, 599 576 >, 600 600 - <T as tonic::codegen::Service< 601 601 - http::Request<tonic::body::BoxBody>, 602 602 - >>::Error: Into<StdError> + std::marker::Send + std::marker::Sync, 577 577 + <T as tonic::codegen::Service<http::Request<tonic::body::BoxBody>>>::Error: 578 578 + Into<StdError> + std::marker::Send + std::marker::Sync, 603 579 { 604 580 LibraryServiceClient::new(InterceptedService::new(inner, interceptor)) 605 581 } ··· 637 613 pub async fn get_albums( 638 614 &mut self, 639 615 request: impl tonic::IntoRequest<super::GetAlbumsRequest>, 640 640 - ) -> std::result::Result< 641 641 - tonic::Response<super::GetAlbumsResponse>, 642 642 - tonic::Status, 643 643 - > { 644 644 - self.inner 645 645 - .ready() 646 646 - .await 647 647 - .map_err(|e| { 648 648 - tonic::Status::unknown( 649 649 - format!("Service was not ready: {}", e.into()), 650 650 - ) 651 651 - })?; 616 616 + ) -> std::result::Result<tonic::Response<super::GetAlbumsResponse>, tonic::Status> { 617 617 + self.inner.ready().await.map_err(|e| { 618 618 + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 619 619 + })?; 652 620 let codec = tonic::codec::ProstCodec::default(); 653 653 - let path = http::uri::PathAndQuery::from_static( 654 654 - "/rockbox.v1alpha1.LibraryService/GetAlbums", 655 655 - ); 621 621 + let path = 622 622 + http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.LibraryService/GetAlbums"); 656 623 let mut req = request.into_request(); 657 657 - req.extensions_mut() 658 658 - .insert(GrpcMethod::new("rockbox.v1alpha1.LibraryService", "GetAlbums")); 624 624 + req.extensions_mut().insert(GrpcMethod::new( 625 625 + "rockbox.v1alpha1.LibraryService", 626 626 + "GetAlbums", 627 627 + )); 659 628 self.inner.unary(req, path, codec).await 660 629 } 661 630 pub async fn get_artists( 662 631 &mut self, 663 632 request: impl tonic::IntoRequest<super::GetArtistsRequest>, 664 664 - ) -> std::result::Result< 665 665 - tonic::Response<super::GetArtistsResponse>, 666 666 - tonic::Status, 667 667 - > { 668 668 - self.inner 669 669 - .ready() 670 670 - .await 671 671 - .map_err(|e| { 672 672 - tonic::Status::unknown( 673 673 - format!("Service was not ready: {}", e.into()), 674 674 - ) 675 675 - })?; 633 633 + ) -> std::result::Result<tonic::Response<super::GetArtistsResponse>, tonic::Status> 634 634 + { 635 635 + self.inner.ready().await.map_err(|e| { 636 636 + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 637 637 + })?; 676 638 let codec = tonic::codec::ProstCodec::default(); 677 677 - let path = http::uri::PathAndQuery::from_static( 678 678 - "/rockbox.v1alpha1.LibraryService/GetArtists", 679 679 - ); 639 639 + let path = 640 640 + http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.LibraryService/GetArtists"); 680 641 let mut req = request.into_request(); 681 681 - req.extensions_mut() 682 682 - .insert( 683 683 - GrpcMethod::new("rockbox.v1alpha1.LibraryService", "GetArtists"), 684 684 - ); 642 642 + req.extensions_mut().insert(GrpcMethod::new( 643 643 + "rockbox.v1alpha1.LibraryService", 644 644 + "GetArtists", 645 645 + )); 685 646 self.inner.unary(req, path, codec).await 686 647 } 687 648 pub async fn get_tracks( 688 649 &mut self, 689 650 request: impl tonic::IntoRequest<super::GetTracksRequest>, 690 690 - ) -> std::result::Result< 691 691 - tonic::Response<super::GetTracksResponse>, 692 692 - tonic::Status, 693 693 - > { 694 694 - self.inner 695 695 - .ready() 696 696 - .await 697 697 - .map_err(|e| { 698 698 - tonic::Status::unknown( 699 699 - format!("Service was not ready: {}", e.into()), 700 700 - ) 701 701 - })?; 651 651 + ) -> std::result::Result<tonic::Response<super::GetTracksResponse>, tonic::Status> { 652 652 + self.inner.ready().await.map_err(|e| { 653 653 + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 654 654 + })?; 702 655 let codec = tonic::codec::ProstCodec::default(); 703 703 - let path = http::uri::PathAndQuery::from_static( 704 704 - "/rockbox.v1alpha1.LibraryService/GetTracks", 705 705 - ); 656 656 + let path = 657 657 + http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.LibraryService/GetTracks"); 706 658 let mut req = request.into_request(); 707 707 - req.extensions_mut() 708 708 - .insert(GrpcMethod::new("rockbox.v1alpha1.LibraryService", "GetTracks")); 659 659 + req.extensions_mut().insert(GrpcMethod::new( 660 660 + "rockbox.v1alpha1.LibraryService", 661 661 + "GetTracks", 662 662 + )); 709 663 self.inner.unary(req, path, codec).await 710 664 } 711 665 pub async fn get_album( 712 666 &mut self, 713 667 request: impl tonic::IntoRequest<super::GetAlbumRequest>, 714 714 - ) -> std::result::Result< 715 715 - tonic::Response<super::GetAlbumResponse>, 716 716 - tonic::Status, 717 717 - > { 718 718 - self.inner 719 719 - .ready() 720 720 - .await 721 721 - .map_err(|e| { 722 722 - tonic::Status::unknown( 723 723 - format!("Service was not ready: {}", e.into()), 724 724 - ) 725 725 - })?; 668 668 + ) -> std::result::Result<tonic::Response<super::GetAlbumResponse>, tonic::Status> { 669 669 + self.inner.ready().await.map_err(|e| { 670 670 + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 671 671 + })?; 726 672 let codec = tonic::codec::ProstCodec::default(); 727 727 - let path = http::uri::PathAndQuery::from_static( 728 728 - "/rockbox.v1alpha1.LibraryService/GetAlbum", 729 729 - ); 673 673 + let path = 674 674 + http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.LibraryService/GetAlbum"); 730 675 let mut req = request.into_request(); 731 731 - req.extensions_mut() 732 732 - .insert(GrpcMethod::new("rockbox.v1alpha1.LibraryService", "GetAlbum")); 676 676 + req.extensions_mut().insert(GrpcMethod::new( 677 677 + "rockbox.v1alpha1.LibraryService", 678 678 + "GetAlbum", 679 679 + )); 733 680 self.inner.unary(req, path, codec).await 734 681 } 735 682 pub async fn get_artist( 736 683 &mut self, 737 684 request: impl tonic::IntoRequest<super::GetArtistRequest>, 738 738 - ) -> std::result::Result< 739 739 - tonic::Response<super::GetArtistResponse>, 740 740 - tonic::Status, 741 741 - > { 742 742 - self.inner 743 743 - .ready() 744 744 - .await 745 745 - .map_err(|e| { 746 746 - tonic::Status::unknown( 747 747 - format!("Service was not ready: {}", e.into()), 748 748 - ) 749 749 - })?; 685 685 + ) -> std::result::Result<tonic::Response<super::GetArtistResponse>, tonic::Status> { 686 686 + self.inner.ready().await.map_err(|e| { 687 687 + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 688 688 + })?; 750 689 let codec = tonic::codec::ProstCodec::default(); 751 751 - let path = http::uri::PathAndQuery::from_static( 752 752 - "/rockbox.v1alpha1.LibraryService/GetArtist", 753 753 - ); 690 690 + let path = 691 691 + http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.LibraryService/GetArtist"); 754 692 let mut req = request.into_request(); 755 755 - req.extensions_mut() 756 756 - .insert(GrpcMethod::new("rockbox.v1alpha1.LibraryService", "GetArtist")); 693 693 + req.extensions_mut().insert(GrpcMethod::new( 694 694 + "rockbox.v1alpha1.LibraryService", 695 695 + "GetArtist", 696 696 + )); 757 697 self.inner.unary(req, path, codec).await 758 698 } 759 699 pub async fn get_track( 760 700 &mut self, 761 701 request: impl tonic::IntoRequest<super::GetTrackRequest>, 762 762 - ) -> std::result::Result< 763 763 - tonic::Response<super::GetTrackResponse>, 764 764 - tonic::Status, 765 765 - > { 766 766 - self.inner 767 767 - .ready() 768 768 - .await 769 769 - .map_err(|e| { 770 770 - tonic::Status::unknown( 771 771 - format!("Service was not ready: {}", e.into()), 772 772 - ) 773 773 - })?; 702 702 + ) -> std::result::Result<tonic::Response<super::GetTrackResponse>, tonic::Status> { 703 703 + self.inner.ready().await.map_err(|e| { 704 704 + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 705 705 + })?; 774 706 let codec = tonic::codec::ProstCodec::default(); 775 775 - let path = http::uri::PathAndQuery::from_static( 776 776 - "/rockbox.v1alpha1.LibraryService/GetTrack", 777 777 - ); 707 707 + let path = 708 708 + http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.LibraryService/GetTrack"); 778 709 let mut req = request.into_request(); 779 779 - req.extensions_mut() 780 780 - .insert(GrpcMethod::new("rockbox.v1alpha1.LibraryService", "GetTrack")); 710 710 + req.extensions_mut().insert(GrpcMethod::new( 711 711 + "rockbox.v1alpha1.LibraryService", 712 712 + "GetTrack", 713 713 + )); 781 714 self.inner.unary(req, path, codec).await 782 715 } 783 716 pub async fn like_track( 784 717 &mut self, 785 718 request: impl tonic::IntoRequest<super::LikeTrackRequest>, 786 786 - ) -> std::result::Result< 787 787 - tonic::Response<super::LikeTrackResponse>, 788 788 - tonic::Status, 789 789 - > { 790 790 - self.inner 791 791 - .ready() 792 792 - .await 793 793 - .map_err(|e| { 794 794 - tonic::Status::unknown( 795 795 - format!("Service was not ready: {}", e.into()), 796 796 - ) 797 797 - })?; 719 719 + ) -> std::result::Result<tonic::Response<super::LikeTrackResponse>, tonic::Status> { 720 720 + self.inner.ready().await.map_err(|e| { 721 721 + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 722 722 + })?; 798 723 let codec = tonic::codec::ProstCodec::default(); 799 799 - let path = http::uri::PathAndQuery::from_static( 800 800 - "/rockbox.v1alpha1.LibraryService/LikeTrack", 801 801 - ); 724 724 + let path = 725 725 + http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.LibraryService/LikeTrack"); 802 726 let mut req = request.into_request(); 803 803 - req.extensions_mut() 804 804 - .insert(GrpcMethod::new("rockbox.v1alpha1.LibraryService", "LikeTrack")); 727 727 + req.extensions_mut().insert(GrpcMethod::new( 728 728 + "rockbox.v1alpha1.LibraryService", 729 729 + "LikeTrack", 730 730 + )); 805 731 self.inner.unary(req, path, codec).await 806 732 } 807 733 pub async fn unlike_track( 808 734 &mut self, 809 735 request: impl tonic::IntoRequest<super::UnlikeTrackRequest>, 810 810 - ) -> std::result::Result< 811 811 - tonic::Response<super::UnlikeTrackResponse>, 812 812 - tonic::Status, 813 813 - > { 814 814 - self.inner 815 815 - .ready() 816 816 - .await 817 817 - .map_err(|e| { 818 818 - tonic::Status::unknown( 819 819 - format!("Service was not ready: {}", e.into()), 820 820 - ) 821 821 - })?; 736 736 + ) -> std::result::Result<tonic::Response<super::UnlikeTrackResponse>, tonic::Status> 737 737 + { 738 738 + self.inner.ready().await.map_err(|e| { 739 739 + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 740 740 + })?; 822 741 let codec = tonic::codec::ProstCodec::default(); 823 742 let path = http::uri::PathAndQuery::from_static( 824 743 "/rockbox.v1alpha1.LibraryService/UnlikeTrack", 825 744 ); 826 745 let mut req = request.into_request(); 827 827 - req.extensions_mut() 828 828 - .insert( 829 829 - GrpcMethod::new("rockbox.v1alpha1.LibraryService", "UnlikeTrack"), 830 830 - ); 746 746 + req.extensions_mut().insert(GrpcMethod::new( 747 747 + "rockbox.v1alpha1.LibraryService", 748 748 + "UnlikeTrack", 749 749 + )); 831 750 self.inner.unary(req, path, codec).await 832 751 } 833 752 pub async fn like_album( 834 753 &mut self, 835 754 request: impl tonic::IntoRequest<super::LikeAlbumRequest>, 836 836 - ) -> std::result::Result< 837 837 - tonic::Response<super::LikeAlbumResponse>, 838 838 - tonic::Status, 839 839 - > { 840 840 - self.inner 841 841 - .ready() 842 842 - .await 843 843 - .map_err(|e| { 844 844 - tonic::Status::unknown( 845 845 - format!("Service was not ready: {}", e.into()), 846 846 - ) 847 847 - })?; 755 755 + ) -> std::result::Result<tonic::Response<super::LikeAlbumResponse>, tonic::Status> { 756 756 + self.inner.ready().await.map_err(|e| { 757 757 + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 758 758 + })?; 848 759 let codec = tonic::codec::ProstCodec::default(); 849 849 - let path = http::uri::PathAndQuery::from_static( 850 850 - "/rockbox.v1alpha1.LibraryService/LikeAlbum", 851 851 - ); 760 760 + let path = 761 761 + http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.LibraryService/LikeAlbum"); 852 762 let mut req = request.into_request(); 853 853 - req.extensions_mut() 854 854 - .insert(GrpcMethod::new("rockbox.v1alpha1.LibraryService", "LikeAlbum")); 763 763 + req.extensions_mut().insert(GrpcMethod::new( 764 764 + "rockbox.v1alpha1.LibraryService", 765 765 + "LikeAlbum", 766 766 + )); 855 767 self.inner.unary(req, path, codec).await 856 768 } 857 769 pub async fn unlike_album( 858 770 &mut self, 859 771 request: impl tonic::IntoRequest<super::UnlikeAlbumRequest>, 860 860 - ) -> std::result::Result< 861 861 - tonic::Response<super::UnlikeAlbumResponse>, 862 862 - tonic::Status, 863 863 - > { 864 864 - self.inner 865 865 - .ready() 866 866 - .await 867 867 - .map_err(|e| { 868 868 - tonic::Status::unknown( 869 869 - format!("Service was not ready: {}", e.into()), 870 870 - ) 871 871 - })?; 772 772 + ) -> std::result::Result<tonic::Response<super::UnlikeAlbumResponse>, tonic::Status> 773 773 + { 774 774 + self.inner.ready().await.map_err(|e| { 775 775 + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 776 776 + })?; 872 777 let codec = tonic::codec::ProstCodec::default(); 873 778 let path = http::uri::PathAndQuery::from_static( 874 779 "/rockbox.v1alpha1.LibraryService/UnlikeAlbum", 875 780 ); 876 781 let mut req = request.into_request(); 877 877 - req.extensions_mut() 878 878 - .insert( 879 879 - GrpcMethod::new("rockbox.v1alpha1.LibraryService", "UnlikeAlbum"), 880 880 - ); 782 782 + req.extensions_mut().insert(GrpcMethod::new( 783 783 + "rockbox.v1alpha1.LibraryService", 784 784 + "UnlikeAlbum", 785 785 + )); 881 786 self.inner.unary(req, path, codec).await 882 787 } 883 788 pub async fn get_liked_tracks( 884 789 &mut self, 885 790 request: impl tonic::IntoRequest<super::GetLikedTracksRequest>, 886 886 - ) -> std::result::Result< 887 887 - tonic::Response<super::GetLikedTracksResponse>, 888 888 - tonic::Status, 889 889 - > { 890 890 - self.inner 891 891 - .ready() 892 892 - .await 893 893 - .map_err(|e| { 894 894 - tonic::Status::unknown( 895 895 - format!("Service was not ready: {}", e.into()), 896 896 - ) 897 897 - })?; 791 791 + ) -> std::result::Result<tonic::Response<super::GetLikedTracksResponse>, tonic::Status> 792 792 + { 793 793 + self.inner.ready().await.map_err(|e| { 794 794 + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 795 795 + })?; 898 796 let codec = tonic::codec::ProstCodec::default(); 899 797 let path = http::uri::PathAndQuery::from_static( 900 798 "/rockbox.v1alpha1.LibraryService/GetLikedTracks", 901 799 ); 902 800 let mut req = request.into_request(); 903 903 - req.extensions_mut() 904 904 - .insert( 905 905 - GrpcMethod::new("rockbox.v1alpha1.LibraryService", "GetLikedTracks"), 906 906 - ); 801 801 + req.extensions_mut().insert(GrpcMethod::new( 802 802 + "rockbox.v1alpha1.LibraryService", 803 803 + "GetLikedTracks", 804 804 + )); 907 805 self.inner.unary(req, path, codec).await 908 806 } 909 807 pub async fn get_liked_albums( 910 808 &mut self, 911 809 request: impl tonic::IntoRequest<super::GetLikedAlbumsRequest>, 912 912 - ) -> std::result::Result< 913 913 - tonic::Response<super::GetLikedAlbumsResponse>, 914 914 - tonic::Status, 915 915 - > { 916 916 - self.inner 917 917 - .ready() 918 918 - .await 919 919 - .map_err(|e| { 920 920 - tonic::Status::unknown( 921 921 - format!("Service was not ready: {}", e.into()), 922 922 - ) 923 923 - })?; 810 810 + ) -> std::result::Result<tonic::Response<super::GetLikedAlbumsResponse>, tonic::Status> 811 811 + { 812 812 + self.inner.ready().await.map_err(|e| { 813 813 + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 814 814 + })?; 924 815 let codec = tonic::codec::ProstCodec::default(); 925 816 let path = http::uri::PathAndQuery::from_static( 926 817 "/rockbox.v1alpha1.LibraryService/GetLikedAlbums", 927 818 ); 928 819 let mut req = request.into_request(); 929 929 - req.extensions_mut() 930 930 - .insert( 931 931 - GrpcMethod::new("rockbox.v1alpha1.LibraryService", "GetLikedAlbums"), 932 932 - ); 820 820 + req.extensions_mut().insert(GrpcMethod::new( 821 821 + "rockbox.v1alpha1.LibraryService", 822 822 + "GetLikedAlbums", 823 823 + )); 933 824 self.inner.unary(req, path, codec).await 934 825 } 935 826 pub async fn scan_library( 936 827 &mut self, 937 828 request: impl tonic::IntoRequest<super::ScanLibraryRequest>, 938 938 - ) -> std::result::Result< 939 939 - tonic::Response<super::ScanLibraryResponse>, 940 940 - tonic::Status, 941 941 - > { 942 942 - self.inner 943 943 - .ready() 944 944 - .await 945 945 - .map_err(|e| { 946 946 - tonic::Status::unknown( 947 947 - format!("Service was not ready: {}", e.into()), 948 948 - ) 949 949 - })?; 829 829 + ) -> std::result::Result<tonic::Response<super::ScanLibraryResponse>, tonic::Status> 830 830 + { 831 831 + self.inner.ready().await.map_err(|e| { 832 832 + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 833 833 + })?; 950 834 let codec = tonic::codec::ProstCodec::default(); 951 835 let path = http::uri::PathAndQuery::from_static( 952 836 "/rockbox.v1alpha1.LibraryService/ScanLibrary", 953 837 ); 954 838 let mut req = request.into_request(); 955 955 - req.extensions_mut() 956 956 - .insert( 957 957 - GrpcMethod::new("rockbox.v1alpha1.LibraryService", "ScanLibrary"), 958 958 - ); 839 839 + req.extensions_mut().insert(GrpcMethod::new( 840 840 + "rockbox.v1alpha1.LibraryService", 841 841 + "ScanLibrary", 842 842 + )); 959 843 self.inner.unary(req, path, codec).await 960 844 } 961 845 pub async fn search( 962 846 &mut self, 963 847 request: impl tonic::IntoRequest<super::SearchRequest>, 964 848 ) -> std::result::Result<tonic::Response<super::SearchResponse>, tonic::Status> { 965 965 - self.inner 966 966 - .ready() 967 967 - .await 968 968 - .map_err(|e| { 969 969 - tonic::Status::unknown( 970 970 - format!("Service was not ready: {}", e.into()), 971 971 - ) 972 972 - })?; 849 849 + self.inner.ready().await.map_err(|e| { 850 850 + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 851 851 + })?; 973 852 let codec = tonic::codec::ProstCodec::default(); 974 974 - let path = http::uri::PathAndQuery::from_static( 975 975 - "/rockbox.v1alpha1.LibraryService/Search", 976 976 - ); 853 853 + let path = 854 854 + http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.LibraryService/Search"); 977 855 let mut req = request.into_request(); 978 856 req.extensions_mut() 979 857 .insert(GrpcMethod::new("rockbox.v1alpha1.LibraryService", "Search")); ··· 988 866 dead_code, 989 867 missing_docs, 990 868 clippy::wildcard_imports, 991 991 - clippy::let_unit_value, 869 869 + clippy::let_unit_value 992 870 )] 993 871 use tonic::codegen::*; 994 872 /// Generated trait containing gRPC methods that should be implemented for use with LibraryServiceServer. ··· 997 875 async fn get_albums( 998 876 &self, 999 877 request: tonic::Request<super::GetAlbumsRequest>, 1000 1000 - ) -> std::result::Result< 1001 1001 - tonic::Response<super::GetAlbumsResponse>, 1002 1002 - tonic::Status, 1003 1003 - >; 878 878 + ) -> std::result::Result<tonic::Response<super::GetAlbumsResponse>, tonic::Status>; 1004 879 async fn get_artists( 1005 880 &self, 1006 881 request: tonic::Request<super::GetArtistsRequest>, 1007 1007 - ) -> std::result::Result< 1008 1008 - tonic::Response<super::GetArtistsResponse>, 1009 1009 - tonic::Status, 1010 1010 - >; 882 882 + ) -> std::result::Result<tonic::Response<super::GetArtistsResponse>, tonic::Status>; 1011 883 async fn get_tracks( 1012 884 &self, 1013 885 request: tonic::Request<super::GetTracksRequest>, 1014 1014 - ) -> std::result::Result< 1015 1015 - tonic::Response<super::GetTracksResponse>, 1016 1016 - tonic::Status, 1017 1017 - >; 886 886 + ) -> std::result::Result<tonic::Response<super::GetTracksResponse>, tonic::Status>; 1018 887 async fn get_album( 1019 888 &self, 1020 889 request: tonic::Request<super::GetAlbumRequest>, 1021 1021 - ) -> std::result::Result< 1022 1022 - tonic::Response<super::GetAlbumResponse>, 1023 1023 - tonic::Status, 1024 1024 - >; 890 890 + ) -> std::result::Result<tonic::Response<super::GetAlbumResponse>, tonic::Status>; 1025 891 async fn get_artist( 1026 892 &self, 1027 893 request: tonic::Request<super::GetArtistRequest>, 1028 1028 - ) -> std::result::Result< 1029 1029 - tonic::Response<super::GetArtistResponse>, 1030 1030 - tonic::Status, 1031 1031 - >; 894 894 + ) -> std::result::Result<tonic::Response<super::GetArtistResponse>, tonic::Status>; 1032 895 async fn get_track( 1033 896 &self, 1034 897 request: tonic::Request<super::GetTrackRequest>, 1035 1035 - ) -> std::result::Result< 1036 1036 - tonic::Response<super::GetTrackResponse>, 1037 1037 - tonic::Status, 1038 1038 - >; 898 898 + ) -> std::result::Result<tonic::Response<super::GetTrackResponse>, tonic::Status>; 1039 899 async fn like_track( 1040 900 &self, 1041 901 request: tonic::Request<super::LikeTrackRequest>, 1042 1042 - ) -> std::result::Result< 1043 1043 - tonic::Response<super::LikeTrackResponse>, 1044 1044 - tonic::Status, 1045 1045 - >; 902 902 + ) -> std::result::Result<tonic::Response<super::LikeTrackResponse>, tonic::Status>; 1046 903 async fn unlike_track( 1047 904 &self, 1048 905 request: tonic::Request<super::UnlikeTrackRequest>, 1049 1049 - ) -> std::result::Result< 1050 1050 - tonic::Response<super::UnlikeTrackResponse>, 1051 1051 - tonic::Status, 1052 1052 - >; 906 906 + ) -> std::result::Result<tonic::Response<super::UnlikeTrackResponse>, tonic::Status>; 1053 907 async fn like_album( 1054 908 &self, 1055 909 request: tonic::Request<super::LikeAlbumRequest>, 1056 1056 - ) -> std::result::Result< 1057 1057 - tonic::Response<super::LikeAlbumResponse>, 1058 1058 - tonic::Status, 1059 1059 - >; 910 910 + ) -> std::result::Result<tonic::Response<super::LikeAlbumResponse>, tonic::Status>; 1060 911 async fn unlike_album( 1061 912 &self, 1062 913 request: tonic::Request<super::UnlikeAlbumRequest>, 1063 1063 - ) -> std::result::Result< 1064 1064 - tonic::Response<super::UnlikeAlbumResponse>, 1065 1065 - tonic::Status, 1066 1066 - >; 914 914 + ) -> std::result::Result<tonic::Response<super::UnlikeAlbumResponse>, tonic::Status>; 1067 915 async fn get_liked_tracks( 1068 916 &self, 1069 917 request: tonic::Request<super::GetLikedTracksRequest>, 1070 1070 - ) -> std::result::Result< 1071 1071 - tonic::Response<super::GetLikedTracksResponse>, 1072 1072 - tonic::Status, 1073 1073 - >; 918 918 + ) -> std::result::Result<tonic::Response<super::GetLikedTracksResponse>, tonic::Status>; 1074 919 async fn get_liked_albums( 1075 920 &self, 1076 921 request: tonic::Request<super::GetLikedAlbumsRequest>, 1077 1077 - ) -> std::result::Result< 1078 1078 - tonic::Response<super::GetLikedAlbumsResponse>, 1079 1079 - tonic::Status, 1080 1080 - >; 922 922 + ) -> std::result::Result<tonic::Response<super::GetLikedAlbumsResponse>, tonic::Status>; 1081 923 async fn scan_library( 1082 924 &self, 1083 925 request: tonic::Request<super::ScanLibraryRequest>, 1084 1084 - ) -> std::result::Result< 1085 1085 - tonic::Response<super::ScanLibraryResponse>, 1086 1086 - tonic::Status, 1087 1087 - >; 926 926 + ) -> std::result::Result<tonic::Response<super::ScanLibraryResponse>, tonic::Status>; 1088 927 async fn search( 1089 928 &self, 1090 929 request: tonic::Request<super::SearchRequest>, ··· 1111 950 max_encoding_message_size: None, 1112 951 } 1113 952 } 1114 1114 - pub fn with_interceptor<F>( 1115 1115 - inner: T, 1116 1116 - interceptor: F, 1117 1117 - ) -> InterceptedService<Self, F> 953 953 + pub fn with_interceptor<F>(inner: T, interceptor: F) -> InterceptedService<Self, F> 1118 954 where 1119 955 F: tonic::service::Interceptor, 1120 956 { ··· 1169 1005 "/rockbox.v1alpha1.LibraryService/GetAlbums" => { 1170 1006 #[allow(non_camel_case_types)] 1171 1007 struct GetAlbumsSvc<T: LibraryService>(pub Arc<T>); 1172 1172 - impl< 1173 1173 - T: LibraryService, 1174 1174 - > tonic::server::UnaryService<super::GetAlbumsRequest> 1175 1175 - for GetAlbumsSvc<T> { 1008 1008 + impl<T: LibraryService> tonic::server::UnaryService<super::GetAlbumsRequest> for GetAlbumsSvc<T> { 1176 1009 type Response = super::GetAlbumsResponse; 1177 1177 - type Future = BoxFuture< 1178 1178 - tonic::Response<Self::Response>, 1179 1179 - tonic::Status, 1180 1180 - >; 1010 1010 + type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 1181 1011 fn call( 1182 1012 &mut self, 1183 1013 request: tonic::Request<super::GetAlbumsRequest>, ··· 1214 1044 "/rockbox.v1alpha1.LibraryService/GetArtists" => { 1215 1045 #[allow(non_camel_case_types)] 1216 1046 struct GetArtistsSvc<T: LibraryService>(pub Arc<T>); 1217 1217 - impl< 1218 1218 - T: LibraryService, 1219 1219 - > tonic::server::UnaryService<super::GetArtistsRequest> 1220 1220 - for GetArtistsSvc<T> { 1047 1047 + impl<T: LibraryService> tonic::server::UnaryService<super::GetArtistsRequest> for GetArtistsSvc<T> { 1221 1048 type Response = super::GetArtistsResponse; 1222 1222 - type Future = BoxFuture< 1223 1223 - tonic::Response<Self::Response>, 1224 1224 - tonic::Status, 1225 1225 - >; 1049 1049 + type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 1226 1050 fn call( 1227 1051 &mut self, 1228 1052 request: tonic::Request<super::GetArtistsRequest>, ··· 1259 1083 "/rockbox.v1alpha1.LibraryService/GetTracks" => { 1260 1084 #[allow(non_camel_case_types)] 1261 1085 struct GetTracksSvc<T: LibraryService>(pub Arc<T>); 1262 1262 - impl< 1263 1263 - T: LibraryService, 1264 1264 - > tonic::server::UnaryService<super::GetTracksRequest> 1265 1265 - for GetTracksSvc<T> { 1086 1086 + impl<T: LibraryService> tonic::server::UnaryService<super::GetTracksRequest> for GetTracksSvc<T> { 1266 1087 type Response = super::GetTracksResponse; 1267 1267 - type Future = BoxFuture< 1268 1268 - tonic::Response<Self::Response>, 1269 1269 - tonic::Status, 1270 1270 - >; 1088 1088 + type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 1271 1089 fn call( 1272 1090 &mut self, 1273 1091 request: tonic::Request<super::GetTracksRequest>, ··· 1304 1122 "/rockbox.v1alpha1.LibraryService/GetAlbum" => { 1305 1123 #[allow(non_camel_case_types)] 1306 1124 struct GetAlbumSvc<T: LibraryService>(pub Arc<T>); 1307 1307 - impl< 1308 1308 - T: LibraryService, 1309 1309 - > tonic::server::UnaryService<super::GetAlbumRequest> 1310 1310 - for GetAlbumSvc<T> { 1125 1125 + impl<T: LibraryService> tonic::server::UnaryService<super::GetAlbumRequest> for GetAlbumSvc<T> { 1311 1126 type Response = super::GetAlbumResponse; 1312 1312 - type Future = BoxFuture< 1313 1313 - tonic::Response<Self::Response>, 1314 1314 - tonic::Status, 1315 1315 - >; 1127 1127 + type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 1316 1128 fn call( 1317 1129 &mut self, 1318 1130 request: tonic::Request<super::GetAlbumRequest>, ··· 1349 1161 "/rockbox.v1alpha1.LibraryService/GetArtist" => { 1350 1162 #[allow(non_camel_case_types)] 1351 1163 struct GetArtistSvc<T: LibraryService>(pub Arc<T>); 1352 1352 - impl< 1353 1353 - T: LibraryService, 1354 1354 - > tonic::server::UnaryService<super::GetArtistRequest> 1355 1355 - for GetArtistSvc<T> { 1164 1164 + impl<T: LibraryService> tonic::server::UnaryService<super::GetArtistRequest> for GetArtistSvc<T> { 1356 1165 type Response = super::GetArtistResponse; 1357 1357 - type Future = BoxFuture< 1358 1358 - tonic::Response<Self::Response>, 1359 1359 - tonic::Status, 1360 1360 - >; 1166 1166 + type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 1361 1167 fn call( 1362 1168 &mut self, 1363 1169 request: tonic::Request<super::GetArtistRequest>, ··· 1394 1200 "/rockbox.v1alpha1.LibraryService/GetTrack" => { 1395 1201 #[allow(non_camel_case_types)] 1396 1202 struct GetTrackSvc<T: LibraryService>(pub Arc<T>); 1397 1397 - impl< 1398 1398 - T: LibraryService, 1399 1399 - > tonic::server::UnaryService<super::GetTrackRequest> 1400 1400 - for GetTrackSvc<T> { 1203 1203 + impl<T: LibraryService> tonic::server::UnaryService<super::GetTrackRequest> for GetTrackSvc<T> { 1401 1204 type Response = super::GetTrackResponse; 1402 1402 - type Future = BoxFuture< 1403 1403 - tonic::Response<Self::Response>, 1404 1404 - tonic::Status, 1405 1405 - >; 1205 1205 + type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 1406 1206 fn call( 1407 1207 &mut self, 1408 1208 request: tonic::Request<super::GetTrackRequest>, ··· 1439 1239 "/rockbox.v1alpha1.LibraryService/LikeTrack" => { 1440 1240 #[allow(non_camel_case_types)] 1441 1241 struct LikeTrackSvc<T: LibraryService>(pub Arc<T>); 1442 1442 - impl< 1443 1443 - T: LibraryService, 1444 1444 - > tonic::server::UnaryService<super::LikeTrackRequest> 1445 1445 - for LikeTrackSvc<T> { 1242 1242 + impl<T: LibraryService> tonic::server::UnaryService<super::LikeTrackRequest> for LikeTrackSvc<T> { 1446 1243 type Response = super::LikeTrackResponse; 1447 1447 - type Future = BoxFuture< 1448 1448 - tonic::Response<Self::Response>, 1449 1449 - tonic::Status, 1450 1450 - >; 1244 1244 + type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 1451 1245 fn call( 1452 1246 &mut self, 1453 1247 request: tonic::Request<super::LikeTrackRequest>, ··· 1484 1278 "/rockbox.v1alpha1.LibraryService/UnlikeTrack" => { 1485 1279 #[allow(non_camel_case_types)] 1486 1280 struct UnlikeTrackSvc<T: LibraryService>(pub Arc<T>); 1487 1487 - impl< 1488 1488 - T: LibraryService, 1489 1489 - > tonic::server::UnaryService<super::UnlikeTrackRequest> 1490 1490 - for UnlikeTrackSvc<T> { 1281 1281 + impl<T: LibraryService> tonic::server::UnaryService<super::UnlikeTrackRequest> 1282 1282 + for UnlikeTrackSvc<T> 1283 1283 + { 1491 1284 type Response = super::UnlikeTrackResponse; 1492 1492 - type Future = BoxFuture< 1493 1493 - tonic::Response<Self::Response>, 1494 1494 - tonic::Status, 1495 1495 - >; 1285 1285 + type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 1496 1286 fn call( 1497 1287 &mut self, 1498 1288 request: tonic::Request<super::UnlikeTrackRequest>, ··· 1529 1319 "/rockbox.v1alpha1.LibraryService/LikeAlbum" => { 1530 1320 #[allow(non_camel_case_types)] 1531 1321 struct LikeAlbumSvc<T: LibraryService>(pub Arc<T>); 1532 1532 - impl< 1533 1533 - T: LibraryService, 1534 1534 - > tonic::server::UnaryService<super::LikeAlbumRequest> 1535 1535 - for LikeAlbumSvc<T> { 1322 1322 + impl<T: LibraryService> tonic::server::UnaryService<super::LikeAlbumRequest> for LikeAlbumSvc<T> { 1536 1323 type Response = super::LikeAlbumResponse; 1537 1537 - type Future = BoxFuture< 1538 1538 - tonic::Response<Self::Response>, 1539 1539 - tonic::Status, 1540 1540 - >; 1324 1324 + type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 1541 1325 fn call( 1542 1326 &mut self, 1543 1327 request: tonic::Request<super::LikeAlbumRequest>, ··· 1574 1358 "/rockbox.v1alpha1.LibraryService/UnlikeAlbum" => { 1575 1359 #[allow(non_camel_case_types)] 1576 1360 struct UnlikeAlbumSvc<T: LibraryService>(pub Arc<T>); 1577 1577 - impl< 1578 1578 - T: LibraryService, 1579 1579 - > tonic::server::UnaryService<super::UnlikeAlbumRequest> 1580 1580 - for UnlikeAlbumSvc<T> { 1361 1361 + impl<T: LibraryService> tonic::server::UnaryService<super::UnlikeAlbumRequest> 1362 1362 + for UnlikeAlbumSvc<T> 1363 1363 + { 1581 1364 type Response = super::UnlikeAlbumResponse; 1582 1582 - type Future = BoxFuture< 1583 1583 - tonic::Response<Self::Response>, 1584 1584 - tonic::Status, 1585 1585 - >; 1365 1365 + type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 1586 1366 fn call( 1587 1367 &mut self, 1588 1368 request: tonic::Request<super::UnlikeAlbumRequest>, ··· 1619 1399 "/rockbox.v1alpha1.LibraryService/GetLikedTracks" => { 1620 1400 #[allow(non_camel_case_types)] 1621 1401 struct GetLikedTracksSvc<T: LibraryService>(pub Arc<T>); 1622 1622 - impl< 1623 1623 - T: LibraryService, 1624 1624 - > tonic::server::UnaryService<super::GetLikedTracksRequest> 1625 1625 - for GetLikedTracksSvc<T> { 1402 1402 + impl<T: LibraryService> 1403 1403 + tonic::server::UnaryService<super::GetLikedTracksRequest> 1404 1404 + for GetLikedTracksSvc<T> 1405 1405 + { 1626 1406 type Response = super::GetLikedTracksResponse; 1627 1627 - type Future = BoxFuture< 1628 1628 - tonic::Response<Self::Response>, 1629 1629 - tonic::Status, 1630 1630 - >; 1407 1407 + type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 1631 1408 fn call( 1632 1409 &mut self, 1633 1410 request: tonic::Request<super::GetLikedTracksRequest>, 1634 1411 ) -> Self::Future { 1635 1412 let inner = Arc::clone(&self.0); 1636 1413 let fut = async move { 1637 1637 - <T as LibraryService>::get_liked_tracks(&inner, request) 1638 1638 - .await 1414 1414 + <T as LibraryService>::get_liked_tracks(&inner, request).await 1639 1415 }; 1640 1416 Box::pin(fut) 1641 1417 } ··· 1665 1441 "/rockbox.v1alpha1.LibraryService/GetLikedAlbums" => { 1666 1442 #[allow(non_camel_case_types)] 1667 1443 struct GetLikedAlbumsSvc<T: LibraryService>(pub Arc<T>); 1668 1668 - impl< 1669 1669 - T: LibraryService, 1670 1670 - > tonic::server::UnaryService<super::GetLikedAlbumsRequest> 1671 1671 - for GetLikedAlbumsSvc<T> { 1444 1444 + impl<T: LibraryService> 1445 1445 + tonic::server::UnaryService<super::GetLikedAlbumsRequest> 1446 1446 + for GetLikedAlbumsSvc<T> 1447 1447 + { 1672 1448 type Response = super::GetLikedAlbumsResponse; 1673 1673 - type Future = BoxFuture< 1674 1674 - tonic::Response<Self::Response>, 1675 1675 - tonic::Status, 1676 1676 - >; 1449 1449 + type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 1677 1450 fn call( 1678 1451 &mut self, 1679 1452 request: tonic::Request<super::GetLikedAlbumsRequest>, 1680 1453 ) -> Self::Future { 1681 1454 let inner = Arc::clone(&self.0); 1682 1455 let fut = async move { 1683 1683 - <T as LibraryService>::get_liked_albums(&inner, request) 1684 1684 - .await 1456 1456 + <T as LibraryService>::get_liked_albums(&inner, request).await 1685 1457 }; 1686 1458 Box::pin(fut) 1687 1459 } ··· 1711 1483 "/rockbox.v1alpha1.LibraryService/ScanLibrary" => { 1712 1484 #[allow(non_camel_case_types)] 1713 1485 struct ScanLibrarySvc<T: LibraryService>(pub Arc<T>); 1714 1714 - impl< 1715 1715 - T: LibraryService, 1716 1716 - > tonic::server::UnaryService<super::ScanLibraryRequest> 1717 1717 - for ScanLibrarySvc<T> { 1486 1486 + impl<T: LibraryService> tonic::server::UnaryService<super::ScanLibraryRequest> 1487 1487 + for ScanLibrarySvc<T> 1488 1488 + { 1718 1489 type Response = super::ScanLibraryResponse; 1719 1719 - type Future = BoxFuture< 1720 1720 - tonic::Response<Self::Response>, 1721 1721 - tonic::Status, 1722 1722 - >; 1490 1490 + type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 1723 1491 fn call( 1724 1492 &mut self, 1725 1493 request: tonic::Request<super::ScanLibraryRequest>, ··· 1756 1524 "/rockbox.v1alpha1.LibraryService/Search" => { 1757 1525 #[allow(non_camel_case_types)] 1758 1526 struct SearchSvc<T: LibraryService>(pub Arc<T>); 1759 1759 - impl< 1760 1760 - T: LibraryService, 1761 1761 - > tonic::server::UnaryService<super::SearchRequest> 1762 1762 - for SearchSvc<T> { 1527 1527 + impl<T: LibraryService> tonic::server::UnaryService<super::SearchRequest> for SearchSvc<T> { 1763 1528 type Response = super::SearchResponse; 1764 1764 - type Future = BoxFuture< 1765 1765 - tonic::Response<Self::Response>, 1766 1766 - tonic::Status, 1767 1767 - >; 1529 1529 + type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 1768 1530 fn call( 1769 1531 &mut self, 1770 1532 request: tonic::Request<super::SearchRequest>, 1771 1533 ) -> Self::Future { 1772 1534 let inner = Arc::clone(&self.0); 1773 1773 - let fut = async move { 1774 1774 - <T as LibraryService>::search(&inner, request).await 1775 1775 - }; 1535 1535 + let fut = 1536 1536 + async move { <T as LibraryService>::search(&inner, request).await }; 1776 1537 Box::pin(fut) 1777 1538 } 1778 1539 } ··· 1798 1559 }; 1799 1560 Box::pin(fut) 1800 1561 } 1801 1801 - _ => { 1802 1802 - Box::pin(async move { 1803 1803 - let mut response = http::Response::new(empty_body()); 1804 1804 - let headers = response.headers_mut(); 1805 1805 - headers 1806 1806 - .insert( 1807 1807 - tonic::Status::GRPC_STATUS, 1808 1808 - (tonic::Code::Unimplemented as i32).into(), 1809 1809 - ); 1810 1810 - headers 1811 1811 - .insert( 1812 1812 - http::header::CONTENT_TYPE, 1813 1813 - tonic::metadata::GRPC_CONTENT_TYPE, 1814 1814 - ); 1815 1815 - Ok(response) 1816 1816 - }) 1817 1817 - } 1562 1562 + _ => Box::pin(async move { 1563 1563 + let mut response = http::Response::new(empty_body()); 1564 1564 + let headers = response.headers_mut(); 1565 1565 + headers.insert( 1566 1566 + tonic::Status::GRPC_STATUS, 1567 1567 + (tonic::Code::Unimplemented as i32).into(), 1568 1568 + ); 1569 1569 + headers.insert( 1570 1570 + http::header::CONTENT_TYPE, 1571 1571 + tonic::metadata::GRPC_CONTENT_TYPE, 1572 1572 + ); 1573 1573 + Ok(response) 1574 1574 + }), 1818 1575 } 1819 1576 } 1820 1577 } ··· 1843 1600 dead_code, 1844 1601 missing_docs, 1845 1602 clippy::wildcard_imports, 1846 1846 - clippy::let_unit_value, 1603 1603 + clippy::let_unit_value 1847 1604 )] 1848 1848 - use tonic::codegen::*; 1849 1605 use tonic::codegen::http::Uri; 1606 1606 + use tonic::codegen::*; 1850 1607 #[derive(Debug, Clone)] 1851 1608 pub struct MetadataServiceClient<T> { 1852 1609 inner: tonic::client::Grpc<T>, ··· 1890 1647 <T as tonic::client::GrpcService<tonic::body::BoxBody>>::ResponseBody, 1891 1648 >, 1892 1649 >, 1893 1893 - <T as tonic::codegen::Service< 1894 1894 - http::Request<tonic::body::BoxBody>, 1895 1895 - >>::Error: Into<StdError> + std::marker::Send + std::marker::Sync, 1650 1650 + <T as tonic::codegen::Service<http::Request<tonic::body::BoxBody>>>::Error: 1651 1651 + Into<StdError> + std::marker::Send + std::marker::Sync, 1896 1652 { 1897 1653 MetadataServiceClient::new(InterceptedService::new(inner, interceptor)) 1898 1654 } ··· 1936 1692 dead_code, 1937 1693 missing_docs, 1938 1694 clippy::wildcard_imports, 1939 1939 - clippy::let_unit_value, 1695 1695 + clippy::let_unit_value 1940 1696 )] 1941 1697 use tonic::codegen::*; 1942 1698 /// Generated trait containing gRPC methods that should be implemented for use with MetadataServiceServer. ··· 1963 1719 max_encoding_message_size: None, 1964 1720 } 1965 1721 } 1966 1966 - pub fn with_interceptor<F>( 1967 1967 - inner: T, 1968 1968 - interceptor: F, 1969 1969 - ) -> InterceptedService<Self, F> 1722 1722 + pub fn with_interceptor<F>(inner: T, interceptor: F) -> InterceptedService<Self, F> 1970 1723 where 1971 1724 F: tonic::service::Interceptor, 1972 1725 { ··· 2018 1771 } 2019 1772 fn call(&mut self, req: http::Request<B>) -> Self::Future { 2020 1773 match req.uri().path() { 2021 2021 - _ => { 2022 2022 - Box::pin(async move { 2023 2023 - let mut response = http::Response::new(empty_body()); 2024 2024 - let headers = response.headers_mut(); 2025 2025 - headers 2026 2026 - .insert( 2027 2027 - tonic::Status::GRPC_STATUS, 2028 2028 - (tonic::Code::Unimplemented as i32).into(), 2029 2029 - ); 2030 2030 - headers 2031 2031 - .insert( 2032 2032 - http::header::CONTENT_TYPE, 2033 2033 - tonic::metadata::GRPC_CONTENT_TYPE, 2034 2034 - ); 2035 2035 - Ok(response) 2036 2036 - }) 2037 2037 - } 1774 1774 + _ => Box::pin(async move { 1775 1775 + let mut response = http::Response::new(empty_body()); 1776 1776 + let headers = response.headers_mut(); 1777 1777 + headers.insert( 1778 1778 + tonic::Status::GRPC_STATUS, 1779 1779 + (tonic::Code::Unimplemented as i32).into(), 1780 1780 + ); 1781 1781 + headers.insert( 1782 1782 + http::header::CONTENT_TYPE, 1783 1783 + tonic::metadata::GRPC_CONTENT_TYPE, 1784 1784 + ); 1785 1785 + Ok(response) 1786 1786 + }), 2038 1787 } 2039 1788 } 2040 1789 } ··· 2318 2067 dead_code, 2319 2068 missing_docs, 2320 2069 clippy::wildcard_imports, 2321 2321 - clippy::let_unit_value, 2070 2070 + clippy::let_unit_value 2322 2071 )] 2323 2323 - use tonic::codegen::*; 2324 2072 use tonic::codegen::http::Uri; 2073 2073 + use tonic::codegen::*; 2325 2074 #[derive(Debug, Clone)] 2326 2075 pub struct PlaybackServiceClient<T> { 2327 2076 inner: tonic::client::Grpc<T>, ··· 2365 2114 <T as tonic::client::GrpcService<tonic::body::BoxBody>>::ResponseBody, 2366 2115 >, 2367 2116 >, 2368 2368 - <T as tonic::codegen::Service< 2369 2369 - http::Request<tonic::body::BoxBody>, 2370 2370 - >>::Error: Into<StdError> + std::marker::Send + std::marker::Sync, 2117 2117 + <T as tonic::codegen::Service<http::Request<tonic::body::BoxBody>>>::Error: 2118 2118 + Into<StdError> + std::marker::Send + std::marker::Sync, 2371 2119 { 2372 2120 PlaybackServiceClient::new(InterceptedService::new(inner, interceptor)) 2373 2121 } ··· 2406 2154 &mut self, 2407 2155 request: impl tonic::IntoRequest<super::PlayRequest>, 2408 2156 ) -> std::result::Result<tonic::Response<super::PlayResponse>, tonic::Status> { 2409 2409 - self.inner 2410 2410 - .ready() 2411 2411 - .await 2412 2412 - .map_err(|e| { 2413 2413 - tonic::Status::unknown( 2414 2414 - format!("Service was not ready: {}", e.into()), 2415 2415 - ) 2416 2416 - })?; 2157 2157 + self.inner.ready().await.map_err(|e| { 2158 2158 + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 2159 2159 + })?; 2417 2160 let codec = tonic::codec::ProstCodec::default(); 2418 2418 - let path = http::uri::PathAndQuery::from_static( 2419 2419 - "/rockbox.v1alpha1.PlaybackService/Play", 2420 2420 - ); 2161 2161 + let path = 2162 2162 + http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.PlaybackService/Play"); 2421 2163 let mut req = request.into_request(); 2422 2164 req.extensions_mut() 2423 2165 .insert(GrpcMethod::new("rockbox.v1alpha1.PlaybackService", "Play")); ··· 2427 2169 &mut self, 2428 2170 request: impl tonic::IntoRequest<super::PauseRequest>, 2429 2171 ) -> std::result::Result<tonic::Response<super::PauseResponse>, tonic::Status> { 2430 2430 - self.inner 2431 2431 - .ready() 2432 2432 - .await 2433 2433 - .map_err(|e| { 2434 2434 - tonic::Status::unknown( 2435 2435 - format!("Service was not ready: {}", e.into()), 2436 2436 - ) 2437 2437 - })?; 2172 2172 + self.inner.ready().await.map_err(|e| { 2173 2173 + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 2174 2174 + })?; 2438 2175 let codec = tonic::codec::ProstCodec::default(); 2439 2439 - let path = http::uri::PathAndQuery::from_static( 2440 2440 - "/rockbox.v1alpha1.PlaybackService/Pause", 2441 2441 - ); 2176 2176 + let path = 2177 2177 + http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.PlaybackService/Pause"); 2442 2178 let mut req = request.into_request(); 2443 2179 req.extensions_mut() 2444 2180 .insert(GrpcMethod::new("rockbox.v1alpha1.PlaybackService", "Pause")); ··· 2447 2183 pub async fn play_or_pause( 2448 2184 &mut self, 2449 2185 request: impl tonic::IntoRequest<super::PlayOrPauseRequest>, 2450 2450 - ) -> std::result::Result< 2451 2451 - tonic::Response<super::PlayOrPauseResponse>, 2452 2452 - tonic::Status, 2453 2453 - > { 2454 2454 - self.inner 2455 2455 - .ready() 2456 2456 - .await 2457 2457 - .map_err(|e| { 2458 2458 - tonic::Status::unknown( 2459 2459 - format!("Service was not ready: {}", e.into()), 2460 2460 - ) 2461 2461 - })?; 2186 2186 + ) -> std::result::Result<tonic::Response<super::PlayOrPauseResponse>, tonic::Status> 2187 2187 + { 2188 2188 + self.inner.ready().await.map_err(|e| { 2189 2189 + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 2190 2190 + })?; 2462 2191 let codec = tonic::codec::ProstCodec::default(); 2463 2192 let path = http::uri::PathAndQuery::from_static( 2464 2193 "/rockbox.v1alpha1.PlaybackService/PlayOrPause", 2465 2194 ); 2466 2195 let mut req = request.into_request(); 2467 2467 - req.extensions_mut() 2468 2468 - .insert( 2469 2469 - GrpcMethod::new("rockbox.v1alpha1.PlaybackService", "PlayOrPause"), 2470 2470 - ); 2196 2196 + req.extensions_mut().insert(GrpcMethod::new( 2197 2197 + "rockbox.v1alpha1.PlaybackService", 2198 2198 + "PlayOrPause", 2199 2199 + )); 2471 2200 self.inner.unary(req, path, codec).await 2472 2201 } 2473 2202 pub async fn resume( 2474 2203 &mut self, 2475 2204 request: impl tonic::IntoRequest<super::ResumeRequest>, 2476 2205 ) -> std::result::Result<tonic::Response<super::ResumeResponse>, tonic::Status> { 2477 2477 - self.inner 2478 2478 - .ready() 2479 2479 - .await 2480 2480 - .map_err(|e| { 2481 2481 - tonic::Status::unknown( 2482 2482 - format!("Service was not ready: {}", e.into()), 2483 2483 - ) 2484 2484 - })?; 2206 2206 + self.inner.ready().await.map_err(|e| { 2207 2207 + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 2208 2208 + })?; 2485 2209 let codec = tonic::codec::ProstCodec::default(); 2486 2486 - let path = http::uri::PathAndQuery::from_static( 2487 2487 - "/rockbox.v1alpha1.PlaybackService/Resume", 2488 2488 - ); 2210 2210 + let path = 2211 2211 + http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.PlaybackService/Resume"); 2489 2212 let mut req = request.into_request(); 2490 2490 - req.extensions_mut() 2491 2491 - .insert(GrpcMethod::new("rockbox.v1alpha1.PlaybackService", "Resume")); 2213 2213 + req.extensions_mut().insert(GrpcMethod::new( 2214 2214 + "rockbox.v1alpha1.PlaybackService", 2215 2215 + "Resume", 2216 2216 + )); 2492 2217 self.inner.unary(req, path, codec).await 2493 2218 } 2494 2219 pub async fn next( 2495 2220 &mut self, 2496 2221 request: impl tonic::IntoRequest<super::NextRequest>, 2497 2222 ) -> std::result::Result<tonic::Response<super::NextResponse>, tonic::Status> { 2498 2498 - self.inner 2499 2499 - .ready() 2500 2500 - .await 2501 2501 - .map_err(|e| { 2502 2502 - tonic::Status::unknown( 2503 2503 - format!("Service was not ready: {}", e.into()), 2504 2504 - ) 2505 2505 - })?; 2223 2223 + self.inner.ready().await.map_err(|e| { 2224 2224 + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 2225 2225 + })?; 2506 2226 let codec = tonic::codec::ProstCodec::default(); 2507 2507 - let path = http::uri::PathAndQuery::from_static( 2508 2508 - "/rockbox.v1alpha1.PlaybackService/Next", 2509 2509 - ); 2227 2227 + let path = 2228 2228 + http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.PlaybackService/Next"); 2510 2229 let mut req = request.into_request(); 2511 2230 req.extensions_mut() 2512 2231 .insert(GrpcMethod::new("rockbox.v1alpha1.PlaybackService", "Next")); ··· 2515 2234 pub async fn previous( 2516 2235 &mut self, 2517 2236 request: impl tonic::IntoRequest<super::PreviousRequest>, 2518 2518 - ) -> std::result::Result< 2519 2519 - tonic::Response<super::PreviousResponse>, 2520 2520 - tonic::Status, 2521 2521 - > { 2522 2522 - self.inner 2523 2523 - .ready() 2524 2524 - .await 2525 2525 - .map_err(|e| { 2526 2526 - tonic::Status::unknown( 2527 2527 - format!("Service was not ready: {}", e.into()), 2528 2528 - ) 2529 2529 - })?; 2237 2237 + ) -> std::result::Result<tonic::Response<super::PreviousResponse>, tonic::Status> { 2238 2238 + self.inner.ready().await.map_err(|e| { 2239 2239 + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 2240 2240 + })?; 2530 2241 let codec = tonic::codec::ProstCodec::default(); 2531 2531 - let path = http::uri::PathAndQuery::from_static( 2532 2532 - "/rockbox.v1alpha1.PlaybackService/Previous", 2533 2533 - ); 2242 2242 + let path = 2243 2243 + http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.PlaybackService/Previous"); 2534 2244 let mut req = request.into_request(); 2535 2535 - req.extensions_mut() 2536 2536 - .insert(GrpcMethod::new("rockbox.v1alpha1.PlaybackService", "Previous")); 2245 2245 + req.extensions_mut().insert(GrpcMethod::new( 2246 2246 + "rockbox.v1alpha1.PlaybackService", 2247 2247 + "Previous", 2248 2248 + )); 2537 2249 self.inner.unary(req, path, codec).await 2538 2250 } 2539 2251 pub async fn fast_forward_rewind( 2540 2252 &mut self, 2541 2253 request: impl tonic::IntoRequest<super::FastForwardRewindRequest>, 2542 2542 - ) -> std::result::Result< 2543 2543 - tonic::Response<super::FastForwardRewindResponse>, 2544 2544 - tonic::Status, 2545 2545 - > { 2546 2546 - self.inner 2547 2547 - .ready() 2548 2548 - .await 2549 2549 - .map_err(|e| { 2550 2550 - tonic::Status::unknown( 2551 2551 - format!("Service was not ready: {}", e.into()), 2552 2552 - ) 2553 2553 - })?; 2254 2254 + ) -> std::result::Result<tonic::Response<super::FastForwardRewindResponse>, tonic::Status> 2255 2255 + { 2256 2256 + self.inner.ready().await.map_err(|e| { 2257 2257 + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 2258 2258 + })?; 2554 2259 let codec = tonic::codec::ProstCodec::default(); 2555 2260 let path = http::uri::PathAndQuery::from_static( 2556 2261 "/rockbox.v1alpha1.PlaybackService/FastForwardRewind", 2557 2262 ); 2558 2263 let mut req = request.into_request(); 2559 2559 - req.extensions_mut() 2560 2560 - .insert( 2561 2561 - GrpcMethod::new( 2562 2562 - "rockbox.v1alpha1.PlaybackService", 2563 2563 - "FastForwardRewind", 2564 2564 - ), 2565 2565 - ); 2264 2264 + req.extensions_mut().insert(GrpcMethod::new( 2265 2265 + "rockbox.v1alpha1.PlaybackService", 2266 2266 + "FastForwardRewind", 2267 2267 + )); 2566 2268 self.inner.unary(req, path, codec).await 2567 2269 } 2568 2270 pub async fn status( 2569 2271 &mut self, 2570 2272 request: impl tonic::IntoRequest<super::StatusRequest>, 2571 2273 ) -> std::result::Result<tonic::Response<super::StatusResponse>, tonic::Status> { 2572 2572 - self.inner 2573 2573 - .ready() 2574 2574 - .await 2575 2575 - .map_err(|e| { 2576 2576 - tonic::Status::unknown( 2577 2577 - format!("Service was not ready: {}", e.into()), 2578 2578 - ) 2579 2579 - })?; 2274 2274 + self.inner.ready().await.map_err(|e| { 2275 2275 + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 2276 2276 + })?; 2580 2277 let codec = tonic::codec::ProstCodec::default(); 2581 2581 - let path = http::uri::PathAndQuery::from_static( 2582 2582 - "/rockbox.v1alpha1.PlaybackService/Status", 2583 2583 - ); 2278 2278 + let path = 2279 2279 + http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.PlaybackService/Status"); 2584 2280 let mut req = request.into_request(); 2585 2585 - req.extensions_mut() 2586 2586 - .insert(GrpcMethod::new("rockbox.v1alpha1.PlaybackService", "Status")); 2281 2281 + req.extensions_mut().insert(GrpcMethod::new( 2282 2282 + "rockbox.v1alpha1.PlaybackService", 2283 2283 + "Status", 2284 2284 + )); 2587 2285 self.inner.unary(req, path, codec).await 2588 2286 } 2589 2287 pub async fn current_track( 2590 2288 &mut self, 2591 2289 request: impl tonic::IntoRequest<super::CurrentTrackRequest>, 2592 2592 - ) -> std::result::Result< 2593 2593 - tonic::Response<super::CurrentTrackResponse>, 2594 2594 - tonic::Status, 2595 2595 - > { 2596 2596 - self.inner 2597 2597 - .ready() 2598 2598 - .await 2599 2599 - .map_err(|e| { 2600 2600 - tonic::Status::unknown( 2601 2601 - format!("Service was not ready: {}", e.into()), 2602 2602 - ) 2603 2603 - })?; 2290 2290 + ) -> std::result::Result<tonic::Response<super::CurrentTrackResponse>, tonic::Status> 2291 2291 + { 2292 2292 + self.inner.ready().await.map_err(|e| { 2293 2293 + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 2294 2294 + })?; 2604 2295 let codec = tonic::codec::ProstCodec::default(); 2605 2296 let path = http::uri::PathAndQuery::from_static( 2606 2297 "/rockbox.v1alpha1.PlaybackService/CurrentTrack", 2607 2298 ); 2608 2299 let mut req = request.into_request(); 2609 2609 - req.extensions_mut() 2610 2610 - .insert( 2611 2611 - GrpcMethod::new("rockbox.v1alpha1.PlaybackService", "CurrentTrack"), 2612 2612 - ); 2300 2300 + req.extensions_mut().insert(GrpcMethod::new( 2301 2301 + "rockbox.v1alpha1.PlaybackService", 2302 2302 + "CurrentTrack", 2303 2303 + )); 2613 2304 self.inner.unary(req, path, codec).await 2614 2305 } 2615 2306 pub async fn next_track( 2616 2307 &mut self, 2617 2308 request: impl tonic::IntoRequest<super::NextTrackRequest>, 2618 2618 - ) -> std::result::Result< 2619 2619 - tonic::Response<super::NextTrackResponse>, 2620 2620 - tonic::Status, 2621 2621 - > { 2622 2622 - self.inner 2623 2623 - .ready() 2624 2624 - .await 2625 2625 - .map_err(|e| { 2626 2626 - tonic::Status::unknown( 2627 2627 - format!("Service was not ready: {}", e.into()), 2628 2628 - ) 2629 2629 - })?; 2309 2309 + ) -> std::result::Result<tonic::Response<super::NextTrackResponse>, tonic::Status> { 2310 2310 + self.inner.ready().await.map_err(|e| { 2311 2311 + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 2312 2312 + })?; 2630 2313 let codec = tonic::codec::ProstCodec::default(); 2631 2631 - let path = http::uri::PathAndQuery::from_static( 2632 2632 - "/rockbox.v1alpha1.PlaybackService/NextTrack", 2633 2633 - ); 2314 2314 + let path = 2315 2315 + http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.PlaybackService/NextTrack"); 2634 2316 let mut req = request.into_request(); 2635 2635 - req.extensions_mut() 2636 2636 - .insert( 2637 2637 - GrpcMethod::new("rockbox.v1alpha1.PlaybackService", "NextTrack"), 2638 2638 - ); 2317 2317 + req.extensions_mut().insert(GrpcMethod::new( 2318 2318 + "rockbox.v1alpha1.PlaybackService", 2319 2319 + "NextTrack", 2320 2320 + )); 2639 2321 self.inner.unary(req, path, codec).await 2640 2322 } 2641 2323 pub async fn flush_and_reload_tracks( 2642 2324 &mut self, 2643 2325 request: impl tonic::IntoRequest<super::FlushAndReloadTracksRequest>, 2644 2644 - ) -> std::result::Result< 2645 2645 - tonic::Response<super::FlushAndReloadTracksResponse>, 2646 2646 - tonic::Status, 2647 2647 - > { 2648 2648 - self.inner 2649 2649 - .ready() 2650 2650 - .await 2651 2651 - .map_err(|e| { 2652 2652 - tonic::Status::unknown( 2653 2653 - format!("Service was not ready: {}", e.into()), 2654 2654 - ) 2655 2655 - })?; 2326 2326 + ) -> std::result::Result<tonic::Response<super::FlushAndReloadTracksResponse>, tonic::Status> 2327 2327 + { 2328 2328 + self.inner.ready().await.map_err(|e| { 2329 2329 + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 2330 2330 + })?; 2656 2331 let codec = tonic::codec::ProstCodec::default(); 2657 2332 let path = http::uri::PathAndQuery::from_static( 2658 2333 "/rockbox.v1alpha1.PlaybackService/FlushAndReloadTracks", 2659 2334 ); 2660 2335 let mut req = request.into_request(); 2661 2661 - req.extensions_mut() 2662 2662 - .insert( 2663 2663 - GrpcMethod::new( 2664 2664 - "rockbox.v1alpha1.PlaybackService", 2665 2665 - "FlushAndReloadTracks", 2666 2666 - ), 2667 2667 - ); 2336 2336 + req.extensions_mut().insert(GrpcMethod::new( 2337 2337 + "rockbox.v1alpha1.PlaybackService", 2338 2338 + "FlushAndReloadTracks", 2339 2339 + )); 2668 2340 self.inner.unary(req, path, codec).await 2669 2341 } 2670 2342 pub async fn get_file_position( 2671 2343 &mut self, 2672 2344 request: impl tonic::IntoRequest<super::GetFilePositionRequest>, 2673 2673 - ) -> std::result::Result< 2674 2674 - tonic::Response<super::GetFilePositionResponse>, 2675 2675 - tonic::Status, 2676 2676 - > { 2677 2677 - self.inner 2678 2678 - .ready() 2679 2679 - .await 2680 2680 - .map_err(|e| { 2681 2681 - tonic::Status::unknown( 2682 2682 - format!("Service was not ready: {}", e.into()), 2683 2683 - ) 2684 2684 - })?; 2345 2345 + ) -> std::result::Result<tonic::Response<super::GetFilePositionResponse>, tonic::Status> 2346 2346 + { 2347 2347 + self.inner.ready().await.map_err(|e| { 2348 2348 + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 2349 2349 + })?; 2685 2350 let codec = tonic::codec::ProstCodec::default(); 2686 2351 let path = http::uri::PathAndQuery::from_static( 2687 2352 "/rockbox.v1alpha1.PlaybackService/GetFilePosition", 2688 2353 ); 2689 2354 let mut req = request.into_request(); 2690 2690 - req.extensions_mut() 2691 2691 - .insert( 2692 2692 - GrpcMethod::new( 2693 2693 - "rockbox.v1alpha1.PlaybackService", 2694 2694 - "GetFilePosition", 2695 2695 - ), 2696 2696 - ); 2355 2355 + req.extensions_mut().insert(GrpcMethod::new( 2356 2356 + "rockbox.v1alpha1.PlaybackService", 2357 2357 + "GetFilePosition", 2358 2358 + )); 2697 2359 self.inner.unary(req, path, codec).await 2698 2360 } 2699 2361 pub async fn hard_stop( 2700 2362 &mut self, 2701 2363 request: impl tonic::IntoRequest<super::HardStopRequest>, 2702 2702 - ) -> std::result::Result< 2703 2703 - tonic::Response<super::HardStopResponse>, 2704 2704 - tonic::Status, 2705 2705 - > { 2706 2706 - self.inner 2707 2707 - .ready() 2708 2708 - .await 2709 2709 - .map_err(|e| { 2710 2710 - tonic::Status::unknown( 2711 2711 - format!("Service was not ready: {}", e.into()), 2712 2712 - ) 2713 2713 - })?; 2364 2364 + ) -> std::result::Result<tonic::Response<super::HardStopResponse>, tonic::Status> { 2365 2365 + self.inner.ready().await.map_err(|e| { 2366 2366 + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 2367 2367 + })?; 2714 2368 let codec = tonic::codec::ProstCodec::default(); 2715 2715 - let path = http::uri::PathAndQuery::from_static( 2716 2716 - "/rockbox.v1alpha1.PlaybackService/HardStop", 2717 2717 - ); 2369 2369 + let path = 2370 2370 + http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.PlaybackService/HardStop"); 2718 2371 let mut req = request.into_request(); 2719 2719 - req.extensions_mut() 2720 2720 - .insert(GrpcMethod::new("rockbox.v1alpha1.PlaybackService", "HardStop")); 2372 2372 + req.extensions_mut().insert(GrpcMethod::new( 2373 2373 + "rockbox.v1alpha1.PlaybackService", 2374 2374 + "HardStop", 2375 2375 + )); 2721 2376 self.inner.unary(req, path, codec).await 2722 2377 } 2723 2378 pub async fn play_album( 2724 2379 &mut self, 2725 2380 request: impl tonic::IntoRequest<super::PlayAlbumRequest>, 2726 2726 - ) -> std::result::Result< 2727 2727 - tonic::Response<super::PlayAlbumResponse>, 2728 2728 - tonic::Status, 2729 2729 - > { 2730 2730 - self.inner 2731 2731 - .ready() 2732 2732 - .await 2733 2733 - .map_err(|e| { 2734 2734 - tonic::Status::unknown( 2735 2735 - format!("Service was not ready: {}", e.into()), 2736 2736 - ) 2737 2737 - })?; 2381 2381 + ) -> std::result::Result<tonic::Response<super::PlayAlbumResponse>, tonic::Status> { 2382 2382 + self.inner.ready().await.map_err(|e| { 2383 2383 + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 2384 2384 + })?; 2738 2385 let codec = tonic::codec::ProstCodec::default(); 2739 2739 - let path = http::uri::PathAndQuery::from_static( 2740 2740 - "/rockbox.v1alpha1.PlaybackService/PlayAlbum", 2741 2741 - ); 2386 2386 + let path = 2387 2387 + http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.PlaybackService/PlayAlbum"); 2742 2388 let mut req = request.into_request(); 2743 2743 - req.extensions_mut() 2744 2744 - .insert( 2745 2745 - GrpcMethod::new("rockbox.v1alpha1.PlaybackService", "PlayAlbum"), 2746 2746 - ); 2389 2389 + req.extensions_mut().insert(GrpcMethod::new( 2390 2390 + "rockbox.v1alpha1.PlaybackService", 2391 2391 + "PlayAlbum", 2392 2392 + )); 2747 2393 self.inner.unary(req, path, codec).await 2748 2394 } 2749 2395 pub async fn play_artist_tracks( 2750 2396 &mut self, 2751 2397 request: impl tonic::IntoRequest<super::PlayArtistTracksRequest>, 2752 2752 - ) -> std::result::Result< 2753 2753 - tonic::Response<super::PlayArtistTracksResponse>, 2754 2754 - tonic::Status, 2755 2755 - > { 2756 2756 - self.inner 2757 2757 - .ready() 2758 2758 - .await 2759 2759 - .map_err(|e| { 2760 2760 - tonic::Status::unknown( 2761 2761 - format!("Service was not ready: {}", e.into()), 2762 2762 - ) 2763 2763 - })?; 2398 2398 + ) -> std::result::Result<tonic::Response<super::PlayArtistTracksResponse>, tonic::Status> 2399 2399 + { 2400 2400 + self.inner.ready().await.map_err(|e| { 2401 2401 + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 2402 2402 + })?; 2764 2403 let codec = tonic::codec::ProstCodec::default(); 2765 2404 let path = http::uri::PathAndQuery::from_static( 2766 2405 "/rockbox.v1alpha1.PlaybackService/PlayArtistTracks", 2767 2406 ); 2768 2407 let mut req = request.into_request(); 2769 2769 - req.extensions_mut() 2770 2770 - .insert( 2771 2771 - GrpcMethod::new( 2772 2772 - "rockbox.v1alpha1.PlaybackService", 2773 2773 - "PlayArtistTracks", 2774 2774 - ), 2775 2775 - ); 2408 2408 + req.extensions_mut().insert(GrpcMethod::new( 2409 2409 + "rockbox.v1alpha1.PlaybackService", 2410 2410 + "PlayArtistTracks", 2411 2411 + )); 2776 2412 self.inner.unary(req, path, codec).await 2777 2413 } 2778 2414 pub async fn play_playlist( 2779 2415 &mut self, 2780 2416 request: impl tonic::IntoRequest<super::PlayPlaylistRequest>, 2781 2781 - ) -> std::result::Result< 2782 2782 - tonic::Response<super::PlayPlaylistResponse>, 2783 2783 - tonic::Status, 2784 2784 - > { 2785 2785 - self.inner 2786 2786 - .ready() 2787 2787 - .await 2788 2788 - .map_err(|e| { 2789 2789 - tonic::Status::unknown( 2790 2790 - format!("Service was not ready: {}", e.into()), 2791 2791 - ) 2792 2792 - })?; 2417 2417 + ) -> std::result::Result<tonic::Response<super::PlayPlaylistResponse>, tonic::Status> 2418 2418 + { 2419 2419 + self.inner.ready().await.map_err(|e| { 2420 2420 + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 2421 2421 + })?; 2793 2422 let codec = tonic::codec::ProstCodec::default(); 2794 2423 let path = http::uri::PathAndQuery::from_static( 2795 2424 "/rockbox.v1alpha1.PlaybackService/PlayPlaylist", 2796 2425 ); 2797 2426 let mut req = request.into_request(); 2798 2798 - req.extensions_mut() 2799 2799 - .insert( 2800 2800 - GrpcMethod::new("rockbox.v1alpha1.PlaybackService", "PlayPlaylist"), 2801 2801 - ); 2427 2427 + req.extensions_mut().insert(GrpcMethod::new( 2428 2428 + "rockbox.v1alpha1.PlaybackService", 2429 2429 + "PlayPlaylist", 2430 2430 + )); 2802 2431 self.inner.unary(req, path, codec).await 2803 2432 } 2804 2433 pub async fn play_directory( 2805 2434 &mut self, 2806 2435 request: impl tonic::IntoRequest<super::PlayDirectoryRequest>, 2807 2807 - ) -> std::result::Result< 2808 2808 - tonic::Response<super::PlayDirectoryResponse>, 2809 2809 - tonic::Status, 2810 2810 - > { 2811 2811 - self.inner 2812 2812 - .ready() 2813 2813 - .await 2814 2814 - .map_err(|e| { 2815 2815 - tonic::Status::unknown( 2816 2816 - format!("Service was not ready: {}", e.into()), 2817 2817 - ) 2818 2818 - })?; 2436 2436 + ) -> std::result::Result<tonic::Response<super::PlayDirectoryResponse>, tonic::Status> 2437 2437 + { 2438 2438 + self.inner.ready().await.map_err(|e| { 2439 2439 + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 2440 2440 + })?; 2819 2441 let codec = tonic::codec::ProstCodec::default(); 2820 2442 let path = http::uri::PathAndQuery::from_static( 2821 2443 "/rockbox.v1alpha1.PlaybackService/PlayDirectory", 2822 2444 ); 2823 2445 let mut req = request.into_request(); 2824 2824 - req.extensions_mut() 2825 2825 - .insert( 2826 2826 - GrpcMethod::new("rockbox.v1alpha1.PlaybackService", "PlayDirectory"), 2827 2827 - ); 2446 2446 + req.extensions_mut().insert(GrpcMethod::new( 2447 2447 + "rockbox.v1alpha1.PlaybackService", 2448 2448 + "PlayDirectory", 2449 2449 + )); 2828 2450 self.inner.unary(req, path, codec).await 2829 2451 } 2830 2452 pub async fn play_music_directory( 2831 2453 &mut self, 2832 2454 request: impl tonic::IntoRequest<super::PlayMusicDirectoryRequest>, 2833 2833 - ) -> std::result::Result< 2834 2834 - tonic::Response<super::PlayMusicDirectoryResponse>, 2835 2835 - tonic::Status, 2836 2836 - > { 2837 2837 - self.inner 2838 2838 - .ready() 2839 2839 - .await 2840 2840 - .map_err(|e| { 2841 2841 - tonic::Status::unknown( 2842 2842 - format!("Service was not ready: {}", e.into()), 2843 2843 - ) 2844 2844 - })?; 2455 2455 + ) -> std::result::Result<tonic::Response<super::PlayMusicDirectoryResponse>, tonic::Status> 2456 2456 + { 2457 2457 + self.inner.ready().await.map_err(|e| { 2458 2458 + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 2459 2459 + })?; 2845 2460 let codec = tonic::codec::ProstCodec::default(); 2846 2461 let path = http::uri::PathAndQuery::from_static( 2847 2462 "/rockbox.v1alpha1.PlaybackService/PlayMusicDirectory", 2848 2463 ); 2849 2464 let mut req = request.into_request(); 2850 2850 - req.extensions_mut() 2851 2851 - .insert( 2852 2852 - GrpcMethod::new( 2853 2853 - "rockbox.v1alpha1.PlaybackService", 2854 2854 - "PlayMusicDirectory", 2855 2855 - ), 2856 2856 - ); 2465 2465 + req.extensions_mut().insert(GrpcMethod::new( 2466 2466 + "rockbox.v1alpha1.PlaybackService", 2467 2467 + "PlayMusicDirectory", 2468 2468 + )); 2857 2469 self.inner.unary(req, path, codec).await 2858 2470 } 2859 2471 pub async fn play_track( 2860 2472 &mut self, 2861 2473 request: impl tonic::IntoRequest<super::PlayTrackRequest>, 2862 2862 - ) -> std::result::Result< 2863 2863 - tonic::Response<super::PlayTrackResponse>, 2864 2864 - tonic::Status, 2865 2865 - > { 2866 2866 - self.inner 2867 2867 - .ready() 2868 2868 - .await 2869 2869 - .map_err(|e| { 2870 2870 - tonic::Status::unknown( 2871 2871 - format!("Service was not ready: {}", e.into()), 2872 2872 - ) 2873 2873 - })?; 2474 2474 + ) -> std::result::Result<tonic::Response<super::PlayTrackResponse>, tonic::Status> { 2475 2475 + self.inner.ready().await.map_err(|e| { 2476 2476 + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 2477 2477 + })?; 2874 2478 let codec = tonic::codec::ProstCodec::default(); 2875 2875 - let path = http::uri::PathAndQuery::from_static( 2876 2876 - "/rockbox.v1alpha1.PlaybackService/PlayTrack", 2877 2877 - ); 2479 2479 + let path = 2480 2480 + http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.PlaybackService/PlayTrack"); 2878 2481 let mut req = request.into_request(); 2879 2879 - req.extensions_mut() 2880 2880 - .insert( 2881 2881 - GrpcMethod::new("rockbox.v1alpha1.PlaybackService", "PlayTrack"), 2882 2882 - ); 2482 2482 + req.extensions_mut().insert(GrpcMethod::new( 2483 2483 + "rockbox.v1alpha1.PlaybackService", 2484 2484 + "PlayTrack", 2485 2485 + )); 2883 2486 self.inner.unary(req, path, codec).await 2884 2487 } 2885 2488 pub async fn play_liked_tracks( 2886 2489 &mut self, 2887 2490 request: impl tonic::IntoRequest<super::PlayLikedTracksRequest>, 2888 2888 - ) -> std::result::Result< 2889 2889 - tonic::Response<super::PlayLikedTracksResponse>, 2890 2890 - tonic::Status, 2891 2891 - > { 2892 2892 - self.inner 2893 2893 - .ready() 2894 2894 - .await 2895 2895 - .map_err(|e| { 2896 2896 - tonic::Status::unknown( 2897 2897 - format!("Service was not ready: {}", e.into()), 2898 2898 - ) 2899 2899 - })?; 2491 2491 + ) -> std::result::Result<tonic::Response<super::PlayLikedTracksResponse>, tonic::Status> 2492 2492 + { 2493 2493 + self.inner.ready().await.map_err(|e| { 2494 2494 + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 2495 2495 + })?; 2900 2496 let codec = tonic::codec::ProstCodec::default(); 2901 2497 let path = http::uri::PathAndQuery::from_static( 2902 2498 "/rockbox.v1alpha1.PlaybackService/PlayLikedTracks", 2903 2499 ); 2904 2500 let mut req = request.into_request(); 2905 2905 - req.extensions_mut() 2906 2906 - .insert( 2907 2907 - GrpcMethod::new( 2908 2908 - "rockbox.v1alpha1.PlaybackService", 2909 2909 - "PlayLikedTracks", 2910 2910 - ), 2911 2911 - ); 2501 2501 + req.extensions_mut().insert(GrpcMethod::new( 2502 2502 + "rockbox.v1alpha1.PlaybackService", 2503 2503 + "PlayLikedTracks", 2504 2504 + )); 2912 2505 self.inner.unary(req, path, codec).await 2913 2506 } 2914 2507 pub async fn play_all_tracks( 2915 2508 &mut self, 2916 2509 request: impl tonic::IntoRequest<super::PlayAllTracksRequest>, 2917 2917 - ) -> std::result::Result< 2918 2918 - tonic::Response<super::PlayAllTracksResponse>, 2919 2919 - tonic::Status, 2920 2920 - > { 2921 2921 - self.inner 2922 2922 - .ready() 2923 2923 - .await 2924 2924 - .map_err(|e| { 2925 2925 - tonic::Status::unknown( 2926 2926 - format!("Service was not ready: {}", e.into()), 2927 2927 - ) 2928 2928 - })?; 2510 2510 + ) -> std::result::Result<tonic::Response<super::PlayAllTracksResponse>, tonic::Status> 2511 2511 + { 2512 2512 + self.inner.ready().await.map_err(|e| { 2513 2513 + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 2514 2514 + })?; 2929 2515 let codec = tonic::codec::ProstCodec::default(); 2930 2516 let path = http::uri::PathAndQuery::from_static( 2931 2517 "/rockbox.v1alpha1.PlaybackService/PlayAllTracks", 2932 2518 ); 2933 2519 let mut req = request.into_request(); 2934 2934 - req.extensions_mut() 2935 2935 - .insert( 2936 2936 - GrpcMethod::new("rockbox.v1alpha1.PlaybackService", "PlayAllTracks"), 2937 2937 - ); 2520 2520 + req.extensions_mut().insert(GrpcMethod::new( 2521 2521 + "rockbox.v1alpha1.PlaybackService", 2522 2522 + "PlayAllTracks", 2523 2523 + )); 2938 2524 self.inner.unary(req, path, codec).await 2939 2525 } 2940 2526 pub async fn stream_current_track( ··· 2944 2530 tonic::Response<tonic::codec::Streaming<super::CurrentTrackResponse>>, 2945 2531 tonic::Status, 2946 2532 > { 2947 2947 - self.inner 2948 2948 - .ready() 2949 2949 - .await 2950 2950 - .map_err(|e| { 2951 2951 - tonic::Status::unknown( 2952 2952 - format!("Service was not ready: {}", e.into()), 2953 2953 - ) 2954 2954 - })?; 2533 2533 + self.inner.ready().await.map_err(|e| { 2534 2534 + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 2535 2535 + })?; 2955 2536 let codec = tonic::codec::ProstCodec::default(); 2956 2537 let path = http::uri::PathAndQuery::from_static( 2957 2538 "/rockbox.v1alpha1.PlaybackService/StreamCurrentTrack", 2958 2539 ); 2959 2540 let mut req = request.into_request(); 2960 2960 - req.extensions_mut() 2961 2961 - .insert( 2962 2962 - GrpcMethod::new( 2963 2963 - "rockbox.v1alpha1.PlaybackService", 2964 2964 - "StreamCurrentTrack", 2965 2965 - ), 2966 2966 - ); 2541 2541 + req.extensions_mut().insert(GrpcMethod::new( 2542 2542 + "rockbox.v1alpha1.PlaybackService", 2543 2543 + "StreamCurrentTrack", 2544 2544 + )); 2967 2545 self.inner.server_streaming(req, path, codec).await 2968 2546 } 2969 2547 pub async fn stream_status( ··· 2973 2551 tonic::Response<tonic::codec::Streaming<super::StatusResponse>>, 2974 2552 tonic::Status, 2975 2553 > { 2976 2976 - self.inner 2977 2977 - .ready() 2978 2978 - .await 2979 2979 - .map_err(|e| { 2980 2980 - tonic::Status::unknown( 2981 2981 - format!("Service was not ready: {}", e.into()), 2982 2982 - ) 2983 2983 - })?; 2554 2554 + self.inner.ready().await.map_err(|e| { 2555 2555 + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 2556 2556 + })?; 2984 2557 let codec = tonic::codec::ProstCodec::default(); 2985 2558 let path = http::uri::PathAndQuery::from_static( 2986 2559 "/rockbox.v1alpha1.PlaybackService/StreamStatus", 2987 2560 ); 2988 2561 let mut req = request.into_request(); 2989 2989 - req.extensions_mut() 2990 2990 - .insert( 2991 2991 - GrpcMethod::new("rockbox.v1alpha1.PlaybackService", "StreamStatus"), 2992 2992 - ); 2562 2562 + req.extensions_mut().insert(GrpcMethod::new( 2563 2563 + "rockbox.v1alpha1.PlaybackService", 2564 2564 + "StreamStatus", 2565 2565 + )); 2993 2566 self.inner.server_streaming(req, path, codec).await 2994 2567 } 2995 2568 pub async fn stream_playlist( ··· 2999 2572 tonic::Response<tonic::codec::Streaming<super::PlaylistResponse>>, 3000 2573 tonic::Status, 3001 2574 > { 3002 3002 - self.inner 3003 3003 - .ready() 3004 3004 - .await 3005 3005 - .map_err(|e| { 3006 3006 - tonic::Status::unknown( 3007 3007 - format!("Service was not ready: {}", e.into()), 3008 3008 - ) 3009 3009 - })?; 2575 2575 + self.inner.ready().await.map_err(|e| { 2576 2576 + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 2577 2577 + })?; 3010 2578 let codec = tonic::codec::ProstCodec::default(); 3011 2579 let path = http::uri::PathAndQuery::from_static( 3012 2580 "/rockbox.v1alpha1.PlaybackService/StreamPlaylist", 3013 2581 ); 3014 2582 let mut req = request.into_request(); 3015 3015 - req.extensions_mut() 3016 3016 - .insert( 3017 3017 - GrpcMethod::new("rockbox.v1alpha1.PlaybackService", "StreamPlaylist"), 3018 3018 - ); 2583 2583 + req.extensions_mut().insert(GrpcMethod::new( 2584 2584 + "rockbox.v1alpha1.PlaybackService", 2585 2585 + "StreamPlaylist", 2586 2586 + )); 3019 2587 self.inner.server_streaming(req, path, codec).await 3020 2588 } 3021 2589 } ··· 3027 2595 dead_code, 3028 2596 missing_docs, 3029 2597 clippy::wildcard_imports, 3030 3030 - clippy::let_unit_value, 2598 2598 + clippy::let_unit_value 3031 2599 )] 3032 2600 use tonic::codegen::*; 3033 2601 /// Generated trait containing gRPC methods that should be implemented for use with PlaybackServiceServer. ··· 3044 2612 async fn play_or_pause( 3045 2613 &self, 3046 2614 request: tonic::Request<super::PlayOrPauseRequest>, 3047 3047 - ) -> std::result::Result< 3048 3048 - tonic::Response<super::PlayOrPauseResponse>, 3049 3049 - tonic::Status, 3050 3050 - >; 2615 2615 + ) -> std::result::Result<tonic::Response<super::PlayOrPauseResponse>, tonic::Status>; 3051 2616 async fn resume( 3052 2617 &self, 3053 2618 request: tonic::Request<super::ResumeRequest>, ··· 3059 2624 async fn previous( 3060 2625 &self, 3061 2626 request: tonic::Request<super::PreviousRequest>, 3062 3062 - ) -> std::result::Result< 3063 3063 - tonic::Response<super::PreviousResponse>, 3064 3064 - tonic::Status, 3065 3065 - >; 2627 2627 + ) -> std::result::Result<tonic::Response<super::PreviousResponse>, tonic::Status>; 3066 2628 async fn fast_forward_rewind( 3067 2629 &self, 3068 2630 request: tonic::Request<super::FastForwardRewindRequest>, 3069 3069 - ) -> std::result::Result< 3070 3070 - tonic::Response<super::FastForwardRewindResponse>, 3071 3071 - tonic::Status, 3072 3072 - >; 2631 2631 + ) -> std::result::Result<tonic::Response<super::FastForwardRewindResponse>, tonic::Status>; 3073 2632 async fn status( 3074 2633 &self, 3075 2634 request: tonic::Request<super::StatusRequest>, ··· 3077 2636 async fn current_track( 3078 2637 &self, 3079 2638 request: tonic::Request<super::CurrentTrackRequest>, 3080 3080 - ) -> std::result::Result< 3081 3081 - tonic::Response<super::CurrentTrackResponse>, 3082 3082 - tonic::Status, 3083 3083 - >; 2639 2639 + ) -> std::result::Result<tonic::Response<super::CurrentTrackResponse>, tonic::Status>; 3084 2640 async fn next_track( 3085 2641 &self, 3086 2642 request: tonic::Request<super::NextTrackRequest>, 3087 3087 - ) -> std::result::Result< 3088 3088 - tonic::Response<super::NextTrackResponse>, 3089 3089 - tonic::Status, 3090 3090 - >; 2643 2643 + ) -> std::result::Result<tonic::Response<super::NextTrackResponse>, tonic::Status>; 3091 2644 async fn flush_and_reload_tracks( 3092 2645 &self, 3093 2646 request: tonic::Request<super::FlushAndReloadTracksRequest>, 3094 3094 - ) -> std::result::Result< 3095 3095 - tonic::Response<super::FlushAndReloadTracksResponse>, 3096 3096 - tonic::Status, 3097 3097 - >; 2647 2647 + ) -> std::result::Result<tonic::Response<super::FlushAndReloadTracksResponse>, tonic::Status>; 3098 2648 async fn get_file_position( 3099 2649 &self, 3100 2650 request: tonic::Request<super::GetFilePositionRequest>, 3101 3101 - ) -> std::result::Result< 3102 3102 - tonic::Response<super::GetFilePositionResponse>, 3103 3103 - tonic::Status, 3104 3104 - >; 2651 2651 + ) -> std::result::Result<tonic::Response<super::GetFilePositionResponse>, tonic::Status>; 3105 2652 async fn hard_stop( 3106 2653 &self, 3107 2654 request: tonic::Request<super::HardStopRequest>, 3108 3108 - ) -> std::result::Result< 3109 3109 - tonic::Response<super::HardStopResponse>, 3110 3110 - tonic::Status, 3111 3111 - >; 2655 2655 + ) -> std::result::Result<tonic::Response<super::HardStopResponse>, tonic::Status>; 3112 2656 async fn play_album( 3113 2657 &self, 3114 2658 request: tonic::Request<super::PlayAlbumRequest>, 3115 3115 - ) -> std::result::Result< 3116 3116 - tonic::Response<super::PlayAlbumResponse>, 3117 3117 - tonic::Status, 3118 3118 - >; 2659 2659 + ) -> std::result::Result<tonic::Response<super::PlayAlbumResponse>, tonic::Status>; 3119 2660 async fn play_artist_tracks( 3120 2661 &self, 3121 2662 request: tonic::Request<super::PlayArtistTracksRequest>, 3122 3122 - ) -> std::result::Result< 3123 3123 - tonic::Response<super::PlayArtistTracksResponse>, 3124 3124 - tonic::Status, 3125 3125 - >; 2663 2663 + ) -> std::result::Result<tonic::Response<super::PlayArtistTracksResponse>, tonic::Status>; 3126 2664 async fn play_playlist( 3127 2665 &self, 3128 2666 request: tonic::Request<super::PlayPlaylistRequest>, 3129 3129 - ) -> std::result::Result< 3130 3130 - tonic::Response<super::PlayPlaylistResponse>, 3131 3131 - tonic::Status, 3132 3132 - >; 2667 2667 + ) -> std::result::Result<tonic::Response<super::PlayPlaylistResponse>, tonic::Status>; 3133 2668 async fn play_directory( 3134 2669 &self, 3135 2670 request: tonic::Request<super::PlayDirectoryRequest>, 3136 3136 - ) -> std::result::Result< 3137 3137 - tonic::Response<super::PlayDirectoryResponse>, 3138 3138 - tonic::Status, 3139 3139 - >; 2671 2671 + ) -> std::result::Result<tonic::Response<super::PlayDirectoryResponse>, tonic::Status>; 3140 2672 async fn play_music_directory( 3141 2673 &self, 3142 2674 request: tonic::Request<super::PlayMusicDirectoryRequest>, 3143 3143 - ) -> std::result::Result< 3144 3144 - tonic::Response<super::PlayMusicDirectoryResponse>, 3145 3145 - tonic::Status, 3146 3146 - >; 2675 2675 + ) -> std::result::Result<tonic::Response<super::PlayMusicDirectoryResponse>, tonic::Status>; 3147 2676 async fn play_track( 3148 2677 &self, 3149 2678 request: tonic::Request<super::PlayTrackRequest>, 3150 3150 - ) -> std::result::Result< 3151 3151 - tonic::Response<super::PlayTrackResponse>, 3152 3152 - tonic::Status, 3153 3153 - >; 2679 2679 + ) -> std::result::Result<tonic::Response<super::PlayTrackResponse>, tonic::Status>; 3154 2680 async fn play_liked_tracks( 3155 2681 &self, 3156 2682 request: tonic::Request<super::PlayLikedTracksRequest>, 3157 3157 - ) -> std::result::Result< 3158 3158 - tonic::Response<super::PlayLikedTracksResponse>, 3159 3159 - tonic::Status, 3160 3160 - >; 2683 2683 + ) -> std::result::Result<tonic::Response<super::PlayLikedTracksResponse>, tonic::Status>; 3161 2684 async fn play_all_tracks( 3162 2685 &self, 3163 2686 request: tonic::Request<super::PlayAllTracksRequest>, 3164 3164 - ) -> std::result::Result< 3165 3165 - tonic::Response<super::PlayAllTracksResponse>, 3166 3166 - tonic::Status, 3167 3167 - >; 2687 2687 + ) -> std::result::Result<tonic::Response<super::PlayAllTracksResponse>, tonic::Status>; 3168 2688 /// Server streaming response type for the StreamCurrentTrack method. 3169 2689 type StreamCurrentTrackStream: tonic::codegen::tokio_stream::Stream< 3170 2690 Item = std::result::Result<super::CurrentTrackResponse, tonic::Status>, 3171 3171 - > 3172 3172 - + std::marker::Send 2691 2691 + > + std::marker::Send 3173 2692 + 'static; 3174 2693 async fn stream_current_track( 3175 2694 &self, 3176 2695 request: tonic::Request<super::StreamCurrentTrackRequest>, 3177 3177 - ) -> std::result::Result< 3178 3178 - tonic::Response<Self::StreamCurrentTrackStream>, 3179 3179 - tonic::Status, 3180 3180 - >; 2696 2696 + ) -> std::result::Result<tonic::Response<Self::StreamCurrentTrackStream>, tonic::Status>; 3181 2697 /// Server streaming response type for the StreamStatus method. 3182 2698 type StreamStatusStream: tonic::codegen::tokio_stream::Stream< 3183 2699 Item = std::result::Result<super::StatusResponse, tonic::Status>, 3184 3184 - > 3185 3185 - + std::marker::Send 2700 2700 + > + std::marker::Send 3186 2701 + 'static; 3187 2702 async fn stream_status( 3188 2703 &self, 3189 2704 request: tonic::Request<super::StreamStatusRequest>, 3190 3190 - ) -> std::result::Result< 3191 3191 - tonic::Response<Self::StreamStatusStream>, 3192 3192 - tonic::Status, 3193 3193 - >; 2705 2705 + ) -> std::result::Result<tonic::Response<Self::StreamStatusStream>, tonic::Status>; 3194 2706 /// Server streaming response type for the StreamPlaylist method. 3195 2707 type StreamPlaylistStream: tonic::codegen::tokio_stream::Stream< 3196 2708 Item = std::result::Result<super::PlaylistResponse, tonic::Status>, 3197 3197 - > 3198 3198 - + std::marker::Send 2709 2709 + > + std::marker::Send 3199 2710 + 'static; 3200 2711 async fn stream_playlist( 3201 2712 &self, 3202 2713 request: tonic::Request<super::StreamPlaylistRequest>, 3203 3203 - ) -> std::result::Result< 3204 3204 - tonic::Response<Self::StreamPlaylistStream>, 3205 3205 - tonic::Status, 3206 3206 - >; 2714 2714 + ) -> std::result::Result<tonic::Response<Self::StreamPlaylistStream>, tonic::Status>; 3207 2715 } 3208 2716 #[derive(Debug)] 3209 2717 pub struct PlaybackServiceServer<T> { ··· 3226 2734 max_encoding_message_size: None, 3227 2735 } 3228 2736 } 3229 3229 - pub fn with_interceptor<F>( 3230 3230 - inner: T, 3231 3231 - interceptor: F, 3232 3232 - ) -> InterceptedService<Self, F> 2737 2737 + pub fn with_interceptor<F>(inner: T, interceptor: F) -> InterceptedService<Self, F> 3233 2738 where 3234 2739 F: tonic::service::Interceptor, 3235 2740 { ··· 3284 2789 "/rockbox.v1alpha1.PlaybackService/Play" => { 3285 2790 #[allow(non_camel_case_types)] 3286 2791 struct PlaySvc<T: PlaybackService>(pub Arc<T>); 3287 3287 - impl< 3288 3288 - T: PlaybackService, 3289 3289 - > tonic::server::UnaryService<super::PlayRequest> for PlaySvc<T> { 2792 2792 + impl<T: PlaybackService> tonic::server::UnaryService<super::PlayRequest> for PlaySvc<T> { 3290 2793 type Response = super::PlayResponse; 3291 3291 - type Future = BoxFuture< 3292 3292 - tonic::Response<Self::Response>, 3293 3293 - tonic::Status, 3294 3294 - >; 2794 2794 + type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 3295 2795 fn call( 3296 2796 &mut self, 3297 2797 request: tonic::Request<super::PlayRequest>, 3298 2798 ) -> Self::Future { 3299 2799 let inner = Arc::clone(&self.0); 3300 3300 - let fut = async move { 3301 3301 - <T as PlaybackService>::play(&inner, request).await 3302 3302 - }; 2800 2800 + let fut = 2801 2801 + async move { <T as PlaybackService>::play(&inner, request).await }; 3303 2802 Box::pin(fut) 3304 2803 } 3305 2804 } ··· 3328 2827 "/rockbox.v1alpha1.PlaybackService/Pause" => { 3329 2828 #[allow(non_camel_case_types)] 3330 2829 struct PauseSvc<T: PlaybackService>(pub Arc<T>); 3331 3331 - impl< 3332 3332 - T: PlaybackService, 3333 3333 - > tonic::server::UnaryService<super::PauseRequest> for PauseSvc<T> { 2830 2830 + impl<T: PlaybackService> tonic::server::UnaryService<super::PauseRequest> for PauseSvc<T> { 3334 2831 type Response = super::PauseResponse; 3335 3335 - type Future = BoxFuture< 3336 3336 - tonic::Response<Self::Response>, 3337 3337 - tonic::Status, 3338 3338 - >; 2832 2832 + type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 3339 2833 fn call( 3340 2834 &mut self, 3341 2835 request: tonic::Request<super::PauseRequest>, 3342 2836 ) -> Self::Future { 3343 2837 let inner = Arc::clone(&self.0); 3344 3344 - let fut = async move { 3345 3345 - <T as PlaybackService>::pause(&inner, request).await 3346 3346 - }; 2838 2838 + let fut = 2839 2839 + async move { <T as PlaybackService>::pause(&inner, request).await }; 3347 2840 Box::pin(fut) 3348 2841 } 3349 2842 } ··· 3372 2865 "/rockbox.v1alpha1.PlaybackService/PlayOrPause" => { 3373 2866 #[allow(non_camel_case_types)] 3374 2867 struct PlayOrPauseSvc<T: PlaybackService>(pub Arc<T>); 3375 3375 - impl< 3376 3376 - T: PlaybackService, 3377 3377 - > tonic::server::UnaryService<super::PlayOrPauseRequest> 3378 3378 - for PlayOrPauseSvc<T> { 2868 2868 + impl<T: PlaybackService> tonic::server::UnaryService<super::PlayOrPauseRequest> 2869 2869 + for PlayOrPauseSvc<T> 2870 2870 + { 3379 2871 type Response = super::PlayOrPauseResponse; 3380 3380 - type Future = BoxFuture< 3381 3381 - tonic::Response<Self::Response>, 3382 3382 - tonic::Status, 3383 3383 - >; 2872 2872 + type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 3384 2873 fn call( 3385 2874 &mut self, 3386 2875 request: tonic::Request<super::PlayOrPauseRequest>, ··· 3417 2906 "/rockbox.v1alpha1.PlaybackService/Resume" => { 3418 2907 #[allow(non_camel_case_types)] 3419 2908 struct ResumeSvc<T: PlaybackService>(pub Arc<T>); 3420 3420 - impl< 3421 3421 - T: PlaybackService, 3422 3422 - > tonic::server::UnaryService<super::ResumeRequest> 3423 3423 - for ResumeSvc<T> { 2909 2909 + impl<T: PlaybackService> tonic::server::UnaryService<super::ResumeRequest> for ResumeSvc<T> { 3424 2910 type Response = super::ResumeResponse; 3425 3425 - type Future = BoxFuture< 3426 3426 - tonic::Response<Self::Response>, 3427 3427 - tonic::Status, 3428 3428 - >; 2911 2911 + type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 3429 2912 fn call( 3430 2913 &mut self, 3431 2914 request: tonic::Request<super::ResumeRequest>, ··· 3462 2945 "/rockbox.v1alpha1.PlaybackService/Next" => { 3463 2946 #[allow(non_camel_case_types)] 3464 2947 struct NextSvc<T: PlaybackService>(pub Arc<T>); 3465 3465 - impl< 3466 3466 - T: PlaybackService, 3467 3467 - > tonic::server::UnaryService<super::NextRequest> for NextSvc<T> { 2948 2948 + impl<T: PlaybackService> tonic::server::UnaryService<super::NextRequest> for NextSvc<T> { 3468 2949 type Response = super::NextResponse; 3469 3469 - type Future = BoxFuture< 3470 3470 - tonic::Response<Self::Response>, 3471 3471 - tonic::Status, 3472 3472 - >; 2950 2950 + type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 3473 2951 fn call( 3474 2952 &mut self, 3475 2953 request: tonic::Request<super::NextRequest>, 3476 2954 ) -> Self::Future { 3477 2955 let inner = Arc::clone(&self.0); 3478 3478 - let fut = async move { 3479 3479 - <T as PlaybackService>::next(&inner, request).await 3480 3480 - }; 2956 2956 + let fut = 2957 2957 + async move { <T as PlaybackService>::next(&inner, request).await }; 3481 2958 Box::pin(fut) 3482 2959 } 3483 2960 } ··· 3506 2983 "/rockbox.v1alpha1.PlaybackService/Previous" => { 3507 2984 #[allow(non_camel_case_types)] 3508 2985 struct PreviousSvc<T: PlaybackService>(pub Arc<T>); 3509 3509 - impl< 3510 3510 - T: PlaybackService, 3511 3511 - > tonic::server::UnaryService<super::PreviousRequest> 3512 3512 - for PreviousSvc<T> { 2986 2986 + impl<T: PlaybackService> tonic::server::UnaryService<super::PreviousRequest> for PreviousSvc<T> { 3513 2987 type Response = super::PreviousResponse; 3514 3514 - type Future = BoxFuture< 3515 3515 - tonic::Response<Self::Response>, 3516 3516 - tonic::Status, 3517 3517 - >; 2988 2988 + type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 3518 2989 fn call( 3519 2990 &mut self, 3520 2991 request: tonic::Request<super::PreviousRequest>, ··· 3551 3022 "/rockbox.v1alpha1.PlaybackService/FastForwardRewind" => { 3552 3023 #[allow(non_camel_case_types)] 3553 3024 struct FastForwardRewindSvc<T: PlaybackService>(pub Arc<T>); 3554 3554 - impl< 3555 3555 - T: PlaybackService, 3556 3556 - > tonic::server::UnaryService<super::FastForwardRewindRequest> 3557 3557 - for FastForwardRewindSvc<T> { 3025 3025 + impl<T: PlaybackService> 3026 3026 + tonic::server::UnaryService<super::FastForwardRewindRequest> 3027 3027 + for FastForwardRewindSvc<T> 3028 3028 + { 3558 3029 type Response = super::FastForwardRewindResponse; 3559 3559 - type Future = BoxFuture< 3560 3560 - tonic::Response<Self::Response>, 3561 3561 - tonic::Status, 3562 3562 - >; 3030 3030 + type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 3563 3031 fn call( 3564 3032 &mut self, 3565 3033 request: tonic::Request<super::FastForwardRewindRequest>, 3566 3034 ) -> Self::Future { 3567 3035 let inner = Arc::clone(&self.0); 3568 3036 let fut = async move { 3569 3569 - <T as PlaybackService>::fast_forward_rewind(&inner, request) 3570 3570 - .await 3037 3037 + <T as PlaybackService>::fast_forward_rewind(&inner, request).await 3571 3038 }; 3572 3039 Box::pin(fut) 3573 3040 } ··· 3597 3064 "/rockbox.v1alpha1.PlaybackService/Status" => { 3598 3065 #[allow(non_camel_case_types)] 3599 3066 struct StatusSvc<T: PlaybackService>(pub Arc<T>); 3600 3600 - impl< 3601 3601 - T: PlaybackService, 3602 3602 - > tonic::server::UnaryService<super::StatusRequest> 3603 3603 - for StatusSvc<T> { 3067 3067 + impl<T: PlaybackService> tonic::server::UnaryService<super::StatusRequest> for StatusSvc<T> { 3604 3068 type Response = super::StatusResponse; 3605 3605 - type Future = BoxFuture< 3606 3606 - tonic::Response<Self::Response>, 3607 3607 - tonic::Status, 3608 3608 - >; 3069 3069 + type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 3609 3070 fn call( 3610 3071 &mut self, 3611 3072 request: tonic::Request<super::StatusRequest>, ··· 3642 3103 "/rockbox.v1alpha1.PlaybackService/CurrentTrack" => { 3643 3104 #[allow(non_camel_case_types)] 3644 3105 struct CurrentTrackSvc<T: PlaybackService>(pub Arc<T>); 3645 3645 - impl< 3646 3646 - T: PlaybackService, 3647 3647 - > tonic::server::UnaryService<super::CurrentTrackRequest> 3648 3648 - for CurrentTrackSvc<T> { 3106 3106 + impl<T: PlaybackService> tonic::server::UnaryService<super::CurrentTrackRequest> 3107 3107 + for CurrentTrackSvc<T> 3108 3108 + { 3649 3109 type Response = super::CurrentTrackResponse; 3650 3650 - type Future = BoxFuture< 3651 3651 - tonic::Response<Self::Response>, 3652 3652 - tonic::Status, 3653 3653 - >; 3110 3110 + type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 3654 3111 fn call( 3655 3112 &mut self, 3656 3113 request: tonic::Request<super::CurrentTrackRequest>, ··· 3687 3144 "/rockbox.v1alpha1.PlaybackService/NextTrack" => { 3688 3145 #[allow(non_camel_case_types)] 3689 3146 struct NextTrackSvc<T: PlaybackService>(pub Arc<T>); 3690 3690 - impl< 3691 3691 - T: PlaybackService, 3692 3692 - > tonic::server::UnaryService<super::NextTrackRequest> 3693 3693 - for NextTrackSvc<T> { 3147 3147 + impl<T: PlaybackService> tonic::server::UnaryService<super::NextTrackRequest> for NextTrackSvc<T> { 3694 3148 type Response = super::NextTrackResponse; 3695 3695 - type Future = BoxFuture< 3696 3696 - tonic::Response<Self::Response>, 3697 3697 - tonic::Status, 3698 3698 - >; 3149 3149 + type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 3699 3150 fn call( 3700 3151 &mut self, 3701 3152 request: tonic::Request<super::NextTrackRequest>, ··· 3732 3183 "/rockbox.v1alpha1.PlaybackService/FlushAndReloadTracks" => { 3733 3184 #[allow(non_camel_case_types)] 3734 3185 struct FlushAndReloadTracksSvc<T: PlaybackService>(pub Arc<T>); 3735 3735 - impl< 3736 3736 - T: PlaybackService, 3737 3737 - > tonic::server::UnaryService<super::FlushAndReloadTracksRequest> 3738 3738 - for FlushAndReloadTracksSvc<T> { 3186 3186 + impl<T: PlaybackService> 3187 3187 + tonic::server::UnaryService<super::FlushAndReloadTracksRequest> 3188 3188 + for FlushAndReloadTracksSvc<T> 3189 3189 + { 3739 3190 type Response = super::FlushAndReloadTracksResponse; 3740 3740 - type Future = BoxFuture< 3741 3741 - tonic::Response<Self::Response>, 3742 3742 - tonic::Status, 3743 3743 - >; 3191 3191 + type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 3744 3192 fn call( 3745 3193 &mut self, 3746 3194 request: tonic::Request<super::FlushAndReloadTracksRequest>, 3747 3195 ) -> Self::Future { 3748 3196 let inner = Arc::clone(&self.0); 3749 3197 let fut = async move { 3750 3750 - <T as PlaybackService>::flush_and_reload_tracks( 3751 3751 - &inner, 3752 3752 - request, 3753 3753 - ) 3198 3198 + <T as PlaybackService>::flush_and_reload_tracks(&inner, request) 3754 3199 .await 3755 3200 }; 3756 3201 Box::pin(fut) ··· 3781 3226 "/rockbox.v1alpha1.PlaybackService/GetFilePosition" => { 3782 3227 #[allow(non_camel_case_types)] 3783 3228 struct GetFilePositionSvc<T: PlaybackService>(pub Arc<T>); 3784 3784 - impl< 3785 3785 - T: PlaybackService, 3786 3786 - > tonic::server::UnaryService<super::GetFilePositionRequest> 3787 3787 - for GetFilePositionSvc<T> { 3229 3229 + impl<T: PlaybackService> 3230 3230 + tonic::server::UnaryService<super::GetFilePositionRequest> 3231 3231 + for GetFilePositionSvc<T> 3232 3232 + { 3788 3233 type Response = super::GetFilePositionResponse; 3789 3789 - type Future = BoxFuture< 3790 3790 - tonic::Response<Self::Response>, 3791 3791 - tonic::Status, 3792 3792 - >; 3234 3234 + type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 3793 3235 fn call( 3794 3236 &mut self, 3795 3237 request: tonic::Request<super::GetFilePositionRequest>, 3796 3238 ) -> Self::Future { 3797 3239 let inner = Arc::clone(&self.0); 3798 3240 let fut = async move { 3799 3799 - <T as PlaybackService>::get_file_position(&inner, request) 3800 3800 - .await 3241 3241 + <T as PlaybackService>::get_file_position(&inner, request).await 3801 3242 }; 3802 3243 Box::pin(fut) 3803 3244 } ··· 3827 3268 "/rockbox.v1alpha1.PlaybackService/HardStop" => { 3828 3269 #[allow(non_camel_case_types)] 3829 3270 struct HardStopSvc<T: PlaybackService>(pub Arc<T>); 3830 3830 - impl< 3831 3831 - T: PlaybackService, 3832 3832 - > tonic::server::UnaryService<super::HardStopRequest> 3833 3833 - for HardStopSvc<T> { 3271 3271 + impl<T: PlaybackService> tonic::server::UnaryService<super::HardStopRequest> for HardStopSvc<T> { 3834 3272 type Response = super::HardStopResponse; 3835 3835 - type Future = BoxFuture< 3836 3836 - tonic::Response<Self::Response>, 3837 3837 - tonic::Status, 3838 3838 - >; 3273 3273 + type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 3839 3274 fn call( 3840 3275 &mut self, 3841 3276 request: tonic::Request<super::HardStopRequest>, ··· 3872 3307 "/rockbox.v1alpha1.PlaybackService/PlayAlbum" => { 3873 3308 #[allow(non_camel_case_types)] 3874 3309 struct PlayAlbumSvc<T: PlaybackService>(pub Arc<T>); 3875 3875 - impl< 3876 3876 - T: PlaybackService, 3877 3877 - > tonic::server::UnaryService<super::PlayAlbumRequest> 3878 3878 - for PlayAlbumSvc<T> { 3310 3310 + impl<T: PlaybackService> tonic::server::UnaryService<super::PlayAlbumRequest> for PlayAlbumSvc<T> { 3879 3311 type Response = super::PlayAlbumResponse; 3880 3880 - type Future = BoxFuture< 3881 3881 - tonic::Response<Self::Response>, 3882 3882 - tonic::Status, 3883 3883 - >; 3312 3312 + type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 3884 3313 fn call( 3885 3314 &mut self, 3886 3315 request: tonic::Request<super::PlayAlbumRequest>, ··· 3917 3346 "/rockbox.v1alpha1.PlaybackService/PlayArtistTracks" => { 3918 3347 #[allow(non_camel_case_types)] 3919 3348 struct PlayArtistTracksSvc<T: PlaybackService>(pub Arc<T>); 3920 3920 - impl< 3921 3921 - T: PlaybackService, 3922 3922 - > tonic::server::UnaryService<super::PlayArtistTracksRequest> 3923 3923 - for PlayArtistTracksSvc<T> { 3349 3349 + impl<T: PlaybackService> 3350 3350 + tonic::server::UnaryService<super::PlayArtistTracksRequest> 3351 3351 + for PlayArtistTracksSvc<T> 3352 3352 + { 3924 3353 type Response = super::PlayArtistTracksResponse; 3925 3925 - type Future = BoxFuture< 3926 3926 - tonic::Response<Self::Response>, 3927 3927 - tonic::Status, 3928 3928 - >; 3354 3354 + type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 3929 3355 fn call( 3930 3356 &mut self, 3931 3357 request: tonic::Request<super::PlayArtistTracksRequest>, 3932 3358 ) -> Self::Future { 3933 3359 let inner = Arc::clone(&self.0); 3934 3360 let fut = async move { 3935 3935 - <T as PlaybackService>::play_artist_tracks(&inner, request) 3936 3936 - .await 3361 3361 + <T as PlaybackService>::play_artist_tracks(&inner, request).await 3937 3362 }; 3938 3363 Box::pin(fut) 3939 3364 } ··· 3963 3388 "/rockbox.v1alpha1.PlaybackService/PlayPlaylist" => { 3964 3389 #[allow(non_camel_case_types)] 3965 3390 struct PlayPlaylistSvc<T: PlaybackService>(pub Arc<T>); 3966 3966 - impl< 3967 3967 - T: PlaybackService, 3968 3968 - > tonic::server::UnaryService<super::PlayPlaylistRequest> 3969 3969 - for PlayPlaylistSvc<T> { 3391 3391 + impl<T: PlaybackService> tonic::server::UnaryService<super::PlayPlaylistRequest> 3392 3392 + for PlayPlaylistSvc<T> 3393 3393 + { 3970 3394 type Response = super::PlayPlaylistResponse; 3971 3971 - type Future = BoxFuture< 3972 3972 - tonic::Response<Self::Response>, 3973 3973 - tonic::Status, 3974 3974 - >; 3395 3395 + type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 3975 3396 fn call( 3976 3397 &mut self, 3977 3398 request: tonic::Request<super::PlayPlaylistRequest>, ··· 4008 3429 "/rockbox.v1alpha1.PlaybackService/PlayDirectory" => { 4009 3430 #[allow(non_camel_case_types)] 4010 3431 struct PlayDirectorySvc<T: PlaybackService>(pub Arc<T>); 4011 4011 - impl< 4012 4012 - T: PlaybackService, 4013 4013 - > tonic::server::UnaryService<super::PlayDirectoryRequest> 4014 4014 - for PlayDirectorySvc<T> { 3432 3432 + impl<T: PlaybackService> 3433 3433 + tonic::server::UnaryService<super::PlayDirectoryRequest> 3434 3434 + for PlayDirectorySvc<T> 3435 3435 + { 4015 3436 type Response = super::PlayDirectoryResponse; 4016 4016 - type Future = BoxFuture< 4017 4017 - tonic::Response<Self::Response>, 4018 4018 - tonic::Status, 4019 4019 - >; 3437 3437 + type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 4020 3438 fn call( 4021 3439 &mut self, 4022 3440 request: tonic::Request<super::PlayDirectoryRequest>, 4023 3441 ) -> Self::Future { 4024 3442 let inner = Arc::clone(&self.0); 4025 3443 let fut = async move { 4026 4026 - <T as PlaybackService>::play_directory(&inner, request) 4027 4027 - .await 3444 3444 + <T as PlaybackService>::play_directory(&inner, request).await 4028 3445 }; 4029 3446 Box::pin(fut) 4030 3447 } ··· 4054 3471 "/rockbox.v1alpha1.PlaybackService/PlayMusicDirectory" => { 4055 3472 #[allow(non_camel_case_types)] 4056 3473 struct PlayMusicDirectorySvc<T: PlaybackService>(pub Arc<T>); 4057 4057 - impl< 4058 4058 - T: PlaybackService, 4059 4059 - > tonic::server::UnaryService<super::PlayMusicDirectoryRequest> 4060 4060 - for PlayMusicDirectorySvc<T> { 3474 3474 + impl<T: PlaybackService> 3475 3475 + tonic::server::UnaryService<super::PlayMusicDirectoryRequest> 3476 3476 + for PlayMusicDirectorySvc<T> 3477 3477 + { 4061 3478 type Response = super::PlayMusicDirectoryResponse; 4062 4062 - type Future = BoxFuture< 4063 4063 - tonic::Response<Self::Response>, 4064 4064 - tonic::Status, 4065 4065 - >; 3479 3479 + type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 4066 3480 fn call( 4067 3481 &mut self, 4068 3482 request: tonic::Request<super::PlayMusicDirectoryRequest>, 4069 3483 ) -> Self::Future { 4070 3484 let inner = Arc::clone(&self.0); 4071 3485 let fut = async move { 4072 4072 - <T as PlaybackService>::play_music_directory( 4073 4073 - &inner, 4074 4074 - request, 4075 4075 - ) 4076 4076 - .await 3486 3486 + <T as PlaybackService>::play_music_directory(&inner, request).await 4077 3487 }; 4078 3488 Box::pin(fut) 4079 3489 } ··· 4103 3513 "/rockbox.v1alpha1.PlaybackService/PlayTrack" => { 4104 3514 #[allow(non_camel_case_types)] 4105 3515 struct PlayTrackSvc<T: PlaybackService>(pub Arc<T>); 4106 4106 - impl< 4107 4107 - T: PlaybackService, 4108 4108 - > tonic::server::UnaryService<super::PlayTrackRequest> 4109 4109 - for PlayTrackSvc<T> { 3516 3516 + impl<T: PlaybackService> tonic::server::UnaryService<super::PlayTrackRequest> for PlayTrackSvc<T> { 4110 3517 type Response = super::PlayTrackResponse; 4111 4111 - type Future = BoxFuture< 4112 4112 - tonic::Response<Self::Response>, 4113 4113 - tonic::Status, 4114 4114 - >; 3518 3518 + type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 4115 3519 fn call( 4116 3520 &mut self, 4117 3521 request: tonic::Request<super::PlayTrackRequest>, ··· 4148 3552 "/rockbox.v1alpha1.PlaybackService/PlayLikedTracks" => { 4149 3553 #[allow(non_camel_case_types)] 4150 3554 struct PlayLikedTracksSvc<T: PlaybackService>(pub Arc<T>); 4151 4151 - impl< 4152 4152 - T: PlaybackService, 4153 4153 - > tonic::server::UnaryService<super::PlayLikedTracksRequest> 4154 4154 - for PlayLikedTracksSvc<T> { 3555 3555 + impl<T: PlaybackService> 3556 3556 + tonic::server::UnaryService<super::PlayLikedTracksRequest> 3557 3557 + for PlayLikedTracksSvc<T> 3558 3558 + { 4155 3559 type Response = super::PlayLikedTracksResponse; 4156 4156 - type Future = BoxFuture< 4157 4157 - tonic::Response<Self::Response>, 4158 4158 - tonic::Status, 4159 4159 - >; 3560 3560 + type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 4160 3561 fn call( 4161 3562 &mut self, 4162 3563 request: tonic::Request<super::PlayLikedTracksRequest>, 4163 3564 ) -> Self::Future { 4164 3565 let inner = Arc::clone(&self.0); 4165 3566 let fut = async move { 4166 4166 - <T as PlaybackService>::play_liked_tracks(&inner, request) 4167 4167 - .await 3567 3567 + <T as PlaybackService>::play_liked_tracks(&inner, request).await 4168 3568 }; 4169 3569 Box::pin(fut) 4170 3570 } ··· 4194 3594 "/rockbox.v1alpha1.PlaybackService/PlayAllTracks" => { 4195 3595 #[allow(non_camel_case_types)] 4196 3596 struct PlayAllTracksSvc<T: PlaybackService>(pub Arc<T>); 4197 4197 - impl< 4198 4198 - T: PlaybackService, 4199 4199 - > tonic::server::UnaryService<super::PlayAllTracksRequest> 4200 4200 - for PlayAllTracksSvc<T> { 3597 3597 + impl<T: PlaybackService> 3598 3598 + tonic::server::UnaryService<super::PlayAllTracksRequest> 3599 3599 + for PlayAllTracksSvc<T> 3600 3600 + { 4201 3601 type Response = super::PlayAllTracksResponse; 4202 4202 - type Future = BoxFuture< 4203 4203 - tonic::Response<Self::Response>, 4204 4204 - tonic::Status, 4205 4205 - >; 3602 3602 + type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 4206 3603 fn call( 4207 3604 &mut self, 4208 3605 request: tonic::Request<super::PlayAllTracksRequest>, 4209 3606 ) -> Self::Future { 4210 3607 let inner = Arc::clone(&self.0); 4211 3608 let fut = async move { 4212 4212 - <T as PlaybackService>::play_all_tracks(&inner, request) 4213 4213 - .await 3609 3609 + <T as PlaybackService>::play_all_tracks(&inner, request).await 4214 3610 }; 4215 3611 Box::pin(fut) 4216 3612 } ··· 4240 3636 "/rockbox.v1alpha1.PlaybackService/StreamCurrentTrack" => { 4241 3637 #[allow(non_camel_case_types)] 4242 3638 struct StreamCurrentTrackSvc<T: PlaybackService>(pub Arc<T>); 4243 4243 - impl< 4244 4244 - T: PlaybackService, 4245 4245 - > tonic::server::ServerStreamingService< 4246 4246 - super::StreamCurrentTrackRequest, 4247 4247 - > for StreamCurrentTrackSvc<T> { 3639 3639 + impl<T: PlaybackService> 3640 3640 + tonic::server::ServerStreamingService<super::StreamCurrentTrackRequest> 3641 3641 + for StreamCurrentTrackSvc<T> 3642 3642 + { 4248 3643 type Response = super::CurrentTrackResponse; 4249 3644 type ResponseStream = T::StreamCurrentTrackStream; 4250 4250 - type Future = BoxFuture< 4251 4251 - tonic::Response<Self::ResponseStream>, 4252 4252 - tonic::Status, 4253 4253 - >; 3645 3645 + type Future = 3646 3646 + BoxFuture<tonic::Response<Self::ResponseStream>, tonic::Status>; 4254 3647 fn call( 4255 3648 &mut self, 4256 3649 request: tonic::Request<super::StreamCurrentTrackRequest>, 4257 3650 ) -> Self::Future { 4258 3651 let inner = Arc::clone(&self.0); 4259 3652 let fut = async move { 4260 4260 - <T as PlaybackService>::stream_current_track( 4261 4261 - &inner, 4262 4262 - request, 4263 4263 - ) 4264 4264 - .await 3653 3653 + <T as PlaybackService>::stream_current_track(&inner, request).await 4265 3654 }; 4266 3655 Box::pin(fut) 4267 3656 } ··· 4291 3680 "/rockbox.v1alpha1.PlaybackService/StreamStatus" => { 4292 3681 #[allow(non_camel_case_types)] 4293 3682 struct StreamStatusSvc<T: PlaybackService>(pub Arc<T>); 4294 4294 - impl< 4295 4295 - T: PlaybackService, 4296 4296 - > tonic::server::ServerStreamingService<super::StreamStatusRequest> 4297 4297 - for StreamStatusSvc<T> { 3683 3683 + impl<T: PlaybackService> 3684 3684 + tonic::server::ServerStreamingService<super::StreamStatusRequest> 3685 3685 + for StreamStatusSvc<T> 3686 3686 + { 4298 3687 type Response = super::StatusResponse; 4299 3688 type ResponseStream = T::StreamStatusStream; 4300 4300 - type Future = BoxFuture< 4301 4301 - tonic::Response<Self::ResponseStream>, 4302 4302 - tonic::Status, 4303 4303 - >; 3689 3689 + type Future = 3690 3690 + BoxFuture<tonic::Response<Self::ResponseStream>, tonic::Status>; 4304 3691 fn call( 4305 3692 &mut self, 4306 3693 request: tonic::Request<super::StreamStatusRequest>, ··· 4337 3724 "/rockbox.v1alpha1.PlaybackService/StreamPlaylist" => { 4338 3725 #[allow(non_camel_case_types)] 4339 3726 struct StreamPlaylistSvc<T: PlaybackService>(pub Arc<T>); 4340 4340 - impl< 4341 4341 - T: PlaybackService, 4342 4342 - > tonic::server::ServerStreamingService<super::StreamPlaylistRequest> 4343 4343 - for StreamPlaylistSvc<T> { 3727 3727 + impl<T: PlaybackService> 3728 3728 + tonic::server::ServerStreamingService<super::StreamPlaylistRequest> 3729 3729 + for StreamPlaylistSvc<T> 3730 3730 + { 4344 3731 type Response = super::PlaylistResponse; 4345 3732 type ResponseStream = T::StreamPlaylistStream; 4346 4346 - type Future = BoxFuture< 4347 4347 - tonic::Response<Self::ResponseStream>, 4348 4348 - tonic::Status, 4349 4349 - >; 3733 3733 + type Future = 3734 3734 + BoxFuture<tonic::Response<Self::ResponseStream>, tonic::Status>; 4350 3735 fn call( 4351 3736 &mut self, 4352 3737 request: tonic::Request<super::StreamPlaylistRequest>, 4353 3738 ) -> Self::Future { 4354 3739 let inner = Arc::clone(&self.0); 4355 3740 let fut = async move { 4356 4356 - <T as PlaybackService>::stream_playlist(&inner, request) 4357 4357 - .await 3741 3741 + <T as PlaybackService>::stream_playlist(&inner, request).await 4358 3742 }; 4359 3743 Box::pin(fut) 4360 3744 } ··· 4381 3765 }; 4382 3766 Box::pin(fut) 4383 3767 } 4384 4384 - _ => { 4385 4385 - Box::pin(async move { 4386 4386 - let mut response = http::Response::new(empty_body()); 4387 4387 - let headers = response.headers_mut(); 4388 4388 - headers 4389 4389 - .insert( 4390 4390 - tonic::Status::GRPC_STATUS, 4391 4391 - (tonic::Code::Unimplemented as i32).into(), 4392 4392 - ); 4393 4393 - headers 4394 4394 - .insert( 4395 4395 - http::header::CONTENT_TYPE, 4396 4396 - tonic::metadata::GRPC_CONTENT_TYPE, 4397 4397 - ); 4398 4398 - Ok(response) 4399 4399 - }) 4400 4400 - } 3768 3768 + _ => Box::pin(async move { 3769 3769 + let mut response = http::Response::new(empty_body()); 3770 3770 + let headers = response.headers_mut(); 3771 3771 + headers.insert( 3772 3772 + tonic::Status::GRPC_STATUS, 3773 3773 + (tonic::Code::Unimplemented as i32).into(), 3774 3774 + ); 3775 3775 + headers.insert( 3776 3776 + http::header::CONTENT_TYPE, 3777 3777 + tonic::metadata::GRPC_CONTENT_TYPE, 3778 3778 + ); 3779 3779 + Ok(response) 3780 3780 + }), 4401 3781 } 4402 3782 } 4403 3783 } ··· 4604 3984 dead_code, 4605 3985 missing_docs, 4606 3986 clippy::wildcard_imports, 4607 4607 - clippy::let_unit_value, 3987 3987 + clippy::let_unit_value 4608 3988 )] 4609 4609 - use tonic::codegen::*; 4610 3989 use tonic::codegen::http::Uri; 3990 3990 + use tonic::codegen::*; 4611 3991 #[derive(Debug, Clone)] 4612 3992 pub struct PlaylistServiceClient<T> { 4613 3993 inner: tonic::client::Grpc<T>, ··· 4651 4031 <T as tonic::client::GrpcService<tonic::body::BoxBody>>::ResponseBody, 4652 4032 >, 4653 4033 >, 4654 4654 - <T as tonic::codegen::Service< 4655 4655 - http::Request<tonic::body::BoxBody>, 4656 4656 - >>::Error: Into<StdError> + std::marker::Send + std::marker::Sync, 4034 4034 + <T as tonic::codegen::Service<http::Request<tonic::body::BoxBody>>>::Error: 4035 4035 + Into<StdError> + std::marker::Send + std::marker::Sync, 4657 4036 { 4658 4037 PlaylistServiceClient::new(InterceptedService::new(inner, interceptor)) 4659 4038 } ··· 4691 4070 pub async fn get_current( 4692 4071 &mut self, 4693 4072 request: impl tonic::IntoRequest<super::GetCurrentRequest>, 4694 4694 - ) -> std::result::Result< 4695 4695 - tonic::Response<super::GetCurrentResponse>, 4696 4696 - tonic::Status, 4697 4697 - > { 4698 4698 - self.inner 4699 4699 - .ready() 4700 4700 - .await 4701 4701 - .map_err(|e| { 4702 4702 - tonic::Status::unknown( 4703 4703 - format!("Service was not ready: {}", e.into()), 4704 4704 - ) 4705 4705 - })?; 4073 4073 + ) -> std::result::Result<tonic::Response<super::GetCurrentResponse>, tonic::Status> 4074 4074 + { 4075 4075 + self.inner.ready().await.map_err(|e| { 4076 4076 + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 4077 4077 + })?; 4706 4078 let codec = tonic::codec::ProstCodec::default(); 4707 4079 let path = http::uri::PathAndQuery::from_static( 4708 4080 "/rockbox.v1alpha1.PlaylistService/GetCurrent", 4709 4081 ); 4710 4082 let mut req = request.into_request(); 4711 4711 - req.extensions_mut() 4712 4712 - .insert( 4713 4713 - GrpcMethod::new("rockbox.v1alpha1.PlaylistService", "GetCurrent"), 4714 4714 - ); 4083 4083 + req.extensions_mut().insert(GrpcMethod::new( 4084 4084 + "rockbox.v1alpha1.PlaylistService", 4085 4085 + "GetCurrent", 4086 4086 + )); 4715 4087 self.inner.unary(req, path, codec).await 4716 4088 } 4717 4089 pub async fn get_resume_info( 4718 4090 &mut self, 4719 4091 request: impl tonic::IntoRequest<super::GetResumeInfoRequest>, 4720 4720 - ) -> std::result::Result< 4721 4721 - tonic::Response<super::GetResumeInfoResponse>, 4722 4722 - tonic::Status, 4723 4723 - > { 4724 4724 - self.inner 4725 4725 - .ready() 4726 4726 - .await 4727 4727 - .map_err(|e| { 4728 4728 - tonic::Status::unknown( 4729 4729 - format!("Service was not ready: {}", e.into()), 4730 4730 - ) 4731 4731 - })?; 4092 4092 + ) -> std::result::Result<tonic::Response<super::GetResumeInfoResponse>, tonic::Status> 4093 4093 + { 4094 4094 + self.inner.ready().await.map_err(|e| { 4095 4095 + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 4096 4096 + })?; 4732 4097 let codec = tonic::codec::ProstCodec::default(); 4733 4098 let path = http::uri::PathAndQuery::from_static( 4734 4099 "/rockbox.v1alpha1.PlaylistService/GetResumeInfo", 4735 4100 ); 4736 4101 let mut req = request.into_request(); 4737 4737 - req.extensions_mut() 4738 4738 - .insert( 4739 4739 - GrpcMethod::new("rockbox.v1alpha1.PlaylistService", "GetResumeInfo"), 4740 4740 - ); 4102 4102 + req.extensions_mut().insert(GrpcMethod::new( 4103 4103 + "rockbox.v1alpha1.PlaylistService", 4104 4104 + "GetResumeInfo", 4105 4105 + )); 4741 4106 self.inner.unary(req, path, codec).await 4742 4107 } 4743 4108 pub async fn get_track_info( 4744 4109 &mut self, 4745 4110 request: impl tonic::IntoRequest<super::GetTrackInfoRequest>, 4746 4746 - ) -> std::result::Result< 4747 4747 - tonic::Response<super::GetTrackInfoResponse>, 4748 4748 - tonic::Status, 4749 4749 - > { 4750 4750 - self.inner 4751 4751 - .ready() 4752 4752 - .await 4753 4753 - .map_err(|e| { 4754 4754 - tonic::Status::unknown( 4755 4755 - format!("Service was not ready: {}", e.into()), 4756 4756 - ) 4757 4757 - })?; 4111 4111 + ) -> std::result::Result<tonic::Response<super::GetTrackInfoResponse>, tonic::Status> 4112 4112 + { 4113 4113 + self.inner.ready().await.map_err(|e| { 4114 4114 + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 4115 4115 + })?; 4758 4116 let codec = tonic::codec::ProstCodec::default(); 4759 4117 let path = http::uri::PathAndQuery::from_static( 4760 4118 "/rockbox.v1alpha1.PlaylistService/GetTrackInfo", 4761 4119 ); 4762 4120 let mut req = request.into_request(); 4763 4763 - req.extensions_mut() 4764 4764 - .insert( 4765 4765 - GrpcMethod::new("rockbox.v1alpha1.PlaylistService", "GetTrackInfo"), 4766 4766 - ); 4121 4121 + req.extensions_mut().insert(GrpcMethod::new( 4122 4122 + "rockbox.v1alpha1.PlaylistService", 4123 4123 + "GetTrackInfo", 4124 4124 + )); 4767 4125 self.inner.unary(req, path, codec).await 4768 4126 } 4769 4127 pub async fn get_first_index( 4770 4128 &mut self, 4771 4129 request: impl tonic::IntoRequest<super::GetFirstIndexRequest>, 4772 4772 - ) -> std::result::Result< 4773 4773 - tonic::Response<super::GetFirstIndexResponse>, 4774 4774 - tonic::Status, 4775 4775 - > { 4776 4776 - self.inner 4777 4777 - .ready() 4778 4778 - .await 4779 4779 - .map_err(|e| { 4780 4780 - tonic::Status::unknown( 4781 4781 - format!("Service was not ready: {}", e.into()), 4782 4782 - ) 4783 4783 - })?; 4130 4130 + ) -> std::result::Result<tonic::Response<super::GetFirstIndexResponse>, tonic::Status> 4131 4131 + { 4132 4132 + self.inner.ready().await.map_err(|e| { 4133 4133 + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 4134 4134 + })?; 4784 4135 let codec = tonic::codec::ProstCodec::default(); 4785 4136 let path = http::uri::PathAndQuery::from_static( 4786 4137 "/rockbox.v1alpha1.PlaylistService/GetFirstIndex", 4787 4138 ); 4788 4139 let mut req = request.into_request(); 4789 4789 - req.extensions_mut() 4790 4790 - .insert( 4791 4791 - GrpcMethod::new("rockbox.v1alpha1.PlaylistService", "GetFirstIndex"), 4792 4792 - ); 4140 4140 + req.extensions_mut().insert(GrpcMethod::new( 4141 4141 + "rockbox.v1alpha1.PlaylistService", 4142 4142 + "GetFirstIndex", 4143 4143 + )); 4793 4144 self.inner.unary(req, path, codec).await 4794 4145 } 4795 4146 pub async fn get_display_index( 4796 4147 &mut self, 4797 4148 request: impl tonic::IntoRequest<super::GetDisplayIndexRequest>, 4798 4798 - ) -> std::result::Result< 4799 4799 - tonic::Response<super::GetDisplayIndexResponse>, 4800 4800 - tonic::Status, 4801 4801 - > { 4802 4802 - self.inner 4803 4803 - .ready() 4804 4804 - .await 4805 4805 - .map_err(|e| { 4806 4806 - tonic::Status::unknown( 4807 4807 - format!("Service was not ready: {}", e.into()), 4808 4808 - ) 4809 4809 - })?; 4149 4149 + ) -> std::result::Result<tonic::Response<super::GetDisplayIndexResponse>, tonic::Status> 4150 4150 + { 4151 4151 + self.inner.ready().await.map_err(|e| { 4152 4152 + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 4153 4153 + })?; 4810 4154 let codec = tonic::codec::ProstCodec::default(); 4811 4155 let path = http::uri::PathAndQuery::from_static( 4812 4156 "/rockbox.v1alpha1.PlaylistService/GetDisplayIndex", 4813 4157 ); 4814 4158 let mut req = request.into_request(); 4815 4815 - req.extensions_mut() 4816 4816 - .insert( 4817 4817 - GrpcMethod::new( 4818 4818 - "rockbox.v1alpha1.PlaylistService", 4819 4819 - "GetDisplayIndex", 4820 4820 - ), 4821 4821 - ); 4159 4159 + req.extensions_mut().insert(GrpcMethod::new( 4160 4160 + "rockbox.v1alpha1.PlaylistService", 4161 4161 + "GetDisplayIndex", 4162 4162 + )); 4822 4163 self.inner.unary(req, path, codec).await 4823 4164 } 4824 4165 pub async fn amount( 4825 4166 &mut self, 4826 4167 request: impl tonic::IntoRequest<super::AmountRequest>, 4827 4168 ) -> std::result::Result<tonic::Response<super::AmountResponse>, tonic::Status> { 4828 4828 - self.inner 4829 4829 - .ready() 4830 4830 - .await 4831 4831 - .map_err(|e| { 4832 4832 - tonic::Status::unknown( 4833 4833 - format!("Service was not ready: {}", e.into()), 4834 4834 - ) 4835 4835 - })?; 4169 4169 + self.inner.ready().await.map_err(|e| { 4170 4170 + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 4171 4171 + })?; 4836 4172 let codec = tonic::codec::ProstCodec::default(); 4837 4837 - let path = http::uri::PathAndQuery::from_static( 4838 4838 - "/rockbox.v1alpha1.PlaylistService/Amount", 4839 4839 - ); 4173 4173 + let path = 4174 4174 + http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.PlaylistService/Amount"); 4840 4175 let mut req = request.into_request(); 4841 4841 - req.extensions_mut() 4842 4842 - .insert(GrpcMethod::new("rockbox.v1alpha1.PlaylistService", "Amount")); 4176 4176 + req.extensions_mut().insert(GrpcMethod::new( 4177 4177 + "rockbox.v1alpha1.PlaylistService", 4178 4178 + "Amount", 4179 4179 + )); 4843 4180 self.inner.unary(req, path, codec).await 4844 4181 } 4845 4182 pub async fn playlist_resume( 4846 4183 &mut self, 4847 4184 request: impl tonic::IntoRequest<super::PlaylistResumeRequest>, 4848 4848 - ) -> std::result::Result< 4849 4849 - tonic::Response<super::PlaylistResumeResponse>, 4850 4850 - tonic::Status, 4851 4851 - > { 4852 4852 - self.inner 4853 4853 - .ready() 4854 4854 - .await 4855 4855 - .map_err(|e| { 4856 4856 - tonic::Status::unknown( 4857 4857 - format!("Service was not ready: {}", e.into()), 4858 4858 - ) 4859 4859 - })?; 4185 4185 + ) -> std::result::Result<tonic::Response<super::PlaylistResumeResponse>, tonic::Status> 4186 4186 + { 4187 4187 + self.inner.ready().await.map_err(|e| { 4188 4188 + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 4189 4189 + })?; 4860 4190 let codec = tonic::codec::ProstCodec::default(); 4861 4191 let path = http::uri::PathAndQuery::from_static( 4862 4192 "/rockbox.v1alpha1.PlaylistService/PlaylistResume", 4863 4193 ); 4864 4194 let mut req = request.into_request(); 4865 4865 - req.extensions_mut() 4866 4866 - .insert( 4867 4867 - GrpcMethod::new("rockbox.v1alpha1.PlaylistService", "PlaylistResume"), 4868 4868 - ); 4195 4195 + req.extensions_mut().insert(GrpcMethod::new( 4196 4196 + "rockbox.v1alpha1.PlaylistService", 4197 4197 + "PlaylistResume", 4198 4198 + )); 4869 4199 self.inner.unary(req, path, codec).await 4870 4200 } 4871 4201 pub async fn resume_track( 4872 4202 &mut self, 4873 4203 request: impl tonic::IntoRequest<super::ResumeTrackRequest>, 4874 4874 - ) -> std::result::Result< 4875 4875 - tonic::Response<super::ResumeTrackResponse>, 4876 4876 - tonic::Status, 4877 4877 - > { 4878 4878 - self.inner 4879 4879 - .ready() 4880 4880 - .await 4881 4881 - .map_err(|e| { 4882 4882 - tonic::Status::unknown( 4883 4883 - format!("Service was not ready: {}", e.into()), 4884 4884 - ) 4885 4885 - })?; 4204 4204 + ) -> std::result::Result<tonic::Response<super::ResumeTrackResponse>, tonic::Status> 4205 4205 + { 4206 4206 + self.inner.ready().await.map_err(|e| { 4207 4207 + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 4208 4208 + })?; 4886 4209 let codec = tonic::codec::ProstCodec::default(); 4887 4210 let path = http::uri::PathAndQuery::from_static( 4888 4211 "/rockbox.v1alpha1.PlaylistService/ResumeTrack", 4889 4212 ); 4890 4213 let mut req = request.into_request(); 4891 4891 - req.extensions_mut() 4892 4892 - .insert( 4893 4893 - GrpcMethod::new("rockbox.v1alpha1.PlaylistService", "ResumeTrack"), 4894 4894 - ); 4214 4214 + req.extensions_mut().insert(GrpcMethod::new( 4215 4215 + "rockbox.v1alpha1.PlaylistService", 4216 4216 + "ResumeTrack", 4217 4217 + )); 4895 4218 self.inner.unary(req, path, codec).await 4896 4219 } 4897 4220 pub async fn set_modified( 4898 4221 &mut self, 4899 4222 request: impl tonic::IntoRequest<super::SetModifiedRequest>, 4900 4900 - ) -> std::result::Result< 4901 4901 - tonic::Response<super::SetModifiedResponse>, 4902 4902 - tonic::Status, 4903 4903 - > { 4904 4904 - self.inner 4905 4905 - .ready() 4906 4906 - .await 4907 4907 - .map_err(|e| { 4908 4908 - tonic::Status::unknown( 4909 4909 - format!("Service was not ready: {}", e.into()), 4910 4910 - ) 4911 4911 - })?; 4223 4223 + ) -> std::result::Result<tonic::Response<super::SetModifiedResponse>, tonic::Status> 4224 4224 + { 4225 4225 + self.inner.ready().await.map_err(|e| { 4226 4226 + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 4227 4227 + })?; 4912 4228 let codec = tonic::codec::ProstCodec::default(); 4913 4229 let path = http::uri::PathAndQuery::from_static( 4914 4230 "/rockbox.v1alpha1.PlaylistService/SetModified", 4915 4231 ); 4916 4232 let mut req = request.into_request(); 4917 4917 - req.extensions_mut() 4918 4918 - .insert( 4919 4919 - GrpcMethod::new("rockbox.v1alpha1.PlaylistService", "SetModified"), 4920 4920 - ); 4233 4233 + req.extensions_mut().insert(GrpcMethod::new( 4234 4234 + "rockbox.v1alpha1.PlaylistService", 4235 4235 + "SetModified", 4236 4236 + )); 4921 4237 self.inner.unary(req, path, codec).await 4922 4238 } 4923 4239 pub async fn start( 4924 4240 &mut self, 4925 4241 request: impl tonic::IntoRequest<super::StartRequest>, 4926 4242 ) -> std::result::Result<tonic::Response<super::StartResponse>, tonic::Status> { 4927 4927 - self.inner 4928 4928 - .ready() 4929 4929 - .await 4930 4930 - .map_err(|e| { 4931 4931 - tonic::Status::unknown( 4932 4932 - format!("Service was not ready: {}", e.into()), 4933 4933 - ) 4934 4934 - })?; 4243 4243 + self.inner.ready().await.map_err(|e| { 4244 4244 + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 4245 4245 + })?; 4935 4246 let codec = tonic::codec::ProstCodec::default(); 4936 4936 - let path = http::uri::PathAndQuery::from_static( 4937 4937 - "/rockbox.v1alpha1.PlaylistService/Start", 4938 4938 - ); 4247 4247 + let path = 4248 4248 + http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.PlaylistService/Start"); 4939 4249 let mut req = request.into_request(); 4940 4250 req.extensions_mut() 4941 4251 .insert(GrpcMethod::new("rockbox.v1alpha1.PlaylistService", "Start")); ··· 4945 4255 &mut self, 4946 4256 request: impl tonic::IntoRequest<super::SyncRequest>, 4947 4257 ) -> std::result::Result<tonic::Response<super::SyncResponse>, tonic::Status> { 4948 4948 - self.inner 4949 4949 - .ready() 4950 4950 - .await 4951 4951 - .map_err(|e| { 4952 4952 - tonic::Status::unknown( 4953 4953 - format!("Service was not ready: {}", e.into()), 4954 4954 - ) 4955 4955 - })?; 4258 4258 + self.inner.ready().await.map_err(|e| { 4259 4259 + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 4260 4260 + })?; 4956 4261 let codec = tonic::codec::ProstCodec::default(); 4957 4957 - let path = http::uri::PathAndQuery::from_static( 4958 4958 - "/rockbox.v1alpha1.PlaylistService/Sync", 4959 4959 - ); 4262 4262 + let path = 4263 4263 + http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.PlaylistService/Sync"); 4960 4264 let mut req = request.into_request(); 4961 4265 req.extensions_mut() 4962 4266 .insert(GrpcMethod::new("rockbox.v1alpha1.PlaylistService", "Sync")); ··· 4965 4269 pub async fn remove_all_tracks( 4966 4270 &mut self, 4967 4271 request: impl tonic::IntoRequest<super::RemoveAllTracksRequest>, 4968 4968 - ) -> std::result::Result< 4969 4969 - tonic::Response<super::RemoveAllTracksResponse>, 4970 4970 - tonic::Status, 4971 4971 - > { 4972 4972 - self.inner 4973 4973 - .ready() 4974 4974 - .await 4975 4975 - .map_err(|e| { 4976 4976 - tonic::Status::unknown( 4977 4977 - format!("Service was not ready: {}", e.into()), 4978 4978 - ) 4979 4979 - })?; 4272 4272 + ) -> std::result::Result<tonic::Response<super::RemoveAllTracksResponse>, tonic::Status> 4273 4273 + { 4274 4274 + self.inner.ready().await.map_err(|e| { 4275 4275 + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 4276 4276 + })?; 4980 4277 let codec = tonic::codec::ProstCodec::default(); 4981 4278 let path = http::uri::PathAndQuery::from_static( 4982 4279 "/rockbox.v1alpha1.PlaylistService/RemoveAllTracks", 4983 4280 ); 4984 4281 let mut req = request.into_request(); 4985 4985 - req.extensions_mut() 4986 4986 - .insert( 4987 4987 - GrpcMethod::new( 4988 4988 - "rockbox.v1alpha1.PlaylistService", 4989 4989 - "RemoveAllTracks", 4990 4990 - ), 4991 4991 - ); 4282 4282 + req.extensions_mut().insert(GrpcMethod::new( 4283 4283 + "rockbox.v1alpha1.PlaylistService", 4284 4284 + "RemoveAllTracks", 4285 4285 + )); 4992 4286 self.inner.unary(req, path, codec).await 4993 4287 } 4994 4288 pub async fn remove_tracks( 4995 4289 &mut self, 4996 4290 request: impl tonic::IntoRequest<super::RemoveTracksRequest>, 4997 4997 - ) -> std::result::Result< 4998 4998 - tonic::Response<super::RemoveTracksResponse>, 4999 4999 - tonic::Status, 5000 5000 - > { 5001 5001 - self.inner 5002 5002 - .ready() 5003 5003 - .await 5004 5004 - .map_err(|e| { 5005 5005 - tonic::Status::unknown( 5006 5006 - format!("Service was not ready: {}", e.into()), 5007 5007 - ) 5008 5008 - })?; 4291 4291 + ) -> std::result::Result<tonic::Response<super::RemoveTracksResponse>, tonic::Status> 4292 4292 + { 4293 4293 + self.inner.ready().await.map_err(|e| { 4294 4294 + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 4295 4295 + })?; 5009 4296 let codec = tonic::codec::ProstCodec::default(); 5010 4297 let path = http::uri::PathAndQuery::from_static( 5011 4298 "/rockbox.v1alpha1.PlaylistService/RemoveTracks", 5012 4299 ); 5013 4300 let mut req = request.into_request(); 5014 5014 - req.extensions_mut() 5015 5015 - .insert( 5016 5016 - GrpcMethod::new("rockbox.v1alpha1.PlaylistService", "RemoveTracks"), 5017 5017 - ); 4301 4301 + req.extensions_mut().insert(GrpcMethod::new( 4302 4302 + "rockbox.v1alpha1.PlaylistService", 4303 4303 + "RemoveTracks", 4304 4304 + )); 5018 4305 self.inner.unary(req, path, codec).await 5019 4306 } 5020 4307 pub async fn create_playlist( 5021 4308 &mut self, 5022 4309 request: impl tonic::IntoRequest<super::CreatePlaylistRequest>, 5023 5023 - ) -> std::result::Result< 5024 5024 - tonic::Response<super::CreatePlaylistResponse>, 5025 5025 - tonic::Status, 5026 5026 - > { 5027 5027 - self.inner 5028 5028 - .ready() 5029 5029 - .await 5030 5030 - .map_err(|e| { 5031 5031 - tonic::Status::unknown( 5032 5032 - format!("Service was not ready: {}", e.into()), 5033 5033 - ) 5034 5034 - })?; 4310 4310 + ) -> std::result::Result<tonic::Response<super::CreatePlaylistResponse>, tonic::Status> 4311 4311 + { 4312 4312 + self.inner.ready().await.map_err(|e| { 4313 4313 + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 4314 4314 + })?; 5035 4315 let codec = tonic::codec::ProstCodec::default(); 5036 4316 let path = http::uri::PathAndQuery::from_static( 5037 4317 "/rockbox.v1alpha1.PlaylistService/CreatePlaylist", 5038 4318 ); 5039 4319 let mut req = request.into_request(); 5040 5040 - req.extensions_mut() 5041 5041 - .insert( 5042 5042 - GrpcMethod::new("rockbox.v1alpha1.PlaylistService", "CreatePlaylist"), 5043 5043 - ); 4320 4320 + req.extensions_mut().insert(GrpcMethod::new( 4321 4321 + "rockbox.v1alpha1.PlaylistService", 4322 4322 + "CreatePlaylist", 4323 4323 + )); 5044 4324 self.inner.unary(req, path, codec).await 5045 4325 } 5046 4326 pub async fn insert_tracks( 5047 4327 &mut self, 5048 4328 request: impl tonic::IntoRequest<super::InsertTracksRequest>, 5049 5049 - ) -> std::result::Result< 5050 5050 - tonic::Response<super::InsertTracksResponse>, 5051 5051 - tonic::Status, 5052 5052 - > { 5053 5053 - self.inner 5054 5054 - .ready() 5055 5055 - .await 5056 5056 - .map_err(|e| { 5057 5057 - tonic::Status::unknown( 5058 5058 - format!("Service was not ready: {}", e.into()), 5059 5059 - ) 5060 5060 - })?; 4329 4329 + ) -> std::result::Result<tonic::Response<super::InsertTracksResponse>, tonic::Status> 4330 4330 + { 4331 4331 + self.inner.ready().await.map_err(|e| { 4332 4332 + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 4333 4333 + })?; 5061 4334 let codec = tonic::codec::ProstCodec::default(); 5062 4335 let path = http::uri::PathAndQuery::from_static( 5063 4336 "/rockbox.v1alpha1.PlaylistService/InsertTracks", 5064 4337 ); 5065 4338 let mut req = request.into_request(); 5066 5066 - req.extensions_mut() 5067 5067 - .insert( 5068 5068 - GrpcMethod::new("rockbox.v1alpha1.PlaylistService", "InsertTracks"), 5069 5069 - ); 4339 4339 + req.extensions_mut().insert(GrpcMethod::new( 4340 4340 + "rockbox.v1alpha1.PlaylistService", 4341 4341 + "InsertTracks", 4342 4342 + )); 5070 4343 self.inner.unary(req, path, codec).await 5071 4344 } 5072 4345 pub async fn insert_directory( 5073 4346 &mut self, 5074 4347 request: impl tonic::IntoRequest<super::InsertDirectoryRequest>, 5075 5075 - ) -> std::result::Result< 5076 5076 - tonic::Response<super::InsertDirectoryResponse>, 5077 5077 - tonic::Status, 5078 5078 - > { 5079 5079 - self.inner 5080 5080 - .ready() 5081 5081 - .await 5082 5082 - .map_err(|e| { 5083 5083 - tonic::Status::unknown( 5084 5084 - format!("Service was not ready: {}", e.into()), 5085 5085 - ) 5086 5086 - })?; 4348 4348 + ) -> std::result::Result<tonic::Response<super::InsertDirectoryResponse>, tonic::Status> 4349 4349 + { 4350 4350 + self.inner.ready().await.map_err(|e| { 4351 4351 + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 4352 4352 + })?; 5087 4353 let codec = tonic::codec::ProstCodec::default(); 5088 4354 let path = http::uri::PathAndQuery::from_static( 5089 4355 "/rockbox.v1alpha1.PlaylistService/InsertDirectory", 5090 4356 ); 5091 4357 let mut req = request.into_request(); 5092 5092 - req.extensions_mut() 5093 5093 - .insert( 5094 5094 - GrpcMethod::new( 5095 5095 - "rockbox.v1alpha1.PlaylistService", 5096 5096 - "InsertDirectory", 5097 5097 - ), 5098 5098 - ); 4358 4358 + req.extensions_mut().insert(GrpcMethod::new( 4359 4359 + "rockbox.v1alpha1.PlaylistService", 4360 4360 + "InsertDirectory", 4361 4361 + )); 5099 4362 self.inner.unary(req, path, codec).await 5100 4363 } 5101 4364 pub async fn insert_playlist( 5102 4365 &mut self, 5103 4366 request: impl tonic::IntoRequest<super::InsertPlaylistRequest>, 5104 5104 - ) -> std::result::Result< 5105 5105 - tonic::Response<super::InsertPlaylistResponse>, 5106 5106 - tonic::Status, 5107 5107 - > { 5108 5108 - self.inner 5109 5109 - .ready() 5110 5110 - .await 5111 5111 - .map_err(|e| { 5112 5112 - tonic::Status::unknown( 5113 5113 - format!("Service was not ready: {}", e.into()), 5114 5114 - ) 5115 5115 - })?; 4367 4367 + ) -> std::result::Result<tonic::Response<super::InsertPlaylistResponse>, 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 + })?; 5116 4372 let codec = tonic::codec::ProstCodec::default(); 5117 4373 let path = http::uri::PathAndQuery::from_static( 5118 4374 "/rockbox.v1alpha1.PlaylistService/InsertPlaylist", 5119 4375 ); 5120 4376 let mut req = request.into_request(); 5121 5121 - req.extensions_mut() 5122 5122 - .insert( 5123 5123 - GrpcMethod::new("rockbox.v1alpha1.PlaylistService", "InsertPlaylist"), 5124 5124 - ); 4377 4377 + req.extensions_mut().insert(GrpcMethod::new( 4378 4378 + "rockbox.v1alpha1.PlaylistService", 4379 4379 + "InsertPlaylist", 4380 4380 + )); 5125 4381 self.inner.unary(req, path, codec).await 5126 4382 } 5127 4383 pub async fn insert_album( 5128 4384 &mut self, 5129 4385 request: impl tonic::IntoRequest<super::InsertAlbumRequest>, 5130 5130 - ) -> std::result::Result< 5131 5131 - tonic::Response<super::InsertAlbumResponse>, 5132 5132 - tonic::Status, 5133 5133 - > { 5134 5134 - self.inner 5135 5135 - .ready() 5136 5136 - .await 5137 5137 - .map_err(|e| { 5138 5138 - tonic::Status::unknown( 5139 5139 - format!("Service was not ready: {}", e.into()), 5140 5140 - ) 5141 5141 - })?; 4386 4386 + ) -> std::result::Result<tonic::Response<super::InsertAlbumResponse>, 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 + })?; 5142 4391 let codec = tonic::codec::ProstCodec::default(); 5143 4392 let path = http::uri::PathAndQuery::from_static( 5144 4393 "/rockbox.v1alpha1.PlaylistService/InsertAlbum", 5145 4394 ); 5146 4395 let mut req = request.into_request(); 5147 5147 - req.extensions_mut() 5148 5148 - .insert( 5149 5149 - GrpcMethod::new("rockbox.v1alpha1.PlaylistService", "InsertAlbum"), 5150 5150 - ); 4396 4396 + req.extensions_mut().insert(GrpcMethod::new( 4397 4397 + "rockbox.v1alpha1.PlaylistService", 4398 4398 + "InsertAlbum", 4399 4399 + )); 5151 4400 self.inner.unary(req, path, codec).await 5152 4401 } 5153 4402 pub async fn insert_artist_tracks( 5154 4403 &mut self, 5155 4404 request: impl tonic::IntoRequest<super::InsertArtistTracksRequest>, 5156 5156 - ) -> std::result::Result< 5157 5157 - tonic::Response<super::InsertArtistTracksResponse>, 5158 5158 - tonic::Status, 5159 5159 - > { 5160 5160 - self.inner 5161 5161 - .ready() 5162 5162 - .await 5163 5163 - .map_err(|e| { 5164 5164 - tonic::Status::unknown( 5165 5165 - format!("Service was not ready: {}", e.into()), 5166 5166 - ) 5167 5167 - })?; 4405 4405 + ) -> std::result::Result<tonic::Response<super::InsertArtistTracksResponse>, 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 + })?; 5168 4410 let codec = tonic::codec::ProstCodec::default(); 5169 4411 let path = http::uri::PathAndQuery::from_static( 5170 4412 "/rockbox.v1alpha1.PlaylistService/InsertArtistTracks", 5171 4413 ); 5172 4414 let mut req = request.into_request(); 5173 5173 - req.extensions_mut() 5174 5174 - .insert( 5175 5175 - GrpcMethod::new( 5176 5176 - "rockbox.v1alpha1.PlaylistService", 5177 5177 - "InsertArtistTracks", 5178 5178 - ), 5179 5179 - ); 4415 4415 + req.extensions_mut().insert(GrpcMethod::new( 4416 4416 + "rockbox.v1alpha1.PlaylistService", 4417 4417 + "InsertArtistTracks", 4418 4418 + )); 5180 4419 self.inner.unary(req, path, codec).await 5181 4420 } 5182 4421 pub async fn shuffle_playlist( 5183 4422 &mut self, 5184 4423 request: impl tonic::IntoRequest<super::ShufflePlaylistRequest>, 5185 5185 - ) -> std::result::Result< 5186 5186 - tonic::Response<super::ShufflePlaylistResponse>, 5187 5187 - tonic::Status, 5188 5188 - > { 5189 5189 - self.inner 5190 5190 - .ready() 5191 5191 - .await 5192 5192 - .map_err(|e| { 5193 5193 - tonic::Status::unknown( 5194 5194 - format!("Service was not ready: {}", e.into()), 5195 5195 - ) 5196 5196 - })?; 4424 4424 + ) -> std::result::Result<tonic::Response<super::ShufflePlaylistResponse>, 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 + })?; 5197 4429 let codec = tonic::codec::ProstCodec::default(); 5198 4430 let path = http::uri::PathAndQuery::from_static( 5199 4431 "/rockbox.v1alpha1.PlaylistService/ShufflePlaylist", 5200 4432 ); 5201 4433 let mut req = request.into_request(); 5202 5202 - req.extensions_mut() 5203 5203 - .insert( 5204 5204 - GrpcMethod::new( 5205 5205 - "rockbox.v1alpha1.PlaylistService", 5206 5206 - "ShufflePlaylist", 5207 5207 - ), 5208 5208 - ); 4434 4434 + req.extensions_mut().insert(GrpcMethod::new( 4435 4435 + "rockbox.v1alpha1.PlaylistService", 4436 4436 + "ShufflePlaylist", 4437 4437 + )); 5209 4438 self.inner.unary(req, path, codec).await 5210 4439 } 5211 4440 } ··· 5217 4446 dead_code, 5218 4447 missing_docs, 5219 4448 clippy::wildcard_imports, 5220 5220 - clippy::let_unit_value, 4449 4449 + clippy::let_unit_value 5221 4450 )] 5222 4451 use tonic::codegen::*; 5223 4452 /// Generated trait containing gRPC methods that should be implemented for use with PlaylistServiceServer. ··· 5226 4455 async fn get_current( 5227 4456 &self, 5228 4457 request: tonic::Request<super::GetCurrentRequest>, 5229 5229 - ) -> std::result::Result< 5230 5230 - tonic::Response<super::GetCurrentResponse>, 5231 5231 - tonic::Status, 5232 5232 - >; 4458 4458 + ) -> std::result::Result<tonic::Response<super::GetCurrentResponse>, tonic::Status>; 5233 4459 async fn get_resume_info( 5234 4460 &self, 5235 4461 request: tonic::Request<super::GetResumeInfoRequest>, 5236 5236 - ) -> std::result::Result< 5237 5237 - tonic::Response<super::GetResumeInfoResponse>, 5238 5238 - tonic::Status, 5239 5239 - >; 4462 4462 + ) -> std::result::Result<tonic::Response<super::GetResumeInfoResponse>, tonic::Status>; 5240 4463 async fn get_track_info( 5241 4464 &self, 5242 4465 request: tonic::Request<super::GetTrackInfoRequest>, 5243 5243 - ) -> std::result::Result< 5244 5244 - tonic::Response<super::GetTrackInfoResponse>, 5245 5245 - tonic::Status, 5246 5246 - >; 4466 4466 + ) -> std::result::Result<tonic::Response<super::GetTrackInfoResponse>, tonic::Status>; 5247 4467 async fn get_first_index( 5248 4468 &self, 5249 4469 request: tonic::Request<super::GetFirstIndexRequest>, 5250 5250 - ) -> std::result::Result< 5251 5251 - tonic::Response<super::GetFirstIndexResponse>, 5252 5252 - tonic::Status, 5253 5253 - >; 4470 4470 + ) -> std::result::Result<tonic::Response<super::GetFirstIndexResponse>, tonic::Status>; 5254 4471 async fn get_display_index( 5255 4472 &self, 5256 4473 request: tonic::Request<super::GetDisplayIndexRequest>, 5257 5257 - ) -> std::result::Result< 5258 5258 - tonic::Response<super::GetDisplayIndexResponse>, 5259 5259 - tonic::Status, 5260 5260 - >; 4474 4474 + ) -> std::result::Result<tonic::Response<super::GetDisplayIndexResponse>, tonic::Status>; 5261 4475 async fn amount( 5262 4476 &self, 5263 4477 request: tonic::Request<super::AmountRequest>, ··· 5265 4479 async fn playlist_resume( 5266 4480 &self, 5267 4481 request: tonic::Request<super::PlaylistResumeRequest>, 5268 5268 - ) -> std::result::Result< 5269 5269 - tonic::Response<super::PlaylistResumeResponse>, 5270 5270 - tonic::Status, 5271 5271 - >; 4482 4482 + ) -> std::result::Result<tonic::Response<super::PlaylistResumeResponse>, tonic::Status>; 5272 4483 async fn resume_track( 5273 4484 &self, 5274 4485 request: tonic::Request<super::ResumeTrackRequest>, 5275 5275 - ) -> std::result::Result< 5276 5276 - tonic::Response<super::ResumeTrackResponse>, 5277 5277 - tonic::Status, 5278 5278 - >; 4486 4486 + ) -> std::result::Result<tonic::Response<super::ResumeTrackResponse>, tonic::Status>; 5279 4487 async fn set_modified( 5280 4488 &self, 5281 4489 request: tonic::Request<super::SetModifiedRequest>, 5282 5282 - ) -> std::result::Result< 5283 5283 - tonic::Response<super::SetModifiedResponse>, 5284 5284 - tonic::Status, 5285 5285 - >; 4490 4490 + ) -> std::result::Result<tonic::Response<super::SetModifiedResponse>, tonic::Status>; 5286 4491 async fn start( 5287 4492 &self, 5288 4493 request: tonic::Request<super::StartRequest>, ··· 5294 4499 async fn remove_all_tracks( 5295 4500 &self, 5296 4501 request: tonic::Request<super::RemoveAllTracksRequest>, 5297 5297 - ) -> std::result::Result< 5298 5298 - tonic::Response<super::RemoveAllTracksResponse>, 5299 5299 - tonic::Status, 5300 5300 - >; 4502 4502 + ) -> std::result::Result<tonic::Response<super::RemoveAllTracksResponse>, tonic::Status>; 5301 4503 async fn remove_tracks( 5302 4504 &self, 5303 4505 request: tonic::Request<super::RemoveTracksRequest>, 5304 5304 - ) -> std::result::Result< 5305 5305 - tonic::Response<super::RemoveTracksResponse>, 5306 5306 - tonic::Status, 5307 5307 - >; 4506 4506 + ) -> std::result::Result<tonic::Response<super::RemoveTracksResponse>, tonic::Status>; 5308 4507 async fn create_playlist( 5309 4508 &self, 5310 4509 request: tonic::Request<super::CreatePlaylistRequest>, 5311 5311 - ) -> std::result::Result< 5312 5312 - tonic::Response<super::CreatePlaylistResponse>, 5313 5313 - tonic::Status, 5314 5314 - >; 4510 4510 + ) -> std::result::Result<tonic::Response<super::CreatePlaylistResponse>, tonic::Status>; 5315 4511 async fn insert_tracks( 5316 4512 &self, 5317 4513 request: tonic::Request<super::InsertTracksRequest>, 5318 5318 - ) -> std::result::Result< 5319 5319 - tonic::Response<super::InsertTracksResponse>, 5320 5320 - tonic::Status, 5321 5321 - >; 4514 4514 + ) -> std::result::Result<tonic::Response<super::InsertTracksResponse>, tonic::Status>; 5322 4515 async fn insert_directory( 5323 4516 &self, 5324 4517 request: tonic::Request<super::InsertDirectoryRequest>, 5325 5325 - ) -> std::result::Result< 5326 5326 - tonic::Response<super::InsertDirectoryResponse>, 5327 5327 - tonic::Status, 5328 5328 - >; 4518 4518 + ) -> std::result::Result<tonic::Response<super::InsertDirectoryResponse>, tonic::Status>; 5329 4519 async fn insert_playlist( 5330 4520 &self, 5331 4521 request: tonic::Request<super::InsertPlaylistRequest>, 5332 5332 - ) -> std::result::Result< 5333 5333 - tonic::Response<super::InsertPlaylistResponse>, 5334 5334 - tonic::Status, 5335 5335 - >; 4522 4522 + ) -> std::result::Result<tonic::Response<super::InsertPlaylistResponse>, tonic::Status>; 5336 4523 async fn insert_album( 5337 4524 &self, 5338 4525 request: tonic::Request<super::InsertAlbumRequest>, 5339 5339 - ) -> std::result::Result< 5340 5340 - tonic::Response<super::InsertAlbumResponse>, 5341 5341 - tonic::Status, 5342 5342 - >; 4526 4526 + ) -> std::result::Result<tonic::Response<super::InsertAlbumResponse>, tonic::Status>; 5343 4527 async fn insert_artist_tracks( 5344 4528 &self, 5345 4529 request: tonic::Request<super::InsertArtistTracksRequest>, 5346 5346 - ) -> std::result::Result< 5347 5347 - tonic::Response<super::InsertArtistTracksResponse>, 5348 5348 - tonic::Status, 5349 5349 - >; 4530 4530 + ) -> std::result::Result<tonic::Response<super::InsertArtistTracksResponse>, tonic::Status>; 5350 4531 async fn shuffle_playlist( 5351 4532 &self, 5352 4533 request: tonic::Request<super::ShufflePlaylistRequest>, 5353 5353 - ) -> std::result::Result< 5354 5354 - tonic::Response<super::ShufflePlaylistResponse>, 5355 5355 - tonic::Status, 5356 5356 - >; 4534 4534 + ) -> std::result::Result<tonic::Response<super::ShufflePlaylistResponse>, tonic::Status>; 5357 4535 } 5358 4536 #[derive(Debug)] 5359 4537 pub struct PlaylistServiceServer<T> { ··· 5376 4554 max_encoding_message_size: None, 5377 4555 } 5378 4556 } 5379 5379 - pub fn with_interceptor<F>( 5380 5380 - inner: T, 5381 5381 - interceptor: F, 5382 5382 - ) -> InterceptedService<Self, F> 4557 4557 + pub fn with_interceptor<F>(inner: T, interceptor: F) -> InterceptedService<Self, F> 5383 4558 where 5384 4559 F: tonic::service::Interceptor, 5385 4560 { ··· 5434 4609 "/rockbox.v1alpha1.PlaylistService/GetCurrent" => { 5435 4610 #[allow(non_camel_case_types)] 5436 4611 struct GetCurrentSvc<T: PlaylistService>(pub Arc<T>); 5437 5437 - impl< 5438 5438 - T: PlaylistService, 5439 5439 - > tonic::server::UnaryService<super::GetCurrentRequest> 5440 5440 - for GetCurrentSvc<T> { 4612 4612 + impl<T: PlaylistService> tonic::server::UnaryService<super::GetCurrentRequest> 4613 4613 + for GetCurrentSvc<T> 4614 4614 + { 5441 4615 type Response = super::GetCurrentResponse; 5442 5442 - type Future = BoxFuture< 5443 5443 - tonic::Response<Self::Response>, 5444 5444 - tonic::Status, 5445 5445 - >; 4616 4616 + type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 5446 4617 fn call( 5447 4618 &mut self, 5448 4619 request: tonic::Request<super::GetCurrentRequest>, ··· 5479 4650 "/rockbox.v1alpha1.PlaylistService/GetResumeInfo" => { 5480 4651 #[allow(non_camel_case_types)] 5481 4652 struct GetResumeInfoSvc<T: PlaylistService>(pub Arc<T>); 5482 5482 - impl< 5483 5483 - T: PlaylistService, 5484 5484 - > tonic::server::UnaryService<super::GetResumeInfoRequest> 5485 5485 - for GetResumeInfoSvc<T> { 4653 4653 + impl<T: PlaylistService> 4654 4654 + tonic::server::UnaryService<super::GetResumeInfoRequest> 4655 4655 + for GetResumeInfoSvc<T> 4656 4656 + { 5486 4657 type Response = super::GetResumeInfoResponse; 5487 5487 - type Future = BoxFuture< 5488 5488 - tonic::Response<Self::Response>, 5489 5489 - tonic::Status, 5490 5490 - >; 4658 4658 + type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 5491 4659 fn call( 5492 4660 &mut self, 5493 4661 request: tonic::Request<super::GetResumeInfoRequest>, 5494 4662 ) -> Self::Future { 5495 4663 let inner = Arc::clone(&self.0); 5496 4664 let fut = async move { 5497 5497 - <T as PlaylistService>::get_resume_info(&inner, request) 5498 5498 - .await 4665 4665 + <T as PlaylistService>::get_resume_info(&inner, request).await 5499 4666 }; 5500 4667 Box::pin(fut) 5501 4668 } ··· 5525 4692 "/rockbox.v1alpha1.PlaylistService/GetTrackInfo" => { 5526 4693 #[allow(non_camel_case_types)] 5527 4694 struct GetTrackInfoSvc<T: PlaylistService>(pub Arc<T>); 5528 5528 - impl< 5529 5529 - T: PlaylistService, 5530 5530 - > tonic::server::UnaryService<super::GetTrackInfoRequest> 5531 5531 - for GetTrackInfoSvc<T> { 4695 4695 + impl<T: PlaylistService> tonic::server::UnaryService<super::GetTrackInfoRequest> 4696 4696 + for GetTrackInfoSvc<T> 4697 4697 + { 5532 4698 type Response = super::GetTrackInfoResponse; 5533 5533 - type Future = BoxFuture< 5534 5534 - tonic::Response<Self::Response>, 5535 5535 - tonic::Status, 5536 5536 - >; 4699 4699 + type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 5537 4700 fn call( 5538 4701 &mut self, 5539 4702 request: tonic::Request<super::GetTrackInfoRequest>, 5540 4703 ) -> Self::Future { 5541 4704 let inner = Arc::clone(&self.0); 5542 4705 let fut = async move { 5543 5543 - <T as PlaylistService>::get_track_info(&inner, request) 5544 5544 - .await 4706 4706 + <T as PlaylistService>::get_track_info(&inner, request).await 5545 4707 }; 5546 4708 Box::pin(fut) 5547 4709 } ··· 5571 4733 "/rockbox.v1alpha1.PlaylistService/GetFirstIndex" => { 5572 4734 #[allow(non_camel_case_types)] 5573 4735 struct GetFirstIndexSvc<T: PlaylistService>(pub Arc<T>); 5574 5574 - impl< 5575 5575 - T: PlaylistService, 5576 5576 - > tonic::server::UnaryService<super::GetFirstIndexRequest> 5577 5577 - for GetFirstIndexSvc<T> { 4736 4736 + impl<T: PlaylistService> 4737 4737 + tonic::server::UnaryService<super::GetFirstIndexRequest> 4738 4738 + for GetFirstIndexSvc<T> 4739 4739 + { 5578 4740 type Response = super::GetFirstIndexResponse; 5579 5579 - type Future = BoxFuture< 5580 5580 - tonic::Response<Self::Response>, 5581 5581 - tonic::Status, 5582 5582 - >; 4741 4741 + type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 5583 4742 fn call( 5584 4743 &mut self, 5585 4744 request: tonic::Request<super::GetFirstIndexRequest>, 5586 4745 ) -> Self::Future { 5587 4746 let inner = Arc::clone(&self.0); 5588 4747 let fut = async move { 5589 5589 - <T as PlaylistService>::get_first_index(&inner, request) 5590 5590 - .await 4748 4748 + <T as PlaylistService>::get_first_index(&inner, request).await 5591 4749 }; 5592 4750 Box::pin(fut) 5593 4751 } ··· 5617 4775 "/rockbox.v1alpha1.PlaylistService/GetDisplayIndex" => { 5618 4776 #[allow(non_camel_case_types)] 5619 4777 struct GetDisplayIndexSvc<T: PlaylistService>(pub Arc<T>); 5620 5620 - impl< 5621 5621 - T: PlaylistService, 5622 5622 - > tonic::server::UnaryService<super::GetDisplayIndexRequest> 5623 5623 - for GetDisplayIndexSvc<T> { 4778 4778 + impl<T: PlaylistService> 4779 4779 + tonic::server::UnaryService<super::GetDisplayIndexRequest> 4780 4780 + for GetDisplayIndexSvc<T> 4781 4781 + { 5624 4782 type Response = super::GetDisplayIndexResponse; 5625 5625 - type Future = BoxFuture< 5626 5626 - tonic::Response<Self::Response>, 5627 5627 - tonic::Status, 5628 5628 - >; 4783 4783 + type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 5629 4784 fn call( 5630 4785 &mut self, 5631 4786 request: tonic::Request<super::GetDisplayIndexRequest>, 5632 4787 ) -> Self::Future { 5633 4788 let inner = Arc::clone(&self.0); 5634 4789 let fut = async move { 5635 5635 - <T as PlaylistService>::get_display_index(&inner, request) 5636 5636 - .await 4790 4790 + <T as PlaylistService>::get_display_index(&inner, request).await 5637 4791 }; 5638 4792 Box::pin(fut) 5639 4793 } ··· 5663 4817 "/rockbox.v1alpha1.PlaylistService/Amount" => { 5664 4818 #[allow(non_camel_case_types)] 5665 4819 struct AmountSvc<T: PlaylistService>(pub Arc<T>); 5666 5666 - impl< 5667 5667 - T: PlaylistService, 5668 5668 - > tonic::server::UnaryService<super::AmountRequest> 5669 5669 - for AmountSvc<T> { 4820 4820 + impl<T: PlaylistService> tonic::server::UnaryService<super::AmountRequest> for AmountSvc<T> { 5670 4821 type Response = super::AmountResponse; 5671 5671 - type Future = BoxFuture< 5672 5672 - tonic::Response<Self::Response>, 5673 5673 - tonic::Status, 5674 5674 - >; 4822 4822 + type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 5675 4823 fn call( 5676 4824 &mut self, 5677 4825 request: tonic::Request<super::AmountRequest>, ··· 5708 4856 "/rockbox.v1alpha1.PlaylistService/PlaylistResume" => { 5709 4857 #[allow(non_camel_case_types)] 5710 4858 struct PlaylistResumeSvc<T: PlaylistService>(pub Arc<T>); 5711 5711 - impl< 5712 5712 - T: PlaylistService, 5713 5713 - > tonic::server::UnaryService<super::PlaylistResumeRequest> 5714 5714 - for PlaylistResumeSvc<T> { 4859 4859 + impl<T: PlaylistService> 4860 4860 + tonic::server::UnaryService<super::PlaylistResumeRequest> 4861 4861 + for PlaylistResumeSvc<T> 4862 4862 + { 5715 4863 type Response = super::PlaylistResumeResponse; 5716 5716 - type Future = BoxFuture< 5717 5717 - tonic::Response<Self::Response>, 5718 5718 - tonic::Status, 5719 5719 - >; 4864 4864 + type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 5720 4865 fn call( 5721 4866 &mut self, 5722 4867 request: tonic::Request<super::PlaylistResumeRequest>, 5723 4868 ) -> Self::Future { 5724 4869 let inner = Arc::clone(&self.0); 5725 4870 let fut = async move { 5726 5726 - <T as PlaylistService>::playlist_resume(&inner, request) 5727 5727 - .await 4871 4871 + <T as PlaylistService>::playlist_resume(&inner, request).await 5728 4872 }; 5729 4873 Box::pin(fut) 5730 4874 } ··· 5754 4898 "/rockbox.v1alpha1.PlaylistService/ResumeTrack" => { 5755 4899 #[allow(non_camel_case_types)] 5756 4900 struct ResumeTrackSvc<T: PlaylistService>(pub Arc<T>); 5757 5757 - impl< 5758 5758 - T: PlaylistService, 5759 5759 - > tonic::server::UnaryService<super::ResumeTrackRequest> 5760 5760 - for ResumeTrackSvc<T> { 4901 4901 + impl<T: PlaylistService> tonic::server::UnaryService<super::ResumeTrackRequest> 4902 4902 + for ResumeTrackSvc<T> 4903 4903 + { 5761 4904 type Response = super::ResumeTrackResponse; 5762 5762 - type Future = BoxFuture< 5763 5763 - tonic::Response<Self::Response>, 5764 5764 - tonic::Status, 5765 5765 - >; 4905 4905 + type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 5766 4906 fn call( 5767 4907 &mut self, 5768 4908 request: tonic::Request<super::ResumeTrackRequest>, ··· 5799 4939 "/rockbox.v1alpha1.PlaylistService/SetModified" => { 5800 4940 #[allow(non_camel_case_types)] 5801 4941 struct SetModifiedSvc<T: PlaylistService>(pub Arc<T>); 5802 5802 - impl< 5803 5803 - T: PlaylistService, 5804 5804 - > tonic::server::UnaryService<super::SetModifiedRequest> 5805 5805 - for SetModifiedSvc<T> { 4942 4942 + impl<T: PlaylistService> tonic::server::UnaryService<super::SetModifiedRequest> 4943 4943 + for SetModifiedSvc<T> 4944 4944 + { 5806 4945 type Response = super::SetModifiedResponse; 5807 5807 - type Future = BoxFuture< 5808 5808 - tonic::Response<Self::Response>, 5809 5809 - tonic::Status, 5810 5810 - >; 4946 4946 + type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 5811 4947 fn call( 5812 4948 &mut self, 5813 4949 request: tonic::Request<super::SetModifiedRequest>, ··· 5844 4980 "/rockbox.v1alpha1.PlaylistService/Start" => { 5845 4981 #[allow(non_camel_case_types)] 5846 4982 struct StartSvc<T: PlaylistService>(pub Arc<T>); 5847 5847 - impl< 5848 5848 - T: PlaylistService, 5849 5849 - > tonic::server::UnaryService<super::StartRequest> for StartSvc<T> { 4983 4983 + impl<T: PlaylistService> tonic::server::UnaryService<super::StartRequest> for StartSvc<T> { 5850 4984 type Response = super::StartResponse; 5851 5851 - type Future = BoxFuture< 5852 5852 - tonic::Response<Self::Response>, 5853 5853 - tonic::Status, 5854 5854 - >; 4985 4985 + type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 5855 4986 fn call( 5856 4987 &mut self, 5857 4988 request: tonic::Request<super::StartRequest>, 5858 4989 ) -> Self::Future { 5859 4990 let inner = Arc::clone(&self.0); 5860 5860 - let fut = async move { 5861 5861 - <T as PlaylistService>::start(&inner, request).await 5862 5862 - }; 4991 4991 + let fut = 4992 4992 + async move { <T as PlaylistService>::start(&inner, request).await }; 5863 4993 Box::pin(fut) 5864 4994 } 5865 4995 } ··· 5888 5018 "/rockbox.v1alpha1.PlaylistService/Sync" => { 5889 5019 #[allow(non_camel_case_types)] 5890 5020 struct SyncSvc<T: PlaylistService>(pub Arc<T>); 5891 5891 - impl< 5892 5892 - T: PlaylistService, 5893 5893 - > tonic::server::UnaryService<super::SyncRequest> for SyncSvc<T> { 5021 5021 + impl<T: PlaylistService> tonic::server::UnaryService<super::SyncRequest> for SyncSvc<T> { 5894 5022 type Response = super::SyncResponse; 5895 5895 - type Future = BoxFuture< 5896 5896 - tonic::Response<Self::Response>, 5897 5897 - tonic::Status, 5898 5898 - >; 5023 5023 + type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 5899 5024 fn call( 5900 5025 &mut self, 5901 5026 request: tonic::Request<super::SyncRequest>, 5902 5027 ) -> Self::Future { 5903 5028 let inner = Arc::clone(&self.0); 5904 5904 - let fut = async move { 5905 5905 - <T as PlaylistService>::sync(&inner, request).await 5906 5906 - }; 5029 5029 + let fut = 5030 5030 + async move { <T as PlaylistService>::sync(&inner, request).await }; 5907 5031 Box::pin(fut) 5908 5032 } 5909 5033 } ··· 5932 5056 "/rockbox.v1alpha1.PlaylistService/RemoveAllTracks" => { 5933 5057 #[allow(non_camel_case_types)] 5934 5058 struct RemoveAllTracksSvc<T: PlaylistService>(pub Arc<T>); 5935 5935 - impl< 5936 5936 - T: PlaylistService, 5937 5937 - > tonic::server::UnaryService<super::RemoveAllTracksRequest> 5938 5938 - for RemoveAllTracksSvc<T> { 5059 5059 + impl<T: PlaylistService> 5060 5060 + tonic::server::UnaryService<super::RemoveAllTracksRequest> 5061 5061 + for RemoveAllTracksSvc<T> 5062 5062 + { 5939 5063 type Response = super::RemoveAllTracksResponse; 5940 5940 - type Future = BoxFuture< 5941 5941 - tonic::Response<Self::Response>, 5942 5942 - tonic::Status, 5943 5943 - >; 5064 5064 + type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 5944 5065 fn call( 5945 5066 &mut self, 5946 5067 request: tonic::Request<super::RemoveAllTracksRequest>, 5947 5068 ) -> Self::Future { 5948 5069 let inner = Arc::clone(&self.0); 5949 5070 let fut = async move { 5950 5950 - <T as PlaylistService>::remove_all_tracks(&inner, request) 5951 5951 - .await 5071 5071 + <T as PlaylistService>::remove_all_tracks(&inner, request).await 5952 5072 }; 5953 5073 Box::pin(fut) 5954 5074 } ··· 5978 5098 "/rockbox.v1alpha1.PlaylistService/RemoveTracks" => { 5979 5099 #[allow(non_camel_case_types)] 5980 5100 struct RemoveTracksSvc<T: PlaylistService>(pub Arc<T>); 5981 5981 - impl< 5982 5982 - T: PlaylistService, 5983 5983 - > tonic::server::UnaryService<super::RemoveTracksRequest> 5984 5984 - for RemoveTracksSvc<T> { 5101 5101 + impl<T: PlaylistService> tonic::server::UnaryService<super::RemoveTracksRequest> 5102 5102 + for RemoveTracksSvc<T> 5103 5103 + { 5985 5104 type Response = super::RemoveTracksResponse; 5986 5986 - type Future = BoxFuture< 5987 5987 - tonic::Response<Self::Response>, 5988 5988 - tonic::Status, 5989 5989 - >; 5105 5105 + type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 5990 5106 fn call( 5991 5107 &mut self, 5992 5108 request: tonic::Request<super::RemoveTracksRequest>, ··· 6023 5139 "/rockbox.v1alpha1.PlaylistService/CreatePlaylist" => { 6024 5140 #[allow(non_camel_case_types)] 6025 5141 struct CreatePlaylistSvc<T: PlaylistService>(pub Arc<T>); 6026 6026 - impl< 6027 6027 - T: PlaylistService, 6028 6028 - > tonic::server::UnaryService<super::CreatePlaylistRequest> 6029 6029 - for CreatePlaylistSvc<T> { 5142 5142 + impl<T: PlaylistService> 5143 5143 + tonic::server::UnaryService<super::CreatePlaylistRequest> 5144 5144 + for CreatePlaylistSvc<T> 5145 5145 + { 6030 5146 type Response = super::CreatePlaylistResponse; 6031 6031 - type Future = BoxFuture< 6032 6032 - tonic::Response<Self::Response>, 6033 6033 - tonic::Status, 6034 6034 - >; 5147 5147 + type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 6035 5148 fn call( 6036 5149 &mut self, 6037 5150 request: tonic::Request<super::CreatePlaylistRequest>, 6038 5151 ) -> Self::Future { 6039 5152 let inner = Arc::clone(&self.0); 6040 5153 let fut = async move { 6041 6041 - <T as PlaylistService>::create_playlist(&inner, request) 6042 6042 - .await 5154 5154 + <T as PlaylistService>::create_playlist(&inner, request).await 6043 5155 }; 6044 5156 Box::pin(fut) 6045 5157 } ··· 6069 5181 "/rockbox.v1alpha1.PlaylistService/InsertTracks" => { 6070 5182 #[allow(non_camel_case_types)] 6071 5183 struct InsertTracksSvc<T: PlaylistService>(pub Arc<T>); 6072 6072 - impl< 6073 6073 - T: PlaylistService, 6074 6074 - > tonic::server::UnaryService<super::InsertTracksRequest> 6075 6075 - for InsertTracksSvc<T> { 5184 5184 + impl<T: PlaylistService> tonic::server::UnaryService<super::InsertTracksRequest> 5185 5185 + for InsertTracksSvc<T> 5186 5186 + { 6076 5187 type Response = super::InsertTracksResponse; 6077 6077 - type Future = BoxFuture< 6078 6078 - tonic::Response<Self::Response>, 6079 6079 - tonic::Status, 6080 6080 - >; 5188 5188 + type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 6081 5189 fn call( 6082 5190 &mut self, 6083 5191 request: tonic::Request<super::InsertTracksRequest>, ··· 6114 5222 "/rockbox.v1alpha1.PlaylistService/InsertDirectory" => { 6115 5223 #[allow(non_camel_case_types)] 6116 5224 struct InsertDirectorySvc<T: PlaylistService>(pub Arc<T>); 6117 6117 - impl< 6118 6118 - T: PlaylistService, 6119 6119 - > tonic::server::UnaryService<super::InsertDirectoryRequest> 6120 6120 - for InsertDirectorySvc<T> { 5225 5225 + impl<T: PlaylistService> 5226 5226 + tonic::server::UnaryService<super::InsertDirectoryRequest> 5227 5227 + for InsertDirectorySvc<T> 5228 5228 + { 6121 5229 type Response = super::InsertDirectoryResponse; 6122 6122 - type Future = BoxFuture< 6123 6123 - tonic::Response<Self::Response>, 6124 6124 - tonic::Status, 6125 6125 - >; 5230 5230 + type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 6126 5231 fn call( 6127 5232 &mut self, 6128 5233 request: tonic::Request<super::InsertDirectoryRequest>, 6129 5234 ) -> Self::Future { 6130 5235 let inner = Arc::clone(&self.0); 6131 5236 let fut = async move { 6132 6132 - <T as PlaylistService>::insert_directory(&inner, request) 6133 6133 - .await 5237 5237 + <T as PlaylistService>::insert_directory(&inner, request).await 6134 5238 }; 6135 5239 Box::pin(fut) 6136 5240 } ··· 6160 5264 "/rockbox.v1alpha1.PlaylistService/InsertPlaylist" => { 6161 5265 #[allow(non_camel_case_types)] 6162 5266 struct InsertPlaylistSvc<T: PlaylistService>(pub Arc<T>); 6163 6163 - impl< 6164 6164 - T: PlaylistService, 6165 6165 - > tonic::server::UnaryService<super::InsertPlaylistRequest> 6166 6166 - for InsertPlaylistSvc<T> { 5267 5267 + impl<T: PlaylistService> 5268 5268 + tonic::server::UnaryService<super::InsertPlaylistRequest> 5269 5269 + for InsertPlaylistSvc<T> 5270 5270 + { 6167 5271 type Response = super::InsertPlaylistResponse; 6168 6168 - type Future = BoxFuture< 6169 6169 - tonic::Response<Self::Response>, 6170 6170 - tonic::Status, 6171 6171 - >; 5272 5272 + type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 6172 5273 fn call( 6173 5274 &mut self, 6174 5275 request: tonic::Request<super::InsertPlaylistRequest>, 6175 5276 ) -> Self::Future { 6176 5277 let inner = Arc::clone(&self.0); 6177 5278 let fut = async move { 6178 6178 - <T as PlaylistService>::insert_playlist(&inner, request) 6179 6179 - .await 5279 5279 + <T as PlaylistService>::insert_playlist(&inner, request).await 6180 5280 }; 6181 5281 Box::pin(fut) 6182 5282 } ··· 6206 5306 "/rockbox.v1alpha1.PlaylistService/InsertAlbum" => { 6207 5307 #[allow(non_camel_case_types)] 6208 5308 struct InsertAlbumSvc<T: PlaylistService>(pub Arc<T>); 6209 6209 - impl< 6210 6210 - T: PlaylistService, 6211 6211 - > tonic::server::UnaryService<super::InsertAlbumRequest> 6212 6212 - for InsertAlbumSvc<T> { 5309 5309 + impl<T: PlaylistService> tonic::server::UnaryService<super::InsertAlbumRequest> 5310 5310 + for InsertAlbumSvc<T> 5311 5311 + { 6213 5312 type Response = super::InsertAlbumResponse; 6214 6214 - type Future = BoxFuture< 6215 6215 - tonic::Response<Self::Response>, 6216 6216 - tonic::Status, 6217 6217 - >; 5313 5313 + type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 6218 5314 fn call( 6219 5315 &mut self, 6220 5316 request: tonic::Request<super::InsertAlbumRequest>, ··· 6251 5347 "/rockbox.v1alpha1.PlaylistService/InsertArtistTracks" => { 6252 5348 #[allow(non_camel_case_types)] 6253 5349 struct InsertArtistTracksSvc<T: PlaylistService>(pub Arc<T>); 6254 6254 - impl< 6255 6255 - T: PlaylistService, 6256 6256 - > tonic::server::UnaryService<super::InsertArtistTracksRequest> 6257 6257 - for InsertArtistTracksSvc<T> { 5350 5350 + impl<T: PlaylistService> 5351 5351 + tonic::server::UnaryService<super::InsertArtistTracksRequest> 5352 5352 + for InsertArtistTracksSvc<T> 5353 5353 + { 6258 5354 type Response = super::InsertArtistTracksResponse; 6259 6259 - type Future = BoxFuture< 6260 6260 - tonic::Response<Self::Response>, 6261 6261 - tonic::Status, 6262 6262 - >; 5355 5355 + type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 6263 5356 fn call( 6264 5357 &mut self, 6265 5358 request: tonic::Request<super::InsertArtistTracksRequest>, 6266 5359 ) -> Self::Future { 6267 5360 let inner = Arc::clone(&self.0); 6268 5361 let fut = async move { 6269 6269 - <T as PlaylistService>::insert_artist_tracks( 6270 6270 - &inner, 6271 6271 - request, 6272 6272 - ) 6273 6273 - .await 5362 5362 + <T as PlaylistService>::insert_artist_tracks(&inner, request).await 6274 5363 }; 6275 5364 Box::pin(fut) 6276 5365 } ··· 6300 5389 "/rockbox.v1alpha1.PlaylistService/ShufflePlaylist" => { 6301 5390 #[allow(non_camel_case_types)] 6302 5391 struct ShufflePlaylistSvc<T: PlaylistService>(pub Arc<T>); 6303 6303 - impl< 6304 6304 - T: PlaylistService, 6305 6305 - > tonic::server::UnaryService<super::ShufflePlaylistRequest> 6306 6306 - for ShufflePlaylistSvc<T> { 5392 5392 + impl<T: PlaylistService> 5393 5393 + tonic::server::UnaryService<super::ShufflePlaylistRequest> 5394 5394 + for ShufflePlaylistSvc<T> 5395 5395 + { 6307 5396 type Response = super::ShufflePlaylistResponse; 6308 6308 - type Future = BoxFuture< 6309 6309 - tonic::Response<Self::Response>, 6310 6310 - tonic::Status, 6311 6311 - >; 5397 5397 + type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 6312 5398 fn call( 6313 5399 &mut self, 6314 5400 request: tonic::Request<super::ShufflePlaylistRequest>, 6315 5401 ) -> Self::Future { 6316 5402 let inner = Arc::clone(&self.0); 6317 5403 let fut = async move { 6318 6318 - <T as PlaylistService>::shuffle_playlist(&inner, request) 6319 6319 - .await 5404 5404 + <T as PlaylistService>::shuffle_playlist(&inner, request).await 6320 5405 }; 6321 5406 Box::pin(fut) 6322 5407 } ··· 6343 5428 }; 6344 5429 Box::pin(fut) 6345 5430 } 6346 6346 - _ => { 6347 6347 - Box::pin(async move { 6348 6348 - let mut response = http::Response::new(empty_body()); 6349 6349 - let headers = response.headers_mut(); 6350 6350 - headers 6351 6351 - .insert( 6352 6352 - tonic::Status::GRPC_STATUS, 6353 6353 - (tonic::Code::Unimplemented as i32).into(), 6354 6354 - ); 6355 6355 - headers 6356 6356 - .insert( 6357 6357 - http::header::CONTENT_TYPE, 6358 6358 - tonic::metadata::GRPC_CONTENT_TYPE, 6359 6359 - ); 6360 6360 - Ok(response) 6361 6361 - }) 6362 6362 - } 5431 5431 + _ => Box::pin(async move { 5432 5432 + let mut response = http::Response::new(empty_body()); 5433 5433 + let headers = response.headers_mut(); 5434 5434 + headers.insert( 5435 5435 + tonic::Status::GRPC_STATUS, 5436 5436 + (tonic::Code::Unimplemented as i32).into(), 5437 5437 + ); 5438 5438 + headers.insert( 5439 5439 + http::header::CONTENT_TYPE, 5440 5440 + tonic::metadata::GRPC_CONTENT_TYPE, 5441 5441 + ); 5442 5442 + Ok(response) 5443 5443 + }), 6363 5444 } 6364 5445 } 6365 5446 } ··· 6869 5950 dead_code, 6870 5951 missing_docs, 6871 5952 clippy::wildcard_imports, 6872 6872 - clippy::let_unit_value, 5953 5953 + clippy::let_unit_value 6873 5954 )] 6874 6874 - use tonic::codegen::*; 6875 5955 use tonic::codegen::http::Uri; 5956 5956 + use tonic::codegen::*; 6876 5957 #[derive(Debug, Clone)] 6877 5958 pub struct SettingsServiceClient<T> { 6878 5959 inner: tonic::client::Grpc<T>, ··· 6916 5997 <T as tonic::client::GrpcService<tonic::body::BoxBody>>::ResponseBody, 6917 5998 >, 6918 5999 >, 6919 6919 - <T as tonic::codegen::Service< 6920 6920 - http::Request<tonic::body::BoxBody>, 6921 6921 - >>::Error: Into<StdError> + std::marker::Send + std::marker::Sync, 6000 6000 + <T as tonic::codegen::Service<http::Request<tonic::body::BoxBody>>>::Error: 6001 6001 + Into<StdError> + std::marker::Send + std::marker::Sync, 6922 6002 { 6923 6003 SettingsServiceClient::new(InterceptedService::new(inner, interceptor)) 6924 6004 } ··· 6956 6036 pub async fn get_settings_list( 6957 6037 &mut self, 6958 6038 request: impl tonic::IntoRequest<super::GetSettingsListRequest>, 6959 6959 - ) -> std::result::Result< 6960 6960 - tonic::Response<super::GetSettingsListResponse>, 6961 6961 - tonic::Status, 6962 6962 - > { 6963 6963 - self.inner 6964 6964 - .ready() 6965 6965 - .await 6966 6966 - .map_err(|e| { 6967 6967 - tonic::Status::unknown( 6968 6968 - format!("Service was not ready: {}", e.into()), 6969 6969 - ) 6970 6970 - })?; 6039 6039 + ) -> std::result::Result<tonic::Response<super::GetSettingsListResponse>, tonic::Status> 6040 6040 + { 6041 6041 + self.inner.ready().await.map_err(|e| { 6042 6042 + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 6043 6043 + })?; 6971 6044 let codec = tonic::codec::ProstCodec::default(); 6972 6045 let path = http::uri::PathAndQuery::from_static( 6973 6046 "/rockbox.v1alpha1.SettingsService/GetSettingsList", 6974 6047 ); 6975 6048 let mut req = request.into_request(); 6976 6976 - req.extensions_mut() 6977 6977 - .insert( 6978 6978 - GrpcMethod::new( 6979 6979 - "rockbox.v1alpha1.SettingsService", 6980 6980 - "GetSettingsList", 6981 6981 - ), 6982 6982 - ); 6049 6049 + req.extensions_mut().insert(GrpcMethod::new( 6050 6050 + "rockbox.v1alpha1.SettingsService", 6051 6051 + "GetSettingsList", 6052 6052 + )); 6983 6053 self.inner.unary(req, path, codec).await 6984 6054 } 6985 6055 pub async fn get_global_settings( 6986 6056 &mut self, 6987 6057 request: impl tonic::IntoRequest<super::GetGlobalSettingsRequest>, 6988 6988 - ) -> std::result::Result< 6989 6989 - tonic::Response<super::GetGlobalSettingsResponse>, 6990 6990 - tonic::Status, 6991 6991 - > { 6992 6992 - self.inner 6993 6993 - .ready() 6994 6994 - .await 6995 6995 - .map_err(|e| { 6996 6996 - tonic::Status::unknown( 6997 6997 - format!("Service was not ready: {}", e.into()), 6998 6998 - ) 6999 6999 - })?; 6058 6058 + ) -> std::result::Result<tonic::Response<super::GetGlobalSettingsResponse>, tonic::Status> 6059 6059 + { 6060 6060 + self.inner.ready().await.map_err(|e| { 6061 6061 + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 6062 6062 + })?; 7000 6063 let codec = tonic::codec::ProstCodec::default(); 7001 6064 let path = http::uri::PathAndQuery::from_static( 7002 6065 "/rockbox.v1alpha1.SettingsService/GetGlobalSettings", 7003 6066 ); 7004 6067 let mut req = request.into_request(); 7005 7005 - req.extensions_mut() 7006 7006 - .insert( 7007 7007 - GrpcMethod::new( 7008 7008 - "rockbox.v1alpha1.SettingsService", 7009 7009 - "GetGlobalSettings", 7010 7010 - ), 7011 7011 - ); 6068 6068 + req.extensions_mut().insert(GrpcMethod::new( 6069 6069 + "rockbox.v1alpha1.SettingsService", 6070 6070 + "GetGlobalSettings", 6071 6071 + )); 7012 6072 self.inner.unary(req, path, codec).await 7013 6073 } 7014 6074 pub async fn save_settings( 7015 6075 &mut self, 7016 6076 request: impl tonic::IntoRequest<super::SaveSettingsRequest>, 7017 7017 - ) -> std::result::Result< 7018 7018 - tonic::Response<super::SaveSettingsResponse>, 7019 7019 - tonic::Status, 7020 7020 - > { 7021 7021 - self.inner 7022 7022 - .ready() 7023 7023 - .await 7024 7024 - .map_err(|e| { 7025 7025 - tonic::Status::unknown( 7026 7026 - format!("Service was not ready: {}", e.into()), 7027 7027 - ) 7028 7028 - })?; 6077 6077 + ) -> std::result::Result<tonic::Response<super::SaveSettingsResponse>, tonic::Status> 6078 6078 + { 6079 6079 + self.inner.ready().await.map_err(|e| { 6080 6080 + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 6081 6081 + })?; 7029 6082 let codec = tonic::codec::ProstCodec::default(); 7030 6083 let path = http::uri::PathAndQuery::from_static( 7031 6084 "/rockbox.v1alpha1.SettingsService/SaveSettings", 7032 6085 ); 7033 6086 let mut req = request.into_request(); 7034 7034 - req.extensions_mut() 7035 7035 - .insert( 7036 7036 - GrpcMethod::new("rockbox.v1alpha1.SettingsService", "SaveSettings"), 7037 7037 - ); 6087 6087 + req.extensions_mut().insert(GrpcMethod::new( 6088 6088 + "rockbox.v1alpha1.SettingsService", 6089 6089 + "SaveSettings", 6090 6090 + )); 7038 6091 self.inner.unary(req, path, codec).await 7039 6092 } 7040 6093 } ··· 7046 6099 dead_code, 7047 6100 missing_docs, 7048 6101 clippy::wildcard_imports, 7049 7049 - clippy::let_unit_value, 6102 6102 + clippy::let_unit_value 7050 6103 )] 7051 6104 use tonic::codegen::*; 7052 6105 /// Generated trait containing gRPC methods that should be implemented for use with SettingsServiceServer. ··· 7055 6108 async fn get_settings_list( 7056 6109 &self, 7057 6110 request: tonic::Request<super::GetSettingsListRequest>, 7058 7058 - ) -> std::result::Result< 7059 7059 - tonic::Response<super::GetSettingsListResponse>, 7060 7060 - tonic::Status, 7061 7061 - >; 6111 6111 + ) -> std::result::Result<tonic::Response<super::GetSettingsListResponse>, tonic::Status>; 7062 6112 async fn get_global_settings( 7063 6113 &self, 7064 6114 request: tonic::Request<super::GetGlobalSettingsRequest>, 7065 7065 - ) -> std::result::Result< 7066 7066 - tonic::Response<super::GetGlobalSettingsResponse>, 7067 7067 - tonic::Status, 7068 7068 - >; 6115 6115 + ) -> std::result::Result<tonic::Response<super::GetGlobalSettingsResponse>, tonic::Status>; 7069 6116 async fn save_settings( 7070 6117 &self, 7071 6118 request: tonic::Request<super::SaveSettingsRequest>, 7072 7072 - ) -> std::result::Result< 7073 7073 - tonic::Response<super::SaveSettingsResponse>, 7074 7074 - tonic::Status, 7075 7075 - >; 6119 6119 + ) -> std::result::Result<tonic::Response<super::SaveSettingsResponse>, tonic::Status>; 7076 6120 } 7077 6121 #[derive(Debug)] 7078 6122 pub struct SettingsServiceServer<T> { ··· 7095 6139 max_encoding_message_size: None, 7096 6140 } 7097 6141 } 7098 7098 - pub fn with_interceptor<F>( 7099 7099 - inner: T, 7100 7100 - interceptor: F, 7101 7101 - ) -> InterceptedService<Self, F> 6142 6142 + pub fn with_interceptor<F>(inner: T, interceptor: F) -> InterceptedService<Self, F> 7102 6143 where 7103 6144 F: tonic::service::Interceptor, 7104 6145 { ··· 7153 6194 "/rockbox.v1alpha1.SettingsService/GetSettingsList" => { 7154 6195 #[allow(non_camel_case_types)] 7155 6196 struct GetSettingsListSvc<T: SettingsService>(pub Arc<T>); 7156 7156 - impl< 7157 7157 - T: SettingsService, 7158 7158 - > tonic::server::UnaryService<super::GetSettingsListRequest> 7159 7159 - for GetSettingsListSvc<T> { 6197 6197 + impl<T: SettingsService> 6198 6198 + tonic::server::UnaryService<super::GetSettingsListRequest> 6199 6199 + for GetSettingsListSvc<T> 6200 6200 + { 7160 6201 type Response = super::GetSettingsListResponse; 7161 7161 - type Future = BoxFuture< 7162 7162 - tonic::Response<Self::Response>, 7163 7163 - tonic::Status, 7164 7164 - >; 6202 6202 + type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 7165 6203 fn call( 7166 6204 &mut self, 7167 6205 request: tonic::Request<super::GetSettingsListRequest>, 7168 6206 ) -> Self::Future { 7169 6207 let inner = Arc::clone(&self.0); 7170 6208 let fut = async move { 7171 7171 - <T as SettingsService>::get_settings_list(&inner, request) 7172 7172 - .await 6209 6209 + <T as SettingsService>::get_settings_list(&inner, request).await 7173 6210 }; 7174 6211 Box::pin(fut) 7175 6212 } ··· 7199 6236 "/rockbox.v1alpha1.SettingsService/GetGlobalSettings" => { 7200 6237 #[allow(non_camel_case_types)] 7201 6238 struct GetGlobalSettingsSvc<T: SettingsService>(pub Arc<T>); 7202 7202 - impl< 7203 7203 - T: SettingsService, 7204 7204 - > tonic::server::UnaryService<super::GetGlobalSettingsRequest> 7205 7205 - for GetGlobalSettingsSvc<T> { 6239 6239 + impl<T: SettingsService> 6240 6240 + tonic::server::UnaryService<super::GetGlobalSettingsRequest> 6241 6241 + for GetGlobalSettingsSvc<T> 6242 6242 + { 7206 6243 type Response = super::GetGlobalSettingsResponse; 7207 7207 - type Future = BoxFuture< 7208 7208 - tonic::Response<Self::Response>, 7209 7209 - tonic::Status, 7210 7210 - >; 6244 6244 + type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 7211 6245 fn call( 7212 6246 &mut self, 7213 6247 request: tonic::Request<super::GetGlobalSettingsRequest>, 7214 6248 ) -> Self::Future { 7215 6249 let inner = Arc::clone(&self.0); 7216 6250 let fut = async move { 7217 7217 - <T as SettingsService>::get_global_settings(&inner, request) 7218 7218 - .await 6251 6251 + <T as SettingsService>::get_global_settings(&inner, request).await 7219 6252 }; 7220 6253 Box::pin(fut) 7221 6254 } ··· 7245 6278 "/rockbox.v1alpha1.SettingsService/SaveSettings" => { 7246 6279 #[allow(non_camel_case_types)] 7247 6280 struct SaveSettingsSvc<T: SettingsService>(pub Arc<T>); 7248 7248 - impl< 7249 7249 - T: SettingsService, 7250 7250 - > tonic::server::UnaryService<super::SaveSettingsRequest> 7251 7251 - for SaveSettingsSvc<T> { 6281 6281 + impl<T: SettingsService> tonic::server::UnaryService<super::SaveSettingsRequest> 6282 6282 + for SaveSettingsSvc<T> 6283 6283 + { 7252 6284 type Response = super::SaveSettingsResponse; 7253 7253 - type Future = BoxFuture< 7254 7254 - tonic::Response<Self::Response>, 7255 7255 - tonic::Status, 7256 7256 - >; 6285 6285 + type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 7257 6286 fn call( 7258 6287 &mut self, 7259 6288 request: tonic::Request<super::SaveSettingsRequest>, ··· 7287 6316 }; 7288 6317 Box::pin(fut) 7289 6318 } 7290 7290 - _ => { 7291 7291 - Box::pin(async move { 7292 7292 - let mut response = http::Response::new(empty_body()); 7293 7293 - let headers = response.headers_mut(); 7294 7294 - headers 7295 7295 - .insert( 7296 7296 - tonic::Status::GRPC_STATUS, 7297 7297 - (tonic::Code::Unimplemented as i32).into(), 7298 7298 - ); 7299 7299 - headers 7300 7300 - .insert( 7301 7301 - http::header::CONTENT_TYPE, 7302 7302 - tonic::metadata::GRPC_CONTENT_TYPE, 7303 7303 - ); 7304 7304 - Ok(response) 7305 7305 - }) 7306 7306 - } 6319 6319 + _ => Box::pin(async move { 6320 6320 + let mut response = http::Response::new(empty_body()); 6321 6321 + let headers = response.headers_mut(); 6322 6322 + headers.insert( 6323 6323 + tonic::Status::GRPC_STATUS, 6324 6324 + (tonic::Code::Unimplemented as i32).into(), 6325 6325 + ); 6326 6326 + headers.insert( 6327 6327 + http::header::CONTENT_TYPE, 6328 6328 + tonic::metadata::GRPC_CONTENT_TYPE, 6329 6329 + ); 6330 6330 + Ok(response) 6331 6331 + }), 7307 6332 } 7308 6333 } 7309 6334 } ··· 7461 6486 dead_code, 7462 6487 missing_docs, 7463 6488 clippy::wildcard_imports, 7464 7464 - clippy::let_unit_value, 6489 6489 + clippy::let_unit_value 7465 6490 )] 7466 7466 - use tonic::codegen::*; 7467 6491 use tonic::codegen::http::Uri; 6492 6492 + use tonic::codegen::*; 7468 6493 #[derive(Debug, Clone)] 7469 6494 pub struct SoundServiceClient<T> { 7470 6495 inner: tonic::client::Grpc<T>, ··· 7508 6533 <T as tonic::client::GrpcService<tonic::body::BoxBody>>::ResponseBody, 7509 6534 >, 7510 6535 >, 7511 7511 - <T as tonic::codegen::Service< 7512 7512 - http::Request<tonic::body::BoxBody>, 7513 7513 - >>::Error: Into<StdError> + std::marker::Send + std::marker::Sync, 6536 6536 + <T as tonic::codegen::Service<http::Request<tonic::body::BoxBody>>>::Error: 6537 6537 + Into<StdError> + std::marker::Send + std::marker::Sync, 7514 6538 { 7515 6539 SoundServiceClient::new(InterceptedService::new(inner, interceptor)) 7516 6540 } ··· 7548 6572 pub async fn adjust_volume( 7549 6573 &mut self, 7550 6574 request: impl tonic::IntoRequest<super::AdjustVolumeRequest>, 7551 7551 - ) -> std::result::Result< 7552 7552 - tonic::Response<super::AdjustVolumeResponse>, 7553 7553 - tonic::Status, 7554 7554 - > { 7555 7555 - self.inner 7556 7556 - .ready() 7557 7557 - .await 7558 7558 - .map_err(|e| { 7559 7559 - tonic::Status::unknown( 7560 7560 - format!("Service was not ready: {}", e.into()), 7561 7561 - ) 7562 7562 - })?; 6575 6575 + ) -> std::result::Result<tonic::Response<super::AdjustVolumeResponse>, tonic::Status> 6576 6576 + { 6577 6577 + self.inner.ready().await.map_err(|e| { 6578 6578 + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 6579 6579 + })?; 7563 6580 let codec = tonic::codec::ProstCodec::default(); 7564 7564 - let path = http::uri::PathAndQuery::from_static( 7565 7565 - "/rockbox.v1alpha1.SoundService/AdjustVolume", 7566 7566 - ); 6581 6581 + let path = 6582 6582 + http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.SoundService/AdjustVolume"); 7567 6583 let mut req = request.into_request(); 7568 7568 - req.extensions_mut() 7569 7569 - .insert( 7570 7570 - GrpcMethod::new("rockbox.v1alpha1.SoundService", "AdjustVolume"), 7571 7571 - ); 6584 6584 + req.extensions_mut().insert(GrpcMethod::new( 6585 6585 + "rockbox.v1alpha1.SoundService", 6586 6586 + "AdjustVolume", 6587 6587 + )); 7572 6588 self.inner.unary(req, path, codec).await 7573 6589 } 7574 6590 pub async fn sound_set( 7575 6591 &mut self, 7576 6592 request: impl tonic::IntoRequest<super::SoundSetRequest>, 7577 7577 - ) -> std::result::Result< 7578 7578 - tonic::Response<super::SoundSetResponse>, 7579 7579 - tonic::Status, 7580 7580 - > { 7581 7581 - self.inner 7582 7582 - .ready() 7583 7583 - .await 7584 7584 - .map_err(|e| { 7585 7585 - tonic::Status::unknown( 7586 7586 - format!("Service was not ready: {}", e.into()), 7587 7587 - ) 7588 7588 - })?; 6593 6593 + ) -> std::result::Result<tonic::Response<super::SoundSetResponse>, tonic::Status> { 6594 6594 + self.inner.ready().await.map_err(|e| { 6595 6595 + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 6596 6596 + })?; 7589 6597 let codec = tonic::codec::ProstCodec::default(); 7590 7590 - let path = http::uri::PathAndQuery::from_static( 7591 7591 - "/rockbox.v1alpha1.SoundService/SoundSet", 7592 7592 - ); 6598 6598 + let path = 6599 6599 + http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.SoundService/SoundSet"); 7593 6600 let mut req = request.into_request(); 7594 6601 req.extensions_mut() 7595 6602 .insert(GrpcMethod::new("rockbox.v1alpha1.SoundService", "SoundSet")); ··· 7598 6605 pub async fn sound_current( 7599 6606 &mut self, 7600 6607 request: impl tonic::IntoRequest<super::SoundCurrentRequest>, 7601 7601 - ) -> std::result::Result< 7602 7602 - tonic::Response<super::SoundCurrentResponse>, 7603 7603 - tonic::Status, 7604 7604 - > { 7605 7605 - self.inner 7606 7606 - .ready() 7607 7607 - .await 7608 7608 - .map_err(|e| { 7609 7609 - tonic::Status::unknown( 7610 7610 - format!("Service was not ready: {}", e.into()), 7611 7611 - ) 7612 7612 - })?; 6608 6608 + ) -> std::result::Result<tonic::Response<super::SoundCurrentResponse>, tonic::Status> 6609 6609 + { 6610 6610 + self.inner.ready().await.map_err(|e| { 6611 6611 + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 6612 6612 + })?; 7613 6613 let codec = tonic::codec::ProstCodec::default(); 7614 7614 - let path = http::uri::PathAndQuery::from_static( 7615 7615 - "/rockbox.v1alpha1.SoundService/SoundCurrent", 7616 7616 - ); 6614 6614 + let path = 6615 6615 + http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.SoundService/SoundCurrent"); 7617 6616 let mut req = request.into_request(); 7618 7618 - req.extensions_mut() 7619 7619 - .insert( 7620 7620 - GrpcMethod::new("rockbox.v1alpha1.SoundService", "SoundCurrent"), 7621 7621 - ); 6617 6617 + req.extensions_mut().insert(GrpcMethod::new( 6618 6618 + "rockbox.v1alpha1.SoundService", 6619 6619 + "SoundCurrent", 6620 6620 + )); 7622 6621 self.inner.unary(req, path, codec).await 7623 6622 } 7624 6623 pub async fn sound_default( 7625 6624 &mut self, 7626 6625 request: impl tonic::IntoRequest<super::SoundDefaultRequest>, 7627 7627 - ) -> std::result::Result< 7628 7628 - tonic::Response<super::SoundDefaultResponse>, 7629 7629 - tonic::Status, 7630 7630 - > { 7631 7631 - self.inner 7632 7632 - .ready() 7633 7633 - .await 7634 7634 - .map_err(|e| { 7635 7635 - tonic::Status::unknown( 7636 7636 - format!("Service was not ready: {}", e.into()), 7637 7637 - ) 7638 7638 - })?; 6626 6626 + ) -> std::result::Result<tonic::Response<super::SoundDefaultResponse>, tonic::Status> 6627 6627 + { 6628 6628 + self.inner.ready().await.map_err(|e| { 6629 6629 + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 6630 6630 + })?; 7639 6631 let codec = tonic::codec::ProstCodec::default(); 7640 7640 - let path = http::uri::PathAndQuery::from_static( 7641 7641 - "/rockbox.v1alpha1.SoundService/SoundDefault", 7642 7642 - ); 6632 6632 + let path = 6633 6633 + http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.SoundService/SoundDefault"); 7643 6634 let mut req = request.into_request(); 7644 7644 - req.extensions_mut() 7645 7645 - .insert( 7646 7646 - GrpcMethod::new("rockbox.v1alpha1.SoundService", "SoundDefault"), 7647 7647 - ); 6635 6635 + req.extensions_mut().insert(GrpcMethod::new( 6636 6636 + "rockbox.v1alpha1.SoundService", 6637 6637 + "SoundDefault", 6638 6638 + )); 7648 6639 self.inner.unary(req, path, codec).await 7649 6640 } 7650 6641 pub async fn sound_min( 7651 6642 &mut self, 7652 6643 request: impl tonic::IntoRequest<super::SoundMinRequest>, 7653 7653 - ) -> std::result::Result< 7654 7654 - tonic::Response<super::SoundMinResponse>, 7655 7655 - tonic::Status, 7656 7656 - > { 7657 7657 - self.inner 7658 7658 - .ready() 7659 7659 - .await 7660 7660 - .map_err(|e| { 7661 7661 - tonic::Status::unknown( 7662 7662 - format!("Service was not ready: {}", e.into()), 7663 7663 - ) 7664 7664 - })?; 6644 6644 + ) -> std::result::Result<tonic::Response<super::SoundMinResponse>, tonic::Status> { 6645 6645 + self.inner.ready().await.map_err(|e| { 6646 6646 + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 6647 6647 + })?; 7665 6648 let codec = tonic::codec::ProstCodec::default(); 7666 7666 - let path = http::uri::PathAndQuery::from_static( 7667 7667 - "/rockbox.v1alpha1.SoundService/SoundMin", 7668 7668 - ); 6649 6649 + let path = 6650 6650 + http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.SoundService/SoundMin"); 7669 6651 let mut req = request.into_request(); 7670 6652 req.extensions_mut() 7671 6653 .insert(GrpcMethod::new("rockbox.v1alpha1.SoundService", "SoundMin")); ··· 7674 6656 pub async fn sound_max( 7675 6657 &mut self, 7676 6658 request: impl tonic::IntoRequest<super::SoundMaxRequest>, 7677 7677 - ) -> std::result::Result< 7678 7678 - tonic::Response<super::SoundMaxResponse>, 7679 7679 - tonic::Status, 7680 7680 - > { 7681 7681 - self.inner 7682 7682 - .ready() 7683 7683 - .await 7684 7684 - .map_err(|e| { 7685 7685 - tonic::Status::unknown( 7686 7686 - format!("Service was not ready: {}", e.into()), 7687 7687 - ) 7688 7688 - })?; 6659 6659 + ) -> std::result::Result<tonic::Response<super::SoundMaxResponse>, tonic::Status> { 6660 6660 + self.inner.ready().await.map_err(|e| { 6661 6661 + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 6662 6662 + })?; 7689 6663 let codec = tonic::codec::ProstCodec::default(); 7690 7690 - let path = http::uri::PathAndQuery::from_static( 7691 7691 - "/rockbox.v1alpha1.SoundService/SoundMax", 7692 7692 - ); 6664 6664 + let path = 6665 6665 + http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.SoundService/SoundMax"); 7693 6666 let mut req = request.into_request(); 7694 6667 req.extensions_mut() 7695 6668 .insert(GrpcMethod::new("rockbox.v1alpha1.SoundService", "SoundMax")); ··· 7698 6671 pub async fn sound_unit( 7699 6672 &mut self, 7700 6673 request: impl tonic::IntoRequest<super::SoundUnitRequest>, 7701 7701 - ) -> std::result::Result< 7702 7702 - tonic::Response<super::SoundUnitResponse>, 7703 7703 - tonic::Status, 7704 7704 - > { 7705 7705 - self.inner 7706 7706 - .ready() 7707 7707 - .await 7708 7708 - .map_err(|e| { 7709 7709 - tonic::Status::unknown( 7710 7710 - format!("Service was not ready: {}", e.into()), 7711 7711 - ) 7712 7712 - })?; 6674 6674 + ) -> std::result::Result<tonic::Response<super::SoundUnitResponse>, tonic::Status> { 6675 6675 + self.inner.ready().await.map_err(|e| { 6676 6676 + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 6677 6677 + })?; 7713 6678 let codec = tonic::codec::ProstCodec::default(); 7714 7714 - let path = http::uri::PathAndQuery::from_static( 7715 7715 - "/rockbox.v1alpha1.SoundService/SoundUnit", 7716 7716 - ); 6679 6679 + let path = 6680 6680 + http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.SoundService/SoundUnit"); 7717 6681 let mut req = request.into_request(); 7718 7718 - req.extensions_mut() 7719 7719 - .insert(GrpcMethod::new("rockbox.v1alpha1.SoundService", "SoundUnit")); 6682 6682 + req.extensions_mut().insert(GrpcMethod::new( 6683 6683 + "rockbox.v1alpha1.SoundService", 6684 6684 + "SoundUnit", 6685 6685 + )); 7720 6686 self.inner.unary(req, path, codec).await 7721 6687 } 7722 6688 pub async fn sound_val2_phys( 7723 6689 &mut self, 7724 6690 request: impl tonic::IntoRequest<super::SoundVal2PhysRequest>, 7725 7725 - ) -> std::result::Result< 7726 7726 - tonic::Response<super::SoundVal2PhysResponse>, 7727 7727 - tonic::Status, 7728 7728 - > { 7729 7729 - self.inner 7730 7730 - .ready() 7731 7731 - .await 7732 7732 - .map_err(|e| { 7733 7733 - tonic::Status::unknown( 7734 7734 - format!("Service was not ready: {}", e.into()), 7735 7735 - ) 7736 7736 - })?; 6691 6691 + ) -> std::result::Result<tonic::Response<super::SoundVal2PhysResponse>, tonic::Status> 6692 6692 + { 6693 6693 + self.inner.ready().await.map_err(|e| { 6694 6694 + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 6695 6695 + })?; 7737 6696 let codec = tonic::codec::ProstCodec::default(); 7738 6697 let path = http::uri::PathAndQuery::from_static( 7739 6698 "/rockbox.v1alpha1.SoundService/SoundVal2Phys", 7740 6699 ); 7741 6700 let mut req = request.into_request(); 7742 7742 - req.extensions_mut() 7743 7743 - .insert( 7744 7744 - GrpcMethod::new("rockbox.v1alpha1.SoundService", "SoundVal2Phys"), 7745 7745 - ); 6701 6701 + req.extensions_mut().insert(GrpcMethod::new( 6702 6702 + "rockbox.v1alpha1.SoundService", 6703 6703 + "SoundVal2Phys", 6704 6704 + )); 7746 6705 self.inner.unary(req, path, codec).await 7747 6706 } 7748 6707 pub async fn get_pitch( 7749 6708 &mut self, 7750 6709 request: impl tonic::IntoRequest<super::GetPitchRequest>, 7751 7751 - ) -> std::result::Result< 7752 7752 - tonic::Response<super::GetPitchResponse>, 7753 7753 - tonic::Status, 7754 7754 - > { 7755 7755 - self.inner 7756 7756 - .ready() 7757 7757 - .await 7758 7758 - .map_err(|e| { 7759 7759 - tonic::Status::unknown( 7760 7760 - format!("Service was not ready: {}", e.into()), 7761 7761 - ) 7762 7762 - })?; 6710 6710 + ) -> std::result::Result<tonic::Response<super::GetPitchResponse>, tonic::Status> { 6711 6711 + self.inner.ready().await.map_err(|e| { 6712 6712 + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 6713 6713 + })?; 7763 6714 let codec = tonic::codec::ProstCodec::default(); 7764 7764 - let path = http::uri::PathAndQuery::from_static( 7765 7765 - "/rockbox.v1alpha1.SoundService/GetPitch", 7766 7766 - ); 6715 6715 + let path = 6716 6716 + http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.SoundService/GetPitch"); 7767 6717 let mut req = request.into_request(); 7768 6718 req.extensions_mut() 7769 6719 .insert(GrpcMethod::new("rockbox.v1alpha1.SoundService", "GetPitch")); ··· 7772 6722 pub async fn set_pitch( 7773 6723 &mut self, 7774 6724 request: impl tonic::IntoRequest<super::SetPitchRequest>, 7775 7775 - ) -> std::result::Result< 7776 7776 - tonic::Response<super::SetPitchResponse>, 7777 7777 - tonic::Status, 7778 7778 - > { 7779 7779 - self.inner 7780 7780 - .ready() 7781 7781 - .await 7782 7782 - .map_err(|e| { 7783 7783 - tonic::Status::unknown( 7784 7784 - format!("Service was not ready: {}", e.into()), 7785 7785 - ) 7786 7786 - })?; 6725 6725 + ) -> std::result::Result<tonic::Response<super::SetPitchResponse>, tonic::Status> { 6726 6726 + self.inner.ready().await.map_err(|e| { 6727 6727 + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 6728 6728 + })?; 7787 6729 let codec = tonic::codec::ProstCodec::default(); 7788 7788 - let path = http::uri::PathAndQuery::from_static( 7789 7789 - "/rockbox.v1alpha1.SoundService/SetPitch", 7790 7790 - ); 6730 6730 + let path = 6731 6731 + http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.SoundService/SetPitch"); 7791 6732 let mut req = request.into_request(); 7792 6733 req.extensions_mut() 7793 6734 .insert(GrpcMethod::new("rockbox.v1alpha1.SoundService", "SetPitch")); ··· 7796 6737 pub async fn beep_play( 7797 6738 &mut self, 7798 6739 request: impl tonic::IntoRequest<super::BeepPlayRequest>, 7799 7799 - ) -> std::result::Result< 7800 7800 - tonic::Response<super::BeepPlayResponse>, 7801 7801 - tonic::Status, 7802 7802 - > { 7803 7803 - self.inner 7804 7804 - .ready() 7805 7805 - .await 7806 7806 - .map_err(|e| { 7807 7807 - tonic::Status::unknown( 7808 7808 - format!("Service was not ready: {}", e.into()), 7809 7809 - ) 7810 7810 - })?; 6740 6740 + ) -> std::result::Result<tonic::Response<super::BeepPlayResponse>, tonic::Status> { 6741 6741 + self.inner.ready().await.map_err(|e| { 6742 6742 + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 6743 6743 + })?; 7811 6744 let codec = tonic::codec::ProstCodec::default(); 7812 7812 - let path = http::uri::PathAndQuery::from_static( 7813 7813 - "/rockbox.v1alpha1.SoundService/BeepPlay", 7814 7814 - ); 6745 6745 + let path = 6746 6746 + http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.SoundService/BeepPlay"); 7815 6747 let mut req = request.into_request(); 7816 6748 req.extensions_mut() 7817 6749 .insert(GrpcMethod::new("rockbox.v1alpha1.SoundService", "BeepPlay")); ··· 7820 6752 pub async fn pcmbuf_fade( 7821 6753 &mut self, 7822 6754 request: impl tonic::IntoRequest<super::PcmbufFadeRequest>, 7823 7823 - ) -> std::result::Result< 7824 7824 - tonic::Response<super::PcmbufFadeResponse>, 7825 7825 - tonic::Status, 7826 7826 - > { 7827 7827 - self.inner 7828 7828 - .ready() 7829 7829 - .await 7830 7830 - .map_err(|e| { 7831 7831 - tonic::Status::unknown( 7832 7832 - format!("Service was not ready: {}", e.into()), 7833 7833 - ) 7834 7834 - })?; 6755 6755 + ) -> std::result::Result<tonic::Response<super::PcmbufFadeResponse>, tonic::Status> 6756 6756 + { 6757 6757 + self.inner.ready().await.map_err(|e| { 6758 6758 + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 6759 6759 + })?; 7835 6760 let codec = tonic::codec::ProstCodec::default(); 7836 7836 - let path = http::uri::PathAndQuery::from_static( 7837 7837 - "/rockbox.v1alpha1.SoundService/PcmbufFade", 7838 7838 - ); 6761 6761 + let path = 6762 6762 + http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.SoundService/PcmbufFade"); 7839 6763 let mut req = request.into_request(); 7840 7840 - req.extensions_mut() 7841 7841 - .insert(GrpcMethod::new("rockbox.v1alpha1.SoundService", "PcmbufFade")); 6764 6764 + req.extensions_mut().insert(GrpcMethod::new( 6765 6765 + "rockbox.v1alpha1.SoundService", 6766 6766 + "PcmbufFade", 6767 6767 + )); 7842 6768 self.inner.unary(req, path, codec).await 7843 6769 } 7844 6770 pub async fn pcmbuf_set_low_latency( 7845 6771 &mut self, 7846 6772 request: impl tonic::IntoRequest<super::PcmbufSetLowLatencyRequest>, 7847 7847 - ) -> std::result::Result< 7848 7848 - tonic::Response<super::PcmbufSetLowLatencyResponse>, 7849 7849 - tonic::Status, 7850 7850 - > { 7851 7851 - self.inner 7852 7852 - .ready() 7853 7853 - .await 7854 7854 - .map_err(|e| { 7855 7855 - tonic::Status::unknown( 7856 7856 - format!("Service was not ready: {}", e.into()), 7857 7857 - ) 7858 7858 - })?; 6773 6773 + ) -> std::result::Result<tonic::Response<super::PcmbufSetLowLatencyResponse>, tonic::Status> 6774 6774 + { 6775 6775 + self.inner.ready().await.map_err(|e| { 6776 6776 + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 6777 6777 + })?; 7859 6778 let codec = tonic::codec::ProstCodec::default(); 7860 6779 let path = http::uri::PathAndQuery::from_static( 7861 6780 "/rockbox.v1alpha1.SoundService/PcmbufSetLowLatency", 7862 6781 ); 7863 6782 let mut req = request.into_request(); 7864 7864 - req.extensions_mut() 7865 7865 - .insert( 7866 7866 - GrpcMethod::new( 7867 7867 - "rockbox.v1alpha1.SoundService", 7868 7868 - "PcmbufSetLowLatency", 7869 7869 - ), 7870 7870 - ); 6783 6783 + req.extensions_mut().insert(GrpcMethod::new( 6784 6784 + "rockbox.v1alpha1.SoundService", 6785 6785 + "PcmbufSetLowLatency", 6786 6786 + )); 7871 6787 self.inner.unary(req, path, codec).await 7872 6788 } 7873 6789 pub async fn system_sound_play( 7874 6790 &mut self, 7875 6791 request: impl tonic::IntoRequest<super::SystemSoundPlayRequest>, 7876 7876 - ) -> std::result::Result< 7877 7877 - tonic::Response<super::SystemSoundPlayResponse>, 7878 7878 - tonic::Status, 7879 7879 - > { 7880 7880 - self.inner 7881 7881 - .ready() 7882 7882 - .await 7883 7883 - .map_err(|e| { 7884 7884 - tonic::Status::unknown( 7885 7885 - format!("Service was not ready: {}", e.into()), 7886 7886 - ) 7887 7887 - })?; 6792 6792 + ) -> std::result::Result<tonic::Response<super::SystemSoundPlayResponse>, tonic::Status> 6793 6793 + { 6794 6794 + self.inner.ready().await.map_err(|e| { 6795 6795 + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 6796 6796 + })?; 7888 6797 let codec = tonic::codec::ProstCodec::default(); 7889 6798 let path = http::uri::PathAndQuery::from_static( 7890 6799 "/rockbox.v1alpha1.SoundService/SystemSoundPlay", 7891 6800 ); 7892 6801 let mut req = request.into_request(); 7893 7893 - req.extensions_mut() 7894 7894 - .insert( 7895 7895 - GrpcMethod::new("rockbox.v1alpha1.SoundService", "SystemSoundPlay"), 7896 7896 - ); 6802 6802 + req.extensions_mut().insert(GrpcMethod::new( 6803 6803 + "rockbox.v1alpha1.SoundService", 6804 6804 + "SystemSoundPlay", 6805 6805 + )); 7897 6806 self.inner.unary(req, path, codec).await 7898 6807 } 7899 6808 pub async fn keyclick_click( 7900 6809 &mut self, 7901 6810 request: impl tonic::IntoRequest<super::KeyclickClickRequest>, 7902 7902 - ) -> std::result::Result< 7903 7903 - tonic::Response<super::KeyclickClickResponse>, 7904 7904 - tonic::Status, 7905 7905 - > { 7906 7906 - self.inner 7907 7907 - .ready() 7908 7908 - .await 7909 7909 - .map_err(|e| { 7910 7910 - tonic::Status::unknown( 7911 7911 - format!("Service was not ready: {}", e.into()), 7912 7912 - ) 7913 7913 - })?; 6811 6811 + ) -> std::result::Result<tonic::Response<super::KeyclickClickResponse>, tonic::Status> 6812 6812 + { 6813 6813 + self.inner.ready().await.map_err(|e| { 6814 6814 + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 6815 6815 + })?; 7914 6816 let codec = tonic::codec::ProstCodec::default(); 7915 6817 let path = http::uri::PathAndQuery::from_static( 7916 6818 "/rockbox.v1alpha1.SoundService/KeyclickClick", 7917 6819 ); 7918 6820 let mut req = request.into_request(); 7919 7919 - req.extensions_mut() 7920 7920 - .insert( 7921 7921 - GrpcMethod::new("rockbox.v1alpha1.SoundService", "KeyclickClick"), 7922 7922 - ); 6821 6821 + req.extensions_mut().insert(GrpcMethod::new( 6822 6822 + "rockbox.v1alpha1.SoundService", 6823 6823 + "KeyclickClick", 6824 6824 + )); 7923 6825 self.inner.unary(req, path, codec).await 7924 6826 } 7925 6827 } ··· 7931 6833 dead_code, 7932 6834 missing_docs, 7933 6835 clippy::wildcard_imports, 7934 7934 - clippy::let_unit_value, 6836 6836 + clippy::let_unit_value 7935 6837 )] 7936 6838 use tonic::codegen::*; 7937 6839 /// Generated trait containing gRPC methods that should be implemented for use with SoundServiceServer. ··· 7940 6842 async fn adjust_volume( 7941 6843 &self, 7942 6844 request: tonic::Request<super::AdjustVolumeRequest>, 7943 7943 - ) -> std::result::Result< 7944 7944 - tonic::Response<super::AdjustVolumeResponse>, 7945 7945 - tonic::Status, 7946 7946 - >; 6845 6845 + ) -> std::result::Result<tonic::Response<super::AdjustVolumeResponse>, tonic::Status>; 7947 6846 async fn sound_set( 7948 6847 &self, 7949 6848 request: tonic::Request<super::SoundSetRequest>, 7950 7950 - ) -> std::result::Result< 7951 7951 - tonic::Response<super::SoundSetResponse>, 7952 7952 - tonic::Status, 7953 7953 - >; 6849 6849 + ) -> std::result::Result<tonic::Response<super::SoundSetResponse>, tonic::Status>; 7954 6850 async fn sound_current( 7955 6851 &self, 7956 6852 request: tonic::Request<super::SoundCurrentRequest>, 7957 7957 - ) -> std::result::Result< 7958 7958 - tonic::Response<super::SoundCurrentResponse>, 7959 7959 - tonic::Status, 7960 7960 - >; 6853 6853 + ) -> std::result::Result<tonic::Response<super::SoundCurrentResponse>, tonic::Status>; 7961 6854 async fn sound_default( 7962 6855 &self, 7963 6856 request: tonic::Request<super::SoundDefaultRequest>, 7964 7964 - ) -> std::result::Result< 7965 7965 - tonic::Response<super::SoundDefaultResponse>, 7966 7966 - tonic::Status, 7967 7967 - >; 6857 6857 + ) -> std::result::Result<tonic::Response<super::SoundDefaultResponse>, tonic::Status>; 7968 6858 async fn sound_min( 7969 6859 &self, 7970 6860 request: tonic::Request<super::SoundMinRequest>, 7971 7971 - ) -> std::result::Result< 7972 7972 - tonic::Response<super::SoundMinResponse>, 7973 7973 - tonic::Status, 7974 7974 - >; 6861 6861 + ) -> std::result::Result<tonic::Response<super::SoundMinResponse>, tonic::Status>; 7975 6862 async fn sound_max( 7976 6863 &self, 7977 6864 request: tonic::Request<super::SoundMaxRequest>, 7978 7978 - ) -> std::result::Result< 7979 7979 - tonic::Response<super::SoundMaxResponse>, 7980 7980 - tonic::Status, 7981 7981 - >; 6865 6865 + ) -> std::result::Result<tonic::Response<super::SoundMaxResponse>, tonic::Status>; 7982 6866 async fn sound_unit( 7983 6867 &self, 7984 6868 request: tonic::Request<super::SoundUnitRequest>, 7985 7985 - ) -> std::result::Result< 7986 7986 - tonic::Response<super::SoundUnitResponse>, 7987 7987 - tonic::Status, 7988 7988 - >; 6869 6869 + ) -> std::result::Result<tonic::Response<super::SoundUnitResponse>, tonic::Status>; 7989 6870 async fn sound_val2_phys( 7990 6871 &self, 7991 6872 request: tonic::Request<super::SoundVal2PhysRequest>, 7992 7992 - ) -> std::result::Result< 7993 7993 - tonic::Response<super::SoundVal2PhysResponse>, 7994 7994 - tonic::Status, 7995 7995 - >; 6873 6873 + ) -> std::result::Result<tonic::Response<super::SoundVal2PhysResponse>, tonic::Status>; 7996 6874 async fn get_pitch( 7997 6875 &self, 7998 6876 request: tonic::Request<super::GetPitchRequest>, 7999 7999 - ) -> std::result::Result< 8000 8000 - tonic::Response<super::GetPitchResponse>, 8001 8001 - tonic::Status, 8002 8002 - >; 6877 6877 + ) -> std::result::Result<tonic::Response<super::GetPitchResponse>, tonic::Status>; 8003 6878 async fn set_pitch( 8004 6879 &self, 8005 6880 request: tonic::Request<super::SetPitchRequest>, 8006 8006 - ) -> std::result::Result< 8007 8007 - tonic::Response<super::SetPitchResponse>, 8008 8008 - tonic::Status, 8009 8009 - >; 6881 6881 + ) -> std::result::Result<tonic::Response<super::SetPitchResponse>, tonic::Status>; 8010 6882 async fn beep_play( 8011 6883 &self, 8012 6884 request: tonic::Request<super::BeepPlayRequest>, 8013 8013 - ) -> std::result::Result< 8014 8014 - tonic::Response<super::BeepPlayResponse>, 8015 8015 - tonic::Status, 8016 8016 - >; 6885 6885 + ) -> std::result::Result<tonic::Response<super::BeepPlayResponse>, tonic::Status>; 8017 6886 async fn pcmbuf_fade( 8018 6887 &self, 8019 6888 request: tonic::Request<super::PcmbufFadeRequest>, 8020 8020 - ) -> std::result::Result< 8021 8021 - tonic::Response<super::PcmbufFadeResponse>, 8022 8022 - tonic::Status, 8023 8023 - >; 6889 6889 + ) -> std::result::Result<tonic::Response<super::PcmbufFadeResponse>, tonic::Status>; 8024 6890 async fn pcmbuf_set_low_latency( 8025 6891 &self, 8026 6892 request: tonic::Request<super::PcmbufSetLowLatencyRequest>, 8027 8027 - ) -> std::result::Result< 8028 8028 - tonic::Response<super::PcmbufSetLowLatencyResponse>, 8029 8029 - tonic::Status, 8030 8030 - >; 6893 6893 + ) -> std::result::Result<tonic::Response<super::PcmbufSetLowLatencyResponse>, tonic::Status>; 8031 6894 async fn system_sound_play( 8032 6895 &self, 8033 6896 request: tonic::Request<super::SystemSoundPlayRequest>, 8034 8034 - ) -> std::result::Result< 8035 8035 - tonic::Response<super::SystemSoundPlayResponse>, 8036 8036 - tonic::Status, 8037 8037 - >; 6897 6897 + ) -> std::result::Result<tonic::Response<super::SystemSoundPlayResponse>, tonic::Status>; 8038 6898 async fn keyclick_click( 8039 6899 &self, 8040 6900 request: tonic::Request<super::KeyclickClickRequest>, 8041 8041 - ) -> std::result::Result< 8042 8042 - tonic::Response<super::KeyclickClickResponse>, 8043 8043 - tonic::Status, 8044 8044 - >; 6901 6901 + ) -> std::result::Result<tonic::Response<super::KeyclickClickResponse>, tonic::Status>; 8045 6902 } 8046 6903 #[derive(Debug)] 8047 6904 pub struct SoundServiceServer<T> { ··· 8064 6921 max_encoding_message_size: None, 8065 6922 } 8066 6923 } 8067 8067 - pub fn with_interceptor<F>( 8068 8068 - inner: T, 8069 8069 - interceptor: F, 8070 8070 - ) -> InterceptedService<Self, F> 6924 6924 + pub fn with_interceptor<F>(inner: T, interceptor: F) -> InterceptedService<Self, F> 8071 6925 where 8072 6926 F: tonic::service::Interceptor, 8073 6927 { ··· 8122 6976 "/rockbox.v1alpha1.SoundService/AdjustVolume" => { 8123 6977 #[allow(non_camel_case_types)] 8124 6978 struct AdjustVolumeSvc<T: SoundService>(pub Arc<T>); 8125 8125 - impl< 8126 8126 - T: SoundService, 8127 8127 - > tonic::server::UnaryService<super::AdjustVolumeRequest> 8128 8128 - for AdjustVolumeSvc<T> { 6979 6979 + impl<T: SoundService> tonic::server::UnaryService<super::AdjustVolumeRequest> 6980 6980 + for AdjustVolumeSvc<T> 6981 6981 + { 8129 6982 type Response = super::AdjustVolumeResponse; 8130 8130 - type Future = BoxFuture< 8131 8131 - tonic::Response<Self::Response>, 8132 8132 - tonic::Status, 8133 8133 - >; 6983 6983 + type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 8134 6984 fn call( 8135 6985 &mut self, 8136 6986 request: tonic::Request<super::AdjustVolumeRequest>, ··· 8167 7017 "/rockbox.v1alpha1.SoundService/SoundSet" => { 8168 7018 #[allow(non_camel_case_types)] 8169 7019 struct SoundSetSvc<T: SoundService>(pub Arc<T>); 8170 8170 - impl< 8171 8171 - T: SoundService, 8172 8172 - > tonic::server::UnaryService<super::SoundSetRequest> 8173 8173 - for SoundSetSvc<T> { 7020 7020 + impl<T: SoundService> tonic::server::UnaryService<super::SoundSetRequest> for SoundSetSvc<T> { 8174 7021 type Response = super::SoundSetResponse; 8175 8175 - type Future = BoxFuture< 8176 8176 - tonic::Response<Self::Response>, 8177 8177 - tonic::Status, 8178 8178 - >; 7022 7022 + type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 8179 7023 fn call( 8180 7024 &mut self, 8181 7025 request: tonic::Request<super::SoundSetRequest>, ··· 8212 7056 "/rockbox.v1alpha1.SoundService/SoundCurrent" => { 8213 7057 #[allow(non_camel_case_types)] 8214 7058 struct SoundCurrentSvc<T: SoundService>(pub Arc<T>); 8215 8215 - impl< 8216 8216 - T: SoundService, 8217 8217 - > tonic::server::UnaryService<super::SoundCurrentRequest> 8218 8218 - for SoundCurrentSvc<T> { 7059 7059 + impl<T: SoundService> tonic::server::UnaryService<super::SoundCurrentRequest> 7060 7060 + for SoundCurrentSvc<T> 7061 7061 + { 8219 7062 type Response = super::SoundCurrentResponse; 8220 8220 - type Future = BoxFuture< 8221 8221 - tonic::Response<Self::Response>, 8222 8222 - tonic::Status, 8223 8223 - >; 7063 7063 + type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 8224 7064 fn call( 8225 7065 &mut self, 8226 7066 request: tonic::Request<super::SoundCurrentRequest>, ··· 8257 7097 "/rockbox.v1alpha1.SoundService/SoundDefault" => { 8258 7098 #[allow(non_camel_case_types)] 8259 7099 struct SoundDefaultSvc<T: SoundService>(pub Arc<T>); 8260 8260 - impl< 8261 8261 - T: SoundService, 8262 8262 - > tonic::server::UnaryService<super::SoundDefaultRequest> 8263 8263 - for SoundDefaultSvc<T> { 7100 7100 + impl<T: SoundService> tonic::server::UnaryService<super::SoundDefaultRequest> 7101 7101 + for SoundDefaultSvc<T> 7102 7102 + { 8264 7103 type Response = super::SoundDefaultResponse; 8265 8265 - type Future = BoxFuture< 8266 8266 - tonic::Response<Self::Response>, 8267 8267 - tonic::Status, 8268 8268 - >; 7104 7104 + type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 8269 7105 fn call( 8270 7106 &mut self, 8271 7107 request: tonic::Request<super::SoundDefaultRequest>, ··· 8302 7138 "/rockbox.v1alpha1.SoundService/SoundMin" => { 8303 7139 #[allow(non_camel_case_types)] 8304 7140 struct SoundMinSvc<T: SoundService>(pub Arc<T>); 8305 8305 - impl< 8306 8306 - T: SoundService, 8307 8307 - > tonic::server::UnaryService<super::SoundMinRequest> 8308 8308 - for SoundMinSvc<T> { 7141 7141 + impl<T: SoundService> tonic::server::UnaryService<super::SoundMinRequest> for SoundMinSvc<T> { 8309 7142 type Response = super::SoundMinResponse; 8310 8310 - type Future = BoxFuture< 8311 8311 - tonic::Response<Self::Response>, 8312 8312 - tonic::Status, 8313 8313 - >; 7143 7143 + type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 8314 7144 fn call( 8315 7145 &mut self, 8316 7146 request: tonic::Request<super::SoundMinRequest>, ··· 8347 7177 "/rockbox.v1alpha1.SoundService/SoundMax" => { 8348 7178 #[allow(non_camel_case_types)] 8349 7179 struct SoundMaxSvc<T: SoundService>(pub Arc<T>); 8350 8350 - impl< 8351 8351 - T: SoundService, 8352 8352 - > tonic::server::UnaryService<super::SoundMaxRequest> 8353 8353 - for SoundMaxSvc<T> { 7180 7180 + impl<T: SoundService> tonic::server::UnaryService<super::SoundMaxRequest> for SoundMaxSvc<T> { 8354 7181 type Response = super::SoundMaxResponse; 8355 8355 - type Future = BoxFuture< 8356 8356 - tonic::Response<Self::Response>, 8357 8357 - tonic::Status, 8358 8358 - >; 7182 7182 + type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 8359 7183 fn call( 8360 7184 &mut self, 8361 7185 request: tonic::Request<super::SoundMaxRequest>, ··· 8392 7216 "/rockbox.v1alpha1.SoundService/SoundUnit" => { 8393 7217 #[allow(non_camel_case_types)] 8394 7218 struct SoundUnitSvc<T: SoundService>(pub Arc<T>); 8395 8395 - impl< 8396 8396 - T: SoundService, 8397 8397 - > tonic::server::UnaryService<super::SoundUnitRequest> 8398 8398 - for SoundUnitSvc<T> { 7219 7219 + impl<T: SoundService> tonic::server::UnaryService<super::SoundUnitRequest> for SoundUnitSvc<T> { 8399 7220 type Response = super::SoundUnitResponse; 8400 8400 - type Future = BoxFuture< 8401 8401 - tonic::Response<Self::Response>, 8402 8402 - tonic::Status, 8403 8403 - >; 7221 7221 + type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 8404 7222 fn call( 8405 7223 &mut self, 8406 7224 request: tonic::Request<super::SoundUnitRequest>, ··· 8437 7255 "/rockbox.v1alpha1.SoundService/SoundVal2Phys" => { 8438 7256 #[allow(non_camel_case_types)] 8439 7257 struct SoundVal2PhysSvc<T: SoundService>(pub Arc<T>); 8440 8440 - impl< 8441 8441 - T: SoundService, 8442 8442 - > tonic::server::UnaryService<super::SoundVal2PhysRequest> 8443 8443 - for SoundVal2PhysSvc<T> { 7258 7258 + impl<T: SoundService> tonic::server::UnaryService<super::SoundVal2PhysRequest> 7259 7259 + for SoundVal2PhysSvc<T> 7260 7260 + { 8444 7261 type Response = super::SoundVal2PhysResponse; 8445 8445 - type Future = BoxFuture< 8446 8446 - tonic::Response<Self::Response>, 8447 8447 - tonic::Status, 8448 8448 - >; 7262 7262 + type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 8449 7263 fn call( 8450 7264 &mut self, 8451 7265 request: tonic::Request<super::SoundVal2PhysRequest>, ··· 8482 7296 "/rockbox.v1alpha1.SoundService/GetPitch" => { 8483 7297 #[allow(non_camel_case_types)] 8484 7298 struct GetPitchSvc<T: SoundService>(pub Arc<T>); 8485 8485 - impl< 8486 8486 - T: SoundService, 8487 8487 - > tonic::server::UnaryService<super::GetPitchRequest> 8488 8488 - for GetPitchSvc<T> { 7299 7299 + impl<T: SoundService> tonic::server::UnaryService<super::GetPitchRequest> for GetPitchSvc<T> { 8489 7300 type Response = super::GetPitchResponse; 8490 8490 - type Future = BoxFuture< 8491 8491 - tonic::Response<Self::Response>, 8492 8492 - tonic::Status, 8493 8493 - >; 7301 7301 + type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 8494 7302 fn call( 8495 7303 &mut self, 8496 7304 request: tonic::Request<super::GetPitchRequest>, ··· 8527 7335 "/rockbox.v1alpha1.SoundService/SetPitch" => { 8528 7336 #[allow(non_camel_case_types)] 8529 7337 struct SetPitchSvc<T: SoundService>(pub Arc<T>); 8530 8530 - impl< 8531 8531 - T: SoundService, 8532 8532 - > tonic::server::UnaryService<super::SetPitchRequest> 8533 8533 - for SetPitchSvc<T> { 7338 7338 + impl<T: SoundService> tonic::server::UnaryService<super::SetPitchRequest> for SetPitchSvc<T> { 8534 7339 type Response = super::SetPitchResponse; 8535 8535 - type Future = BoxFuture< 8536 8536 - tonic::Response<Self::Response>, 8537 8537 - tonic::Status, 8538 8538 - >; 7340 7340 + type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 8539 7341 fn call( 8540 7342 &mut self, 8541 7343 request: tonic::Request<super::SetPitchRequest>, ··· 8572 7374 "/rockbox.v1alpha1.SoundService/BeepPlay" => { 8573 7375 #[allow(non_camel_case_types)] 8574 7376 struct BeepPlaySvc<T: SoundService>(pub Arc<T>); 8575 8575 - impl< 8576 8576 - T: SoundService, 8577 8577 - > tonic::server::UnaryService<super::BeepPlayRequest> 8578 8578 - for BeepPlaySvc<T> { 7377 7377 + impl<T: SoundService> tonic::server::UnaryService<super::BeepPlayRequest> for BeepPlaySvc<T> { 8579 7378 type Response = super::BeepPlayResponse; 8580 8580 - type Future = BoxFuture< 8581 8581 - tonic::Response<Self::Response>, 8582 8582 - tonic::Status, 8583 8583 - >; 7379 7379 + type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 8584 7380 fn call( 8585 7381 &mut self, 8586 7382 request: tonic::Request<super::BeepPlayRequest>, ··· 8617 7413 "/rockbox.v1alpha1.SoundService/PcmbufFade" => { 8618 7414 #[allow(non_camel_case_types)] 8619 7415 struct PcmbufFadeSvc<T: SoundService>(pub Arc<T>); 8620 8620 - impl< 8621 8621 - T: SoundService, 8622 8622 - > tonic::server::UnaryService<super::PcmbufFadeRequest> 8623 8623 - for PcmbufFadeSvc<T> { 7416 7416 + impl<T: SoundService> tonic::server::UnaryService<super::PcmbufFadeRequest> for PcmbufFadeSvc<T> { 8624 7417 type Response = super::PcmbufFadeResponse; 8625 8625 - type Future = BoxFuture< 8626 8626 - tonic::Response<Self::Response>, 8627 8627 - tonic::Status, 8628 8628 - >; 7418 7418 + type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 8629 7419 fn call( 8630 7420 &mut self, 8631 7421 request: tonic::Request<super::PcmbufFadeRequest>, ··· 8662 7452 "/rockbox.v1alpha1.SoundService/PcmbufSetLowLatency" => { 8663 7453 #[allow(non_camel_case_types)] 8664 7454 struct PcmbufSetLowLatencySvc<T: SoundService>(pub Arc<T>); 8665 8665 - impl< 8666 8666 - T: SoundService, 8667 8667 - > tonic::server::UnaryService<super::PcmbufSetLowLatencyRequest> 8668 8668 - for PcmbufSetLowLatencySvc<T> { 7455 7455 + impl<T: SoundService> 7456 7456 + tonic::server::UnaryService<super::PcmbufSetLowLatencyRequest> 7457 7457 + for PcmbufSetLowLatencySvc<T> 7458 7458 + { 8669 7459 type Response = super::PcmbufSetLowLatencyResponse; 8670 8670 - type Future = BoxFuture< 8671 8671 - tonic::Response<Self::Response>, 8672 8672 - tonic::Status, 8673 8673 - >; 7460 7460 + type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 8674 7461 fn call( 8675 7462 &mut self, 8676 7463 request: tonic::Request<super::PcmbufSetLowLatencyRequest>, 8677 7464 ) -> Self::Future { 8678 7465 let inner = Arc::clone(&self.0); 8679 7466 let fut = async move { 8680 8680 - <T as SoundService>::pcmbuf_set_low_latency(&inner, request) 8681 8681 - .await 7467 7467 + <T as SoundService>::pcmbuf_set_low_latency(&inner, request).await 8682 7468 }; 8683 7469 Box::pin(fut) 8684 7470 } ··· 8708 7494 "/rockbox.v1alpha1.SoundService/SystemSoundPlay" => { 8709 7495 #[allow(non_camel_case_types)] 8710 7496 struct SystemSoundPlaySvc<T: SoundService>(pub Arc<T>); 8711 8711 - impl< 8712 8712 - T: SoundService, 8713 8713 - > tonic::server::UnaryService<super::SystemSoundPlayRequest> 8714 8714 - for SystemSoundPlaySvc<T> { 7497 7497 + impl<T: SoundService> tonic::server::UnaryService<super::SystemSoundPlayRequest> 7498 7498 + for SystemSoundPlaySvc<T> 7499 7499 + { 8715 7500 type Response = super::SystemSoundPlayResponse; 8716 8716 - type Future = BoxFuture< 8717 8717 - tonic::Response<Self::Response>, 8718 8718 - tonic::Status, 8719 8719 - >; 7501 7501 + type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 8720 7502 fn call( 8721 7503 &mut self, 8722 7504 request: tonic::Request<super::SystemSoundPlayRequest>, 8723 7505 ) -> Self::Future { 8724 7506 let inner = Arc::clone(&self.0); 8725 7507 let fut = async move { 8726 8726 - <T as SoundService>::system_sound_play(&inner, request) 8727 8727 - .await 7508 7508 + <T as SoundService>::system_sound_play(&inner, request).await 8728 7509 }; 8729 7510 Box::pin(fut) 8730 7511 } ··· 8754 7535 "/rockbox.v1alpha1.SoundService/KeyclickClick" => { 8755 7536 #[allow(non_camel_case_types)] 8756 7537 struct KeyclickClickSvc<T: SoundService>(pub Arc<T>); 8757 8757 - impl< 8758 8758 - T: SoundService, 8759 8759 - > tonic::server::UnaryService<super::KeyclickClickRequest> 8760 8760 - for KeyclickClickSvc<T> { 7538 7538 + impl<T: SoundService> tonic::server::UnaryService<super::KeyclickClickRequest> 7539 7539 + for KeyclickClickSvc<T> 7540 7540 + { 8761 7541 type Response = super::KeyclickClickResponse; 8762 8762 - type Future = BoxFuture< 8763 8763 - tonic::Response<Self::Response>, 8764 8764 - tonic::Status, 8765 8765 - >; 7542 7542 + type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 8766 7543 fn call( 8767 7544 &mut self, 8768 7545 request: tonic::Request<super::KeyclickClickRequest>, ··· 8796 7573 }; 8797 7574 Box::pin(fut) 8798 7575 } 8799 8799 - _ => { 8800 8800 - Box::pin(async move { 8801 8801 - let mut response = http::Response::new(empty_body()); 8802 8802 - let headers = response.headers_mut(); 8803 8803 - headers 8804 8804 - .insert( 8805 8805 - tonic::Status::GRPC_STATUS, 8806 8806 - (tonic::Code::Unimplemented as i32).into(), 8807 8807 - ); 8808 8808 - headers 8809 8809 - .insert( 8810 8810 - http::header::CONTENT_TYPE, 8811 8811 - tonic::metadata::GRPC_CONTENT_TYPE, 8812 8812 - ); 8813 8813 - Ok(response) 8814 8814 - }) 8815 8815 - } 7576 7576 + _ => Box::pin(async move { 7577 7577 + let mut response = http::Response::new(empty_body()); 7578 7578 + let headers = response.headers_mut(); 7579 7579 + headers.insert( 7580 7580 + tonic::Status::GRPC_STATUS, 7581 7581 + (tonic::Code::Unimplemented as i32).into(), 7582 7582 + ); 7583 7583 + headers.insert( 7584 7584 + http::header::CONTENT_TYPE, 7585 7585 + tonic::metadata::GRPC_CONTENT_TYPE, 7586 7586 + ); 7587 7587 + Ok(response) 7588 7588 + }), 8816 7589 } 8817 7590 } 8818 7591 } ··· 8873 7646 dead_code, 8874 7647 missing_docs, 8875 7648 clippy::wildcard_imports, 8876 8876 - clippy::let_unit_value, 7649 7649 + clippy::let_unit_value 8877 7650 )] 7651 7651 + use tonic::codegen::http::Uri; 8878 7652 use tonic::codegen::*; 8879 8879 - use tonic::codegen::http::Uri; 8880 7653 #[derive(Debug, Clone)] 8881 7654 pub struct SystemServiceClient<T> { 8882 7655 inner: tonic::client::Grpc<T>, ··· 8920 7693 <T as tonic::client::GrpcService<tonic::body::BoxBody>>::ResponseBody, 8921 7694 >, 8922 7695 >, 8923 8923 - <T as tonic::codegen::Service< 8924 8924 - http::Request<tonic::body::BoxBody>, 8925 8925 - >>::Error: Into<StdError> + std::marker::Send + std::marker::Sync, 7696 7696 + <T as tonic::codegen::Service<http::Request<tonic::body::BoxBody>>>::Error: 7697 7697 + Into<StdError> + std::marker::Send + std::marker::Sync, 8926 7698 { 8927 7699 SystemServiceClient::new(InterceptedService::new(inner, interceptor)) 8928 7700 } ··· 8960 7732 pub async fn get_rockbox_version( 8961 7733 &mut self, 8962 7734 request: impl tonic::IntoRequest<super::GetRockboxVersionRequest>, 8963 8963 - ) -> std::result::Result< 8964 8964 - tonic::Response<super::GetRockboxVersionResponse>, 8965 8965 - tonic::Status, 8966 8966 - > { 8967 8967 - self.inner 8968 8968 - .ready() 8969 8969 - .await 8970 8970 - .map_err(|e| { 8971 8971 - tonic::Status::unknown( 8972 8972 - format!("Service was not ready: {}", e.into()), 8973 8973 - ) 8974 8974 - })?; 7735 7735 + ) -> std::result::Result<tonic::Response<super::GetRockboxVersionResponse>, tonic::Status> 7736 7736 + { 7737 7737 + self.inner.ready().await.map_err(|e| { 7738 7738 + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 7739 7739 + })?; 8975 7740 let codec = tonic::codec::ProstCodec::default(); 8976 7741 let path = http::uri::PathAndQuery::from_static( 8977 7742 "/rockbox.v1alpha1.SystemService/GetRockboxVersion", 8978 7743 ); 8979 7744 let mut req = request.into_request(); 8980 8980 - req.extensions_mut() 8981 8981 - .insert( 8982 8982 - GrpcMethod::new( 8983 8983 - "rockbox.v1alpha1.SystemService", 8984 8984 - "GetRockboxVersion", 8985 8985 - ), 8986 8986 - ); 7745 7745 + req.extensions_mut().insert(GrpcMethod::new( 7746 7746 + "rockbox.v1alpha1.SystemService", 7747 7747 + "GetRockboxVersion", 7748 7748 + )); 8987 7749 self.inner.unary(req, path, codec).await 8988 7750 } 8989 7751 pub async fn get_global_status( 8990 7752 &mut self, 8991 7753 request: impl tonic::IntoRequest<super::GetGlobalStatusRequest>, 8992 8992 - ) -> std::result::Result< 8993 8993 - tonic::Response<super::GetGlobalStatusResponse>, 8994 8994 - tonic::Status, 8995 8995 - > { 8996 8996 - self.inner 8997 8997 - .ready() 8998 8998 - .await 8999 8999 - .map_err(|e| { 9000 9000 - tonic::Status::unknown( 9001 9001 - format!("Service was not ready: {}", e.into()), 9002 9002 - ) 9003 9003 - })?; 7754 7754 + ) -> std::result::Result<tonic::Response<super::GetGlobalStatusResponse>, tonic::Status> 7755 7755 + { 7756 7756 + self.inner.ready().await.map_err(|e| { 7757 7757 + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 7758 7758 + })?; 9004 7759 let codec = tonic::codec::ProstCodec::default(); 9005 7760 let path = http::uri::PathAndQuery::from_static( 9006 7761 "/rockbox.v1alpha1.SystemService/GetGlobalStatus", 9007 7762 ); 9008 7763 let mut req = request.into_request(); 9009 9009 - req.extensions_mut() 9010 9010 - .insert( 9011 9011 - GrpcMethod::new("rockbox.v1alpha1.SystemService", "GetGlobalStatus"), 9012 9012 - ); 7764 7764 + req.extensions_mut().insert(GrpcMethod::new( 7765 7765 + "rockbox.v1alpha1.SystemService", 7766 7766 + "GetGlobalStatus", 7767 7767 + )); 9013 7768 self.inner.unary(req, path, codec).await 9014 7769 } 9015 7770 } ··· 9021 7776 dead_code, 9022 7777 missing_docs, 9023 7778 clippy::wildcard_imports, 9024 9024 - clippy::let_unit_value, 7779 7779 + clippy::let_unit_value 9025 7780 )] 9026 7781 use tonic::codegen::*; 9027 7782 /// Generated trait containing gRPC methods that should be implemented for use with SystemServiceServer. ··· 9030 7785 async fn get_rockbox_version( 9031 7786 &self, 9032 7787 request: tonic::Request<super::GetRockboxVersionRequest>, 9033 9033 - ) -> std::result::Result< 9034 9034 - tonic::Response<super::GetRockboxVersionResponse>, 9035 9035 - tonic::Status, 9036 9036 - >; 7788 7788 + ) -> std::result::Result<tonic::Response<super::GetRockboxVersionResponse>, tonic::Status>; 9037 7789 async fn get_global_status( 9038 7790 &self, 9039 7791 request: tonic::Request<super::GetGlobalStatusRequest>, 9040 9040 - ) -> std::result::Result< 9041 9041 - tonic::Response<super::GetGlobalStatusResponse>, 9042 9042 - tonic::Status, 9043 9043 - >; 7792 7792 + ) -> std::result::Result<tonic::Response<super::GetGlobalStatusResponse>, tonic::Status>; 9044 7793 } 9045 7794 #[derive(Debug)] 9046 7795 pub struct SystemServiceServer<T> { ··· 9063 7812 max_encoding_message_size: None, 9064 7813 } 9065 7814 } 9066 9066 - pub fn with_interceptor<F>( 9067 9067 - inner: T, 9068 9068 - interceptor: F, 9069 9069 - ) -> InterceptedService<Self, F> 7815 7815 + pub fn with_interceptor<F>(inner: T, interceptor: F) -> InterceptedService<Self, F> 9070 7816 where 9071 7817 F: tonic::service::Interceptor, 9072 7818 { ··· 9121 7867 "/rockbox.v1alpha1.SystemService/GetRockboxVersion" => { 9122 7868 #[allow(non_camel_case_types)] 9123 7869 struct GetRockboxVersionSvc<T: SystemService>(pub Arc<T>); 9124 9124 - impl< 9125 9125 - T: SystemService, 9126 9126 - > tonic::server::UnaryService<super::GetRockboxVersionRequest> 9127 9127 - for GetRockboxVersionSvc<T> { 7870 7870 + impl<T: SystemService> 7871 7871 + tonic::server::UnaryService<super::GetRockboxVersionRequest> 7872 7872 + for GetRockboxVersionSvc<T> 7873 7873 + { 9128 7874 type Response = super::GetRockboxVersionResponse; 9129 9129 - type Future = BoxFuture< 9130 9130 - tonic::Response<Self::Response>, 9131 9131 - tonic::Status, 9132 9132 - >; 7875 7875 + type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 9133 7876 fn call( 9134 7877 &mut self, 9135 7878 request: tonic::Request<super::GetRockboxVersionRequest>, 9136 7879 ) -> Self::Future { 9137 7880 let inner = Arc::clone(&self.0); 9138 7881 let fut = async move { 9139 9139 - <T as SystemService>::get_rockbox_version(&inner, request) 9140 9140 - .await 7882 7882 + <T as SystemService>::get_rockbox_version(&inner, request).await 9141 7883 }; 9142 7884 Box::pin(fut) 9143 7885 } ··· 9167 7909 "/rockbox.v1alpha1.SystemService/GetGlobalStatus" => { 9168 7910 #[allow(non_camel_case_types)] 9169 7911 struct GetGlobalStatusSvc<T: SystemService>(pub Arc<T>); 9170 9170 - impl< 9171 9171 - T: SystemService, 9172 9172 - > tonic::server::UnaryService<super::GetGlobalStatusRequest> 9173 9173 - for GetGlobalStatusSvc<T> { 7912 7912 + impl<T: SystemService> 7913 7913 + tonic::server::UnaryService<super::GetGlobalStatusRequest> 7914 7914 + for GetGlobalStatusSvc<T> 7915 7915 + { 9174 7916 type Response = super::GetGlobalStatusResponse; 9175 9175 - type Future = BoxFuture< 9176 9176 - tonic::Response<Self::Response>, 9177 9177 - tonic::Status, 9178 9178 - >; 7917 7917 + type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 9179 7918 fn call( 9180 7919 &mut self, 9181 7920 request: tonic::Request<super::GetGlobalStatusRequest>, 9182 7921 ) -> Self::Future { 9183 7922 let inner = Arc::clone(&self.0); 9184 7923 let fut = async move { 9185 9185 - <T as SystemService>::get_global_status(&inner, request) 9186 9186 - .await 7924 7924 + <T as SystemService>::get_global_status(&inner, request).await 9187 7925 }; 9188 7926 Box::pin(fut) 9189 7927 } ··· 9210 7948 }; 9211 7949 Box::pin(fut) 9212 7950 } 9213 9213 - _ => { 9214 9214 - Box::pin(async move { 9215 9215 - let mut response = http::Response::new(empty_body()); 9216 9216 - let headers = response.headers_mut(); 9217 9217 - headers 9218 9218 - .insert( 9219 9219 - tonic::Status::GRPC_STATUS, 9220 9220 - (tonic::Code::Unimplemented as i32).into(), 9221 9221 - ); 9222 9222 - headers 9223 9223 - .insert( 9224 9224 - http::header::CONTENT_TYPE, 9225 9225 - tonic::metadata::GRPC_CONTENT_TYPE, 9226 9226 - ); 9227 9227 - Ok(response) 9228 9228 - }) 9229 9229 - } 7951 7951 + _ => Box::pin(async move { 7952 7952 + let mut response = http::Response::new(empty_body()); 7953 7953 + let headers = response.headers_mut(); 7954 7954 + headers.insert( 7955 7955 + tonic::Status::GRPC_STATUS, 7956 7956 + (tonic::Code::Unimplemented as i32).into(), 7957 7957 + ); 7958 7958 + headers.insert( 7959 7959 + http::header::CONTENT_TYPE, 7960 7960 + tonic::metadata::GRPC_CONTENT_TYPE, 7961 7961 + ); 7962 7962 + Ok(response) 7963 7963 + }), 9230 7964 } 9231 7965 } 9232 7966 }

+1240 -2506

crates/rocksky/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::*; 49 48 use tonic::codegen::http::Uri; 49 49 + use tonic::codegen::*; 50 50 #[derive(Debug, Clone)] 51 51 pub struct BrowseServiceClient<T> { 52 52 inner: tonic::client::Grpc<T>, ··· 90 90 <T as tonic::client::GrpcService<tonic::body::BoxBody>>::ResponseBody, 91 91 >, 92 92 >, 93 93 - <T as tonic::codegen::Service< 94 94 - http::Request<tonic::body::BoxBody>, 95 95 - >>::Error: Into<StdError> + std::marker::Send + std::marker::Sync, 93 93 + <T as tonic::codegen::Service<http::Request<tonic::body::BoxBody>>>::Error: 94 94 + Into<StdError> + std::marker::Send + std::marker::Sync, 96 95 { 97 96 BrowseServiceClient::new(InterceptedService::new(inner, interceptor)) 98 97 } ··· 130 129 pub async fn tree_get_entries( 131 130 &mut self, 132 131 request: impl tonic::IntoRequest<super::TreeGetEntriesRequest>, 133 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 - })?; 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 + })?; 145 137 let codec = tonic::codec::ProstCodec::default(); 146 138 let path = http::uri::PathAndQuery::from_static( 147 139 "/rockbox.v1alpha1.BrowseService/TreeGetEntries", 148 140 ); 149 141 let mut req = request.into_request(); 150 150 - req.extensions_mut() 151 151 - .insert( 152 152 - GrpcMethod::new("rockbox.v1alpha1.BrowseService", "TreeGetEntries"), 153 153 - ); 142 142 + req.extensions_mut().insert(GrpcMethod::new( 143 143 + "rockbox.v1alpha1.BrowseService", 144 144 + "TreeGetEntries", 145 145 + )); 154 146 self.inner.unary(req, path, codec).await 155 147 } 156 148 } ··· 162 154 dead_code, 163 155 missing_docs, 164 156 clippy::wildcard_imports, 165 165 - clippy::let_unit_value, 157 157 + clippy::let_unit_value 166 158 )] 167 159 use tonic::codegen::*; 168 160 /// Generated trait containing gRPC methods that should be implemented for use with BrowseServiceServer. ··· 171 163 async fn tree_get_entries( 172 164 &self, 173 165 request: tonic::Request<super::TreeGetEntriesRequest>, 174 174 - ) -> std::result::Result< 175 175 - tonic::Response<super::TreeGetEntriesResponse>, 176 176 - tonic::Status, 177 177 - >; 166 166 + ) -> std::result::Result<tonic::Response<super::TreeGetEntriesResponse>, tonic::Status>; 178 167 } 179 168 #[derive(Debug)] 180 169 pub struct BrowseServiceServer<T> { ··· 197 186 max_encoding_message_size: None, 198 187 } 199 188 } 200 200 - pub fn with_interceptor<F>( 201 201 - inner: T, 202 202 - interceptor: F, 203 203 - ) -> InterceptedService<Self, F> 189 189 + pub fn with_interceptor<F>(inner: T, interceptor: F) -> InterceptedService<Self, F> 204 190 where 205 191 F: tonic::service::Interceptor, 206 192 { ··· 255 241 "/rockbox.v1alpha1.BrowseService/TreeGetEntries" => { 256 242 #[allow(non_camel_case_types)] 257 243 struct TreeGetEntriesSvc<T: BrowseService>(pub Arc<T>); 258 258 - impl< 259 259 - T: BrowseService, 260 260 - > tonic::server::UnaryService<super::TreeGetEntriesRequest> 261 261 - for TreeGetEntriesSvc<T> { 244 244 + impl<T: BrowseService> tonic::server::UnaryService<super::TreeGetEntriesRequest> 245 245 + for TreeGetEntriesSvc<T> 246 246 + { 262 247 type Response = super::TreeGetEntriesResponse; 263 263 - type Future = BoxFuture< 264 264 - tonic::Response<Self::Response>, 265 265 - tonic::Status, 266 266 - >; 248 248 + type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 267 249 fn call( 268 250 &mut self, 269 251 request: tonic::Request<super::TreeGetEntriesRequest>, 270 252 ) -> Self::Future { 271 253 let inner = Arc::clone(&self.0); 272 254 let fut = async move { 273 273 - <T as BrowseService>::tree_get_entries(&inner, request) 274 274 - .await 255 255 + <T as BrowseService>::tree_get_entries(&inner, request).await 275 256 }; 276 257 Box::pin(fut) 277 258 } ··· 298 279 }; 299 280 Box::pin(fut) 300 281 } 301 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 - } 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 + }), 318 295 } 319 296 } 320 297 } ··· 550 527 dead_code, 551 528 missing_docs, 552 529 clippy::wildcard_imports, 553 553 - clippy::let_unit_value, 530 530 + clippy::let_unit_value 554 531 )] 555 555 - use tonic::codegen::*; 556 532 use tonic::codegen::http::Uri; 533 533 + use tonic::codegen::*; 557 534 #[derive(Debug, Clone)] 558 535 pub struct LibraryServiceClient<T> { 559 536 inner: tonic::client::Grpc<T>, ··· 597 574 <T as tonic::client::GrpcService<tonic::body::BoxBody>>::ResponseBody, 598 575 >, 599 576 >, 600 600 - <T as tonic::codegen::Service< 601 601 - http::Request<tonic::body::BoxBody>, 602 602 - >>::Error: Into<StdError> + std::marker::Send + std::marker::Sync, 577 577 + <T as tonic::codegen::Service<http::Request<tonic::body::BoxBody>>>::Error: 578 578 + Into<StdError> + std::marker::Send + std::marker::Sync, 603 579 { 604 580 LibraryServiceClient::new(InterceptedService::new(inner, interceptor)) 605 581 } ··· 637 613 pub async fn get_albums( 638 614 &mut self, 639 615 request: impl tonic::IntoRequest<super::GetAlbumsRequest>, 640 640 - ) -> std::result::Result< 641 641 - tonic::Response<super::GetAlbumsResponse>, 642 642 - tonic::Status, 643 643 - > { 644 644 - self.inner 645 645 - .ready() 646 646 - .await 647 647 - .map_err(|e| { 648 648 - tonic::Status::unknown( 649 649 - format!("Service was not ready: {}", e.into()), 650 650 - ) 651 651 - })?; 616 616 + ) -> std::result::Result<tonic::Response<super::GetAlbumsResponse>, tonic::Status> { 617 617 + self.inner.ready().await.map_err(|e| { 618 618 + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 619 619 + })?; 652 620 let codec = tonic::codec::ProstCodec::default(); 653 653 - let path = http::uri::PathAndQuery::from_static( 654 654 - "/rockbox.v1alpha1.LibraryService/GetAlbums", 655 655 - ); 621 621 + let path = 622 622 + http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.LibraryService/GetAlbums"); 656 623 let mut req = request.into_request(); 657 657 - req.extensions_mut() 658 658 - .insert(GrpcMethod::new("rockbox.v1alpha1.LibraryService", "GetAlbums")); 624 624 + req.extensions_mut().insert(GrpcMethod::new( 625 625 + "rockbox.v1alpha1.LibraryService", 626 626 + "GetAlbums", 627 627 + )); 659 628 self.inner.unary(req, path, codec).await 660 629 } 661 630 pub async fn get_artists( 662 631 &mut self, 663 632 request: impl tonic::IntoRequest<super::GetArtistsRequest>, 664 664 - ) -> std::result::Result< 665 665 - tonic::Response<super::GetArtistsResponse>, 666 666 - tonic::Status, 667 667 - > { 668 668 - self.inner 669 669 - .ready() 670 670 - .await 671 671 - .map_err(|e| { 672 672 - tonic::Status::unknown( 673 673 - format!("Service was not ready: {}", e.into()), 674 674 - ) 675 675 - })?; 633 633 + ) -> std::result::Result<tonic::Response<super::GetArtistsResponse>, tonic::Status> 634 634 + { 635 635 + self.inner.ready().await.map_err(|e| { 636 636 + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 637 637 + })?; 676 638 let codec = tonic::codec::ProstCodec::default(); 677 677 - let path = http::uri::PathAndQuery::from_static( 678 678 - "/rockbox.v1alpha1.LibraryService/GetArtists", 679 679 - ); 639 639 + let path = 640 640 + http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.LibraryService/GetArtists"); 680 641 let mut req = request.into_request(); 681 681 - req.extensions_mut() 682 682 - .insert( 683 683 - GrpcMethod::new("rockbox.v1alpha1.LibraryService", "GetArtists"), 684 684 - ); 642 642 + req.extensions_mut().insert(GrpcMethod::new( 643 643 + "rockbox.v1alpha1.LibraryService", 644 644 + "GetArtists", 645 645 + )); 685 646 self.inner.unary(req, path, codec).await 686 647 } 687 648 pub async fn get_tracks( 688 649 &mut self, 689 650 request: impl tonic::IntoRequest<super::GetTracksRequest>, 690 690 - ) -> std::result::Result< 691 691 - tonic::Response<super::GetTracksResponse>, 692 692 - tonic::Status, 693 693 - > { 694 694 - self.inner 695 695 - .ready() 696 696 - .await 697 697 - .map_err(|e| { 698 698 - tonic::Status::unknown( 699 699 - format!("Service was not ready: {}", e.into()), 700 700 - ) 701 701 - })?; 651 651 + ) -> std::result::Result<tonic::Response<super::GetTracksResponse>, tonic::Status> { 652 652 + self.inner.ready().await.map_err(|e| { 653 653 + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 654 654 + })?; 702 655 let codec = tonic::codec::ProstCodec::default(); 703 703 - let path = http::uri::PathAndQuery::from_static( 704 704 - "/rockbox.v1alpha1.LibraryService/GetTracks", 705 705 - ); 656 656 + let path = 657 657 + http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.LibraryService/GetTracks"); 706 658 let mut req = request.into_request(); 707 707 - req.extensions_mut() 708 708 - .insert(GrpcMethod::new("rockbox.v1alpha1.LibraryService", "GetTracks")); 659 659 + req.extensions_mut().insert(GrpcMethod::new( 660 660 + "rockbox.v1alpha1.LibraryService", 661 661 + "GetTracks", 662 662 + )); 709 663 self.inner.unary(req, path, codec).await 710 664 } 711 665 pub async fn get_album( 712 666 &mut self, 713 667 request: impl tonic::IntoRequest<super::GetAlbumRequest>, 714 714 - ) -> std::result::Result< 715 715 - tonic::Response<super::GetAlbumResponse>, 716 716 - tonic::Status, 717 717 - > { 718 718 - self.inner 719 719 - .ready() 720 720 - .await 721 721 - .map_err(|e| { 722 722 - tonic::Status::unknown( 723 723 - format!("Service was not ready: {}", e.into()), 724 724 - ) 725 725 - })?; 668 668 + ) -> std::result::Result<tonic::Response<super::GetAlbumResponse>, tonic::Status> { 669 669 + self.inner.ready().await.map_err(|e| { 670 670 + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 671 671 + })?; 726 672 let codec = tonic::codec::ProstCodec::default(); 727 727 - let path = http::uri::PathAndQuery::from_static( 728 728 - "/rockbox.v1alpha1.LibraryService/GetAlbum", 729 729 - ); 673 673 + let path = 674 674 + http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.LibraryService/GetAlbum"); 730 675 let mut req = request.into_request(); 731 731 - req.extensions_mut() 732 732 - .insert(GrpcMethod::new("rockbox.v1alpha1.LibraryService", "GetAlbum")); 676 676 + req.extensions_mut().insert(GrpcMethod::new( 677 677 + "rockbox.v1alpha1.LibraryService", 678 678 + "GetAlbum", 679 679 + )); 733 680 self.inner.unary(req, path, codec).await 734 681 } 735 682 pub async fn get_artist( 736 683 &mut self, 737 684 request: impl tonic::IntoRequest<super::GetArtistRequest>, 738 738 - ) -> std::result::Result< 739 739 - tonic::Response<super::GetArtistResponse>, 740 740 - tonic::Status, 741 741 - > { 742 742 - self.inner 743 743 - .ready() 744 744 - .await 745 745 - .map_err(|e| { 746 746 - tonic::Status::unknown( 747 747 - format!("Service was not ready: {}", e.into()), 748 748 - ) 749 749 - })?; 685 685 + ) -> std::result::Result<tonic::Response<super::GetArtistResponse>, tonic::Status> { 686 686 + self.inner.ready().await.map_err(|e| { 687 687 + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 688 688 + })?; 750 689 let codec = tonic::codec::ProstCodec::default(); 751 751 - let path = http::uri::PathAndQuery::from_static( 752 752 - "/rockbox.v1alpha1.LibraryService/GetArtist", 753 753 - ); 690 690 + let path = 691 691 + http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.LibraryService/GetArtist"); 754 692 let mut req = request.into_request(); 755 755 - req.extensions_mut() 756 756 - .insert(GrpcMethod::new("rockbox.v1alpha1.LibraryService", "GetArtist")); 693 693 + req.extensions_mut().insert(GrpcMethod::new( 694 694 + "rockbox.v1alpha1.LibraryService", 695 695 + "GetArtist", 696 696 + )); 757 697 self.inner.unary(req, path, codec).await 758 698 } 759 699 pub async fn get_track( 760 700 &mut self, 761 701 request: impl tonic::IntoRequest<super::GetTrackRequest>, 762 762 - ) -> std::result::Result< 763 763 - tonic::Response<super::GetTrackResponse>, 764 764 - tonic::Status, 765 765 - > { 766 766 - self.inner 767 767 - .ready() 768 768 - .await 769 769 - .map_err(|e| { 770 770 - tonic::Status::unknown( 771 771 - format!("Service was not ready: {}", e.into()), 772 772 - ) 773 773 - })?; 702 702 + ) -> std::result::Result<tonic::Response<super::GetTrackResponse>, tonic::Status> { 703 703 + self.inner.ready().await.map_err(|e| { 704 704 + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 705 705 + })?; 774 706 let codec = tonic::codec::ProstCodec::default(); 775 775 - let path = http::uri::PathAndQuery::from_static( 776 776 - "/rockbox.v1alpha1.LibraryService/GetTrack", 777 777 - ); 707 707 + let path = 708 708 + http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.LibraryService/GetTrack"); 778 709 let mut req = request.into_request(); 779 779 - req.extensions_mut() 780 780 - .insert(GrpcMethod::new("rockbox.v1alpha1.LibraryService", "GetTrack")); 710 710 + req.extensions_mut().insert(GrpcMethod::new( 711 711 + "rockbox.v1alpha1.LibraryService", 712 712 + "GetTrack", 713 713 + )); 781 714 self.inner.unary(req, path, codec).await 782 715 } 783 716 pub async fn like_track( 784 717 &mut self, 785 718 request: impl tonic::IntoRequest<super::LikeTrackRequest>, 786 786 - ) -> std::result::Result< 787 787 - tonic::Response<super::LikeTrackResponse>, 788 788 - tonic::Status, 789 789 - > { 790 790 - self.inner 791 791 - .ready() 792 792 - .await 793 793 - .map_err(|e| { 794 794 - tonic::Status::unknown( 795 795 - format!("Service was not ready: {}", e.into()), 796 796 - ) 797 797 - })?; 719 719 + ) -> std::result::Result<tonic::Response<super::LikeTrackResponse>, tonic::Status> { 720 720 + self.inner.ready().await.map_err(|e| { 721 721 + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 722 722 + })?; 798 723 let codec = tonic::codec::ProstCodec::default(); 799 799 - let path = http::uri::PathAndQuery::from_static( 800 800 - "/rockbox.v1alpha1.LibraryService/LikeTrack", 801 801 - ); 724 724 + let path = 725 725 + http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.LibraryService/LikeTrack"); 802 726 let mut req = request.into_request(); 803 803 - req.extensions_mut() 804 804 - .insert(GrpcMethod::new("rockbox.v1alpha1.LibraryService", "LikeTrack")); 727 727 + req.extensions_mut().insert(GrpcMethod::new( 728 728 + "rockbox.v1alpha1.LibraryService", 729 729 + "LikeTrack", 730 730 + )); 805 731 self.inner.unary(req, path, codec).await 806 732 } 807 733 pub async fn unlike_track( 808 734 &mut self, 809 735 request: impl tonic::IntoRequest<super::UnlikeTrackRequest>, 810 810 - ) -> std::result::Result< 811 811 - tonic::Response<super::UnlikeTrackResponse>, 812 812 - tonic::Status, 813 813 - > { 814 814 - self.inner 815 815 - .ready() 816 816 - .await 817 817 - .map_err(|e| { 818 818 - tonic::Status::unknown( 819 819 - format!("Service was not ready: {}", e.into()), 820 820 - ) 821 821 - })?; 736 736 + ) -> std::result::Result<tonic::Response<super::UnlikeTrackResponse>, tonic::Status> 737 737 + { 738 738 + self.inner.ready().await.map_err(|e| { 739 739 + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 740 740 + })?; 822 741 let codec = tonic::codec::ProstCodec::default(); 823 742 let path = http::uri::PathAndQuery::from_static( 824 743 "/rockbox.v1alpha1.LibraryService/UnlikeTrack", 825 744 ); 826 745 let mut req = request.into_request(); 827 827 - req.extensions_mut() 828 828 - .insert( 829 829 - GrpcMethod::new("rockbox.v1alpha1.LibraryService", "UnlikeTrack"), 830 830 - ); 746 746 + req.extensions_mut().insert(GrpcMethod::new( 747 747 + "rockbox.v1alpha1.LibraryService", 748 748 + "UnlikeTrack", 749 749 + )); 831 750 self.inner.unary(req, path, codec).await 832 751 } 833 752 pub async fn like_album( 834 753 &mut self, 835 754 request: impl tonic::IntoRequest<super::LikeAlbumRequest>, 836 836 - ) -> std::result::Result< 837 837 - tonic::Response<super::LikeAlbumResponse>, 838 838 - tonic::Status, 839 839 - > { 840 840 - self.inner 841 841 - .ready() 842 842 - .await 843 843 - .map_err(|e| { 844 844 - tonic::Status::unknown( 845 845 - format!("Service was not ready: {}", e.into()), 846 846 - ) 847 847 - })?; 755 755 + ) -> std::result::Result<tonic::Response<super::LikeAlbumResponse>, tonic::Status> { 756 756 + self.inner.ready().await.map_err(|e| { 757 757 + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 758 758 + })?; 848 759 let codec = tonic::codec::ProstCodec::default(); 849 849 - let path = http::uri::PathAndQuery::from_static( 850 850 - "/rockbox.v1alpha1.LibraryService/LikeAlbum", 851 851 - ); 760 760 + let path = 761 761 + http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.LibraryService/LikeAlbum"); 852 762 let mut req = request.into_request(); 853 853 - req.extensions_mut() 854 854 - .insert(GrpcMethod::new("rockbox.v1alpha1.LibraryService", "LikeAlbum")); 763 763 + req.extensions_mut().insert(GrpcMethod::new( 764 764 + "rockbox.v1alpha1.LibraryService", 765 765 + "LikeAlbum", 766 766 + )); 855 767 self.inner.unary(req, path, codec).await 856 768 } 857 769 pub async fn unlike_album( 858 770 &mut self, 859 771 request: impl tonic::IntoRequest<super::UnlikeAlbumRequest>, 860 860 - ) -> std::result::Result< 861 861 - tonic::Response<super::UnlikeAlbumResponse>, 862 862 - tonic::Status, 863 863 - > { 864 864 - self.inner 865 865 - .ready() 866 866 - .await 867 867 - .map_err(|e| { 868 868 - tonic::Status::unknown( 869 869 - format!("Service was not ready: {}", e.into()), 870 870 - ) 871 871 - })?; 772 772 + ) -> std::result::Result<tonic::Response<super::UnlikeAlbumResponse>, tonic::Status> 773 773 + { 774 774 + self.inner.ready().await.map_err(|e| { 775 775 + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 776 776 + })?; 872 777 let codec = tonic::codec::ProstCodec::default(); 873 778 let path = http::uri::PathAndQuery::from_static( 874 779 "/rockbox.v1alpha1.LibraryService/UnlikeAlbum", 875 780 ); 876 781 let mut req = request.into_request(); 877 877 - req.extensions_mut() 878 878 - .insert( 879 879 - GrpcMethod::new("rockbox.v1alpha1.LibraryService", "UnlikeAlbum"), 880 880 - ); 782 782 + req.extensions_mut().insert(GrpcMethod::new( 783 783 + "rockbox.v1alpha1.LibraryService", 784 784 + "UnlikeAlbum", 785 785 + )); 881 786 self.inner.unary(req, path, codec).await 882 787 } 883 788 pub async fn get_liked_tracks( 884 789 &mut self, 885 790 request: impl tonic::IntoRequest<super::GetLikedTracksRequest>, 886 886 - ) -> std::result::Result< 887 887 - tonic::Response<super::GetLikedTracksResponse>, 888 888 - tonic::Status, 889 889 - > { 890 890 - self.inner 891 891 - .ready() 892 892 - .await 893 893 - .map_err(|e| { 894 894 - tonic::Status::unknown( 895 895 - format!("Service was not ready: {}", e.into()), 896 896 - ) 897 897 - })?; 791 791 + ) -> std::result::Result<tonic::Response<super::GetLikedTracksResponse>, tonic::Status> 792 792 + { 793 793 + self.inner.ready().await.map_err(|e| { 794 794 + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 795 795 + })?; 898 796 let codec = tonic::codec::ProstCodec::default(); 899 797 let path = http::uri::PathAndQuery::from_static( 900 798 "/rockbox.v1alpha1.LibraryService/GetLikedTracks", 901 799 ); 902 800 let mut req = request.into_request(); 903 903 - req.extensions_mut() 904 904 - .insert( 905 905 - GrpcMethod::new("rockbox.v1alpha1.LibraryService", "GetLikedTracks"), 906 906 - ); 801 801 + req.extensions_mut().insert(GrpcMethod::new( 802 802 + "rockbox.v1alpha1.LibraryService", 803 803 + "GetLikedTracks", 804 804 + )); 907 805 self.inner.unary(req, path, codec).await 908 806 } 909 807 pub async fn get_liked_albums( 910 808 &mut self, 911 809 request: impl tonic::IntoRequest<super::GetLikedAlbumsRequest>, 912 912 - ) -> std::result::Result< 913 913 - tonic::Response<super::GetLikedAlbumsResponse>, 914 914 - tonic::Status, 915 915 - > { 916 916 - self.inner 917 917 - .ready() 918 918 - .await 919 919 - .map_err(|e| { 920 920 - tonic::Status::unknown( 921 921 - format!("Service was not ready: {}", e.into()), 922 922 - ) 923 923 - })?; 810 810 + ) -> std::result::Result<tonic::Response<super::GetLikedAlbumsResponse>, tonic::Status> 811 811 + { 812 812 + self.inner.ready().await.map_err(|e| { 813 813 + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 814 814 + })?; 924 815 let codec = tonic::codec::ProstCodec::default(); 925 816 let path = http::uri::PathAndQuery::from_static( 926 817 "/rockbox.v1alpha1.LibraryService/GetLikedAlbums", 927 818 ); 928 819 let mut req = request.into_request(); 929 929 - req.extensions_mut() 930 930 - .insert( 931 931 - GrpcMethod::new("rockbox.v1alpha1.LibraryService", "GetLikedAlbums"), 932 932 - ); 820 820 + req.extensions_mut().insert(GrpcMethod::new( 821 821 + "rockbox.v1alpha1.LibraryService", 822 822 + "GetLikedAlbums", 823 823 + )); 933 824 self.inner.unary(req, path, codec).await 934 825 } 935 826 pub async fn scan_library( 936 827 &mut self, 937 828 request: impl tonic::IntoRequest<super::ScanLibraryRequest>, 938 938 - ) -> std::result::Result< 939 939 - tonic::Response<super::ScanLibraryResponse>, 940 940 - tonic::Status, 941 941 - > { 942 942 - self.inner 943 943 - .ready() 944 944 - .await 945 945 - .map_err(|e| { 946 946 - tonic::Status::unknown( 947 947 - format!("Service was not ready: {}", e.into()), 948 948 - ) 949 949 - })?; 829 829 + ) -> std::result::Result<tonic::Response<super::ScanLibraryResponse>, tonic::Status> 830 830 + { 831 831 + self.inner.ready().await.map_err(|e| { 832 832 + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 833 833 + })?; 950 834 let codec = tonic::codec::ProstCodec::default(); 951 835 let path = http::uri::PathAndQuery::from_static( 952 836 "/rockbox.v1alpha1.LibraryService/ScanLibrary", 953 837 ); 954 838 let mut req = request.into_request(); 955 955 - req.extensions_mut() 956 956 - .insert( 957 957 - GrpcMethod::new("rockbox.v1alpha1.LibraryService", "ScanLibrary"), 958 958 - ); 839 839 + req.extensions_mut().insert(GrpcMethod::new( 840 840 + "rockbox.v1alpha1.LibraryService", 841 841 + "ScanLibrary", 842 842 + )); 959 843 self.inner.unary(req, path, codec).await 960 844 } 961 845 pub async fn search( 962 846 &mut self, 963 847 request: impl tonic::IntoRequest<super::SearchRequest>, 964 848 ) -> std::result::Result<tonic::Response<super::SearchResponse>, tonic::Status> { 965 965 - self.inner 966 966 - .ready() 967 967 - .await 968 968 - .map_err(|e| { 969 969 - tonic::Status::unknown( 970 970 - format!("Service was not ready: {}", e.into()), 971 971 - ) 972 972 - })?; 849 849 + self.inner.ready().await.map_err(|e| { 850 850 + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 851 851 + })?; 973 852 let codec = tonic::codec::ProstCodec::default(); 974 974 - let path = http::uri::PathAndQuery::from_static( 975 975 - "/rockbox.v1alpha1.LibraryService/Search", 976 976 - ); 853 853 + let path = 854 854 + http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.LibraryService/Search"); 977 855 let mut req = request.into_request(); 978 856 req.extensions_mut() 979 857 .insert(GrpcMethod::new("rockbox.v1alpha1.LibraryService", "Search")); ··· 988 866 dead_code, 989 867 missing_docs, 990 868 clippy::wildcard_imports, 991 991 - clippy::let_unit_value, 869 869 + clippy::let_unit_value 992 870 )] 993 871 use tonic::codegen::*; 994 872 /// Generated trait containing gRPC methods that should be implemented for use with LibraryServiceServer. ··· 997 875 async fn get_albums( 998 876 &self, 999 877 request: tonic::Request<super::GetAlbumsRequest>, 1000 1000 - ) -> std::result::Result< 1001 1001 - tonic::Response<super::GetAlbumsResponse>, 1002 1002 - tonic::Status, 1003 1003 - >; 878 878 + ) -> std::result::Result<tonic::Response<super::GetAlbumsResponse>, tonic::Status>; 1004 879 async fn get_artists( 1005 880 &self, 1006 881 request: tonic::Request<super::GetArtistsRequest>, 1007 1007 - ) -> std::result::Result< 1008 1008 - tonic::Response<super::GetArtistsResponse>, 1009 1009 - tonic::Status, 1010 1010 - >; 882 882 + ) -> std::result::Result<tonic::Response<super::GetArtistsResponse>, tonic::Status>; 1011 883 async fn get_tracks( 1012 884 &self, 1013 885 request: tonic::Request<super::GetTracksRequest>, 1014 1014 - ) -> std::result::Result< 1015 1015 - tonic::Response<super::GetTracksResponse>, 1016 1016 - tonic::Status, 1017 1017 - >; 886 886 + ) -> std::result::Result<tonic::Response<super::GetTracksResponse>, tonic::Status>; 1018 887 async fn get_album( 1019 888 &self, 1020 889 request: tonic::Request<super::GetAlbumRequest>, 1021 1021 - ) -> std::result::Result< 1022 1022 - tonic::Response<super::GetAlbumResponse>, 1023 1023 - tonic::Status, 1024 1024 - >; 890 890 + ) -> std::result::Result<tonic::Response<super::GetAlbumResponse>, tonic::Status>; 1025 891 async fn get_artist( 1026 892 &self, 1027 893 request: tonic::Request<super::GetArtistRequest>, 1028 1028 - ) -> std::result::Result< 1029 1029 - tonic::Response<super::GetArtistResponse>, 1030 1030 - tonic::Status, 1031 1031 - >; 894 894 + ) -> std::result::Result<tonic::Response<super::GetArtistResponse>, tonic::Status>; 1032 895 async fn get_track( 1033 896 &self, 1034 897 request: tonic::Request<super::GetTrackRequest>, 1035 1035 - ) -> std::result::Result< 1036 1036 - tonic::Response<super::GetTrackResponse>, 1037 1037 - tonic::Status, 1038 1038 - >; 898 898 + ) -> std::result::Result<tonic::Response<super::GetTrackResponse>, tonic::Status>; 1039 899 async fn like_track( 1040 900 &self, 1041 901 request: tonic::Request<super::LikeTrackRequest>, 1042 1042 - ) -> std::result::Result< 1043 1043 - tonic::Response<super::LikeTrackResponse>, 1044 1044 - tonic::Status, 1045 1045 - >; 902 902 + ) -> std::result::Result<tonic::Response<super::LikeTrackResponse>, tonic::Status>; 1046 903 async fn unlike_track( 1047 904 &self, 1048 905 request: tonic::Request<super::UnlikeTrackRequest>, 1049 1049 - ) -> std::result::Result< 1050 1050 - tonic::Response<super::UnlikeTrackResponse>, 1051 1051 - tonic::Status, 1052 1052 - >; 906 906 + ) -> std::result::Result<tonic::Response<super::UnlikeTrackResponse>, tonic::Status>; 1053 907 async fn like_album( 1054 908 &self, 1055 909 request: tonic::Request<super::LikeAlbumRequest>, 1056 1056 - ) -> std::result::Result< 1057 1057 - tonic::Response<super::LikeAlbumResponse>, 1058 1058 - tonic::Status, 1059 1059 - >; 910 910 + ) -> std::result::Result<tonic::Response<super::LikeAlbumResponse>, tonic::Status>; 1060 911 async fn unlike_album( 1061 912 &self, 1062 913 request: tonic::Request<super::UnlikeAlbumRequest>, 1063 1063 - ) -> std::result::Result< 1064 1064 - tonic::Response<super::UnlikeAlbumResponse>, 1065 1065 - tonic::Status, 1066 1066 - >; 914 914 + ) -> std::result::Result<tonic::Response<super::UnlikeAlbumResponse>, tonic::Status>; 1067 915 async fn get_liked_tracks( 1068 916 &self, 1069 917 request: tonic::Request<super::GetLikedTracksRequest>, 1070 1070 - ) -> std::result::Result< 1071 1071 - tonic::Response<super::GetLikedTracksResponse>, 1072 1072 - tonic::Status, 1073 1073 - >; 918 918 + ) -> std::result::Result<tonic::Response<super::GetLikedTracksResponse>, tonic::Status>; 1074 919 async fn get_liked_albums( 1075 920 &self, 1076 921 request: tonic::Request<super::GetLikedAlbumsRequest>, 1077 1077 - ) -> std::result::Result< 1078 1078 - tonic::Response<super::GetLikedAlbumsResponse>, 1079 1079 - tonic::Status, 1080 1080 - >; 922 922 + ) -> std::result::Result<tonic::Response<super::GetLikedAlbumsResponse>, tonic::Status>; 1081 923 async fn scan_library( 1082 924 &self, 1083 925 request: tonic::Request<super::ScanLibraryRequest>, 1084 1084 - ) -> std::result::Result< 1085 1085 - tonic::Response<super::ScanLibraryResponse>, 1086 1086 - tonic::Status, 1087 1087 - >; 926 926 + ) -> std::result::Result<tonic::Response<super::ScanLibraryResponse>, tonic::Status>; 1088 927 async fn search( 1089 928 &self, 1090 929 request: tonic::Request<super::SearchRequest>, ··· 1111 950 max_encoding_message_size: None, 1112 951 } 1113 952 } 1114 1114 - pub fn with_interceptor<F>( 1115 1115 - inner: T, 1116 1116 - interceptor: F, 1117 1117 - ) -> InterceptedService<Self, F> 953 953 + pub fn with_interceptor<F>(inner: T, interceptor: F) -> InterceptedService<Self, F> 1118 954 where 1119 955 F: tonic::service::Interceptor, 1120 956 { ··· 1169 1005 "/rockbox.v1alpha1.LibraryService/GetAlbums" => { 1170 1006 #[allow(non_camel_case_types)] 1171 1007 struct GetAlbumsSvc<T: LibraryService>(pub Arc<T>); 1172 1172 - impl< 1173 1173 - T: LibraryService, 1174 1174 - > tonic::server::UnaryService<super::GetAlbumsRequest> 1175 1175 - for GetAlbumsSvc<T> { 1008 1008 + impl<T: LibraryService> tonic::server::UnaryService<super::GetAlbumsRequest> for GetAlbumsSvc<T> { 1176 1009 type Response = super::GetAlbumsResponse; 1177 1177 - type Future = BoxFuture< 1178 1178 - tonic::Response<Self::Response>, 1179 1179 - tonic::Status, 1180 1180 - >; 1010 1010 + type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 1181 1011 fn call( 1182 1012 &mut self, 1183 1013 request: tonic::Request<super::GetAlbumsRequest>, ··· 1214 1044 "/rockbox.v1alpha1.LibraryService/GetArtists" => { 1215 1045 #[allow(non_camel_case_types)] 1216 1046 struct GetArtistsSvc<T: LibraryService>(pub Arc<T>); 1217 1217 - impl< 1218 1218 - T: LibraryService, 1219 1219 - > tonic::server::UnaryService<super::GetArtistsRequest> 1220 1220 - for GetArtistsSvc<T> { 1047 1047 + impl<T: LibraryService> tonic::server::UnaryService<super::GetArtistsRequest> for GetArtistsSvc<T> { 1221 1048 type Response = super::GetArtistsResponse; 1222 1222 - type Future = BoxFuture< 1223 1223 - tonic::Response<Self::Response>, 1224 1224 - tonic::Status, 1225 1225 - >; 1049 1049 + type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 1226 1050 fn call( 1227 1051 &mut self, 1228 1052 request: tonic::Request<super::GetArtistsRequest>, ··· 1259 1083 "/rockbox.v1alpha1.LibraryService/GetTracks" => { 1260 1084 #[allow(non_camel_case_types)] 1261 1085 struct GetTracksSvc<T: LibraryService>(pub Arc<T>); 1262 1262 - impl< 1263 1263 - T: LibraryService, 1264 1264 - > tonic::server::UnaryService<super::GetTracksRequest> 1265 1265 - for GetTracksSvc<T> { 1086 1086 + impl<T: LibraryService> tonic::server::UnaryService<super::GetTracksRequest> for GetTracksSvc<T> { 1266 1087 type Response = super::GetTracksResponse; 1267 1267 - type Future = BoxFuture< 1268 1268 - tonic::Response<Self::Response>, 1269 1269 - tonic::Status, 1270 1270 - >; 1088 1088 + type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 1271 1089 fn call( 1272 1090 &mut self, 1273 1091 request: tonic::Request<super::GetTracksRequest>, ··· 1304 1122 "/rockbox.v1alpha1.LibraryService/GetAlbum" => { 1305 1123 #[allow(non_camel_case_types)] 1306 1124 struct GetAlbumSvc<T: LibraryService>(pub Arc<T>); 1307 1307 - impl< 1308 1308 - T: LibraryService, 1309 1309 - > tonic::server::UnaryService<super::GetAlbumRequest> 1310 1310 - for GetAlbumSvc<T> { 1125 1125 + impl<T: LibraryService> tonic::server::UnaryService<super::GetAlbumRequest> for GetAlbumSvc<T> { 1311 1126 type Response = super::GetAlbumResponse; 1312 1312 - type Future = BoxFuture< 1313 1313 - tonic::Response<Self::Response>, 1314 1314 - tonic::Status, 1315 1315 - >; 1127 1127 + type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 1316 1128 fn call( 1317 1129 &mut self, 1318 1130 request: tonic::Request<super::GetAlbumRequest>, ··· 1349 1161 "/rockbox.v1alpha1.LibraryService/GetArtist" => { 1350 1162 #[allow(non_camel_case_types)] 1351 1163 struct GetArtistSvc<T: LibraryService>(pub Arc<T>); 1352 1352 - impl< 1353 1353 - T: LibraryService, 1354 1354 - > tonic::server::UnaryService<super::GetArtistRequest> 1355 1355 - for GetArtistSvc<T> { 1164 1164 + impl<T: LibraryService> tonic::server::UnaryService<super::GetArtistRequest> for GetArtistSvc<T> { 1356 1165 type Response = super::GetArtistResponse; 1357 1357 - type Future = BoxFuture< 1358 1358 - tonic::Response<Self::Response>, 1359 1359 - tonic::Status, 1360 1360 - >; 1166 1166 + type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 1361 1167 fn call( 1362 1168 &mut self, 1363 1169 request: tonic::Request<super::GetArtistRequest>, ··· 1394 1200 "/rockbox.v1alpha1.LibraryService/GetTrack" => { 1395 1201 #[allow(non_camel_case_types)] 1396 1202 struct GetTrackSvc<T: LibraryService>(pub Arc<T>); 1397 1397 - impl< 1398 1398 - T: LibraryService, 1399 1399 - > tonic::server::UnaryService<super::GetTrackRequest> 1400 1400 - for GetTrackSvc<T> { 1203 1203 + impl<T: LibraryService> tonic::server::UnaryService<super::GetTrackRequest> for GetTrackSvc<T> { 1401 1204 type Response = super::GetTrackResponse; 1402 1402 - type Future = BoxFuture< 1403 1403 - tonic::Response<Self::Response>, 1404 1404 - tonic::Status, 1405 1405 - >; 1205 1205 + type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 1406 1206 fn call( 1407 1207 &mut self, 1408 1208 request: tonic::Request<super::GetTrackRequest>, ··· 1439 1239 "/rockbox.v1alpha1.LibraryService/LikeTrack" => { 1440 1240 #[allow(non_camel_case_types)] 1441 1241 struct LikeTrackSvc<T: LibraryService>(pub Arc<T>); 1442 1442 - impl< 1443 1443 - T: LibraryService, 1444 1444 - > tonic::server::UnaryService<super::LikeTrackRequest> 1445 1445 - for LikeTrackSvc<T> { 1242 1242 + impl<T: LibraryService> tonic::server::UnaryService<super::LikeTrackRequest> for LikeTrackSvc<T> { 1446 1243 type Response = super::LikeTrackResponse; 1447 1447 - type Future = BoxFuture< 1448 1448 - tonic::Response<Self::Response>, 1449 1449 - tonic::Status, 1450 1450 - >; 1244 1244 + type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 1451 1245 fn call( 1452 1246 &mut self, 1453 1247 request: tonic::Request<super::LikeTrackRequest>, ··· 1484 1278 "/rockbox.v1alpha1.LibraryService/UnlikeTrack" => { 1485 1279 #[allow(non_camel_case_types)] 1486 1280 struct UnlikeTrackSvc<T: LibraryService>(pub Arc<T>); 1487 1487 - impl< 1488 1488 - T: LibraryService, 1489 1489 - > tonic::server::UnaryService<super::UnlikeTrackRequest> 1490 1490 - for UnlikeTrackSvc<T> { 1281 1281 + impl<T: LibraryService> tonic::server::UnaryService<super::UnlikeTrackRequest> 1282 1282 + for UnlikeTrackSvc<T> 1283 1283 + { 1491 1284 type Response = super::UnlikeTrackResponse; 1492 1492 - type Future = BoxFuture< 1493 1493 - tonic::Response<Self::Response>, 1494 1494 - tonic::Status, 1495 1495 - >; 1285 1285 + type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 1496 1286 fn call( 1497 1287 &mut self, 1498 1288 request: tonic::Request<super::UnlikeTrackRequest>, ··· 1529 1319 "/rockbox.v1alpha1.LibraryService/LikeAlbum" => { 1530 1320 #[allow(non_camel_case_types)] 1531 1321 struct LikeAlbumSvc<T: LibraryService>(pub Arc<T>); 1532 1532 - impl< 1533 1533 - T: LibraryService, 1534 1534 - > tonic::server::UnaryService<super::LikeAlbumRequest> 1535 1535 - for LikeAlbumSvc<T> { 1322 1322 + impl<T: LibraryService> tonic::server::UnaryService<super::LikeAlbumRequest> for LikeAlbumSvc<T> { 1536 1323 type Response = super::LikeAlbumResponse; 1537 1537 - type Future = BoxFuture< 1538 1538 - tonic::Response<Self::Response>, 1539 1539 - tonic::Status, 1540 1540 - >; 1324 1324 + type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 1541 1325 fn call( 1542 1326 &mut self, 1543 1327 request: tonic::Request<super::LikeAlbumRequest>, ··· 1574 1358 "/rockbox.v1alpha1.LibraryService/UnlikeAlbum" => { 1575 1359 #[allow(non_camel_case_types)] 1576 1360 struct UnlikeAlbumSvc<T: LibraryService>(pub Arc<T>); 1577 1577 - impl< 1578 1578 - T: LibraryService, 1579 1579 - > tonic::server::UnaryService<super::UnlikeAlbumRequest> 1580 1580 - for UnlikeAlbumSvc<T> { 1361 1361 + impl<T: LibraryService> tonic::server::UnaryService<super::UnlikeAlbumRequest> 1362 1362 + for UnlikeAlbumSvc<T> 1363 1363 + { 1581 1364 type Response = super::UnlikeAlbumResponse; 1582 1582 - type Future = BoxFuture< 1583 1583 - tonic::Response<Self::Response>, 1584 1584 - tonic::Status, 1585 1585 - >; 1365 1365 + type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 1586 1366 fn call( 1587 1367 &mut self, 1588 1368 request: tonic::Request<super::UnlikeAlbumRequest>, ··· 1619 1399 "/rockbox.v1alpha1.LibraryService/GetLikedTracks" => { 1620 1400 #[allow(non_camel_case_types)] 1621 1401 struct GetLikedTracksSvc<T: LibraryService>(pub Arc<T>); 1622 1622 - impl< 1623 1623 - T: LibraryService, 1624 1624 - > tonic::server::UnaryService<super::GetLikedTracksRequest> 1625 1625 - for GetLikedTracksSvc<T> { 1402 1402 + impl<T: LibraryService> 1403 1403 + tonic::server::UnaryService<super::GetLikedTracksRequest> 1404 1404 + for GetLikedTracksSvc<T> 1405 1405 + { 1626 1406 type Response = super::GetLikedTracksResponse; 1627 1627 - type Future = BoxFuture< 1628 1628 - tonic::Response<Self::Response>, 1629 1629 - tonic::Status, 1630 1630 - >; 1407 1407 + type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 1631 1408 fn call( 1632 1409 &mut self, 1633 1410 request: tonic::Request<super::GetLikedTracksRequest>, 1634 1411 ) -> Self::Future { 1635 1412 let inner = Arc::clone(&self.0); 1636 1413 let fut = async move { 1637 1637 - <T as LibraryService>::get_liked_tracks(&inner, request) 1638 1638 - .await 1414 1414 + <T as LibraryService>::get_liked_tracks(&inner, request).await 1639 1415 }; 1640 1416 Box::pin(fut) 1641 1417 } ··· 1665 1441 "/rockbox.v1alpha1.LibraryService/GetLikedAlbums" => { 1666 1442 #[allow(non_camel_case_types)] 1667 1443 struct GetLikedAlbumsSvc<T: LibraryService>(pub Arc<T>); 1668 1668 - impl< 1669 1669 - T: LibraryService, 1670 1670 - > tonic::server::UnaryService<super::GetLikedAlbumsRequest> 1671 1671 - for GetLikedAlbumsSvc<T> { 1444 1444 + impl<T: LibraryService> 1445 1445 + tonic::server::UnaryService<super::GetLikedAlbumsRequest> 1446 1446 + for GetLikedAlbumsSvc<T> 1447 1447 + { 1672 1448 type Response = super::GetLikedAlbumsResponse; 1673 1673 - type Future = BoxFuture< 1674 1674 - tonic::Response<Self::Response>, 1675 1675 - tonic::Status, 1676 1676 - >; 1449 1449 + type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 1677 1450 fn call( 1678 1451 &mut self, 1679 1452 request: tonic::Request<super::GetLikedAlbumsRequest>, 1680 1453 ) -> Self::Future { 1681 1454 let inner = Arc::clone(&self.0); 1682 1455 let fut = async move { 1683 1683 - <T as LibraryService>::get_liked_albums(&inner, request) 1684 1684 - .await 1456 1456 + <T as LibraryService>::get_liked_albums(&inner, request).await 1685 1457 }; 1686 1458 Box::pin(fut) 1687 1459 } ··· 1711 1483 "/rockbox.v1alpha1.LibraryService/ScanLibrary" => { 1712 1484 #[allow(non_camel_case_types)] 1713 1485 struct ScanLibrarySvc<T: LibraryService>(pub Arc<T>); 1714 1714 - impl< 1715 1715 - T: LibraryService, 1716 1716 - > tonic::server::UnaryService<super::ScanLibraryRequest> 1717 1717 - for ScanLibrarySvc<T> { 1486 1486 + impl<T: LibraryService> tonic::server::UnaryService<super::ScanLibraryRequest> 1487 1487 + for ScanLibrarySvc<T> 1488 1488 + { 1718 1489 type Response = super::ScanLibraryResponse; 1719 1719 - type Future = BoxFuture< 1720 1720 - tonic::Response<Self::Response>, 1721 1721 - tonic::Status, 1722 1722 - >; 1490 1490 + type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 1723 1491 fn call( 1724 1492 &mut self, 1725 1493 request: tonic::Request<super::ScanLibraryRequest>, ··· 1756 1524 "/rockbox.v1alpha1.LibraryService/Search" => { 1757 1525 #[allow(non_camel_case_types)] 1758 1526 struct SearchSvc<T: LibraryService>(pub Arc<T>); 1759 1759 - impl< 1760 1760 - T: LibraryService, 1761 1761 - > tonic::server::UnaryService<super::SearchRequest> 1762 1762 - for SearchSvc<T> { 1527 1527 + impl<T: LibraryService> tonic::server::UnaryService<super::SearchRequest> for SearchSvc<T> { 1763 1528 type Response = super::SearchResponse; 1764 1764 - type Future = BoxFuture< 1765 1765 - tonic::Response<Self::Response>, 1766 1766 - tonic::Status, 1767 1767 - >; 1529 1529 + type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 1768 1530 fn call( 1769 1531 &mut self, 1770 1532 request: tonic::Request<super::SearchRequest>, 1771 1533 ) -> Self::Future { 1772 1534 let inner = Arc::clone(&self.0); 1773 1773 - let fut = async move { 1774 1774 - <T as LibraryService>::search(&inner, request).await 1775 1775 - }; 1535 1535 + let fut = 1536 1536 + async move { <T as LibraryService>::search(&inner, request).await }; 1776 1537 Box::pin(fut) 1777 1538 } 1778 1539 } ··· 1798 1559 }; 1799 1560 Box::pin(fut) 1800 1561 } 1801 1801 - _ => { 1802 1802 - Box::pin(async move { 1803 1803 - let mut response = http::Response::new(empty_body()); 1804 1804 - let headers = response.headers_mut(); 1805 1805 - headers 1806 1806 - .insert( 1807 1807 - tonic::Status::GRPC_STATUS, 1808 1808 - (tonic::Code::Unimplemented as i32).into(), 1809 1809 - ); 1810 1810 - headers 1811 1811 - .insert( 1812 1812 - http::header::CONTENT_TYPE, 1813 1813 - tonic::metadata::GRPC_CONTENT_TYPE, 1814 1814 - ); 1815 1815 - Ok(response) 1816 1816 - }) 1817 1817 - } 1562 1562 + _ => Box::pin(async move { 1563 1563 + let mut response = http::Response::new(empty_body()); 1564 1564 + let headers = response.headers_mut(); 1565 1565 + headers.insert( 1566 1566 + tonic::Status::GRPC_STATUS, 1567 1567 + (tonic::Code::Unimplemented as i32).into(), 1568 1568 + ); 1569 1569 + headers.insert( 1570 1570 + http::header::CONTENT_TYPE, 1571 1571 + tonic::metadata::GRPC_CONTENT_TYPE, 1572 1572 + ); 1573 1573 + Ok(response) 1574 1574 + }), 1818 1575 } 1819 1576 } 1820 1577 } ··· 1843 1600 dead_code, 1844 1601 missing_docs, 1845 1602 clippy::wildcard_imports, 1846 1846 - clippy::let_unit_value, 1603 1603 + clippy::let_unit_value 1847 1604 )] 1848 1848 - use tonic::codegen::*; 1849 1605 use tonic::codegen::http::Uri; 1606 1606 + use tonic::codegen::*; 1850 1607 #[derive(Debug, Clone)] 1851 1608 pub struct MetadataServiceClient<T> { 1852 1609 inner: tonic::client::Grpc<T>, ··· 1890 1647 <T as tonic::client::GrpcService<tonic::body::BoxBody>>::ResponseBody, 1891 1648 >, 1892 1649 >, 1893 1893 - <T as tonic::codegen::Service< 1894 1894 - http::Request<tonic::body::BoxBody>, 1895 1895 - >>::Error: Into<StdError> + std::marker::Send + std::marker::Sync, 1650 1650 + <T as tonic::codegen::Service<http::Request<tonic::body::BoxBody>>>::Error: 1651 1651 + Into<StdError> + std::marker::Send + std::marker::Sync, 1896 1652 { 1897 1653 MetadataServiceClient::new(InterceptedService::new(inner, interceptor)) 1898 1654 } ··· 1936 1692 dead_code, 1937 1693 missing_docs, 1938 1694 clippy::wildcard_imports, 1939 1939 - clippy::let_unit_value, 1695 1695 + clippy::let_unit_value 1940 1696 )] 1941 1697 use tonic::codegen::*; 1942 1698 /// Generated trait containing gRPC methods that should be implemented for use with MetadataServiceServer. ··· 1963 1719 max_encoding_message_size: None, 1964 1720 } 1965 1721 } 1966 1966 - pub fn with_interceptor<F>( 1967 1967 - inner: T, 1968 1968 - interceptor: F, 1969 1969 - ) -> InterceptedService<Self, F> 1722 1722 + pub fn with_interceptor<F>(inner: T, interceptor: F) -> InterceptedService<Self, F> 1970 1723 where 1971 1724 F: tonic::service::Interceptor, 1972 1725 { ··· 2018 1771 } 2019 1772 fn call(&mut self, req: http::Request<B>) -> Self::Future { 2020 1773 match req.uri().path() { 2021 2021 - _ => { 2022 2022 - Box::pin(async move { 2023 2023 - let mut response = http::Response::new(empty_body()); 2024 2024 - let headers = response.headers_mut(); 2025 2025 - headers 2026 2026 - .insert( 2027 2027 - tonic::Status::GRPC_STATUS, 2028 2028 - (tonic::Code::Unimplemented as i32).into(), 2029 2029 - ); 2030 2030 - headers 2031 2031 - .insert( 2032 2032 - http::header::CONTENT_TYPE, 2033 2033 - tonic::metadata::GRPC_CONTENT_TYPE, 2034 2034 - ); 2035 2035 - Ok(response) 2036 2036 - }) 2037 2037 - } 1774 1774 + _ => Box::pin(async move { 1775 1775 + let mut response = http::Response::new(empty_body()); 1776 1776 + let headers = response.headers_mut(); 1777 1777 + headers.insert( 1778 1778 + tonic::Status::GRPC_STATUS, 1779 1779 + (tonic::Code::Unimplemented as i32).into(), 1780 1780 + ); 1781 1781 + headers.insert( 1782 1782 + http::header::CONTENT_TYPE, 1783 1783 + tonic::metadata::GRPC_CONTENT_TYPE, 1784 1784 + ); 1785 1785 + Ok(response) 1786 1786 + }), 2038 1787 } 2039 1788 } 2040 1789 } ··· 2318 2067 dead_code, 2319 2068 missing_docs, 2320 2069 clippy::wildcard_imports, 2321 2321 - clippy::let_unit_value, 2070 2070 + clippy::let_unit_value 2322 2071 )] 2323 2323 - use tonic::codegen::*; 2324 2072 use tonic::codegen::http::Uri; 2073 2073 + use tonic::codegen::*; 2325 2074 #[derive(Debug, Clone)] 2326 2075 pub struct PlaybackServiceClient<T> { 2327 2076 inner: tonic::client::Grpc<T>, ··· 2365 2114 <T as tonic::client::GrpcService<tonic::body::BoxBody>>::ResponseBody, 2366 2115 >, 2367 2116 >, 2368 2368 - <T as tonic::codegen::Service< 2369 2369 - http::Request<tonic::body::BoxBody>, 2370 2370 - >>::Error: Into<StdError> + std::marker::Send + std::marker::Sync, 2117 2117 + <T as tonic::codegen::Service<http::Request<tonic::body::BoxBody>>>::Error: 2118 2118 + Into<StdError> + std::marker::Send + std::marker::Sync, 2371 2119 { 2372 2120 PlaybackServiceClient::new(InterceptedService::new(inner, interceptor)) 2373 2121 } ··· 2406 2154 &mut self, 2407 2155 request: impl tonic::IntoRequest<super::PlayRequest>, 2408 2156 ) -> std::result::Result<tonic::Response<super::PlayResponse>, tonic::Status> { 2409 2409 - self.inner 2410 2410 - .ready() 2411 2411 - .await 2412 2412 - .map_err(|e| { 2413 2413 - tonic::Status::unknown( 2414 2414 - format!("Service was not ready: {}", e.into()), 2415 2415 - ) 2416 2416 - })?; 2157 2157 + self.inner.ready().await.map_err(|e| { 2158 2158 + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 2159 2159 + })?; 2417 2160 let codec = tonic::codec::ProstCodec::default(); 2418 2418 - let path = http::uri::PathAndQuery::from_static( 2419 2419 - "/rockbox.v1alpha1.PlaybackService/Play", 2420 2420 - ); 2161 2161 + let path = 2162 2162 + http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.PlaybackService/Play"); 2421 2163 let mut req = request.into_request(); 2422 2164 req.extensions_mut() 2423 2165 .insert(GrpcMethod::new("rockbox.v1alpha1.PlaybackService", "Play")); ··· 2427 2169 &mut self, 2428 2170 request: impl tonic::IntoRequest<super::PauseRequest>, 2429 2171 ) -> std::result::Result<tonic::Response<super::PauseResponse>, tonic::Status> { 2430 2430 - self.inner 2431 2431 - .ready() 2432 2432 - .await 2433 2433 - .map_err(|e| { 2434 2434 - tonic::Status::unknown( 2435 2435 - format!("Service was not ready: {}", e.into()), 2436 2436 - ) 2437 2437 - })?; 2172 2172 + self.inner.ready().await.map_err(|e| { 2173 2173 + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 2174 2174 + })?; 2438 2175 let codec = tonic::codec::ProstCodec::default(); 2439 2439 - let path = http::uri::PathAndQuery::from_static( 2440 2440 - "/rockbox.v1alpha1.PlaybackService/Pause", 2441 2441 - ); 2176 2176 + let path = 2177 2177 + http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.PlaybackService/Pause"); 2442 2178 let mut req = request.into_request(); 2443 2179 req.extensions_mut() 2444 2180 .insert(GrpcMethod::new("rockbox.v1alpha1.PlaybackService", "Pause")); ··· 2447 2183 pub async fn play_or_pause( 2448 2184 &mut self, 2449 2185 request: impl tonic::IntoRequest<super::PlayOrPauseRequest>, 2450 2450 - ) -> std::result::Result< 2451 2451 - tonic::Response<super::PlayOrPauseResponse>, 2452 2452 - tonic::Status, 2453 2453 - > { 2454 2454 - self.inner 2455 2455 - .ready() 2456 2456 - .await 2457 2457 - .map_err(|e| { 2458 2458 - tonic::Status::unknown( 2459 2459 - format!("Service was not ready: {}", e.into()), 2460 2460 - ) 2461 2461 - })?; 2186 2186 + ) -> std::result::Result<tonic::Response<super::PlayOrPauseResponse>, tonic::Status> 2187 2187 + { 2188 2188 + self.inner.ready().await.map_err(|e| { 2189 2189 + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 2190 2190 + })?; 2462 2191 let codec = tonic::codec::ProstCodec::default(); 2463 2192 let path = http::uri::PathAndQuery::from_static( 2464 2193 "/rockbox.v1alpha1.PlaybackService/PlayOrPause", 2465 2194 ); 2466 2195 let mut req = request.into_request(); 2467 2467 - req.extensions_mut() 2468 2468 - .insert( 2469 2469 - GrpcMethod::new("rockbox.v1alpha1.PlaybackService", "PlayOrPause"), 2470 2470 - ); 2196 2196 + req.extensions_mut().insert(GrpcMethod::new( 2197 2197 + "rockbox.v1alpha1.PlaybackService", 2198 2198 + "PlayOrPause", 2199 2199 + )); 2471 2200 self.inner.unary(req, path, codec).await 2472 2201 } 2473 2202 pub async fn resume( 2474 2203 &mut self, 2475 2204 request: impl tonic::IntoRequest<super::ResumeRequest>, 2476 2205 ) -> std::result::Result<tonic::Response<super::ResumeResponse>, tonic::Status> { 2477 2477 - self.inner 2478 2478 - .ready() 2479 2479 - .await 2480 2480 - .map_err(|e| { 2481 2481 - tonic::Status::unknown( 2482 2482 - format!("Service was not ready: {}", e.into()), 2483 2483 - ) 2484 2484 - })?; 2206 2206 + self.inner.ready().await.map_err(|e| { 2207 2207 + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 2208 2208 + })?; 2485 2209 let codec = tonic::codec::ProstCodec::default(); 2486 2486 - let path = http::uri::PathAndQuery::from_static( 2487 2487 - "/rockbox.v1alpha1.PlaybackService/Resume", 2488 2488 - ); 2210 2210 + let path = 2211 2211 + http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.PlaybackService/Resume"); 2489 2212 let mut req = request.into_request(); 2490 2490 - req.extensions_mut() 2491 2491 - .insert(GrpcMethod::new("rockbox.v1alpha1.PlaybackService", "Resume")); 2213 2213 + req.extensions_mut().insert(GrpcMethod::new( 2214 2214 + "rockbox.v1alpha1.PlaybackService", 2215 2215 + "Resume", 2216 2216 + )); 2492 2217 self.inner.unary(req, path, codec).await 2493 2218 } 2494 2219 pub async fn next( 2495 2220 &mut self, 2496 2221 request: impl tonic::IntoRequest<super::NextRequest>, 2497 2222 ) -> std::result::Result<tonic::Response<super::NextResponse>, tonic::Status> { 2498 2498 - self.inner 2499 2499 - .ready() 2500 2500 - .await 2501 2501 - .map_err(|e| { 2502 2502 - tonic::Status::unknown( 2503 2503 - format!("Service was not ready: {}", e.into()), 2504 2504 - ) 2505 2505 - })?; 2223 2223 + self.inner.ready().await.map_err(|e| { 2224 2224 + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 2225 2225 + })?; 2506 2226 let codec = tonic::codec::ProstCodec::default(); 2507 2507 - let path = http::uri::PathAndQuery::from_static( 2508 2508 - "/rockbox.v1alpha1.PlaybackService/Next", 2509 2509 - ); 2227 2227 + let path = 2228 2228 + http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.PlaybackService/Next"); 2510 2229 let mut req = request.into_request(); 2511 2230 req.extensions_mut() 2512 2231 .insert(GrpcMethod::new("rockbox.v1alpha1.PlaybackService", "Next")); ··· 2515 2234 pub async fn previous( 2516 2235 &mut self, 2517 2236 request: impl tonic::IntoRequest<super::PreviousRequest>, 2518 2518 - ) -> std::result::Result< 2519 2519 - tonic::Response<super::PreviousResponse>, 2520 2520 - tonic::Status, 2521 2521 - > { 2522 2522 - self.inner 2523 2523 - .ready() 2524 2524 - .await 2525 2525 - .map_err(|e| { 2526 2526 - tonic::Status::unknown( 2527 2527 - format!("Service was not ready: {}", e.into()), 2528 2528 - ) 2529 2529 - })?; 2237 2237 + ) -> std::result::Result<tonic::Response<super::PreviousResponse>, tonic::Status> { 2238 2238 + self.inner.ready().await.map_err(|e| { 2239 2239 + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 2240 2240 + })?; 2530 2241 let codec = tonic::codec::ProstCodec::default(); 2531 2531 - let path = http::uri::PathAndQuery::from_static( 2532 2532 - "/rockbox.v1alpha1.PlaybackService/Previous", 2533 2533 - ); 2242 2242 + let path = 2243 2243 + http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.PlaybackService/Previous"); 2534 2244 let mut req = request.into_request(); 2535 2535 - req.extensions_mut() 2536 2536 - .insert(GrpcMethod::new("rockbox.v1alpha1.PlaybackService", "Previous")); 2245 2245 + req.extensions_mut().insert(GrpcMethod::new( 2246 2246 + "rockbox.v1alpha1.PlaybackService", 2247 2247 + "Previous", 2248 2248 + )); 2537 2249 self.inner.unary(req, path, codec).await 2538 2250 } 2539 2251 pub async fn fast_forward_rewind( 2540 2252 &mut self, 2541 2253 request: impl tonic::IntoRequest<super::FastForwardRewindRequest>, 2542 2542 - ) -> std::result::Result< 2543 2543 - tonic::Response<super::FastForwardRewindResponse>, 2544 2544 - tonic::Status, 2545 2545 - > { 2546 2546 - self.inner 2547 2547 - .ready() 2548 2548 - .await 2549 2549 - .map_err(|e| { 2550 2550 - tonic::Status::unknown( 2551 2551 - format!("Service was not ready: {}", e.into()), 2552 2552 - ) 2553 2553 - })?; 2254 2254 + ) -> std::result::Result<tonic::Response<super::FastForwardRewindResponse>, tonic::Status> 2255 2255 + { 2256 2256 + self.inner.ready().await.map_err(|e| { 2257 2257 + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 2258 2258 + })?; 2554 2259 let codec = tonic::codec::ProstCodec::default(); 2555 2260 let path = http::uri::PathAndQuery::from_static( 2556 2261 "/rockbox.v1alpha1.PlaybackService/FastForwardRewind", 2557 2262 ); 2558 2263 let mut req = request.into_request(); 2559 2559 - req.extensions_mut() 2560 2560 - .insert( 2561 2561 - GrpcMethod::new( 2562 2562 - "rockbox.v1alpha1.PlaybackService", 2563 2563 - "FastForwardRewind", 2564 2564 - ), 2565 2565 - ); 2264 2264 + req.extensions_mut().insert(GrpcMethod::new( 2265 2265 + "rockbox.v1alpha1.PlaybackService", 2266 2266 + "FastForwardRewind", 2267 2267 + )); 2566 2268 self.inner.unary(req, path, codec).await 2567 2269 } 2568 2270 pub async fn status( 2569 2271 &mut self, 2570 2272 request: impl tonic::IntoRequest<super::StatusRequest>, 2571 2273 ) -> std::result::Result<tonic::Response<super::StatusResponse>, tonic::Status> { 2572 2572 - self.inner 2573 2573 - .ready() 2574 2574 - .await 2575 2575 - .map_err(|e| { 2576 2576 - tonic::Status::unknown( 2577 2577 - format!("Service was not ready: {}", e.into()), 2578 2578 - ) 2579 2579 - })?; 2274 2274 + self.inner.ready().await.map_err(|e| { 2275 2275 + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 2276 2276 + })?; 2580 2277 let codec = tonic::codec::ProstCodec::default(); 2581 2581 - let path = http::uri::PathAndQuery::from_static( 2582 2582 - "/rockbox.v1alpha1.PlaybackService/Status", 2583 2583 - ); 2278 2278 + let path = 2279 2279 + http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.PlaybackService/Status"); 2584 2280 let mut req = request.into_request(); 2585 2585 - req.extensions_mut() 2586 2586 - .insert(GrpcMethod::new("rockbox.v1alpha1.PlaybackService", "Status")); 2281 2281 + req.extensions_mut().insert(GrpcMethod::new( 2282 2282 + "rockbox.v1alpha1.PlaybackService", 2283 2283 + "Status", 2284 2284 + )); 2587 2285 self.inner.unary(req, path, codec).await 2588 2286 } 2589 2287 pub async fn current_track( 2590 2288 &mut self, 2591 2289 request: impl tonic::IntoRequest<super::CurrentTrackRequest>, 2592 2592 - ) -> std::result::Result< 2593 2593 - tonic::Response<super::CurrentTrackResponse>, 2594 2594 - tonic::Status, 2595 2595 - > { 2596 2596 - self.inner 2597 2597 - .ready() 2598 2598 - .await 2599 2599 - .map_err(|e| { 2600 2600 - tonic::Status::unknown( 2601 2601 - format!("Service was not ready: {}", e.into()), 2602 2602 - ) 2603 2603 - })?; 2290 2290 + ) -> std::result::Result<tonic::Response<super::CurrentTrackResponse>, tonic::Status> 2291 2291 + { 2292 2292 + self.inner.ready().await.map_err(|e| { 2293 2293 + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 2294 2294 + })?; 2604 2295 let codec = tonic::codec::ProstCodec::default(); 2605 2296 let path = http::uri::PathAndQuery::from_static( 2606 2297 "/rockbox.v1alpha1.PlaybackService/CurrentTrack", 2607 2298 ); 2608 2299 let mut req = request.into_request(); 2609 2609 - req.extensions_mut() 2610 2610 - .insert( 2611 2611 - GrpcMethod::new("rockbox.v1alpha1.PlaybackService", "CurrentTrack"), 2612 2612 - ); 2300 2300 + req.extensions_mut().insert(GrpcMethod::new( 2301 2301 + "rockbox.v1alpha1.PlaybackService", 2302 2302 + "CurrentTrack", 2303 2303 + )); 2613 2304 self.inner.unary(req, path, codec).await 2614 2305 } 2615 2306 pub async fn next_track( 2616 2307 &mut self, 2617 2308 request: impl tonic::IntoRequest<super::NextTrackRequest>, 2618 2618 - ) -> std::result::Result< 2619 2619 - tonic::Response<super::NextTrackResponse>, 2620 2620 - tonic::Status, 2621 2621 - > { 2622 2622 - self.inner 2623 2623 - .ready() 2624 2624 - .await 2625 2625 - .map_err(|e| { 2626 2626 - tonic::Status::unknown( 2627 2627 - format!("Service was not ready: {}", e.into()), 2628 2628 - ) 2629 2629 - })?; 2309 2309 + ) -> std::result::Result<tonic::Response<super::NextTrackResponse>, tonic::Status> { 2310 2310 + self.inner.ready().await.map_err(|e| { 2311 2311 + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 2312 2312 + })?; 2630 2313 let codec = tonic::codec::ProstCodec::default(); 2631 2631 - let path = http::uri::PathAndQuery::from_static( 2632 2632 - "/rockbox.v1alpha1.PlaybackService/NextTrack", 2633 2633 - ); 2314 2314 + let path = 2315 2315 + http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.PlaybackService/NextTrack"); 2634 2316 let mut req = request.into_request(); 2635 2635 - req.extensions_mut() 2636 2636 - .insert( 2637 2637 - GrpcMethod::new("rockbox.v1alpha1.PlaybackService", "NextTrack"), 2638 2638 - ); 2317 2317 + req.extensions_mut().insert(GrpcMethod::new( 2318 2318 + "rockbox.v1alpha1.PlaybackService", 2319 2319 + "NextTrack", 2320 2320 + )); 2639 2321 self.inner.unary(req, path, codec).await 2640 2322 } 2641 2323 pub async fn flush_and_reload_tracks( 2642 2324 &mut self, 2643 2325 request: impl tonic::IntoRequest<super::FlushAndReloadTracksRequest>, 2644 2644 - ) -> std::result::Result< 2645 2645 - tonic::Response<super::FlushAndReloadTracksResponse>, 2646 2646 - tonic::Status, 2647 2647 - > { 2648 2648 - self.inner 2649 2649 - .ready() 2650 2650 - .await 2651 2651 - .map_err(|e| { 2652 2652 - tonic::Status::unknown( 2653 2653 - format!("Service was not ready: {}", e.into()), 2654 2654 - ) 2655 2655 - })?; 2326 2326 + ) -> std::result::Result<tonic::Response<super::FlushAndReloadTracksResponse>, tonic::Status> 2327 2327 + { 2328 2328 + self.inner.ready().await.map_err(|e| { 2329 2329 + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 2330 2330 + })?; 2656 2331 let codec = tonic::codec::ProstCodec::default(); 2657 2332 let path = http::uri::PathAndQuery::from_static( 2658 2333 "/rockbox.v1alpha1.PlaybackService/FlushAndReloadTracks", 2659 2334 ); 2660 2335 let mut req = request.into_request(); 2661 2661 - req.extensions_mut() 2662 2662 - .insert( 2663 2663 - GrpcMethod::new( 2664 2664 - "rockbox.v1alpha1.PlaybackService", 2665 2665 - "FlushAndReloadTracks", 2666 2666 - ), 2667 2667 - ); 2336 2336 + req.extensions_mut().insert(GrpcMethod::new( 2337 2337 + "rockbox.v1alpha1.PlaybackService", 2338 2338 + "FlushAndReloadTracks", 2339 2339 + )); 2668 2340 self.inner.unary(req, path, codec).await 2669 2341 } 2670 2342 pub async fn get_file_position( 2671 2343 &mut self, 2672 2344 request: impl tonic::IntoRequest<super::GetFilePositionRequest>, 2673 2673 - ) -> std::result::Result< 2674 2674 - tonic::Response<super::GetFilePositionResponse>, 2675 2675 - tonic::Status, 2676 2676 - > { 2677 2677 - self.inner 2678 2678 - .ready() 2679 2679 - .await 2680 2680 - .map_err(|e| { 2681 2681 - tonic::Status::unknown( 2682 2682 - format!("Service was not ready: {}", e.into()), 2683 2683 - ) 2684 2684 - })?; 2345 2345 + ) -> std::result::Result<tonic::Response<super::GetFilePositionResponse>, tonic::Status> 2346 2346 + { 2347 2347 + self.inner.ready().await.map_err(|e| { 2348 2348 + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 2349 2349 + })?; 2685 2350 let codec = tonic::codec::ProstCodec::default(); 2686 2351 let path = http::uri::PathAndQuery::from_static( 2687 2352 "/rockbox.v1alpha1.PlaybackService/GetFilePosition", 2688 2353 ); 2689 2354 let mut req = request.into_request(); 2690 2690 - req.extensions_mut() 2691 2691 - .insert( 2692 2692 - GrpcMethod::new( 2693 2693 - "rockbox.v1alpha1.PlaybackService", 2694 2694 - "GetFilePosition", 2695 2695 - ), 2696 2696 - ); 2355 2355 + req.extensions_mut().insert(GrpcMethod::new( 2356 2356 + "rockbox.v1alpha1.PlaybackService", 2357 2357 + "GetFilePosition", 2358 2358 + )); 2697 2359 self.inner.unary(req, path, codec).await 2698 2360 } 2699 2361 pub async fn hard_stop( 2700 2362 &mut self, 2701 2363 request: impl tonic::IntoRequest<super::HardStopRequest>, 2702 2702 - ) -> std::result::Result< 2703 2703 - tonic::Response<super::HardStopResponse>, 2704 2704 - tonic::Status, 2705 2705 - > { 2706 2706 - self.inner 2707 2707 - .ready() 2708 2708 - .await 2709 2709 - .map_err(|e| { 2710 2710 - tonic::Status::unknown( 2711 2711 - format!("Service was not ready: {}", e.into()), 2712 2712 - ) 2713 2713 - })?; 2364 2364 + ) -> std::result::Result<tonic::Response<super::HardStopResponse>, tonic::Status> { 2365 2365 + self.inner.ready().await.map_err(|e| { 2366 2366 + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 2367 2367 + })?; 2714 2368 let codec = tonic::codec::ProstCodec::default(); 2715 2715 - let path = http::uri::PathAndQuery::from_static( 2716 2716 - "/rockbox.v1alpha1.PlaybackService/HardStop", 2717 2717 - ); 2369 2369 + let path = 2370 2370 + http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.PlaybackService/HardStop"); 2718 2371 let mut req = request.into_request(); 2719 2719 - req.extensions_mut() 2720 2720 - .insert(GrpcMethod::new("rockbox.v1alpha1.PlaybackService", "HardStop")); 2372 2372 + req.extensions_mut().insert(GrpcMethod::new( 2373 2373 + "rockbox.v1alpha1.PlaybackService", 2374 2374 + "HardStop", 2375 2375 + )); 2721 2376 self.inner.unary(req, path, codec).await 2722 2377 } 2723 2378 pub async fn play_album( 2724 2379 &mut self, 2725 2380 request: impl tonic::IntoRequest<super::PlayAlbumRequest>, 2726 2726 - ) -> std::result::Result< 2727 2727 - tonic::Response<super::PlayAlbumResponse>, 2728 2728 - tonic::Status, 2729 2729 - > { 2730 2730 - self.inner 2731 2731 - .ready() 2732 2732 - .await 2733 2733 - .map_err(|e| { 2734 2734 - tonic::Status::unknown( 2735 2735 - format!("Service was not ready: {}", e.into()), 2736 2736 - ) 2737 2737 - })?; 2381 2381 + ) -> std::result::Result<tonic::Response<super::PlayAlbumResponse>, tonic::Status> { 2382 2382 + self.inner.ready().await.map_err(|e| { 2383 2383 + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 2384 2384 + })?; 2738 2385 let codec = tonic::codec::ProstCodec::default(); 2739 2739 - let path = http::uri::PathAndQuery::from_static( 2740 2740 - "/rockbox.v1alpha1.PlaybackService/PlayAlbum", 2741 2741 - ); 2386 2386 + let path = 2387 2387 + http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.PlaybackService/PlayAlbum"); 2742 2388 let mut req = request.into_request(); 2743 2743 - req.extensions_mut() 2744 2744 - .insert( 2745 2745 - GrpcMethod::new("rockbox.v1alpha1.PlaybackService", "PlayAlbum"), 2746 2746 - ); 2389 2389 + req.extensions_mut().insert(GrpcMethod::new( 2390 2390 + "rockbox.v1alpha1.PlaybackService", 2391 2391 + "PlayAlbum", 2392 2392 + )); 2747 2393 self.inner.unary(req, path, codec).await 2748 2394 } 2749 2395 pub async fn play_artist_tracks( 2750 2396 &mut self, 2751 2397 request: impl tonic::IntoRequest<super::PlayArtistTracksRequest>, 2752 2752 - ) -> std::result::Result< 2753 2753 - tonic::Response<super::PlayArtistTracksResponse>, 2754 2754 - tonic::Status, 2755 2755 - > { 2756 2756 - self.inner 2757 2757 - .ready() 2758 2758 - .await 2759 2759 - .map_err(|e| { 2760 2760 - tonic::Status::unknown( 2761 2761 - format!("Service was not ready: {}", e.into()), 2762 2762 - ) 2763 2763 - })?; 2398 2398 + ) -> std::result::Result<tonic::Response<super::PlayArtistTracksResponse>, tonic::Status> 2399 2399 + { 2400 2400 + self.inner.ready().await.map_err(|e| { 2401 2401 + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 2402 2402 + })?; 2764 2403 let codec = tonic::codec::ProstCodec::default(); 2765 2404 let path = http::uri::PathAndQuery::from_static( 2766 2405 "/rockbox.v1alpha1.PlaybackService/PlayArtistTracks", 2767 2406 ); 2768 2407 let mut req = request.into_request(); 2769 2769 - req.extensions_mut() 2770 2770 - .insert( 2771 2771 - GrpcMethod::new( 2772 2772 - "rockbox.v1alpha1.PlaybackService", 2773 2773 - "PlayArtistTracks", 2774 2774 - ), 2775 2775 - ); 2408 2408 + req.extensions_mut().insert(GrpcMethod::new( 2409 2409 + "rockbox.v1alpha1.PlaybackService", 2410 2410 + "PlayArtistTracks", 2411 2411 + )); 2776 2412 self.inner.unary(req, path, codec).await 2777 2413 } 2778 2414 pub async fn play_playlist( 2779 2415 &mut self, 2780 2416 request: impl tonic::IntoRequest<super::PlayPlaylistRequest>, 2781 2781 - ) -> std::result::Result< 2782 2782 - tonic::Response<super::PlayPlaylistResponse>, 2783 2783 - tonic::Status, 2784 2784 - > { 2785 2785 - self.inner 2786 2786 - .ready() 2787 2787 - .await 2788 2788 - .map_err(|e| { 2789 2789 - tonic::Status::unknown( 2790 2790 - format!("Service was not ready: {}", e.into()), 2791 2791 - ) 2792 2792 - })?; 2417 2417 + ) -> std::result::Result<tonic::Response<super::PlayPlaylistResponse>, tonic::Status> 2418 2418 + { 2419 2419 + self.inner.ready().await.map_err(|e| { 2420 2420 + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 2421 2421 + })?; 2793 2422 let codec = tonic::codec::ProstCodec::default(); 2794 2423 let path = http::uri::PathAndQuery::from_static( 2795 2424 "/rockbox.v1alpha1.PlaybackService/PlayPlaylist", 2796 2425 ); 2797 2426 let mut req = request.into_request(); 2798 2798 - req.extensions_mut() 2799 2799 - .insert( 2800 2800 - GrpcMethod::new("rockbox.v1alpha1.PlaybackService", "PlayPlaylist"), 2801 2801 - ); 2427 2427 + req.extensions_mut().insert(GrpcMethod::new( 2428 2428 + "rockbox.v1alpha1.PlaybackService", 2429 2429 + "PlayPlaylist", 2430 2430 + )); 2802 2431 self.inner.unary(req, path, codec).await 2803 2432 } 2804 2433 pub async fn play_directory( 2805 2434 &mut self, 2806 2435 request: impl tonic::IntoRequest<super::PlayDirectoryRequest>, 2807 2807 - ) -> std::result::Result< 2808 2808 - tonic::Response<super::PlayDirectoryResponse>, 2809 2809 - tonic::Status, 2810 2810 - > { 2811 2811 - self.inner 2812 2812 - .ready() 2813 2813 - .await 2814 2814 - .map_err(|e| { 2815 2815 - tonic::Status::unknown( 2816 2816 - format!("Service was not ready: {}", e.into()), 2817 2817 - ) 2818 2818 - })?; 2436 2436 + ) -> std::result::Result<tonic::Response<super::PlayDirectoryResponse>, tonic::Status> 2437 2437 + { 2438 2438 + self.inner.ready().await.map_err(|e| { 2439 2439 + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 2440 2440 + })?; 2819 2441 let codec = tonic::codec::ProstCodec::default(); 2820 2442 let path = http::uri::PathAndQuery::from_static( 2821 2443 "/rockbox.v1alpha1.PlaybackService/PlayDirectory", 2822 2444 ); 2823 2445 let mut req = request.into_request(); 2824 2824 - req.extensions_mut() 2825 2825 - .insert( 2826 2826 - GrpcMethod::new("rockbox.v1alpha1.PlaybackService", "PlayDirectory"), 2827 2827 - ); 2446 2446 + req.extensions_mut().insert(GrpcMethod::new( 2447 2447 + "rockbox.v1alpha1.PlaybackService", 2448 2448 + "PlayDirectory", 2449 2449 + )); 2828 2450 self.inner.unary(req, path, codec).await 2829 2451 } 2830 2452 pub async fn play_music_directory( 2831 2453 &mut self, 2832 2454 request: impl tonic::IntoRequest<super::PlayMusicDirectoryRequest>, 2833 2833 - ) -> std::result::Result< 2834 2834 - tonic::Response<super::PlayMusicDirectoryResponse>, 2835 2835 - tonic::Status, 2836 2836 - > { 2837 2837 - self.inner 2838 2838 - .ready() 2839 2839 - .await 2840 2840 - .map_err(|e| { 2841 2841 - tonic::Status::unknown( 2842 2842 - format!("Service was not ready: {}", e.into()), 2843 2843 - ) 2844 2844 - })?; 2455 2455 + ) -> std::result::Result<tonic::Response<super::PlayMusicDirectoryResponse>, tonic::Status> 2456 2456 + { 2457 2457 + self.inner.ready().await.map_err(|e| { 2458 2458 + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 2459 2459 + })?; 2845 2460 let codec = tonic::codec::ProstCodec::default(); 2846 2461 let path = http::uri::PathAndQuery::from_static( 2847 2462 "/rockbox.v1alpha1.PlaybackService/PlayMusicDirectory", 2848 2463 ); 2849 2464 let mut req = request.into_request(); 2850 2850 - req.extensions_mut() 2851 2851 - .insert( 2852 2852 - GrpcMethod::new( 2853 2853 - "rockbox.v1alpha1.PlaybackService", 2854 2854 - "PlayMusicDirectory", 2855 2855 - ), 2856 2856 - ); 2465 2465 + req.extensions_mut().insert(GrpcMethod::new( 2466 2466 + "rockbox.v1alpha1.PlaybackService", 2467 2467 + "PlayMusicDirectory", 2468 2468 + )); 2857 2469 self.inner.unary(req, path, codec).await 2858 2470 } 2859 2471 pub async fn play_track( 2860 2472 &mut self, 2861 2473 request: impl tonic::IntoRequest<super::PlayTrackRequest>, 2862 2862 - ) -> std::result::Result< 2863 2863 - tonic::Response<super::PlayTrackResponse>, 2864 2864 - tonic::Status, 2865 2865 - > { 2866 2866 - self.inner 2867 2867 - .ready() 2868 2868 - .await 2869 2869 - .map_err(|e| { 2870 2870 - tonic::Status::unknown( 2871 2871 - format!("Service was not ready: {}", e.into()), 2872 2872 - ) 2873 2873 - })?; 2474 2474 + ) -> std::result::Result<tonic::Response<super::PlayTrackResponse>, tonic::Status> { 2475 2475 + self.inner.ready().await.map_err(|e| { 2476 2476 + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 2477 2477 + })?; 2874 2478 let codec = tonic::codec::ProstCodec::default(); 2875 2875 - let path = http::uri::PathAndQuery::from_static( 2876 2876 - "/rockbox.v1alpha1.PlaybackService/PlayTrack", 2877 2877 - ); 2479 2479 + let path = 2480 2480 + http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.PlaybackService/PlayTrack"); 2878 2481 let mut req = request.into_request(); 2879 2879 - req.extensions_mut() 2880 2880 - .insert( 2881 2881 - GrpcMethod::new("rockbox.v1alpha1.PlaybackService", "PlayTrack"), 2882 2882 - ); 2482 2482 + req.extensions_mut().insert(GrpcMethod::new( 2483 2483 + "rockbox.v1alpha1.PlaybackService", 2484 2484 + "PlayTrack", 2485 2485 + )); 2883 2486 self.inner.unary(req, path, codec).await 2884 2487 } 2885 2488 pub async fn play_liked_tracks( 2886 2489 &mut self, 2887 2490 request: impl tonic::IntoRequest<super::PlayLikedTracksRequest>, 2888 2888 - ) -> std::result::Result< 2889 2889 - tonic::Response<super::PlayLikedTracksResponse>, 2890 2890 - tonic::Status, 2891 2891 - > { 2892 2892 - self.inner 2893 2893 - .ready() 2894 2894 - .await 2895 2895 - .map_err(|e| { 2896 2896 - tonic::Status::unknown( 2897 2897 - format!("Service was not ready: {}", e.into()), 2898 2898 - ) 2899 2899 - })?; 2491 2491 + ) -> std::result::Result<tonic::Response<super::PlayLikedTracksResponse>, tonic::Status> 2492 2492 + { 2493 2493 + self.inner.ready().await.map_err(|e| { 2494 2494 + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 2495 2495 + })?; 2900 2496 let codec = tonic::codec::ProstCodec::default(); 2901 2497 let path = http::uri::PathAndQuery::from_static( 2902 2498 "/rockbox.v1alpha1.PlaybackService/PlayLikedTracks", 2903 2499 ); 2904 2500 let mut req = request.into_request(); 2905 2905 - req.extensions_mut() 2906 2906 - .insert( 2907 2907 - GrpcMethod::new( 2908 2908 - "rockbox.v1alpha1.PlaybackService", 2909 2909 - "PlayLikedTracks", 2910 2910 - ), 2911 2911 - ); 2501 2501 + req.extensions_mut().insert(GrpcMethod::new( 2502 2502 + "rockbox.v1alpha1.PlaybackService", 2503 2503 + "PlayLikedTracks", 2504 2504 + )); 2912 2505 self.inner.unary(req, path, codec).await 2913 2506 } 2914 2507 pub async fn play_all_tracks( 2915 2508 &mut self, 2916 2509 request: impl tonic::IntoRequest<super::PlayAllTracksRequest>, 2917 2917 - ) -> std::result::Result< 2918 2918 - tonic::Response<super::PlayAllTracksResponse>, 2919 2919 - tonic::Status, 2920 2920 - > { 2921 2921 - self.inner 2922 2922 - .ready() 2923 2923 - .await 2924 2924 - .map_err(|e| { 2925 2925 - tonic::Status::unknown( 2926 2926 - format!("Service was not ready: {}", e.into()), 2927 2927 - ) 2928 2928 - })?; 2510 2510 + ) -> std::result::Result<tonic::Response<super::PlayAllTracksResponse>, tonic::Status> 2511 2511 + { 2512 2512 + self.inner.ready().await.map_err(|e| { 2513 2513 + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 2514 2514 + })?; 2929 2515 let codec = tonic::codec::ProstCodec::default(); 2930 2516 let path = http::uri::PathAndQuery::from_static( 2931 2517 "/rockbox.v1alpha1.PlaybackService/PlayAllTracks", 2932 2518 ); 2933 2519 let mut req = request.into_request(); 2934 2934 - req.extensions_mut() 2935 2935 - .insert( 2936 2936 - GrpcMethod::new("rockbox.v1alpha1.PlaybackService", "PlayAllTracks"), 2937 2937 - ); 2520 2520 + req.extensions_mut().insert(GrpcMethod::new( 2521 2521 + "rockbox.v1alpha1.PlaybackService", 2522 2522 + "PlayAllTracks", 2523 2523 + )); 2938 2524 self.inner.unary(req, path, codec).await 2939 2525 } 2940 2526 pub async fn stream_current_track( ··· 2944 2530 tonic::Response<tonic::codec::Streaming<super::CurrentTrackResponse>>, 2945 2531 tonic::Status, 2946 2532 > { 2947 2947 - self.inner 2948 2948 - .ready() 2949 2949 - .await 2950 2950 - .map_err(|e| { 2951 2951 - tonic::Status::unknown( 2952 2952 - format!("Service was not ready: {}", e.into()), 2953 2953 - ) 2954 2954 - })?; 2533 2533 + self.inner.ready().await.map_err(|e| { 2534 2534 + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 2535 2535 + })?; 2955 2536 let codec = tonic::codec::ProstCodec::default(); 2956 2537 let path = http::uri::PathAndQuery::from_static( 2957 2538 "/rockbox.v1alpha1.PlaybackService/StreamCurrentTrack", 2958 2539 ); 2959 2540 let mut req = request.into_request(); 2960 2960 - req.extensions_mut() 2961 2961 - .insert( 2962 2962 - GrpcMethod::new( 2963 2963 - "rockbox.v1alpha1.PlaybackService", 2964 2964 - "StreamCurrentTrack", 2965 2965 - ), 2966 2966 - ); 2541 2541 + req.extensions_mut().insert(GrpcMethod::new( 2542 2542 + "rockbox.v1alpha1.PlaybackService", 2543 2543 + "StreamCurrentTrack", 2544 2544 + )); 2967 2545 self.inner.server_streaming(req, path, codec).await 2968 2546 } 2969 2547 pub async fn stream_status( ··· 2973 2551 tonic::Response<tonic::codec::Streaming<super::StatusResponse>>, 2974 2552 tonic::Status, 2975 2553 > { 2976 2976 - self.inner 2977 2977 - .ready() 2978 2978 - .await 2979 2979 - .map_err(|e| { 2980 2980 - tonic::Status::unknown( 2981 2981 - format!("Service was not ready: {}", e.into()), 2982 2982 - ) 2983 2983 - })?; 2554 2554 + self.inner.ready().await.map_err(|e| { 2555 2555 + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 2556 2556 + })?; 2984 2557 let codec = tonic::codec::ProstCodec::default(); 2985 2558 let path = http::uri::PathAndQuery::from_static( 2986 2559 "/rockbox.v1alpha1.PlaybackService/StreamStatus", 2987 2560 ); 2988 2561 let mut req = request.into_request(); 2989 2989 - req.extensions_mut() 2990 2990 - .insert( 2991 2991 - GrpcMethod::new("rockbox.v1alpha1.PlaybackService", "StreamStatus"), 2992 2992 - ); 2562 2562 + req.extensions_mut().insert(GrpcMethod::new( 2563 2563 + "rockbox.v1alpha1.PlaybackService", 2564 2564 + "StreamStatus", 2565 2565 + )); 2993 2566 self.inner.server_streaming(req, path, codec).await 2994 2567 } 2995 2568 pub async fn stream_playlist( ··· 2999 2572 tonic::Response<tonic::codec::Streaming<super::PlaylistResponse>>, 3000 2573 tonic::Status, 3001 2574 > { 3002 3002 - self.inner 3003 3003 - .ready() 3004 3004 - .await 3005 3005 - .map_err(|e| { 3006 3006 - tonic::Status::unknown( 3007 3007 - format!("Service was not ready: {}", e.into()), 3008 3008 - ) 3009 3009 - })?; 2575 2575 + self.inner.ready().await.map_err(|e| { 2576 2576 + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 2577 2577 + })?; 3010 2578 let codec = tonic::codec::ProstCodec::default(); 3011 2579 let path = http::uri::PathAndQuery::from_static( 3012 2580 "/rockbox.v1alpha1.PlaybackService/StreamPlaylist", 3013 2581 ); 3014 2582 let mut req = request.into_request(); 3015 3015 - req.extensions_mut() 3016 3016 - .insert( 3017 3017 - GrpcMethod::new("rockbox.v1alpha1.PlaybackService", "StreamPlaylist"), 3018 3018 - ); 2583 2583 + req.extensions_mut().insert(GrpcMethod::new( 2584 2584 + "rockbox.v1alpha1.PlaybackService", 2585 2585 + "StreamPlaylist", 2586 2586 + )); 3019 2587 self.inner.server_streaming(req, path, codec).await 3020 2588 } 3021 2589 } ··· 3027 2595 dead_code, 3028 2596 missing_docs, 3029 2597 clippy::wildcard_imports, 3030 3030 - clippy::let_unit_value, 2598 2598 + clippy::let_unit_value 3031 2599 )] 3032 2600 use tonic::codegen::*; 3033 2601 /// Generated trait containing gRPC methods that should be implemented for use with PlaybackServiceServer. ··· 3044 2612 async fn play_or_pause( 3045 2613 &self, 3046 2614 request: tonic::Request<super::PlayOrPauseRequest>, 3047 3047 - ) -> std::result::Result< 3048 3048 - tonic::Response<super::PlayOrPauseResponse>, 3049 3049 - tonic::Status, 3050 3050 - >; 2615 2615 + ) -> std::result::Result<tonic::Response<super::PlayOrPauseResponse>, tonic::Status>; 3051 2616 async fn resume( 3052 2617 &self, 3053 2618 request: tonic::Request<super::ResumeRequest>, ··· 3059 2624 async fn previous( 3060 2625 &self, 3061 2626 request: tonic::Request<super::PreviousRequest>, 3062 3062 - ) -> std::result::Result< 3063 3063 - tonic::Response<super::PreviousResponse>, 3064 3064 - tonic::Status, 3065 3065 - >; 2627 2627 + ) -> std::result::Result<tonic::Response<super::PreviousResponse>, tonic::Status>; 3066 2628 async fn fast_forward_rewind( 3067 2629 &self, 3068 2630 request: tonic::Request<super::FastForwardRewindRequest>, 3069 3069 - ) -> std::result::Result< 3070 3070 - tonic::Response<super::FastForwardRewindResponse>, 3071 3071 - tonic::Status, 3072 3072 - >; 2631 2631 + ) -> std::result::Result<tonic::Response<super::FastForwardRewindResponse>, tonic::Status>; 3073 2632 async fn status( 3074 2633 &self, 3075 2634 request: tonic::Request<super::StatusRequest>, ··· 3077 2636 async fn current_track( 3078 2637 &self, 3079 2638 request: tonic::Request<super::CurrentTrackRequest>, 3080 3080 - ) -> std::result::Result< 3081 3081 - tonic::Response<super::CurrentTrackResponse>, 3082 3082 - tonic::Status, 3083 3083 - >; 2639 2639 + ) -> std::result::Result<tonic::Response<super::CurrentTrackResponse>, tonic::Status>; 3084 2640 async fn next_track( 3085 2641 &self, 3086 2642 request: tonic::Request<super::NextTrackRequest>, 3087 3087 - ) -> std::result::Result< 3088 3088 - tonic::Response<super::NextTrackResponse>, 3089 3089 - tonic::Status, 3090 3090 - >; 2643 2643 + ) -> std::result::Result<tonic::Response<super::NextTrackResponse>, tonic::Status>; 3091 2644 async fn flush_and_reload_tracks( 3092 2645 &self, 3093 2646 request: tonic::Request<super::FlushAndReloadTracksRequest>, 3094 3094 - ) -> std::result::Result< 3095 3095 - tonic::Response<super::FlushAndReloadTracksResponse>, 3096 3096 - tonic::Status, 3097 3097 - >; 2647 2647 + ) -> std::result::Result<tonic::Response<super::FlushAndReloadTracksResponse>, tonic::Status>; 3098 2648 async fn get_file_position( 3099 2649 &self, 3100 2650 request: tonic::Request<super::GetFilePositionRequest>, 3101 3101 - ) -> std::result::Result< 3102 3102 - tonic::Response<super::GetFilePositionResponse>, 3103 3103 - tonic::Status, 3104 3104 - >; 2651 2651 + ) -> std::result::Result<tonic::Response<super::GetFilePositionResponse>, tonic::Status>; 3105 2652 async fn hard_stop( 3106 2653 &self, 3107 2654 request: tonic::Request<super::HardStopRequest>, 3108 3108 - ) -> std::result::Result< 3109 3109 - tonic::Response<super::HardStopResponse>, 3110 3110 - tonic::Status, 3111 3111 - >; 2655 2655 + ) -> std::result::Result<tonic::Response<super::HardStopResponse>, tonic::Status>; 3112 2656 async fn play_album( 3113 2657 &self, 3114 2658 request: tonic::Request<super::PlayAlbumRequest>, 3115 3115 - ) -> std::result::Result< 3116 3116 - tonic::Response<super::PlayAlbumResponse>, 3117 3117 - tonic::Status, 3118 3118 - >; 2659 2659 + ) -> std::result::Result<tonic::Response<super::PlayAlbumResponse>, tonic::Status>; 3119 2660 async fn play_artist_tracks( 3120 2661 &self, 3121 2662 request: tonic::Request<super::PlayArtistTracksRequest>, 3122 3122 - ) -> std::result::Result< 3123 3123 - tonic::Response<super::PlayArtistTracksResponse>, 3124 3124 - tonic::Status, 3125 3125 - >; 2663 2663 + ) -> std::result::Result<tonic::Response<super::PlayArtistTracksResponse>, tonic::Status>; 3126 2664 async fn play_playlist( 3127 2665 &self, 3128 2666 request: tonic::Request<super::PlayPlaylistRequest>, 3129 3129 - ) -> std::result::Result< 3130 3130 - tonic::Response<super::PlayPlaylistResponse>, 3131 3131 - tonic::Status, 3132 3132 - >; 2667 2667 + ) -> std::result::Result<tonic::Response<super::PlayPlaylistResponse>, tonic::Status>; 3133 2668 async fn play_directory( 3134 2669 &self, 3135 2670 request: tonic::Request<super::PlayDirectoryRequest>, 3136 3136 - ) -> std::result::Result< 3137 3137 - tonic::Response<super::PlayDirectoryResponse>, 3138 3138 - tonic::Status, 3139 3139 - >; 2671 2671 + ) -> std::result::Result<tonic::Response<super::PlayDirectoryResponse>, tonic::Status>; 3140 2672 async fn play_music_directory( 3141 2673 &self, 3142 2674 request: tonic::Request<super::PlayMusicDirectoryRequest>, 3143 3143 - ) -> std::result::Result< 3144 3144 - tonic::Response<super::PlayMusicDirectoryResponse>, 3145 3145 - tonic::Status, 3146 3146 - >; 2675 2675 + ) -> std::result::Result<tonic::Response<super::PlayMusicDirectoryResponse>, tonic::Status>; 3147 2676 async fn play_track( 3148 2677 &self, 3149 2678 request: tonic::Request<super::PlayTrackRequest>, 3150 3150 - ) -> std::result::Result< 3151 3151 - tonic::Response<super::PlayTrackResponse>, 3152 3152 - tonic::Status, 3153 3153 - >; 2679 2679 + ) -> std::result::Result<tonic::Response<super::PlayTrackResponse>, tonic::Status>; 3154 2680 async fn play_liked_tracks( 3155 2681 &self, 3156 2682 request: tonic::Request<super::PlayLikedTracksRequest>, 3157 3157 - ) -> std::result::Result< 3158 3158 - tonic::Response<super::PlayLikedTracksResponse>, 3159 3159 - tonic::Status, 3160 3160 - >; 2683 2683 + ) -> std::result::Result<tonic::Response<super::PlayLikedTracksResponse>, tonic::Status>; 3161 2684 async fn play_all_tracks( 3162 2685 &self, 3163 2686 request: tonic::Request<super::PlayAllTracksRequest>, 3164 3164 - ) -> std::result::Result< 3165 3165 - tonic::Response<super::PlayAllTracksResponse>, 3166 3166 - tonic::Status, 3167 3167 - >; 2687 2687 + ) -> std::result::Result<tonic::Response<super::PlayAllTracksResponse>, tonic::Status>; 3168 2688 /// Server streaming response type for the StreamCurrentTrack method. 3169 2689 type StreamCurrentTrackStream: tonic::codegen::tokio_stream::Stream< 3170 2690 Item = std::result::Result<super::CurrentTrackResponse, tonic::Status>, 3171 3171 - > 3172 3172 - + std::marker::Send 2691 2691 + > + std::marker::Send 3173 2692 + 'static; 3174 2693 async fn stream_current_track( 3175 2694 &self, 3176 2695 request: tonic::Request<super::StreamCurrentTrackRequest>, 3177 3177 - ) -> std::result::Result< 3178 3178 - tonic::Response<Self::StreamCurrentTrackStream>, 3179 3179 - tonic::Status, 3180 3180 - >; 2696 2696 + ) -> std::result::Result<tonic::Response<Self::StreamCurrentTrackStream>, tonic::Status>; 3181 2697 /// Server streaming response type for the StreamStatus method. 3182 2698 type StreamStatusStream: tonic::codegen::tokio_stream::Stream< 3183 2699 Item = std::result::Result<super::StatusResponse, tonic::Status>, 3184 3184 - > 3185 3185 - + std::marker::Send 2700 2700 + > + std::marker::Send 3186 2701 + 'static; 3187 2702 async fn stream_status( 3188 2703 &self, 3189 2704 request: tonic::Request<super::StreamStatusRequest>, 3190 3190 - ) -> std::result::Result< 3191 3191 - tonic::Response<Self::StreamStatusStream>, 3192 3192 - tonic::Status, 3193 3193 - >; 2705 2705 + ) -> std::result::Result<tonic::Response<Self::StreamStatusStream>, tonic::Status>; 3194 2706 /// Server streaming response type for the StreamPlaylist method. 3195 2707 type StreamPlaylistStream: tonic::codegen::tokio_stream::Stream< 3196 2708 Item = std::result::Result<super::PlaylistResponse, tonic::Status>, 3197 3197 - > 3198 3198 - + std::marker::Send 2709 2709 + > + std::marker::Send 3199 2710 + 'static; 3200 2711 async fn stream_playlist( 3201 2712 &self, 3202 2713 request: tonic::Request<super::StreamPlaylistRequest>, 3203 3203 - ) -> std::result::Result< 3204 3204 - tonic::Response<Self::StreamPlaylistStream>, 3205 3205 - tonic::Status, 3206 3206 - >; 2714 2714 + ) -> std::result::Result<tonic::Response<Self::StreamPlaylistStream>, tonic::Status>; 3207 2715 } 3208 2716 #[derive(Debug)] 3209 2717 pub struct PlaybackServiceServer<T> { ··· 3226 2734 max_encoding_message_size: None, 3227 2735 } 3228 2736 } 3229 3229 - pub fn with_interceptor<F>( 3230 3230 - inner: T, 3231 3231 - interceptor: F, 3232 3232 - ) -> InterceptedService<Self, F> 2737 2737 + pub fn with_interceptor<F>(inner: T, interceptor: F) -> InterceptedService<Self, F> 3233 2738 where 3234 2739 F: tonic::service::Interceptor, 3235 2740 { ··· 3284 2789 "/rockbox.v1alpha1.PlaybackService/Play" => { 3285 2790 #[allow(non_camel_case_types)] 3286 2791 struct PlaySvc<T: PlaybackService>(pub Arc<T>); 3287 3287 - impl< 3288 3288 - T: PlaybackService, 3289 3289 - > tonic::server::UnaryService<super::PlayRequest> for PlaySvc<T> { 2792 2792 + impl<T: PlaybackService> tonic::server::UnaryService<super::PlayRequest> for PlaySvc<T> { 3290 2793 type Response = super::PlayResponse; 3291 3291 - type Future = BoxFuture< 3292 3292 - tonic::Response<Self::Response>, 3293 3293 - tonic::Status, 3294 3294 - >; 2794 2794 + type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 3295 2795 fn call( 3296 2796 &mut self, 3297 2797 request: tonic::Request<super::PlayRequest>, 3298 2798 ) -> Self::Future { 3299 2799 let inner = Arc::clone(&self.0); 3300 3300 - let fut = async move { 3301 3301 - <T as PlaybackService>::play(&inner, request).await 3302 3302 - }; 2800 2800 + let fut = 2801 2801 + async move { <T as PlaybackService>::play(&inner, request).await }; 3303 2802 Box::pin(fut) 3304 2803 } 3305 2804 } ··· 3328 2827 "/rockbox.v1alpha1.PlaybackService/Pause" => { 3329 2828 #[allow(non_camel_case_types)] 3330 2829 struct PauseSvc<T: PlaybackService>(pub Arc<T>); 3331 3331 - impl< 3332 3332 - T: PlaybackService, 3333 3333 - > tonic::server::UnaryService<super::PauseRequest> for PauseSvc<T> { 2830 2830 + impl<T: PlaybackService> tonic::server::UnaryService<super::PauseRequest> for PauseSvc<T> { 3334 2831 type Response = super::PauseResponse; 3335 3335 - type Future = BoxFuture< 3336 3336 - tonic::Response<Self::Response>, 3337 3337 - tonic::Status, 3338 3338 - >; 2832 2832 + type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 3339 2833 fn call( 3340 2834 &mut self, 3341 2835 request: tonic::Request<super::PauseRequest>, 3342 2836 ) -> Self::Future { 3343 2837 let inner = Arc::clone(&self.0); 3344 3344 - let fut = async move { 3345 3345 - <T as PlaybackService>::pause(&inner, request).await 3346 3346 - }; 2838 2838 + let fut = 2839 2839 + async move { <T as PlaybackService>::pause(&inner, request).await }; 3347 2840 Box::pin(fut) 3348 2841 } 3349 2842 } ··· 3372 2865 "/rockbox.v1alpha1.PlaybackService/PlayOrPause" => { 3373 2866 #[allow(non_camel_case_types)] 3374 2867 struct PlayOrPauseSvc<T: PlaybackService>(pub Arc<T>); 3375 3375 - impl< 3376 3376 - T: PlaybackService, 3377 3377 - > tonic::server::UnaryService<super::PlayOrPauseRequest> 3378 3378 - for PlayOrPauseSvc<T> { 2868 2868 + impl<T: PlaybackService> tonic::server::UnaryService<super::PlayOrPauseRequest> 2869 2869 + for PlayOrPauseSvc<T> 2870 2870 + { 3379 2871 type Response = super::PlayOrPauseResponse; 3380 3380 - type Future = BoxFuture< 3381 3381 - tonic::Response<Self::Response>, 3382 3382 - tonic::Status, 3383 3383 - >; 2872 2872 + type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 3384 2873 fn call( 3385 2874 &mut self, 3386 2875 request: tonic::Request<super::PlayOrPauseRequest>, ··· 3417 2906 "/rockbox.v1alpha1.PlaybackService/Resume" => { 3418 2907 #[allow(non_camel_case_types)] 3419 2908 struct ResumeSvc<T: PlaybackService>(pub Arc<T>); 3420 3420 - impl< 3421 3421 - T: PlaybackService, 3422 3422 - > tonic::server::UnaryService<super::ResumeRequest> 3423 3423 - for ResumeSvc<T> { 2909 2909 + impl<T: PlaybackService> tonic::server::UnaryService<super::ResumeRequest> for ResumeSvc<T> { 3424 2910 type Response = super::ResumeResponse; 3425 3425 - type Future = BoxFuture< 3426 3426 - tonic::Response<Self::Response>, 3427 3427 - tonic::Status, 3428 3428 - >; 2911 2911 + type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 3429 2912 fn call( 3430 2913 &mut self, 3431 2914 request: tonic::Request<super::ResumeRequest>, ··· 3462 2945 "/rockbox.v1alpha1.PlaybackService/Next" => { 3463 2946 #[allow(non_camel_case_types)] 3464 2947 struct NextSvc<T: PlaybackService>(pub Arc<T>); 3465 3465 - impl< 3466 3466 - T: PlaybackService, 3467 3467 - > tonic::server::UnaryService<super::NextRequest> for NextSvc<T> { 2948 2948 + impl<T: PlaybackService> tonic::server::UnaryService<super::NextRequest> for NextSvc<T> { 3468 2949 type Response = super::NextResponse; 3469 3469 - type Future = BoxFuture< 3470 3470 - tonic::Response<Self::Response>, 3471 3471 - tonic::Status, 3472 3472 - >; 2950 2950 + type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 3473 2951 fn call( 3474 2952 &mut self, 3475 2953 request: tonic::Request<super::NextRequest>, 3476 2954 ) -> Self::Future { 3477 2955 let inner = Arc::clone(&self.0); 3478 3478 - let fut = async move { 3479 3479 - <T as PlaybackService>::next(&inner, request).await 3480 3480 - }; 2956 2956 + let fut = 2957 2957 + async move { <T as PlaybackService>::next(&inner, request).await }; 3481 2958 Box::pin(fut) 3482 2959 } 3483 2960 } ··· 3506 2983 "/rockbox.v1alpha1.PlaybackService/Previous" => { 3507 2984 #[allow(non_camel_case_types)] 3508 2985 struct PreviousSvc<T: PlaybackService>(pub Arc<T>); 3509 3509 - impl< 3510 3510 - T: PlaybackService, 3511 3511 - > tonic::server::UnaryService<super::PreviousRequest> 3512 3512 - for PreviousSvc<T> { 2986 2986 + impl<T: PlaybackService> tonic::server::UnaryService<super::PreviousRequest> for PreviousSvc<T> { 3513 2987 type Response = super::PreviousResponse; 3514 3514 - type Future = BoxFuture< 3515 3515 - tonic::Response<Self::Response>, 3516 3516 - tonic::Status, 3517 3517 - >; 2988 2988 + type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 3518 2989 fn call( 3519 2990 &mut self, 3520 2991 request: tonic::Request<super::PreviousRequest>, ··· 3551 3022 "/rockbox.v1alpha1.PlaybackService/FastForwardRewind" => { 3552 3023 #[allow(non_camel_case_types)] 3553 3024 struct FastForwardRewindSvc<T: PlaybackService>(pub Arc<T>); 3554 3554 - impl< 3555 3555 - T: PlaybackService, 3556 3556 - > tonic::server::UnaryService<super::FastForwardRewindRequest> 3557 3557 - for FastForwardRewindSvc<T> { 3025 3025 + impl<T: PlaybackService> 3026 3026 + tonic::server::UnaryService<super::FastForwardRewindRequest> 3027 3027 + for FastForwardRewindSvc<T> 3028 3028 + { 3558 3029 type Response = super::FastForwardRewindResponse; 3559 3559 - type Future = BoxFuture< 3560 3560 - tonic::Response<Self::Response>, 3561 3561 - tonic::Status, 3562 3562 - >; 3030 3030 + type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 3563 3031 fn call( 3564 3032 &mut self, 3565 3033 request: tonic::Request<super::FastForwardRewindRequest>, 3566 3034 ) -> Self::Future { 3567 3035 let inner = Arc::clone(&self.0); 3568 3036 let fut = async move { 3569 3569 - <T as PlaybackService>::fast_forward_rewind(&inner, request) 3570 3570 - .await 3037 3037 + <T as PlaybackService>::fast_forward_rewind(&inner, request).await 3571 3038 }; 3572 3039 Box::pin(fut) 3573 3040 } ··· 3597 3064 "/rockbox.v1alpha1.PlaybackService/Status" => { 3598 3065 #[allow(non_camel_case_types)] 3599 3066 struct StatusSvc<T: PlaybackService>(pub Arc<T>); 3600 3600 - impl< 3601 3601 - T: PlaybackService, 3602 3602 - > tonic::server::UnaryService<super::StatusRequest> 3603 3603 - for StatusSvc<T> { 3067 3067 + impl<T: PlaybackService> tonic::server::UnaryService<super::StatusRequest> for StatusSvc<T> { 3604 3068 type Response = super::StatusResponse; 3605 3605 - type Future = BoxFuture< 3606 3606 - tonic::Response<Self::Response>, 3607 3607 - tonic::Status, 3608 3608 - >; 3069 3069 + type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 3609 3070 fn call( 3610 3071 &mut self, 3611 3072 request: tonic::Request<super::StatusRequest>, ··· 3642 3103 "/rockbox.v1alpha1.PlaybackService/CurrentTrack" => { 3643 3104 #[allow(non_camel_case_types)] 3644 3105 struct CurrentTrackSvc<T: PlaybackService>(pub Arc<T>); 3645 3645 - impl< 3646 3646 - T: PlaybackService, 3647 3647 - > tonic::server::UnaryService<super::CurrentTrackRequest> 3648 3648 - for CurrentTrackSvc<T> { 3106 3106 + impl<T: PlaybackService> tonic::server::UnaryService<super::CurrentTrackRequest> 3107 3107 + for CurrentTrackSvc<T> 3108 3108 + { 3649 3109 type Response = super::CurrentTrackResponse; 3650 3650 - type Future = BoxFuture< 3651 3651 - tonic::Response<Self::Response>, 3652 3652 - tonic::Status, 3653 3653 - >; 3110 3110 + type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 3654 3111 fn call( 3655 3112 &mut self, 3656 3113 request: tonic::Request<super::CurrentTrackRequest>, ··· 3687 3144 "/rockbox.v1alpha1.PlaybackService/NextTrack" => { 3688 3145 #[allow(non_camel_case_types)] 3689 3146 struct NextTrackSvc<T: PlaybackService>(pub Arc<T>); 3690 3690 - impl< 3691 3691 - T: PlaybackService, 3692 3692 - > tonic::server::UnaryService<super::NextTrackRequest> 3693 3693 - for NextTrackSvc<T> { 3147 3147 + impl<T: PlaybackService> tonic::server::UnaryService<super::NextTrackRequest> for NextTrackSvc<T> { 3694 3148 type Response = super::NextTrackResponse; 3695 3695 - type Future = BoxFuture< 3696 3696 - tonic::Response<Self::Response>, 3697 3697 - tonic::Status, 3698 3698 - >; 3149 3149 + type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 3699 3150 fn call( 3700 3151 &mut self, 3701 3152 request: tonic::Request<super::NextTrackRequest>, ··· 3732 3183 "/rockbox.v1alpha1.PlaybackService/FlushAndReloadTracks" => { 3733 3184 #[allow(non_camel_case_types)] 3734 3185 struct FlushAndReloadTracksSvc<T: PlaybackService>(pub Arc<T>); 3735 3735 - impl< 3736 3736 - T: PlaybackService, 3737 3737 - > tonic::server::UnaryService<super::FlushAndReloadTracksRequest> 3738 3738 - for FlushAndReloadTracksSvc<T> { 3186 3186 + impl<T: PlaybackService> 3187 3187 + tonic::server::UnaryService<super::FlushAndReloadTracksRequest> 3188 3188 + for FlushAndReloadTracksSvc<T> 3189 3189 + { 3739 3190 type Response = super::FlushAndReloadTracksResponse; 3740 3740 - type Future = BoxFuture< 3741 3741 - tonic::Response<Self::Response>, 3742 3742 - tonic::Status, 3743 3743 - >; 3191 3191 + type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 3744 3192 fn call( 3745 3193 &mut self, 3746 3194 request: tonic::Request<super::FlushAndReloadTracksRequest>, 3747 3195 ) -> Self::Future { 3748 3196 let inner = Arc::clone(&self.0); 3749 3197 let fut = async move { 3750 3750 - <T as PlaybackService>::flush_and_reload_tracks( 3751 3751 - &inner, 3752 3752 - request, 3753 3753 - ) 3198 3198 + <T as PlaybackService>::flush_and_reload_tracks(&inner, request) 3754 3199 .await 3755 3200 }; 3756 3201 Box::pin(fut) ··· 3781 3226 "/rockbox.v1alpha1.PlaybackService/GetFilePosition" => { 3782 3227 #[allow(non_camel_case_types)] 3783 3228 struct GetFilePositionSvc<T: PlaybackService>(pub Arc<T>); 3784 3784 - impl< 3785 3785 - T: PlaybackService, 3786 3786 - > tonic::server::UnaryService<super::GetFilePositionRequest> 3787 3787 - for GetFilePositionSvc<T> { 3229 3229 + impl<T: PlaybackService> 3230 3230 + tonic::server::UnaryService<super::GetFilePositionRequest> 3231 3231 + for GetFilePositionSvc<T> 3232 3232 + { 3788 3233 type Response = super::GetFilePositionResponse; 3789 3789 - type Future = BoxFuture< 3790 3790 - tonic::Response<Self::Response>, 3791 3791 - tonic::Status, 3792 3792 - >; 3234 3234 + type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 3793 3235 fn call( 3794 3236 &mut self, 3795 3237 request: tonic::Request<super::GetFilePositionRequest>, 3796 3238 ) -> Self::Future { 3797 3239 let inner = Arc::clone(&self.0); 3798 3240 let fut = async move { 3799 3799 - <T as PlaybackService>::get_file_position(&inner, request) 3800 3800 - .await 3241 3241 + <T as PlaybackService>::get_file_position(&inner, request).await 3801 3242 }; 3802 3243 Box::pin(fut) 3803 3244 } ··· 3827 3268 "/rockbox.v1alpha1.PlaybackService/HardStop" => { 3828 3269 #[allow(non_camel_case_types)] 3829 3270 struct HardStopSvc<T: PlaybackService>(pub Arc<T>); 3830 3830 - impl< 3831 3831 - T: PlaybackService, 3832 3832 - > tonic::server::UnaryService<super::HardStopRequest> 3833 3833 - for HardStopSvc<T> { 3271 3271 + impl<T: PlaybackService> tonic::server::UnaryService<super::HardStopRequest> for HardStopSvc<T> { 3834 3272 type Response = super::HardStopResponse; 3835 3835 - type Future = BoxFuture< 3836 3836 - tonic::Response<Self::Response>, 3837 3837 - tonic::Status, 3838 3838 - >; 3273 3273 + type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 3839 3274 fn call( 3840 3275 &mut self, 3841 3276 request: tonic::Request<super::HardStopRequest>, ··· 3872 3307 "/rockbox.v1alpha1.PlaybackService/PlayAlbum" => { 3873 3308 #[allow(non_camel_case_types)] 3874 3309 struct PlayAlbumSvc<T: PlaybackService>(pub Arc<T>); 3875 3875 - impl< 3876 3876 - T: PlaybackService, 3877 3877 - > tonic::server::UnaryService<super::PlayAlbumRequest> 3878 3878 - for PlayAlbumSvc<T> { 3310 3310 + impl<T: PlaybackService> tonic::server::UnaryService<super::PlayAlbumRequest> for PlayAlbumSvc<T> { 3879 3311 type Response = super::PlayAlbumResponse; 3880 3880 - type Future = BoxFuture< 3881 3881 - tonic::Response<Self::Response>, 3882 3882 - tonic::Status, 3883 3883 - >; 3312 3312 + type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 3884 3313 fn call( 3885 3314 &mut self, 3886 3315 request: tonic::Request<super::PlayAlbumRequest>, ··· 3917 3346 "/rockbox.v1alpha1.PlaybackService/PlayArtistTracks" => { 3918 3347 #[allow(non_camel_case_types)] 3919 3348 struct PlayArtistTracksSvc<T: PlaybackService>(pub Arc<T>); 3920 3920 - impl< 3921 3921 - T: PlaybackService, 3922 3922 - > tonic::server::UnaryService<super::PlayArtistTracksRequest> 3923 3923 - for PlayArtistTracksSvc<T> { 3349 3349 + impl<T: PlaybackService> 3350 3350 + tonic::server::UnaryService<super::PlayArtistTracksRequest> 3351 3351 + for PlayArtistTracksSvc<T> 3352 3352 + { 3924 3353 type Response = super::PlayArtistTracksResponse; 3925 3925 - type Future = BoxFuture< 3926 3926 - tonic::Response<Self::Response>, 3927 3927 - tonic::Status, 3928 3928 - >; 3354 3354 + type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 3929 3355 fn call( 3930 3356 &mut self, 3931 3357 request: tonic::Request<super::PlayArtistTracksRequest>, 3932 3358 ) -> Self::Future { 3933 3359 let inner = Arc::clone(&self.0); 3934 3360 let fut = async move { 3935 3935 - <T as PlaybackService>::play_artist_tracks(&inner, request) 3936 3936 - .await 3361 3361 + <T as PlaybackService>::play_artist_tracks(&inner, request).await 3937 3362 }; 3938 3363 Box::pin(fut) 3939 3364 } ··· 3963 3388 "/rockbox.v1alpha1.PlaybackService/PlayPlaylist" => { 3964 3389 #[allow(non_camel_case_types)] 3965 3390 struct PlayPlaylistSvc<T: PlaybackService>(pub Arc<T>); 3966 3966 - impl< 3967 3967 - T: PlaybackService, 3968 3968 - > tonic::server::UnaryService<super::PlayPlaylistRequest> 3969 3969 - for PlayPlaylistSvc<T> { 3391 3391 + impl<T: PlaybackService> tonic::server::UnaryService<super::PlayPlaylistRequest> 3392 3392 + for PlayPlaylistSvc<T> 3393 3393 + { 3970 3394 type Response = super::PlayPlaylistResponse; 3971 3971 - type Future = BoxFuture< 3972 3972 - tonic::Response<Self::Response>, 3973 3973 - tonic::Status, 3974 3974 - >; 3395 3395 + type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 3975 3396 fn call( 3976 3397 &mut self, 3977 3398 request: tonic::Request<super::PlayPlaylistRequest>, ··· 4008 3429 "/rockbox.v1alpha1.PlaybackService/PlayDirectory" => { 4009 3430 #[allow(non_camel_case_types)] 4010 3431 struct PlayDirectorySvc<T: PlaybackService>(pub Arc<T>); 4011 4011 - impl< 4012 4012 - T: PlaybackService, 4013 4013 - > tonic::server::UnaryService<super::PlayDirectoryRequest> 4014 4014 - for PlayDirectorySvc<T> { 3432 3432 + impl<T: PlaybackService> 3433 3433 + tonic::server::UnaryService<super::PlayDirectoryRequest> 3434 3434 + for PlayDirectorySvc<T> 3435 3435 + { 4015 3436 type Response = super::PlayDirectoryResponse; 4016 4016 - type Future = BoxFuture< 4017 4017 - tonic::Response<Self::Response>, 4018 4018 - tonic::Status, 4019 4019 - >; 3437 3437 + type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 4020 3438 fn call( 4021 3439 &mut self, 4022 3440 request: tonic::Request<super::PlayDirectoryRequest>, 4023 3441 ) -> Self::Future { 4024 3442 let inner = Arc::clone(&self.0); 4025 3443 let fut = async move { 4026 4026 - <T as PlaybackService>::play_directory(&inner, request) 4027 4027 - .await 3444 3444 + <T as PlaybackService>::play_directory(&inner, request).await 4028 3445 }; 4029 3446 Box::pin(fut) 4030 3447 } ··· 4054 3471 "/rockbox.v1alpha1.PlaybackService/PlayMusicDirectory" => { 4055 3472 #[allow(non_camel_case_types)] 4056 3473 struct PlayMusicDirectorySvc<T: PlaybackService>(pub Arc<T>); 4057 4057 - impl< 4058 4058 - T: PlaybackService, 4059 4059 - > tonic::server::UnaryService<super::PlayMusicDirectoryRequest> 4060 4060 - for PlayMusicDirectorySvc<T> { 3474 3474 + impl<T: PlaybackService> 3475 3475 + tonic::server::UnaryService<super::PlayMusicDirectoryRequest> 3476 3476 + for PlayMusicDirectorySvc<T> 3477 3477 + { 4061 3478 type Response = super::PlayMusicDirectoryResponse; 4062 4062 - type Future = BoxFuture< 4063 4063 - tonic::Response<Self::Response>, 4064 4064 - tonic::Status, 4065 4065 - >; 3479 3479 + type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 4066 3480 fn call( 4067 3481 &mut self, 4068 3482 request: tonic::Request<super::PlayMusicDirectoryRequest>, 4069 3483 ) -> Self::Future { 4070 3484 let inner = Arc::clone(&self.0); 4071 3485 let fut = async move { 4072 4072 - <T as PlaybackService>::play_music_directory( 4073 4073 - &inner, 4074 4074 - request, 4075 4075 - ) 4076 4076 - .await 3486 3486 + <T as PlaybackService>::play_music_directory(&inner, request).await 4077 3487 }; 4078 3488 Box::pin(fut) 4079 3489 } ··· 4103 3513 "/rockbox.v1alpha1.PlaybackService/PlayTrack" => { 4104 3514 #[allow(non_camel_case_types)] 4105 3515 struct PlayTrackSvc<T: PlaybackService>(pub Arc<T>); 4106 4106 - impl< 4107 4107 - T: PlaybackService, 4108 4108 - > tonic::server::UnaryService<super::PlayTrackRequest> 4109 4109 - for PlayTrackSvc<T> { 3516 3516 + impl<T: PlaybackService> tonic::server::UnaryService<super::PlayTrackRequest> for PlayTrackSvc<T> { 4110 3517 type Response = super::PlayTrackResponse; 4111 4111 - type Future = BoxFuture< 4112 4112 - tonic::Response<Self::Response>, 4113 4113 - tonic::Status, 4114 4114 - >; 3518 3518 + type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 4115 3519 fn call( 4116 3520 &mut self, 4117 3521 request: tonic::Request<super::PlayTrackRequest>, ··· 4148 3552 "/rockbox.v1alpha1.PlaybackService/PlayLikedTracks" => { 4149 3553 #[allow(non_camel_case_types)] 4150 3554 struct PlayLikedTracksSvc<T: PlaybackService>(pub Arc<T>); 4151 4151 - impl< 4152 4152 - T: PlaybackService, 4153 4153 - > tonic::server::UnaryService<super::PlayLikedTracksRequest> 4154 4154 - for PlayLikedTracksSvc<T> { 3555 3555 + impl<T: PlaybackService> 3556 3556 + tonic::server::UnaryService<super::PlayLikedTracksRequest> 3557 3557 + for PlayLikedTracksSvc<T> 3558 3558 + { 4155 3559 type Response = super::PlayLikedTracksResponse; 4156 4156 - type Future = BoxFuture< 4157 4157 - tonic::Response<Self::Response>, 4158 4158 - tonic::Status, 4159 4159 - >; 3560 3560 + type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 4160 3561 fn call( 4161 3562 &mut self, 4162 3563 request: tonic::Request<super::PlayLikedTracksRequest>, 4163 3564 ) -> Self::Future { 4164 3565 let inner = Arc::clone(&self.0); 4165 3566 let fut = async move { 4166 4166 - <T as PlaybackService>::play_liked_tracks(&inner, request) 4167 4167 - .await 3567 3567 + <T as PlaybackService>::play_liked_tracks(&inner, request).await 4168 3568 }; 4169 3569 Box::pin(fut) 4170 3570 } ··· 4194 3594 "/rockbox.v1alpha1.PlaybackService/PlayAllTracks" => { 4195 3595 #[allow(non_camel_case_types)] 4196 3596 struct PlayAllTracksSvc<T: PlaybackService>(pub Arc<T>); 4197 4197 - impl< 4198 4198 - T: PlaybackService, 4199 4199 - > tonic::server::UnaryService<super::PlayAllTracksRequest> 4200 4200 - for PlayAllTracksSvc<T> { 3597 3597 + impl<T: PlaybackService> 3598 3598 + tonic::server::UnaryService<super::PlayAllTracksRequest> 3599 3599 + for PlayAllTracksSvc<T> 3600 3600 + { 4201 3601 type Response = super::PlayAllTracksResponse; 4202 4202 - type Future = BoxFuture< 4203 4203 - tonic::Response<Self::Response>, 4204 4204 - tonic::Status, 4205 4205 - >; 3602 3602 + type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 4206 3603 fn call( 4207 3604 &mut self, 4208 3605 request: tonic::Request<super::PlayAllTracksRequest>, 4209 3606 ) -> Self::Future { 4210 3607 let inner = Arc::clone(&self.0); 4211 3608 let fut = async move { 4212 4212 - <T as PlaybackService>::play_all_tracks(&inner, request) 4213 4213 - .await 3609 3609 + <T as PlaybackService>::play_all_tracks(&inner, request).await 4214 3610 }; 4215 3611 Box::pin(fut) 4216 3612 } ··· 4240 3636 "/rockbox.v1alpha1.PlaybackService/StreamCurrentTrack" => { 4241 3637 #[allow(non_camel_case_types)] 4242 3638 struct StreamCurrentTrackSvc<T: PlaybackService>(pub Arc<T>); 4243 4243 - impl< 4244 4244 - T: PlaybackService, 4245 4245 - > tonic::server::ServerStreamingService< 4246 4246 - super::StreamCurrentTrackRequest, 4247 4247 - > for StreamCurrentTrackSvc<T> { 3639 3639 + impl<T: PlaybackService> 3640 3640 + tonic::server::ServerStreamingService<super::StreamCurrentTrackRequest> 3641 3641 + for StreamCurrentTrackSvc<T> 3642 3642 + { 4248 3643 type Response = super::CurrentTrackResponse; 4249 3644 type ResponseStream = T::StreamCurrentTrackStream; 4250 4250 - type Future = BoxFuture< 4251 4251 - tonic::Response<Self::ResponseStream>, 4252 4252 - tonic::Status, 4253 4253 - >; 3645 3645 + type Future = 3646 3646 + BoxFuture<tonic::Response<Self::ResponseStream>, tonic::Status>; 4254 3647 fn call( 4255 3648 &mut self, 4256 3649 request: tonic::Request<super::StreamCurrentTrackRequest>, 4257 3650 ) -> Self::Future { 4258 3651 let inner = Arc::clone(&self.0); 4259 3652 let fut = async move { 4260 4260 - <T as PlaybackService>::stream_current_track( 4261 4261 - &inner, 4262 4262 - request, 4263 4263 - ) 4264 4264 - .await 3653 3653 + <T as PlaybackService>::stream_current_track(&inner, request).await 4265 3654 }; 4266 3655 Box::pin(fut) 4267 3656 } ··· 4291 3680 "/rockbox.v1alpha1.PlaybackService/StreamStatus" => { 4292 3681 #[allow(non_camel_case_types)] 4293 3682 struct StreamStatusSvc<T: PlaybackService>(pub Arc<T>); 4294 4294 - impl< 4295 4295 - T: PlaybackService, 4296 4296 - > tonic::server::ServerStreamingService<super::StreamStatusRequest> 4297 4297 - for StreamStatusSvc<T> { 3683 3683 + impl<T: PlaybackService> 3684 3684 + tonic::server::ServerStreamingService<super::StreamStatusRequest> 3685 3685 + for StreamStatusSvc<T> 3686 3686 + { 4298 3687 type Response = super::StatusResponse; 4299 3688 type ResponseStream = T::StreamStatusStream; 4300 4300 - type Future = BoxFuture< 4301 4301 - tonic::Response<Self::ResponseStream>, 4302 4302 - tonic::Status, 4303 4303 - >; 3689 3689 + type Future = 3690 3690 + BoxFuture<tonic::Response<Self::ResponseStream>, tonic::Status>; 4304 3691 fn call( 4305 3692 &mut self, 4306 3693 request: tonic::Request<super::StreamStatusRequest>, ··· 4337 3724 "/rockbox.v1alpha1.PlaybackService/StreamPlaylist" => { 4338 3725 #[allow(non_camel_case_types)] 4339 3726 struct StreamPlaylistSvc<T: PlaybackService>(pub Arc<T>); 4340 4340 - impl< 4341 4341 - T: PlaybackService, 4342 4342 - > tonic::server::ServerStreamingService<super::StreamPlaylistRequest> 4343 4343 - for StreamPlaylistSvc<T> { 3727 3727 + impl<T: PlaybackService> 3728 3728 + tonic::server::ServerStreamingService<super::StreamPlaylistRequest> 3729 3729 + for StreamPlaylistSvc<T> 3730 3730 + { 4344 3731 type Response = super::PlaylistResponse; 4345 3732 type ResponseStream = T::StreamPlaylistStream; 4346 4346 - type Future = BoxFuture< 4347 4347 - tonic::Response<Self::ResponseStream>, 4348 4348 - tonic::Status, 4349 4349 - >; 3733 3733 + type Future = 3734 3734 + BoxFuture<tonic::Response<Self::ResponseStream>, tonic::Status>; 4350 3735 fn call( 4351 3736 &mut self, 4352 3737 request: tonic::Request<super::StreamPlaylistRequest>, 4353 3738 ) -> Self::Future { 4354 3739 let inner = Arc::clone(&self.0); 4355 3740 let fut = async move { 4356 4356 - <T as PlaybackService>::stream_playlist(&inner, request) 4357 4357 - .await 3741 3741 + <T as PlaybackService>::stream_playlist(&inner, request).await 4358 3742 }; 4359 3743 Box::pin(fut) 4360 3744 } ··· 4381 3765 }; 4382 3766 Box::pin(fut) 4383 3767 } 4384 4384 - _ => { 4385 4385 - Box::pin(async move { 4386 4386 - let mut response = http::Response::new(empty_body()); 4387 4387 - let headers = response.headers_mut(); 4388 4388 - headers 4389 4389 - .insert( 4390 4390 - tonic::Status::GRPC_STATUS, 4391 4391 - (tonic::Code::Unimplemented as i32).into(), 4392 4392 - ); 4393 4393 - headers 4394 4394 - .insert( 4395 4395 - http::header::CONTENT_TYPE, 4396 4396 - tonic::metadata::GRPC_CONTENT_TYPE, 4397 4397 - ); 4398 4398 - Ok(response) 4399 4399 - }) 4400 4400 - } 3768 3768 + _ => Box::pin(async move { 3769 3769 + let mut response = http::Response::new(empty_body()); 3770 3770 + let headers = response.headers_mut(); 3771 3771 + headers.insert( 3772 3772 + tonic::Status::GRPC_STATUS, 3773 3773 + (tonic::Code::Unimplemented as i32).into(), 3774 3774 + ); 3775 3775 + headers.insert( 3776 3776 + http::header::CONTENT_TYPE, 3777 3777 + tonic::metadata::GRPC_CONTENT_TYPE, 3778 3778 + ); 3779 3779 + Ok(response) 3780 3780 + }), 4401 3781 } 4402 3782 } 4403 3783 } ··· 4604 3984 dead_code, 4605 3985 missing_docs, 4606 3986 clippy::wildcard_imports, 4607 4607 - clippy::let_unit_value, 3987 3987 + clippy::let_unit_value 4608 3988 )] 4609 4609 - use tonic::codegen::*; 4610 3989 use tonic::codegen::http::Uri; 3990 3990 + use tonic::codegen::*; 4611 3991 #[derive(Debug, Clone)] 4612 3992 pub struct PlaylistServiceClient<T> { 4613 3993 inner: tonic::client::Grpc<T>, ··· 4651 4031 <T as tonic::client::GrpcService<tonic::body::BoxBody>>::ResponseBody, 4652 4032 >, 4653 4033 >, 4654 4654 - <T as tonic::codegen::Service< 4655 4655 - http::Request<tonic::body::BoxBody>, 4656 4656 - >>::Error: Into<StdError> + std::marker::Send + std::marker::Sync, 4034 4034 + <T as tonic::codegen::Service<http::Request<tonic::body::BoxBody>>>::Error: 4035 4035 + Into<StdError> + std::marker::Send + std::marker::Sync, 4657 4036 { 4658 4037 PlaylistServiceClient::new(InterceptedService::new(inner, interceptor)) 4659 4038 } ··· 4691 4070 pub async fn get_current( 4692 4071 &mut self, 4693 4072 request: impl tonic::IntoRequest<super::GetCurrentRequest>, 4694 4694 - ) -> std::result::Result< 4695 4695 - tonic::Response<super::GetCurrentResponse>, 4696 4696 - tonic::Status, 4697 4697 - > { 4698 4698 - self.inner 4699 4699 - .ready() 4700 4700 - .await 4701 4701 - .map_err(|e| { 4702 4702 - tonic::Status::unknown( 4703 4703 - format!("Service was not ready: {}", e.into()), 4704 4704 - ) 4705 4705 - })?; 4073 4073 + ) -> std::result::Result<tonic::Response<super::GetCurrentResponse>, tonic::Status> 4074 4074 + { 4075 4075 + self.inner.ready().await.map_err(|e| { 4076 4076 + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 4077 4077 + })?; 4706 4078 let codec = tonic::codec::ProstCodec::default(); 4707 4079 let path = http::uri::PathAndQuery::from_static( 4708 4080 "/rockbox.v1alpha1.PlaylistService/GetCurrent", 4709 4081 ); 4710 4082 let mut req = request.into_request(); 4711 4711 - req.extensions_mut() 4712 4712 - .insert( 4713 4713 - GrpcMethod::new("rockbox.v1alpha1.PlaylistService", "GetCurrent"), 4714 4714 - ); 4083 4083 + req.extensions_mut().insert(GrpcMethod::new( 4084 4084 + "rockbox.v1alpha1.PlaylistService", 4085 4085 + "GetCurrent", 4086 4086 + )); 4715 4087 self.inner.unary(req, path, codec).await 4716 4088 } 4717 4089 pub async fn get_resume_info( 4718 4090 &mut self, 4719 4091 request: impl tonic::IntoRequest<super::GetResumeInfoRequest>, 4720 4720 - ) -> std::result::Result< 4721 4721 - tonic::Response<super::GetResumeInfoResponse>, 4722 4722 - tonic::Status, 4723 4723 - > { 4724 4724 - self.inner 4725 4725 - .ready() 4726 4726 - .await 4727 4727 - .map_err(|e| { 4728 4728 - tonic::Status::unknown( 4729 4729 - format!("Service was not ready: {}", e.into()), 4730 4730 - ) 4731 4731 - })?; 4092 4092 + ) -> std::result::Result<tonic::Response<super::GetResumeInfoResponse>, tonic::Status> 4093 4093 + { 4094 4094 + self.inner.ready().await.map_err(|e| { 4095 4095 + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 4096 4096 + })?; 4732 4097 let codec = tonic::codec::ProstCodec::default(); 4733 4098 let path = http::uri::PathAndQuery::from_static( 4734 4099 "/rockbox.v1alpha1.PlaylistService/GetResumeInfo", 4735 4100 ); 4736 4101 let mut req = request.into_request(); 4737 4737 - req.extensions_mut() 4738 4738 - .insert( 4739 4739 - GrpcMethod::new("rockbox.v1alpha1.PlaylistService", "GetResumeInfo"), 4740 4740 - ); 4102 4102 + req.extensions_mut().insert(GrpcMethod::new( 4103 4103 + "rockbox.v1alpha1.PlaylistService", 4104 4104 + "GetResumeInfo", 4105 4105 + )); 4741 4106 self.inner.unary(req, path, codec).await 4742 4107 } 4743 4108 pub async fn get_track_info( 4744 4109 &mut self, 4745 4110 request: impl tonic::IntoRequest<super::GetTrackInfoRequest>, 4746 4746 - ) -> std::result::Result< 4747 4747 - tonic::Response<super::GetTrackInfoResponse>, 4748 4748 - tonic::Status, 4749 4749 - > { 4750 4750 - self.inner 4751 4751 - .ready() 4752 4752 - .await 4753 4753 - .map_err(|e| { 4754 4754 - tonic::Status::unknown( 4755 4755 - format!("Service was not ready: {}", e.into()), 4756 4756 - ) 4757 4757 - })?; 4111 4111 + ) -> std::result::Result<tonic::Response<super::GetTrackInfoResponse>, tonic::Status> 4112 4112 + { 4113 4113 + self.inner.ready().await.map_err(|e| { 4114 4114 + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 4115 4115 + })?; 4758 4116 let codec = tonic::codec::ProstCodec::default(); 4759 4117 let path = http::uri::PathAndQuery::from_static( 4760 4118 "/rockbox.v1alpha1.PlaylistService/GetTrackInfo", 4761 4119 ); 4762 4120 let mut req = request.into_request(); 4763 4763 - req.extensions_mut() 4764 4764 - .insert( 4765 4765 - GrpcMethod::new("rockbox.v1alpha1.PlaylistService", "GetTrackInfo"), 4766 4766 - ); 4121 4121 + req.extensions_mut().insert(GrpcMethod::new( 4122 4122 + "rockbox.v1alpha1.PlaylistService", 4123 4123 + "GetTrackInfo", 4124 4124 + )); 4767 4125 self.inner.unary(req, path, codec).await 4768 4126 } 4769 4127 pub async fn get_first_index( 4770 4128 &mut self, 4771 4129 request: impl tonic::IntoRequest<super::GetFirstIndexRequest>, 4772 4772 - ) -> std::result::Result< 4773 4773 - tonic::Response<super::GetFirstIndexResponse>, 4774 4774 - tonic::Status, 4775 4775 - > { 4776 4776 - self.inner 4777 4777 - .ready() 4778 4778 - .await 4779 4779 - .map_err(|e| { 4780 4780 - tonic::Status::unknown( 4781 4781 - format!("Service was not ready: {}", e.into()), 4782 4782 - ) 4783 4783 - })?; 4130 4130 + ) -> std::result::Result<tonic::Response<super::GetFirstIndexResponse>, tonic::Status> 4131 4131 + { 4132 4132 + self.inner.ready().await.map_err(|e| { 4133 4133 + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 4134 4134 + })?; 4784 4135 let codec = tonic::codec::ProstCodec::default(); 4785 4136 let path = http::uri::PathAndQuery::from_static( 4786 4137 "/rockbox.v1alpha1.PlaylistService/GetFirstIndex", 4787 4138 ); 4788 4139 let mut req = request.into_request(); 4789 4789 - req.extensions_mut() 4790 4790 - .insert( 4791 4791 - GrpcMethod::new("rockbox.v1alpha1.PlaylistService", "GetFirstIndex"), 4792 4792 - ); 4140 4140 + req.extensions_mut().insert(GrpcMethod::new( 4141 4141 + "rockbox.v1alpha1.PlaylistService", 4142 4142 + "GetFirstIndex", 4143 4143 + )); 4793 4144 self.inner.unary(req, path, codec).await 4794 4145 } 4795 4146 pub async fn get_display_index( 4796 4147 &mut self, 4797 4148 request: impl tonic::IntoRequest<super::GetDisplayIndexRequest>, 4798 4798 - ) -> std::result::Result< 4799 4799 - tonic::Response<super::GetDisplayIndexResponse>, 4800 4800 - tonic::Status, 4801 4801 - > { 4802 4802 - self.inner 4803 4803 - .ready() 4804 4804 - .await 4805 4805 - .map_err(|e| { 4806 4806 - tonic::Status::unknown( 4807 4807 - format!("Service was not ready: {}", e.into()), 4808 4808 - ) 4809 4809 - })?; 4149 4149 + ) -> std::result::Result<tonic::Response<super::GetDisplayIndexResponse>, tonic::Status> 4150 4150 + { 4151 4151 + self.inner.ready().await.map_err(|e| { 4152 4152 + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 4153 4153 + })?; 4810 4154 let codec = tonic::codec::ProstCodec::default(); 4811 4155 let path = http::uri::PathAndQuery::from_static( 4812 4156 "/rockbox.v1alpha1.PlaylistService/GetDisplayIndex", 4813 4157 ); 4814 4158 let mut req = request.into_request(); 4815 4815 - req.extensions_mut() 4816 4816 - .insert( 4817 4817 - GrpcMethod::new( 4818 4818 - "rockbox.v1alpha1.PlaylistService", 4819 4819 - "GetDisplayIndex", 4820 4820 - ), 4821 4821 - ); 4159 4159 + req.extensions_mut().insert(GrpcMethod::new( 4160 4160 + "rockbox.v1alpha1.PlaylistService", 4161 4161 + "GetDisplayIndex", 4162 4162 + )); 4822 4163 self.inner.unary(req, path, codec).await 4823 4164 } 4824 4165 pub async fn amount( 4825 4166 &mut self, 4826 4167 request: impl tonic::IntoRequest<super::AmountRequest>, 4827 4168 ) -> std::result::Result<tonic::Response<super::AmountResponse>, tonic::Status> { 4828 4828 - self.inner 4829 4829 - .ready() 4830 4830 - .await 4831 4831 - .map_err(|e| { 4832 4832 - tonic::Status::unknown( 4833 4833 - format!("Service was not ready: {}", e.into()), 4834 4834 - ) 4835 4835 - })?; 4169 4169 + self.inner.ready().await.map_err(|e| { 4170 4170 + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 4171 4171 + })?; 4836 4172 let codec = tonic::codec::ProstCodec::default(); 4837 4837 - let path = http::uri::PathAndQuery::from_static( 4838 4838 - "/rockbox.v1alpha1.PlaylistService/Amount", 4839 4839 - ); 4173 4173 + let path = 4174 4174 + http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.PlaylistService/Amount"); 4840 4175 let mut req = request.into_request(); 4841 4841 - req.extensions_mut() 4842 4842 - .insert(GrpcMethod::new("rockbox.v1alpha1.PlaylistService", "Amount")); 4176 4176 + req.extensions_mut().insert(GrpcMethod::new( 4177 4177 + "rockbox.v1alpha1.PlaylistService", 4178 4178 + "Amount", 4179 4179 + )); 4843 4180 self.inner.unary(req, path, codec).await 4844 4181 } 4845 4182 pub async fn playlist_resume( 4846 4183 &mut self, 4847 4184 request: impl tonic::IntoRequest<super::PlaylistResumeRequest>, 4848 4848 - ) -> std::result::Result< 4849 4849 - tonic::Response<super::PlaylistResumeResponse>, 4850 4850 - tonic::Status, 4851 4851 - > { 4852 4852 - self.inner 4853 4853 - .ready() 4854 4854 - .await 4855 4855 - .map_err(|e| { 4856 4856 - tonic::Status::unknown( 4857 4857 - format!("Service was not ready: {}", e.into()), 4858 4858 - ) 4859 4859 - })?; 4185 4185 + ) -> std::result::Result<tonic::Response<super::PlaylistResumeResponse>, tonic::Status> 4186 4186 + { 4187 4187 + self.inner.ready().await.map_err(|e| { 4188 4188 + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 4189 4189 + })?; 4860 4190 let codec = tonic::codec::ProstCodec::default(); 4861 4191 let path = http::uri::PathAndQuery::from_static( 4862 4192 "/rockbox.v1alpha1.PlaylistService/PlaylistResume", 4863 4193 ); 4864 4194 let mut req = request.into_request(); 4865 4865 - req.extensions_mut() 4866 4866 - .insert( 4867 4867 - GrpcMethod::new("rockbox.v1alpha1.PlaylistService", "PlaylistResume"), 4868 4868 - ); 4195 4195 + req.extensions_mut().insert(GrpcMethod::new( 4196 4196 + "rockbox.v1alpha1.PlaylistService", 4197 4197 + "PlaylistResume", 4198 4198 + )); 4869 4199 self.inner.unary(req, path, codec).await 4870 4200 } 4871 4201 pub async fn resume_track( 4872 4202 &mut self, 4873 4203 request: impl tonic::IntoRequest<super::ResumeTrackRequest>, 4874 4874 - ) -> std::result::Result< 4875 4875 - tonic::Response<super::ResumeTrackResponse>, 4876 4876 - tonic::Status, 4877 4877 - > { 4878 4878 - self.inner 4879 4879 - .ready() 4880 4880 - .await 4881 4881 - .map_err(|e| { 4882 4882 - tonic::Status::unknown( 4883 4883 - format!("Service was not ready: {}", e.into()), 4884 4884 - ) 4885 4885 - })?; 4204 4204 + ) -> std::result::Result<tonic::Response<super::ResumeTrackResponse>, tonic::Status> 4205 4205 + { 4206 4206 + self.inner.ready().await.map_err(|e| { 4207 4207 + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 4208 4208 + })?; 4886 4209 let codec = tonic::codec::ProstCodec::default(); 4887 4210 let path = http::uri::PathAndQuery::from_static( 4888 4211 "/rockbox.v1alpha1.PlaylistService/ResumeTrack", 4889 4212 ); 4890 4213 let mut req = request.into_request(); 4891 4891 - req.extensions_mut() 4892 4892 - .insert( 4893 4893 - GrpcMethod::new("rockbox.v1alpha1.PlaylistService", "ResumeTrack"), 4894 4894 - ); 4214 4214 + req.extensions_mut().insert(GrpcMethod::new( 4215 4215 + "rockbox.v1alpha1.PlaylistService", 4216 4216 + "ResumeTrack", 4217 4217 + )); 4895 4218 self.inner.unary(req, path, codec).await 4896 4219 } 4897 4220 pub async fn set_modified( 4898 4221 &mut self, 4899 4222 request: impl tonic::IntoRequest<super::SetModifiedRequest>, 4900 4900 - ) -> std::result::Result< 4901 4901 - tonic::Response<super::SetModifiedResponse>, 4902 4902 - tonic::Status, 4903 4903 - > { 4904 4904 - self.inner 4905 4905 - .ready() 4906 4906 - .await 4907 4907 - .map_err(|e| { 4908 4908 - tonic::Status::unknown( 4909 4909 - format!("Service was not ready: {}", e.into()), 4910 4910 - ) 4911 4911 - })?; 4223 4223 + ) -> std::result::Result<tonic::Response<super::SetModifiedResponse>, tonic::Status> 4224 4224 + { 4225 4225 + self.inner.ready().await.map_err(|e| { 4226 4226 + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 4227 4227 + })?; 4912 4228 let codec = tonic::codec::ProstCodec::default(); 4913 4229 let path = http::uri::PathAndQuery::from_static( 4914 4230 "/rockbox.v1alpha1.PlaylistService/SetModified", 4915 4231 ); 4916 4232 let mut req = request.into_request(); 4917 4917 - req.extensions_mut() 4918 4918 - .insert( 4919 4919 - GrpcMethod::new("rockbox.v1alpha1.PlaylistService", "SetModified"), 4920 4920 - ); 4233 4233 + req.extensions_mut().insert(GrpcMethod::new( 4234 4234 + "rockbox.v1alpha1.PlaylistService", 4235 4235 + "SetModified", 4236 4236 + )); 4921 4237 self.inner.unary(req, path, codec).await 4922 4238 } 4923 4239 pub async fn start( 4924 4240 &mut self, 4925 4241 request: impl tonic::IntoRequest<super::StartRequest>, 4926 4242 ) -> std::result::Result<tonic::Response<super::StartResponse>, tonic::Status> { 4927 4927 - self.inner 4928 4928 - .ready() 4929 4929 - .await 4930 4930 - .map_err(|e| { 4931 4931 - tonic::Status::unknown( 4932 4932 - format!("Service was not ready: {}", e.into()), 4933 4933 - ) 4934 4934 - })?; 4243 4243 + self.inner.ready().await.map_err(|e| { 4244 4244 + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 4245 4245 + })?; 4935 4246 let codec = tonic::codec::ProstCodec::default(); 4936 4936 - let path = http::uri::PathAndQuery::from_static( 4937 4937 - "/rockbox.v1alpha1.PlaylistService/Start", 4938 4938 - ); 4247 4247 + let path = 4248 4248 + http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.PlaylistService/Start"); 4939 4249 let mut req = request.into_request(); 4940 4250 req.extensions_mut() 4941 4251 .insert(GrpcMethod::new("rockbox.v1alpha1.PlaylistService", "Start")); ··· 4945 4255 &mut self, 4946 4256 request: impl tonic::IntoRequest<super::SyncRequest>, 4947 4257 ) -> std::result::Result<tonic::Response<super::SyncResponse>, tonic::Status> { 4948 4948 - self.inner 4949 4949 - .ready() 4950 4950 - .await 4951 4951 - .map_err(|e| { 4952 4952 - tonic::Status::unknown( 4953 4953 - format!("Service was not ready: {}", e.into()), 4954 4954 - ) 4955 4955 - })?; 4258 4258 + self.inner.ready().await.map_err(|e| { 4259 4259 + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 4260 4260 + })?; 4956 4261 let codec = tonic::codec::ProstCodec::default(); 4957 4957 - let path = http::uri::PathAndQuery::from_static( 4958 4958 - "/rockbox.v1alpha1.PlaylistService/Sync", 4959 4959 - ); 4262 4262 + let path = 4263 4263 + http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.PlaylistService/Sync"); 4960 4264 let mut req = request.into_request(); 4961 4265 req.extensions_mut() 4962 4266 .insert(GrpcMethod::new("rockbox.v1alpha1.PlaylistService", "Sync")); ··· 4965 4269 pub async fn remove_all_tracks( 4966 4270 &mut self, 4967 4271 request: impl tonic::IntoRequest<super::RemoveAllTracksRequest>, 4968 4968 - ) -> std::result::Result< 4969 4969 - tonic::Response<super::RemoveAllTracksResponse>, 4970 4970 - tonic::Status, 4971 4971 - > { 4972 4972 - self.inner 4973 4973 - .ready() 4974 4974 - .await 4975 4975 - .map_err(|e| { 4976 4976 - tonic::Status::unknown( 4977 4977 - format!("Service was not ready: {}", e.into()), 4978 4978 - ) 4979 4979 - })?; 4272 4272 + ) -> std::result::Result<tonic::Response<super::RemoveAllTracksResponse>, tonic::Status> 4273 4273 + { 4274 4274 + self.inner.ready().await.map_err(|e| { 4275 4275 + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 4276 4276 + })?; 4980 4277 let codec = tonic::codec::ProstCodec::default(); 4981 4278 let path = http::uri::PathAndQuery::from_static( 4982 4279 "/rockbox.v1alpha1.PlaylistService/RemoveAllTracks", 4983 4280 ); 4984 4281 let mut req = request.into_request(); 4985 4985 - req.extensions_mut() 4986 4986 - .insert( 4987 4987 - GrpcMethod::new( 4988 4988 - "rockbox.v1alpha1.PlaylistService", 4989 4989 - "RemoveAllTracks", 4990 4990 - ), 4991 4991 - ); 4282 4282 + req.extensions_mut().insert(GrpcMethod::new( 4283 4283 + "rockbox.v1alpha1.PlaylistService", 4284 4284 + "RemoveAllTracks", 4285 4285 + )); 4992 4286 self.inner.unary(req, path, codec).await 4993 4287 } 4994 4288 pub async fn remove_tracks( 4995 4289 &mut self, 4996 4290 request: impl tonic::IntoRequest<super::RemoveTracksRequest>, 4997 4997 - ) -> std::result::Result< 4998 4998 - tonic::Response<super::RemoveTracksResponse>, 4999 4999 - tonic::Status, 5000 5000 - > { 5001 5001 - self.inner 5002 5002 - .ready() 5003 5003 - .await 5004 5004 - .map_err(|e| { 5005 5005 - tonic::Status::unknown( 5006 5006 - format!("Service was not ready: {}", e.into()), 5007 5007 - ) 5008 5008 - })?; 4291 4291 + ) -> std::result::Result<tonic::Response<super::RemoveTracksResponse>, tonic::Status> 4292 4292 + { 4293 4293 + self.inner.ready().await.map_err(|e| { 4294 4294 + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 4295 4295 + })?; 5009 4296 let codec = tonic::codec::ProstCodec::default(); 5010 4297 let path = http::uri::PathAndQuery::from_static( 5011 4298 "/rockbox.v1alpha1.PlaylistService/RemoveTracks", 5012 4299 ); 5013 4300 let mut req = request.into_request(); 5014 5014 - req.extensions_mut() 5015 5015 - .insert( 5016 5016 - GrpcMethod::new("rockbox.v1alpha1.PlaylistService", "RemoveTracks"), 5017 5017 - ); 4301 4301 + req.extensions_mut().insert(GrpcMethod::new( 4302 4302 + "rockbox.v1alpha1.PlaylistService", 4303 4303 + "RemoveTracks", 4304 4304 + )); 5018 4305 self.inner.unary(req, path, codec).await 5019 4306 } 5020 4307 pub async fn create_playlist( 5021 4308 &mut self, 5022 4309 request: impl tonic::IntoRequest<super::CreatePlaylistRequest>, 5023 5023 - ) -> std::result::Result< 5024 5024 - tonic::Response<super::CreatePlaylistResponse>, 5025 5025 - tonic::Status, 5026 5026 - > { 5027 5027 - self.inner 5028 5028 - .ready() 5029 5029 - .await 5030 5030 - .map_err(|e| { 5031 5031 - tonic::Status::unknown( 5032 5032 - format!("Service was not ready: {}", e.into()), 5033 5033 - ) 5034 5034 - })?; 4310 4310 + ) -> std::result::Result<tonic::Response<super::CreatePlaylistResponse>, tonic::Status> 4311 4311 + { 4312 4312 + self.inner.ready().await.map_err(|e| { 4313 4313 + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 4314 4314 + })?; 5035 4315 let codec = tonic::codec::ProstCodec::default(); 5036 4316 let path = http::uri::PathAndQuery::from_static( 5037 4317 "/rockbox.v1alpha1.PlaylistService/CreatePlaylist", 5038 4318 ); 5039 4319 let mut req = request.into_request(); 5040 5040 - req.extensions_mut() 5041 5041 - .insert( 5042 5042 - GrpcMethod::new("rockbox.v1alpha1.PlaylistService", "CreatePlaylist"), 5043 5043 - ); 4320 4320 + req.extensions_mut().insert(GrpcMethod::new( 4321 4321 + "rockbox.v1alpha1.PlaylistService", 4322 4322 + "CreatePlaylist", 4323 4323 + )); 5044 4324 self.inner.unary(req, path, codec).await 5045 4325 } 5046 4326 pub async fn insert_tracks( 5047 4327 &mut self, 5048 4328 request: impl tonic::IntoRequest<super::InsertTracksRequest>, 5049 5049 - ) -> std::result::Result< 5050 5050 - tonic::Response<super::InsertTracksResponse>, 5051 5051 - tonic::Status, 5052 5052 - > { 5053 5053 - self.inner 5054 5054 - .ready() 5055 5055 - .await 5056 5056 - .map_err(|e| { 5057 5057 - tonic::Status::unknown( 5058 5058 - format!("Service was not ready: {}", e.into()), 5059 5059 - ) 5060 5060 - })?; 4329 4329 + ) -> std::result::Result<tonic::Response<super::InsertTracksResponse>, tonic::Status> 4330 4330 + { 4331 4331 + self.inner.ready().await.map_err(|e| { 4332 4332 + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 4333 4333 + })?; 5061 4334 let codec = tonic::codec::ProstCodec::default(); 5062 4335 let path = http::uri::PathAndQuery::from_static( 5063 4336 "/rockbox.v1alpha1.PlaylistService/InsertTracks", 5064 4337 ); 5065 4338 let mut req = request.into_request(); 5066 5066 - req.extensions_mut() 5067 5067 - .insert( 5068 5068 - GrpcMethod::new("rockbox.v1alpha1.PlaylistService", "InsertTracks"), 5069 5069 - ); 4339 4339 + req.extensions_mut().insert(GrpcMethod::new( 4340 4340 + "rockbox.v1alpha1.PlaylistService", 4341 4341 + "InsertTracks", 4342 4342 + )); 5070 4343 self.inner.unary(req, path, codec).await 5071 4344 } 5072 4345 pub async fn insert_directory( 5073 4346 &mut self, 5074 4347 request: impl tonic::IntoRequest<super::InsertDirectoryRequest>, 5075 5075 - ) -> std::result::Result< 5076 5076 - tonic::Response<super::InsertDirectoryResponse>, 5077 5077 - tonic::Status, 5078 5078 - > { 5079 5079 - self.inner 5080 5080 - .ready() 5081 5081 - .await 5082 5082 - .map_err(|e| { 5083 5083 - tonic::Status::unknown( 5084 5084 - format!("Service was not ready: {}", e.into()), 5085 5085 - ) 5086 5086 - })?; 4348 4348 + ) -> std::result::Result<tonic::Response<super::InsertDirectoryResponse>, tonic::Status> 4349 4349 + { 4350 4350 + self.inner.ready().await.map_err(|e| { 4351 4351 + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 4352 4352 + })?; 5087 4353 let codec = tonic::codec::ProstCodec::default(); 5088 4354 let path = http::uri::PathAndQuery::from_static( 5089 4355 "/rockbox.v1alpha1.PlaylistService/InsertDirectory", 5090 4356 ); 5091 4357 let mut req = request.into_request(); 5092 5092 - req.extensions_mut() 5093 5093 - .insert( 5094 5094 - GrpcMethod::new( 5095 5095 - "rockbox.v1alpha1.PlaylistService", 5096 5096 - "InsertDirectory", 5097 5097 - ), 5098 5098 - ); 4358 4358 + req.extensions_mut().insert(GrpcMethod::new( 4359 4359 + "rockbox.v1alpha1.PlaylistService", 4360 4360 + "InsertDirectory", 4361 4361 + )); 5099 4362 self.inner.unary(req, path, codec).await 5100 4363 } 5101 4364 pub async fn insert_playlist( 5102 4365 &mut self, 5103 4366 request: impl tonic::IntoRequest<super::InsertPlaylistRequest>, 5104 5104 - ) -> std::result::Result< 5105 5105 - tonic::Response<super::InsertPlaylistResponse>, 5106 5106 - tonic::Status, 5107 5107 - > { 5108 5108 - self.inner 5109 5109 - .ready() 5110 5110 - .await 5111 5111 - .map_err(|e| { 5112 5112 - tonic::Status::unknown( 5113 5113 - format!("Service was not ready: {}", e.into()), 5114 5114 - ) 5115 5115 - })?; 4367 4367 + ) -> std::result::Result<tonic::Response<super::InsertPlaylistResponse>, 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 + })?; 5116 4372 let codec = tonic::codec::ProstCodec::default(); 5117 4373 let path = http::uri::PathAndQuery::from_static( 5118 4374 "/rockbox.v1alpha1.PlaylistService/InsertPlaylist", 5119 4375 ); 5120 4376 let mut req = request.into_request(); 5121 5121 - req.extensions_mut() 5122 5122 - .insert( 5123 5123 - GrpcMethod::new("rockbox.v1alpha1.PlaylistService", "InsertPlaylist"), 5124 5124 - ); 4377 4377 + req.extensions_mut().insert(GrpcMethod::new( 4378 4378 + "rockbox.v1alpha1.PlaylistService", 4379 4379 + "InsertPlaylist", 4380 4380 + )); 5125 4381 self.inner.unary(req, path, codec).await 5126 4382 } 5127 4383 pub async fn insert_album( 5128 4384 &mut self, 5129 4385 request: impl tonic::IntoRequest<super::InsertAlbumRequest>, 5130 5130 - ) -> std::result::Result< 5131 5131 - tonic::Response<super::InsertAlbumResponse>, 5132 5132 - tonic::Status, 5133 5133 - > { 5134 5134 - self.inner 5135 5135 - .ready() 5136 5136 - .await 5137 5137 - .map_err(|e| { 5138 5138 - tonic::Status::unknown( 5139 5139 - format!("Service was not ready: {}", e.into()), 5140 5140 - ) 5141 5141 - })?; 4386 4386 + ) -> std::result::Result<tonic::Response<super::InsertAlbumResponse>, 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 + })?; 5142 4391 let codec = tonic::codec::ProstCodec::default(); 5143 4392 let path = http::uri::PathAndQuery::from_static( 5144 4393 "/rockbox.v1alpha1.PlaylistService/InsertAlbum", 5145 4394 ); 5146 4395 let mut req = request.into_request(); 5147 5147 - req.extensions_mut() 5148 5148 - .insert( 5149 5149 - GrpcMethod::new("rockbox.v1alpha1.PlaylistService", "InsertAlbum"), 5150 5150 - ); 4396 4396 + req.extensions_mut().insert(GrpcMethod::new( 4397 4397 + "rockbox.v1alpha1.PlaylistService", 4398 4398 + "InsertAlbum", 4399 4399 + )); 5151 4400 self.inner.unary(req, path, codec).await 5152 4401 } 5153 4402 pub async fn insert_artist_tracks( 5154 4403 &mut self, 5155 4404 request: impl tonic::IntoRequest<super::InsertArtistTracksRequest>, 5156 5156 - ) -> std::result::Result< 5157 5157 - tonic::Response<super::InsertArtistTracksResponse>, 5158 5158 - tonic::Status, 5159 5159 - > { 5160 5160 - self.inner 5161 5161 - .ready() 5162 5162 - .await 5163 5163 - .map_err(|e| { 5164 5164 - tonic::Status::unknown( 5165 5165 - format!("Service was not ready: {}", e.into()), 5166 5166 - ) 5167 5167 - })?; 4405 4405 + ) -> std::result::Result<tonic::Response<super::InsertArtistTracksResponse>, 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 + })?; 5168 4410 let codec = tonic::codec::ProstCodec::default(); 5169 4411 let path = http::uri::PathAndQuery::from_static( 5170 4412 "/rockbox.v1alpha1.PlaylistService/InsertArtistTracks", 5171 4413 ); 5172 4414 let mut req = request.into_request(); 5173 5173 - req.extensions_mut() 5174 5174 - .insert( 5175 5175 - GrpcMethod::new( 5176 5176 - "rockbox.v1alpha1.PlaylistService", 5177 5177 - "InsertArtistTracks", 5178 5178 - ), 5179 5179 - ); 4415 4415 + req.extensions_mut().insert(GrpcMethod::new( 4416 4416 + "rockbox.v1alpha1.PlaylistService", 4417 4417 + "InsertArtistTracks", 4418 4418 + )); 5180 4419 self.inner.unary(req, path, codec).await 5181 4420 } 5182 4421 pub async fn shuffle_playlist( 5183 4422 &mut self, 5184 4423 request: impl tonic::IntoRequest<super::ShufflePlaylistRequest>, 5185 5185 - ) -> std::result::Result< 5186 5186 - tonic::Response<super::ShufflePlaylistResponse>, 5187 5187 - tonic::Status, 5188 5188 - > { 5189 5189 - self.inner 5190 5190 - .ready() 5191 5191 - .await 5192 5192 - .map_err(|e| { 5193 5193 - tonic::Status::unknown( 5194 5194 - format!("Service was not ready: {}", e.into()), 5195 5195 - ) 5196 5196 - })?; 4424 4424 + ) -> std::result::Result<tonic::Response<super::ShufflePlaylistResponse>, 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 + })?; 5197 4429 let codec = tonic::codec::ProstCodec::default(); 5198 4430 let path = http::uri::PathAndQuery::from_static( 5199 4431 "/rockbox.v1alpha1.PlaylistService/ShufflePlaylist", 5200 4432 ); 5201 4433 let mut req = request.into_request(); 5202 5202 - req.extensions_mut() 5203 5203 - .insert( 5204 5204 - GrpcMethod::new( 5205 5205 - "rockbox.v1alpha1.PlaylistService", 5206 5206 - "ShufflePlaylist", 5207 5207 - ), 5208 5208 - ); 4434 4434 + req.extensions_mut().insert(GrpcMethod::new( 4435 4435 + "rockbox.v1alpha1.PlaylistService", 4436 4436 + "ShufflePlaylist", 4437 4437 + )); 5209 4438 self.inner.unary(req, path, codec).await 5210 4439 } 5211 4440 } ··· 5217 4446 dead_code, 5218 4447 missing_docs, 5219 4448 clippy::wildcard_imports, 5220 5220 - clippy::let_unit_value, 4449 4449 + clippy::let_unit_value 5221 4450 )] 5222 4451 use tonic::codegen::*; 5223 4452 /// Generated trait containing gRPC methods that should be implemented for use with PlaylistServiceServer. ··· 5226 4455 async fn get_current( 5227 4456 &self, 5228 4457 request: tonic::Request<super::GetCurrentRequest>, 5229 5229 - ) -> std::result::Result< 5230 5230 - tonic::Response<super::GetCurrentResponse>, 5231 5231 - tonic::Status, 5232 5232 - >; 4458 4458 + ) -> std::result::Result<tonic::Response<super::GetCurrentResponse>, tonic::Status>; 5233 4459 async fn get_resume_info( 5234 4460 &self, 5235 4461 request: tonic::Request<super::GetResumeInfoRequest>, 5236 5236 - ) -> std::result::Result< 5237 5237 - tonic::Response<super::GetResumeInfoResponse>, 5238 5238 - tonic::Status, 5239 5239 - >; 4462 4462 + ) -> std::result::Result<tonic::Response<super::GetResumeInfoResponse>, tonic::Status>; 5240 4463 async fn get_track_info( 5241 4464 &self, 5242 4465 request: tonic::Request<super::GetTrackInfoRequest>, 5243 5243 - ) -> std::result::Result< 5244 5244 - tonic::Response<super::GetTrackInfoResponse>, 5245 5245 - tonic::Status, 5246 5246 - >; 4466 4466 + ) -> std::result::Result<tonic::Response<super::GetTrackInfoResponse>, tonic::Status>; 5247 4467 async fn get_first_index( 5248 4468 &self, 5249 4469 request: tonic::Request<super::GetFirstIndexRequest>, 5250 5250 - ) -> std::result::Result< 5251 5251 - tonic::Response<super::GetFirstIndexResponse>, 5252 5252 - tonic::Status, 5253 5253 - >; 4470 4470 + ) -> std::result::Result<tonic::Response<super::GetFirstIndexResponse>, tonic::Status>; 5254 4471 async fn get_display_index( 5255 4472 &self, 5256 4473 request: tonic::Request<super::GetDisplayIndexRequest>, 5257 5257 - ) -> std::result::Result< 5258 5258 - tonic::Response<super::GetDisplayIndexResponse>, 5259 5259 - tonic::Status, 5260 5260 - >; 4474 4474 + ) -> std::result::Result<tonic::Response<super::GetDisplayIndexResponse>, tonic::Status>; 5261 4475 async fn amount( 5262 4476 &self, 5263 4477 request: tonic::Request<super::AmountRequest>, ··· 5265 4479 async fn playlist_resume( 5266 4480 &self, 5267 4481 request: tonic::Request<super::PlaylistResumeRequest>, 5268 5268 - ) -> std::result::Result< 5269 5269 - tonic::Response<super::PlaylistResumeResponse>, 5270 5270 - tonic::Status, 5271 5271 - >; 4482 4482 + ) -> std::result::Result<tonic::Response<super::PlaylistResumeResponse>, tonic::Status>; 5272 4483 async fn resume_track( 5273 4484 &self, 5274 4485 request: tonic::Request<super::ResumeTrackRequest>, 5275 5275 - ) -> std::result::Result< 5276 5276 - tonic::Response<super::ResumeTrackResponse>, 5277 5277 - tonic::Status, 5278 5278 - >; 4486 4486 + ) -> std::result::Result<tonic::Response<super::ResumeTrackResponse>, tonic::Status>; 5279 4487 async fn set_modified( 5280 4488 &self, 5281 4489 request: tonic::Request<super::SetModifiedRequest>, 5282 5282 - ) -> std::result::Result< 5283 5283 - tonic::Response<super::SetModifiedResponse>, 5284 5284 - tonic::Status, 5285 5285 - >; 4490 4490 + ) -> std::result::Result<tonic::Response<super::SetModifiedResponse>, tonic::Status>; 5286 4491 async fn start( 5287 4492 &self, 5288 4493 request: tonic::Request<super::StartRequest>, ··· 5294 4499 async fn remove_all_tracks( 5295 4500 &self, 5296 4501 request: tonic::Request<super::RemoveAllTracksRequest>, 5297 5297 - ) -> std::result::Result< 5298 5298 - tonic::Response<super::RemoveAllTracksResponse>, 5299 5299 - tonic::Status, 5300 5300 - >; 4502 4502 + ) -> std::result::Result<tonic::Response<super::RemoveAllTracksResponse>, tonic::Status>; 5301 4503 async fn remove_tracks( 5302 4504 &self, 5303 4505 request: tonic::Request<super::RemoveTracksRequest>, 5304 5304 - ) -> std::result::Result< 5305 5305 - tonic::Response<super::RemoveTracksResponse>, 5306 5306 - tonic::Status, 5307 5307 - >; 4506 4506 + ) -> std::result::Result<tonic::Response<super::RemoveTracksResponse>, tonic::Status>; 5308 4507 async fn create_playlist( 5309 4508 &self, 5310 4509 request: tonic::Request<super::CreatePlaylistRequest>, 5311 5311 - ) -> std::result::Result< 5312 5312 - tonic::Response<super::CreatePlaylistResponse>, 5313 5313 - tonic::Status, 5314 5314 - >; 4510 4510 + ) -> std::result::Result<tonic::Response<super::CreatePlaylistResponse>, tonic::Status>; 5315 4511 async fn insert_tracks( 5316 4512 &self, 5317 4513 request: tonic::Request<super::InsertTracksRequest>, 5318 5318 - ) -> std::result::Result< 5319 5319 - tonic::Response<super::InsertTracksResponse>, 5320 5320 - tonic::Status, 5321 5321 - >; 4514 4514 + ) -> std::result::Result<tonic::Response<super::InsertTracksResponse>, tonic::Status>; 5322 4515 async fn insert_directory( 5323 4516 &self, 5324 4517 request: tonic::Request<super::InsertDirectoryRequest>, 5325 5325 - ) -> std::result::Result< 5326 5326 - tonic::Response<super::InsertDirectoryResponse>, 5327 5327 - tonic::Status, 5328 5328 - >; 4518 4518 + ) -> std::result::Result<tonic::Response<super::InsertDirectoryResponse>, tonic::Status>; 5329 4519 async fn insert_playlist( 5330 4520 &self, 5331 4521 request: tonic::Request<super::InsertPlaylistRequest>, 5332 5332 - ) -> std::result::Result< 5333 5333 - tonic::Response<super::InsertPlaylistResponse>, 5334 5334 - tonic::Status, 5335 5335 - >; 4522 4522 + ) -> std::result::Result<tonic::Response<super::InsertPlaylistResponse>, tonic::Status>; 5336 4523 async fn insert_album( 5337 4524 &self, 5338 4525 request: tonic::Request<super::InsertAlbumRequest>, 5339 5339 - ) -> std::result::Result< 5340 5340 - tonic::Response<super::InsertAlbumResponse>, 5341 5341 - tonic::Status, 5342 5342 - >; 4526 4526 + ) -> std::result::Result<tonic::Response<super::InsertAlbumResponse>, tonic::Status>; 5343 4527 async fn insert_artist_tracks( 5344 4528 &self, 5345 4529 request: tonic::Request<super::InsertArtistTracksRequest>, 5346 5346 - ) -> std::result::Result< 5347 5347 - tonic::Response<super::InsertArtistTracksResponse>, 5348 5348 - tonic::Status, 5349 5349 - >; 4530 4530 + ) -> std::result::Result<tonic::Response<super::InsertArtistTracksResponse>, tonic::Status>; 5350 4531 async fn shuffle_playlist( 5351 4532 &self, 5352 4533 request: tonic::Request<super::ShufflePlaylistRequest>, 5353 5353 - ) -> std::result::Result< 5354 5354 - tonic::Response<super::ShufflePlaylistResponse>, 5355 5355 - tonic::Status, 5356 5356 - >; 4534 4534 + ) -> std::result::Result<tonic::Response<super::ShufflePlaylistResponse>, tonic::Status>; 5357 4535 } 5358 4536 #[derive(Debug)] 5359 4537 pub struct PlaylistServiceServer<T> { ··· 5376 4554 max_encoding_message_size: None, 5377 4555 } 5378 4556 } 5379 5379 - pub fn with_interceptor<F>( 5380 5380 - inner: T, 5381 5381 - interceptor: F, 5382 5382 - ) -> InterceptedService<Self, F> 4557 4557 + pub fn with_interceptor<F>(inner: T, interceptor: F) -> InterceptedService<Self, F> 5383 4558 where 5384 4559 F: tonic::service::Interceptor, 5385 4560 { ··· 5434 4609 "/rockbox.v1alpha1.PlaylistService/GetCurrent" => { 5435 4610 #[allow(non_camel_case_types)] 5436 4611 struct GetCurrentSvc<T: PlaylistService>(pub Arc<T>); 5437 5437 - impl< 5438 5438 - T: PlaylistService, 5439 5439 - > tonic::server::UnaryService<super::GetCurrentRequest> 5440 5440 - for GetCurrentSvc<T> { 4612 4612 + impl<T: PlaylistService> tonic::server::UnaryService<super::GetCurrentRequest> 4613 4613 + for GetCurrentSvc<T> 4614 4614 + { 5441 4615 type Response = super::GetCurrentResponse; 5442 5442 - type Future = BoxFuture< 5443 5443 - tonic::Response<Self::Response>, 5444 5444 - tonic::Status, 5445 5445 - >; 4616 4616 + type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 5446 4617 fn call( 5447 4618 &mut self, 5448 4619 request: tonic::Request<super::GetCurrentRequest>, ··· 5479 4650 "/rockbox.v1alpha1.PlaylistService/GetResumeInfo" => { 5480 4651 #[allow(non_camel_case_types)] 5481 4652 struct GetResumeInfoSvc<T: PlaylistService>(pub Arc<T>); 5482 5482 - impl< 5483 5483 - T: PlaylistService, 5484 5484 - > tonic::server::UnaryService<super::GetResumeInfoRequest> 5485 5485 - for GetResumeInfoSvc<T> { 4653 4653 + impl<T: PlaylistService> 4654 4654 + tonic::server::UnaryService<super::GetResumeInfoRequest> 4655 4655 + for GetResumeInfoSvc<T> 4656 4656 + { 5486 4657 type Response = super::GetResumeInfoResponse; 5487 5487 - type Future = BoxFuture< 5488 5488 - tonic::Response<Self::Response>, 5489 5489 - tonic::Status, 5490 5490 - >; 4658 4658 + type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 5491 4659 fn call( 5492 4660 &mut self, 5493 4661 request: tonic::Request<super::GetResumeInfoRequest>, 5494 4662 ) -> Self::Future { 5495 4663 let inner = Arc::clone(&self.0); 5496 4664 let fut = async move { 5497 5497 - <T as PlaylistService>::get_resume_info(&inner, request) 5498 5498 - .await 4665 4665 + <T as PlaylistService>::get_resume_info(&inner, request).await 5499 4666 }; 5500 4667 Box::pin(fut) 5501 4668 } ··· 5525 4692 "/rockbox.v1alpha1.PlaylistService/GetTrackInfo" => { 5526 4693 #[allow(non_camel_case_types)] 5527 4694 struct GetTrackInfoSvc<T: PlaylistService>(pub Arc<T>); 5528 5528 - impl< 5529 5529 - T: PlaylistService, 5530 5530 - > tonic::server::UnaryService<super::GetTrackInfoRequest> 5531 5531 - for GetTrackInfoSvc<T> { 4695 4695 + impl<T: PlaylistService> tonic::server::UnaryService<super::GetTrackInfoRequest> 4696 4696 + for GetTrackInfoSvc<T> 4697 4697 + { 5532 4698 type Response = super::GetTrackInfoResponse; 5533 5533 - type Future = BoxFuture< 5534 5534 - tonic::Response<Self::Response>, 5535 5535 - tonic::Status, 5536 5536 - >; 4699 4699 + type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 5537 4700 fn call( 5538 4701 &mut self, 5539 4702 request: tonic::Request<super::GetTrackInfoRequest>, 5540 4703 ) -> Self::Future { 5541 4704 let inner = Arc::clone(&self.0); 5542 4705 let fut = async move { 5543 5543 - <T as PlaylistService>::get_track_info(&inner, request) 5544 5544 - .await 4706 4706 + <T as PlaylistService>::get_track_info(&inner, request).await 5545 4707 }; 5546 4708 Box::pin(fut) 5547 4709 } ··· 5571 4733 "/rockbox.v1alpha1.PlaylistService/GetFirstIndex" => { 5572 4734 #[allow(non_camel_case_types)] 5573 4735 struct GetFirstIndexSvc<T: PlaylistService>(pub Arc<T>); 5574 5574 - impl< 5575 5575 - T: PlaylistService, 5576 5576 - > tonic::server::UnaryService<super::GetFirstIndexRequest> 5577 5577 - for GetFirstIndexSvc<T> { 4736 4736 + impl<T: PlaylistService> 4737 4737 + tonic::server::UnaryService<super::GetFirstIndexRequest> 4738 4738 + for GetFirstIndexSvc<T> 4739 4739 + { 5578 4740 type Response = super::GetFirstIndexResponse; 5579 5579 - type Future = BoxFuture< 5580 5580 - tonic::Response<Self::Response>, 5581 5581 - tonic::Status, 5582 5582 - >; 4741 4741 + type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 5583 4742 fn call( 5584 4743 &mut self, 5585 4744 request: tonic::Request<super::GetFirstIndexRequest>, 5586 4745 ) -> Self::Future { 5587 4746 let inner = Arc::clone(&self.0); 5588 4747 let fut = async move { 5589 5589 - <T as PlaylistService>::get_first_index(&inner, request) 5590 5590 - .await 4748 4748 + <T as PlaylistService>::get_first_index(&inner, request).await 5591 4749 }; 5592 4750 Box::pin(fut) 5593 4751 } ··· 5617 4775 "/rockbox.v1alpha1.PlaylistService/GetDisplayIndex" => { 5618 4776 #[allow(non_camel_case_types)] 5619 4777 struct GetDisplayIndexSvc<T: PlaylistService>(pub Arc<T>); 5620 5620 - impl< 5621 5621 - T: PlaylistService, 5622 5622 - > tonic::server::UnaryService<super::GetDisplayIndexRequest> 5623 5623 - for GetDisplayIndexSvc<T> { 4778 4778 + impl<T: PlaylistService> 4779 4779 + tonic::server::UnaryService<super::GetDisplayIndexRequest> 4780 4780 + for GetDisplayIndexSvc<T> 4781 4781 + { 5624 4782 type Response = super::GetDisplayIndexResponse; 5625 5625 - type Future = BoxFuture< 5626 5626 - tonic::Response<Self::Response>, 5627 5627 - tonic::Status, 5628 5628 - >; 4783 4783 + type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 5629 4784 fn call( 5630 4785 &mut self, 5631 4786 request: tonic::Request<super::GetDisplayIndexRequest>, 5632 4787 ) -> Self::Future { 5633 4788 let inner = Arc::clone(&self.0); 5634 4789 let fut = async move { 5635 5635 - <T as PlaylistService>::get_display_index(&inner, request) 5636 5636 - .await 4790 4790 + <T as PlaylistService>::get_display_index(&inner, request).await 5637 4791 }; 5638 4792 Box::pin(fut) 5639 4793 } ··· 5663 4817 "/rockbox.v1alpha1.PlaylistService/Amount" => { 5664 4818 #[allow(non_camel_case_types)] 5665 4819 struct AmountSvc<T: PlaylistService>(pub Arc<T>); 5666 5666 - impl< 5667 5667 - T: PlaylistService, 5668 5668 - > tonic::server::UnaryService<super::AmountRequest> 5669 5669 - for AmountSvc<T> { 4820 4820 + impl<T: PlaylistService> tonic::server::UnaryService<super::AmountRequest> for AmountSvc<T> { 5670 4821 type Response = super::AmountResponse; 5671 5671 - type Future = BoxFuture< 5672 5672 - tonic::Response<Self::Response>, 5673 5673 - tonic::Status, 5674 5674 - >; 4822 4822 + type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 5675 4823 fn call( 5676 4824 &mut self, 5677 4825 request: tonic::Request<super::AmountRequest>, ··· 5708 4856 "/rockbox.v1alpha1.PlaylistService/PlaylistResume" => { 5709 4857 #[allow(non_camel_case_types)] 5710 4858 struct PlaylistResumeSvc<T: PlaylistService>(pub Arc<T>); 5711 5711 - impl< 5712 5712 - T: PlaylistService, 5713 5713 - > tonic::server::UnaryService<super::PlaylistResumeRequest> 5714 5714 - for PlaylistResumeSvc<T> { 4859 4859 + impl<T: PlaylistService> 4860 4860 + tonic::server::UnaryService<super::PlaylistResumeRequest> 4861 4861 + for PlaylistResumeSvc<T> 4862 4862 + { 5715 4863 type Response = super::PlaylistResumeResponse; 5716 5716 - type Future = BoxFuture< 5717 5717 - tonic::Response<Self::Response>, 5718 5718 - tonic::Status, 5719 5719 - >; 4864 4864 + type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 5720 4865 fn call( 5721 4866 &mut self, 5722 4867 request: tonic::Request<super::PlaylistResumeRequest>, 5723 4868 ) -> Self::Future { 5724 4869 let inner = Arc::clone(&self.0); 5725 4870 let fut = async move { 5726 5726 - <T as PlaylistService>::playlist_resume(&inner, request) 5727 5727 - .await 4871 4871 + <T as PlaylistService>::playlist_resume(&inner, request).await 5728 4872 }; 5729 4873 Box::pin(fut) 5730 4874 } ··· 5754 4898 "/rockbox.v1alpha1.PlaylistService/ResumeTrack" => { 5755 4899 #[allow(non_camel_case_types)] 5756 4900 struct ResumeTrackSvc<T: PlaylistService>(pub Arc<T>); 5757 5757 - impl< 5758 5758 - T: PlaylistService, 5759 5759 - > tonic::server::UnaryService<super::ResumeTrackRequest> 5760 5760 - for ResumeTrackSvc<T> { 4901 4901 + impl<T: PlaylistService> tonic::server::UnaryService<super::ResumeTrackRequest> 4902 4902 + for ResumeTrackSvc<T> 4903 4903 + { 5761 4904 type Response = super::ResumeTrackResponse; 5762 5762 - type Future = BoxFuture< 5763 5763 - tonic::Response<Self::Response>, 5764 5764 - tonic::Status, 5765 5765 - >; 4905 4905 + type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 5766 4906 fn call( 5767 4907 &mut self, 5768 4908 request: tonic::Request<super::ResumeTrackRequest>, ··· 5799 4939 "/rockbox.v1alpha1.PlaylistService/SetModified" => { 5800 4940 #[allow(non_camel_case_types)] 5801 4941 struct SetModifiedSvc<T: PlaylistService>(pub Arc<T>); 5802 5802 - impl< 5803 5803 - T: PlaylistService, 5804 5804 - > tonic::server::UnaryService<super::SetModifiedRequest> 5805 5805 - for SetModifiedSvc<T> { 4942 4942 + impl<T: PlaylistService> tonic::server::UnaryService<super::SetModifiedRequest> 4943 4943 + for SetModifiedSvc<T> 4944 4944 + { 5806 4945 type Response = super::SetModifiedResponse; 5807 5807 - type Future = BoxFuture< 5808 5808 - tonic::Response<Self::Response>, 5809 5809 - tonic::Status, 5810 5810 - >; 4946 4946 + type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 5811 4947 fn call( 5812 4948 &mut self, 5813 4949 request: tonic::Request<super::SetModifiedRequest>, ··· 5844 4980 "/rockbox.v1alpha1.PlaylistService/Start" => { 5845 4981 #[allow(non_camel_case_types)] 5846 4982 struct StartSvc<T: PlaylistService>(pub Arc<T>); 5847 5847 - impl< 5848 5848 - T: PlaylistService, 5849 5849 - > tonic::server::UnaryService<super::StartRequest> for StartSvc<T> { 4983 4983 + impl<T: PlaylistService> tonic::server::UnaryService<super::StartRequest> for StartSvc<T> { 5850 4984 type Response = super::StartResponse; 5851 5851 - type Future = BoxFuture< 5852 5852 - tonic::Response<Self::Response>, 5853 5853 - tonic::Status, 5854 5854 - >; 4985 4985 + type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 5855 4986 fn call( 5856 4987 &mut self, 5857 4988 request: tonic::Request<super::StartRequest>, 5858 4989 ) -> Self::Future { 5859 4990 let inner = Arc::clone(&self.0); 5860 5860 - let fut = async move { 5861 5861 - <T as PlaylistService>::start(&inner, request).await 5862 5862 - }; 4991 4991 + let fut = 4992 4992 + async move { <T as PlaylistService>::start(&inner, request).await }; 5863 4993 Box::pin(fut) 5864 4994 } 5865 4995 } ··· 5888 5018 "/rockbox.v1alpha1.PlaylistService/Sync" => { 5889 5019 #[allow(non_camel_case_types)] 5890 5020 struct SyncSvc<T: PlaylistService>(pub Arc<T>); 5891 5891 - impl< 5892 5892 - T: PlaylistService, 5893 5893 - > tonic::server::UnaryService<super::SyncRequest> for SyncSvc<T> { 5021 5021 + impl<T: PlaylistService> tonic::server::UnaryService<super::SyncRequest> for SyncSvc<T> { 5894 5022 type Response = super::SyncResponse; 5895 5895 - type Future = BoxFuture< 5896 5896 - tonic::Response<Self::Response>, 5897 5897 - tonic::Status, 5898 5898 - >; 5023 5023 + type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 5899 5024 fn call( 5900 5025 &mut self, 5901 5026 request: tonic::Request<super::SyncRequest>, 5902 5027 ) -> Self::Future { 5903 5028 let inner = Arc::clone(&self.0); 5904 5904 - let fut = async move { 5905 5905 - <T as PlaylistService>::sync(&inner, request).await 5906 5906 - }; 5029 5029 + let fut = 5030 5030 + async move { <T as PlaylistService>::sync(&inner, request).await }; 5907 5031 Box::pin(fut) 5908 5032 } 5909 5033 } ··· 5932 5056 "/rockbox.v1alpha1.PlaylistService/RemoveAllTracks" => { 5933 5057 #[allow(non_camel_case_types)] 5934 5058 struct RemoveAllTracksSvc<T: PlaylistService>(pub Arc<T>); 5935 5935 - impl< 5936 5936 - T: PlaylistService, 5937 5937 - > tonic::server::UnaryService<super::RemoveAllTracksRequest> 5938 5938 - for RemoveAllTracksSvc<T> { 5059 5059 + impl<T: PlaylistService> 5060 5060 + tonic::server::UnaryService<super::RemoveAllTracksRequest> 5061 5061 + for RemoveAllTracksSvc<T> 5062 5062 + { 5939 5063 type Response = super::RemoveAllTracksResponse; 5940 5940 - type Future = BoxFuture< 5941 5941 - tonic::Response<Self::Response>, 5942 5942 - tonic::Status, 5943 5943 - >; 5064 5064 + type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 5944 5065 fn call( 5945 5066 &mut self, 5946 5067 request: tonic::Request<super::RemoveAllTracksRequest>, 5947 5068 ) -> Self::Future { 5948 5069 let inner = Arc::clone(&self.0); 5949 5070 let fut = async move { 5950 5950 - <T as PlaylistService>::remove_all_tracks(&inner, request) 5951 5951 - .await 5071 5071 + <T as PlaylistService>::remove_all_tracks(&inner, request).await 5952 5072 }; 5953 5073 Box::pin(fut) 5954 5074 } ··· 5978 5098 "/rockbox.v1alpha1.PlaylistService/RemoveTracks" => { 5979 5099 #[allow(non_camel_case_types)] 5980 5100 struct RemoveTracksSvc<T: PlaylistService>(pub Arc<T>); 5981 5981 - impl< 5982 5982 - T: PlaylistService, 5983 5983 - > tonic::server::UnaryService<super::RemoveTracksRequest> 5984 5984 - for RemoveTracksSvc<T> { 5101 5101 + impl<T: PlaylistService> tonic::server::UnaryService<super::RemoveTracksRequest> 5102 5102 + for RemoveTracksSvc<T> 5103 5103 + { 5985 5104 type Response = super::RemoveTracksResponse; 5986 5986 - type Future = BoxFuture< 5987 5987 - tonic::Response<Self::Response>, 5988 5988 - tonic::Status, 5989 5989 - >; 5105 5105 + type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 5990 5106 fn call( 5991 5107 &mut self, 5992 5108 request: tonic::Request<super::RemoveTracksRequest>, ··· 6023 5139 "/rockbox.v1alpha1.PlaylistService/CreatePlaylist" => { 6024 5140 #[allow(non_camel_case_types)] 6025 5141 struct CreatePlaylistSvc<T: PlaylistService>(pub Arc<T>); 6026 6026 - impl< 6027 6027 - T: PlaylistService, 6028 6028 - > tonic::server::UnaryService<super::CreatePlaylistRequest> 6029 6029 - for CreatePlaylistSvc<T> { 5142 5142 + impl<T: PlaylistService> 5143 5143 + tonic::server::UnaryService<super::CreatePlaylistRequest> 5144 5144 + for CreatePlaylistSvc<T> 5145 5145 + { 6030 5146 type Response = super::CreatePlaylistResponse; 6031 6031 - type Future = BoxFuture< 6032 6032 - tonic::Response<Self::Response>, 6033 6033 - tonic::Status, 6034 6034 - >; 5147 5147 + type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 6035 5148 fn call( 6036 5149 &mut self, 6037 5150 request: tonic::Request<super::CreatePlaylistRequest>, 6038 5151 ) -> Self::Future { 6039 5152 let inner = Arc::clone(&self.0); 6040 5153 let fut = async move { 6041 6041 - <T as PlaylistService>::create_playlist(&inner, request) 6042 6042 - .await 5154 5154 + <T as PlaylistService>::create_playlist(&inner, request).await 6043 5155 }; 6044 5156 Box::pin(fut) 6045 5157 } ··· 6069 5181 "/rockbox.v1alpha1.PlaylistService/InsertTracks" => { 6070 5182 #[allow(non_camel_case_types)] 6071 5183 struct InsertTracksSvc<T: PlaylistService>(pub Arc<T>); 6072 6072 - impl< 6073 6073 - T: PlaylistService, 6074 6074 - > tonic::server::UnaryService<super::InsertTracksRequest> 6075 6075 - for InsertTracksSvc<T> { 5184 5184 + impl<T: PlaylistService> tonic::server::UnaryService<super::InsertTracksRequest> 5185 5185 + for InsertTracksSvc<T> 5186 5186 + { 6076 5187 type Response = super::InsertTracksResponse; 6077 6077 - type Future = BoxFuture< 6078 6078 - tonic::Response<Self::Response>, 6079 6079 - tonic::Status, 6080 6080 - >; 5188 5188 + type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 6081 5189 fn call( 6082 5190 &mut self, 6083 5191 request: tonic::Request<super::InsertTracksRequest>, ··· 6114 5222 "/rockbox.v1alpha1.PlaylistService/InsertDirectory" => { 6115 5223 #[allow(non_camel_case_types)] 6116 5224 struct InsertDirectorySvc<T: PlaylistService>(pub Arc<T>); 6117 6117 - impl< 6118 6118 - T: PlaylistService, 6119 6119 - > tonic::server::UnaryService<super::InsertDirectoryRequest> 6120 6120 - for InsertDirectorySvc<T> { 5225 5225 + impl<T: PlaylistService> 5226 5226 + tonic::server::UnaryService<super::InsertDirectoryRequest> 5227 5227 + for InsertDirectorySvc<T> 5228 5228 + { 6121 5229 type Response = super::InsertDirectoryResponse; 6122 6122 - type Future = BoxFuture< 6123 6123 - tonic::Response<Self::Response>, 6124 6124 - tonic::Status, 6125 6125 - >; 5230 5230 + type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 6126 5231 fn call( 6127 5232 &mut self, 6128 5233 request: tonic::Request<super::InsertDirectoryRequest>, 6129 5234 ) -> Self::Future { 6130 5235 let inner = Arc::clone(&self.0); 6131 5236 let fut = async move { 6132 6132 - <T as PlaylistService>::insert_directory(&inner, request) 6133 6133 - .await 5237 5237 + <T as PlaylistService>::insert_directory(&inner, request).await 6134 5238 }; 6135 5239 Box::pin(fut) 6136 5240 } ··· 6160 5264 "/rockbox.v1alpha1.PlaylistService/InsertPlaylist" => { 6161 5265 #[allow(non_camel_case_types)] 6162 5266 struct InsertPlaylistSvc<T: PlaylistService>(pub Arc<T>); 6163 6163 - impl< 6164 6164 - T: PlaylistService, 6165 6165 - > tonic::server::UnaryService<super::InsertPlaylistRequest> 6166 6166 - for InsertPlaylistSvc<T> { 5267 5267 + impl<T: PlaylistService> 5268 5268 + tonic::server::UnaryService<super::InsertPlaylistRequest> 5269 5269 + for InsertPlaylistSvc<T> 5270 5270 + { 6167 5271 type Response = super::InsertPlaylistResponse; 6168 6168 - type Future = BoxFuture< 6169 6169 - tonic::Response<Self::Response>, 6170 6170 - tonic::Status, 6171 6171 - >; 5272 5272 + type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 6172 5273 fn call( 6173 5274 &mut self, 6174 5275 request: tonic::Request<super::InsertPlaylistRequest>, 6175 5276 ) -> Self::Future { 6176 5277 let inner = Arc::clone(&self.0); 6177 5278 let fut = async move { 6178 6178 - <T as PlaylistService>::insert_playlist(&inner, request) 6179 6179 - .await 5279 5279 + <T as PlaylistService>::insert_playlist(&inner, request).await 6180 5280 }; 6181 5281 Box::pin(fut) 6182 5282 } ··· 6206 5306 "/rockbox.v1alpha1.PlaylistService/InsertAlbum" => { 6207 5307 #[allow(non_camel_case_types)] 6208 5308 struct InsertAlbumSvc<T: PlaylistService>(pub Arc<T>); 6209 6209 - impl< 6210 6210 - T: PlaylistService, 6211 6211 - > tonic::server::UnaryService<super::InsertAlbumRequest> 6212 6212 - for InsertAlbumSvc<T> { 5309 5309 + impl<T: PlaylistService> tonic::server::UnaryService<super::InsertAlbumRequest> 5310 5310 + for InsertAlbumSvc<T> 5311 5311 + { 6213 5312 type Response = super::InsertAlbumResponse; 6214 6214 - type Future = BoxFuture< 6215 6215 - tonic::Response<Self::Response>, 6216 6216 - tonic::Status, 6217 6217 - >; 5313 5313 + type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 6218 5314 fn call( 6219 5315 &mut self, 6220 5316 request: tonic::Request<super::InsertAlbumRequest>, ··· 6251 5347 "/rockbox.v1alpha1.PlaylistService/InsertArtistTracks" => { 6252 5348 #[allow(non_camel_case_types)] 6253 5349 struct InsertArtistTracksSvc<T: PlaylistService>(pub Arc<T>); 6254 6254 - impl< 6255 6255 - T: PlaylistService, 6256 6256 - > tonic::server::UnaryService<super::InsertArtistTracksRequest> 6257 6257 - for InsertArtistTracksSvc<T> { 5350 5350 + impl<T: PlaylistService> 5351 5351 + tonic::server::UnaryService<super::InsertArtistTracksRequest> 5352 5352 + for InsertArtistTracksSvc<T> 5353 5353 + { 6258 5354 type Response = super::InsertArtistTracksResponse; 6259 6259 - type Future = BoxFuture< 6260 6260 - tonic::Response<Self::Response>, 6261 6261 - tonic::Status, 6262 6262 - >; 5355 5355 + type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 6263 5356 fn call( 6264 5357 &mut self, 6265 5358 request: tonic::Request<super::InsertArtistTracksRequest>, 6266 5359 ) -> Self::Future { 6267 5360 let inner = Arc::clone(&self.0); 6268 5361 let fut = async move { 6269 6269 - <T as PlaylistService>::insert_artist_tracks( 6270 6270 - &inner, 6271 6271 - request, 6272 6272 - ) 6273 6273 - .await 5362 5362 + <T as PlaylistService>::insert_artist_tracks(&inner, request).await 6274 5363 }; 6275 5364 Box::pin(fut) 6276 5365 } ··· 6300 5389 "/rockbox.v1alpha1.PlaylistService/ShufflePlaylist" => { 6301 5390 #[allow(non_camel_case_types)] 6302 5391 struct ShufflePlaylistSvc<T: PlaylistService>(pub Arc<T>); 6303 6303 - impl< 6304 6304 - T: PlaylistService, 6305 6305 - > tonic::server::UnaryService<super::ShufflePlaylistRequest> 6306 6306 - for ShufflePlaylistSvc<T> { 5392 5392 + impl<T: PlaylistService> 5393 5393 + tonic::server::UnaryService<super::ShufflePlaylistRequest> 5394 5394 + for ShufflePlaylistSvc<T> 5395 5395 + { 6307 5396 type Response = super::ShufflePlaylistResponse; 6308 6308 - type Future = BoxFuture< 6309 6309 - tonic::Response<Self::Response>, 6310 6310 - tonic::Status, 6311 6311 - >; 5397 5397 + type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 6312 5398 fn call( 6313 5399 &mut self, 6314 5400 request: tonic::Request<super::ShufflePlaylistRequest>, 6315 5401 ) -> Self::Future { 6316 5402 let inner = Arc::clone(&self.0); 6317 5403 let fut = async move { 6318 6318 - <T as PlaylistService>::shuffle_playlist(&inner, request) 6319 6319 - .await 5404 5404 + <T as PlaylistService>::shuffle_playlist(&inner, request).await 6320 5405 }; 6321 5406 Box::pin(fut) 6322 5407 } ··· 6343 5428 }; 6344 5429 Box::pin(fut) 6345 5430 } 6346 6346 - _ => { 6347 6347 - Box::pin(async move { 6348 6348 - let mut response = http::Response::new(empty_body()); 6349 6349 - let headers = response.headers_mut(); 6350 6350 - headers 6351 6351 - .insert( 6352 6352 - tonic::Status::GRPC_STATUS, 6353 6353 - (tonic::Code::Unimplemented as i32).into(), 6354 6354 - ); 6355 6355 - headers 6356 6356 - .insert( 6357 6357 - http::header::CONTENT_TYPE, 6358 6358 - tonic::metadata::GRPC_CONTENT_TYPE, 6359 6359 - ); 6360 6360 - Ok(response) 6361 6361 - }) 6362 6362 - } 5431 5431 + _ => Box::pin(async move { 5432 5432 + let mut response = http::Response::new(empty_body()); 5433 5433 + let headers = response.headers_mut(); 5434 5434 + headers.insert( 5435 5435 + tonic::Status::GRPC_STATUS, 5436 5436 + (tonic::Code::Unimplemented as i32).into(), 5437 5437 + ); 5438 5438 + headers.insert( 5439 5439 + http::header::CONTENT_TYPE, 5440 5440 + tonic::metadata::GRPC_CONTENT_TYPE, 5441 5441 + ); 5442 5442 + Ok(response) 5443 5443 + }), 6363 5444 } 6364 5445 } 6365 5446 } ··· 6869 5950 dead_code, 6870 5951 missing_docs, 6871 5952 clippy::wildcard_imports, 6872 6872 - clippy::let_unit_value, 5953 5953 + clippy::let_unit_value 6873 5954 )] 6874 6874 - use tonic::codegen::*; 6875 5955 use tonic::codegen::http::Uri; 5956 5956 + use tonic::codegen::*; 6876 5957 #[derive(Debug, Clone)] 6877 5958 pub struct SettingsServiceClient<T> { 6878 5959 inner: tonic::client::Grpc<T>, ··· 6916 5997 <T as tonic::client::GrpcService<tonic::body::BoxBody>>::ResponseBody, 6917 5998 >, 6918 5999 >, 6919 6919 - <T as tonic::codegen::Service< 6920 6920 - http::Request<tonic::body::BoxBody>, 6921 6921 - >>::Error: Into<StdError> + std::marker::Send + std::marker::Sync, 6000 6000 + <T as tonic::codegen::Service<http::Request<tonic::body::BoxBody>>>::Error: 6001 6001 + Into<StdError> + std::marker::Send + std::marker::Sync, 6922 6002 { 6923 6003 SettingsServiceClient::new(InterceptedService::new(inner, interceptor)) 6924 6004 } ··· 6956 6036 pub async fn get_settings_list( 6957 6037 &mut self, 6958 6038 request: impl tonic::IntoRequest<super::GetSettingsListRequest>, 6959 6959 - ) -> std::result::Result< 6960 6960 - tonic::Response<super::GetSettingsListResponse>, 6961 6961 - tonic::Status, 6962 6962 - > { 6963 6963 - self.inner 6964 6964 - .ready() 6965 6965 - .await 6966 6966 - .map_err(|e| { 6967 6967 - tonic::Status::unknown( 6968 6968 - format!("Service was not ready: {}", e.into()), 6969 6969 - ) 6970 6970 - })?; 6039 6039 + ) -> std::result::Result<tonic::Response<super::GetSettingsListResponse>, tonic::Status> 6040 6040 + { 6041 6041 + self.inner.ready().await.map_err(|e| { 6042 6042 + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 6043 6043 + })?; 6971 6044 let codec = tonic::codec::ProstCodec::default(); 6972 6045 let path = http::uri::PathAndQuery::from_static( 6973 6046 "/rockbox.v1alpha1.SettingsService/GetSettingsList", 6974 6047 ); 6975 6048 let mut req = request.into_request(); 6976 6976 - req.extensions_mut() 6977 6977 - .insert( 6978 6978 - GrpcMethod::new( 6979 6979 - "rockbox.v1alpha1.SettingsService", 6980 6980 - "GetSettingsList", 6981 6981 - ), 6982 6982 - ); 6049 6049 + req.extensions_mut().insert(GrpcMethod::new( 6050 6050 + "rockbox.v1alpha1.SettingsService", 6051 6051 + "GetSettingsList", 6052 6052 + )); 6983 6053 self.inner.unary(req, path, codec).await 6984 6054 } 6985 6055 pub async fn get_global_settings( 6986 6056 &mut self, 6987 6057 request: impl tonic::IntoRequest<super::GetGlobalSettingsRequest>, 6988 6988 - ) -> std::result::Result< 6989 6989 - tonic::Response<super::GetGlobalSettingsResponse>, 6990 6990 - tonic::Status, 6991 6991 - > { 6992 6992 - self.inner 6993 6993 - .ready() 6994 6994 - .await 6995 6995 - .map_err(|e| { 6996 6996 - tonic::Status::unknown( 6997 6997 - format!("Service was not ready: {}", e.into()), 6998 6998 - ) 6999 6999 - })?; 6058 6058 + ) -> std::result::Result<tonic::Response<super::GetGlobalSettingsResponse>, tonic::Status> 6059 6059 + { 6060 6060 + self.inner.ready().await.map_err(|e| { 6061 6061 + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 6062 6062 + })?; 7000 6063 let codec = tonic::codec::ProstCodec::default(); 7001 6064 let path = http::uri::PathAndQuery::from_static( 7002 6065 "/rockbox.v1alpha1.SettingsService/GetGlobalSettings", 7003 6066 ); 7004 6067 let mut req = request.into_request(); 7005 7005 - req.extensions_mut() 7006 7006 - .insert( 7007 7007 - GrpcMethod::new( 7008 7008 - "rockbox.v1alpha1.SettingsService", 7009 7009 - "GetGlobalSettings", 7010 7010 - ), 7011 7011 - ); 6068 6068 + req.extensions_mut().insert(GrpcMethod::new( 6069 6069 + "rockbox.v1alpha1.SettingsService", 6070 6070 + "GetGlobalSettings", 6071 6071 + )); 7012 6072 self.inner.unary(req, path, codec).await 7013 6073 } 7014 6074 pub async fn save_settings( 7015 6075 &mut self, 7016 6076 request: impl tonic::IntoRequest<super::SaveSettingsRequest>, 7017 7017 - ) -> std::result::Result< 7018 7018 - tonic::Response<super::SaveSettingsResponse>, 7019 7019 - tonic::Status, 7020 7020 - > { 7021 7021 - self.inner 7022 7022 - .ready() 7023 7023 - .await 7024 7024 - .map_err(|e| { 7025 7025 - tonic::Status::unknown( 7026 7026 - format!("Service was not ready: {}", e.into()), 7027 7027 - ) 7028 7028 - })?; 6077 6077 + ) -> std::result::Result<tonic::Response<super::SaveSettingsResponse>, tonic::Status> 6078 6078 + { 6079 6079 + self.inner.ready().await.map_err(|e| { 6080 6080 + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 6081 6081 + })?; 7029 6082 let codec = tonic::codec::ProstCodec::default(); 7030 6083 let path = http::uri::PathAndQuery::from_static( 7031 6084 "/rockbox.v1alpha1.SettingsService/SaveSettings", 7032 6085 ); 7033 6086 let mut req = request.into_request(); 7034 7034 - req.extensions_mut() 7035 7035 - .insert( 7036 7036 - GrpcMethod::new("rockbox.v1alpha1.SettingsService", "SaveSettings"), 7037 7037 - ); 6087 6087 + req.extensions_mut().insert(GrpcMethod::new( 6088 6088 + "rockbox.v1alpha1.SettingsService", 6089 6089 + "SaveSettings", 6090 6090 + )); 7038 6091 self.inner.unary(req, path, codec).await 7039 6092 } 7040 6093 } ··· 7046 6099 dead_code, 7047 6100 missing_docs, 7048 6101 clippy::wildcard_imports, 7049 7049 - clippy::let_unit_value, 6102 6102 + clippy::let_unit_value 7050 6103 )] 7051 6104 use tonic::codegen::*; 7052 6105 /// Generated trait containing gRPC methods that should be implemented for use with SettingsServiceServer. ··· 7055 6108 async fn get_settings_list( 7056 6109 &self, 7057 6110 request: tonic::Request<super::GetSettingsListRequest>, 7058 7058 - ) -> std::result::Result< 7059 7059 - tonic::Response<super::GetSettingsListResponse>, 7060 7060 - tonic::Status, 7061 7061 - >; 6111 6111 + ) -> std::result::Result<tonic::Response<super::GetSettingsListResponse>, tonic::Status>; 7062 6112 async fn get_global_settings( 7063 6113 &self, 7064 6114 request: tonic::Request<super::GetGlobalSettingsRequest>, 7065 7065 - ) -> std::result::Result< 7066 7066 - tonic::Response<super::GetGlobalSettingsResponse>, 7067 7067 - tonic::Status, 7068 7068 - >; 6115 6115 + ) -> std::result::Result<tonic::Response<super::GetGlobalSettingsResponse>, tonic::Status>; 7069 6116 async fn save_settings( 7070 6117 &self, 7071 6118 request: tonic::Request<super::SaveSettingsRequest>, 7072 7072 - ) -> std::result::Result< 7073 7073 - tonic::Response<super::SaveSettingsResponse>, 7074 7074 - tonic::Status, 7075 7075 - >; 6119 6119 + ) -> std::result::Result<tonic::Response<super::SaveSettingsResponse>, tonic::Status>; 7076 6120 } 7077 6121 #[derive(Debug)] 7078 6122 pub struct SettingsServiceServer<T> { ··· 7095 6139 max_encoding_message_size: None, 7096 6140 } 7097 6141 } 7098 7098 - pub fn with_interceptor<F>( 7099 7099 - inner: T, 7100 7100 - interceptor: F, 7101 7101 - ) -> InterceptedService<Self, F> 6142 6142 + pub fn with_interceptor<F>(inner: T, interceptor: F) -> InterceptedService<Self, F> 7102 6143 where 7103 6144 F: tonic::service::Interceptor, 7104 6145 { ··· 7153 6194 "/rockbox.v1alpha1.SettingsService/GetSettingsList" => { 7154 6195 #[allow(non_camel_case_types)] 7155 6196 struct GetSettingsListSvc<T: SettingsService>(pub Arc<T>); 7156 7156 - impl< 7157 7157 - T: SettingsService, 7158 7158 - > tonic::server::UnaryService<super::GetSettingsListRequest> 7159 7159 - for GetSettingsListSvc<T> { 6197 6197 + impl<T: SettingsService> 6198 6198 + tonic::server::UnaryService<super::GetSettingsListRequest> 6199 6199 + for GetSettingsListSvc<T> 6200 6200 + { 7160 6201 type Response = super::GetSettingsListResponse; 7161 7161 - type Future = BoxFuture< 7162 7162 - tonic::Response<Self::Response>, 7163 7163 - tonic::Status, 7164 7164 - >; 6202 6202 + type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 7165 6203 fn call( 7166 6204 &mut self, 7167 6205 request: tonic::Request<super::GetSettingsListRequest>, 7168 6206 ) -> Self::Future { 7169 6207 let inner = Arc::clone(&self.0); 7170 6208 let fut = async move { 7171 7171 - <T as SettingsService>::get_settings_list(&inner, request) 7172 7172 - .await 6209 6209 + <T as SettingsService>::get_settings_list(&inner, request).await 7173 6210 }; 7174 6211 Box::pin(fut) 7175 6212 } ··· 7199 6236 "/rockbox.v1alpha1.SettingsService/GetGlobalSettings" => { 7200 6237 #[allow(non_camel_case_types)] 7201 6238 struct GetGlobalSettingsSvc<T: SettingsService>(pub Arc<T>); 7202 7202 - impl< 7203 7203 - T: SettingsService, 7204 7204 - > tonic::server::UnaryService<super::GetGlobalSettingsRequest> 7205 7205 - for GetGlobalSettingsSvc<T> { 6239 6239 + impl<T: SettingsService> 6240 6240 + tonic::server::UnaryService<super::GetGlobalSettingsRequest> 6241 6241 + for GetGlobalSettingsSvc<T> 6242 6242 + { 7206 6243 type Response = super::GetGlobalSettingsResponse; 7207 7207 - type Future = BoxFuture< 7208 7208 - tonic::Response<Self::Response>, 7209 7209 - tonic::Status, 7210 7210 - >; 6244 6244 + type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 7211 6245 fn call( 7212 6246 &mut self, 7213 6247 request: tonic::Request<super::GetGlobalSettingsRequest>, 7214 6248 ) -> Self::Future { 7215 6249 let inner = Arc::clone(&self.0); 7216 6250 let fut = async move { 7217 7217 - <T as SettingsService>::get_global_settings(&inner, request) 7218 7218 - .await 6251 6251 + <T as SettingsService>::get_global_settings(&inner, request).await 7219 6252 }; 7220 6253 Box::pin(fut) 7221 6254 } ··· 7245 6278 "/rockbox.v1alpha1.SettingsService/SaveSettings" => { 7246 6279 #[allow(non_camel_case_types)] 7247 6280 struct SaveSettingsSvc<T: SettingsService>(pub Arc<T>); 7248 7248 - impl< 7249 7249 - T: SettingsService, 7250 7250 - > tonic::server::UnaryService<super::SaveSettingsRequest> 7251 7251 - for SaveSettingsSvc<T> { 6281 6281 + impl<T: SettingsService> tonic::server::UnaryService<super::SaveSettingsRequest> 6282 6282 + for SaveSettingsSvc<T> 6283 6283 + { 7252 6284 type Response = super::SaveSettingsResponse; 7253 7253 - type Future = BoxFuture< 7254 7254 - tonic::Response<Self::Response>, 7255 7255 - tonic::Status, 7256 7256 - >; 6285 6285 + type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 7257 6286 fn call( 7258 6287 &mut self, 7259 6288 request: tonic::Request<super::SaveSettingsRequest>, ··· 7287 6316 }; 7288 6317 Box::pin(fut) 7289 6318 } 7290 7290 - _ => { 7291 7291 - Box::pin(async move { 7292 7292 - let mut response = http::Response::new(empty_body()); 7293 7293 - let headers = response.headers_mut(); 7294 7294 - headers 7295 7295 - .insert( 7296 7296 - tonic::Status::GRPC_STATUS, 7297 7297 - (tonic::Code::Unimplemented as i32).into(), 7298 7298 - ); 7299 7299 - headers 7300 7300 - .insert( 7301 7301 - http::header::CONTENT_TYPE, 7302 7302 - tonic::metadata::GRPC_CONTENT_TYPE, 7303 7303 - ); 7304 7304 - Ok(response) 7305 7305 - }) 7306 7306 - } 6319 6319 + _ => Box::pin(async move { 6320 6320 + let mut response = http::Response::new(empty_body()); 6321 6321 + let headers = response.headers_mut(); 6322 6322 + headers.insert( 6323 6323 + tonic::Status::GRPC_STATUS, 6324 6324 + (tonic::Code::Unimplemented as i32).into(), 6325 6325 + ); 6326 6326 + headers.insert( 6327 6327 + http::header::CONTENT_TYPE, 6328 6328 + tonic::metadata::GRPC_CONTENT_TYPE, 6329 6329 + ); 6330 6330 + Ok(response) 6331 6331 + }), 7307 6332 } 7308 6333 } 7309 6334 } ··· 7461 6486 dead_code, 7462 6487 missing_docs, 7463 6488 clippy::wildcard_imports, 7464 7464 - clippy::let_unit_value, 6489 6489 + clippy::let_unit_value 7465 6490 )] 7466 7466 - use tonic::codegen::*; 7467 6491 use tonic::codegen::http::Uri; 6492 6492 + use tonic::codegen::*; 7468 6493 #[derive(Debug, Clone)] 7469 6494 pub struct SoundServiceClient<T> { 7470 6495 inner: tonic::client::Grpc<T>, ··· 7508 6533 <T as tonic::client::GrpcService<tonic::body::BoxBody>>::ResponseBody, 7509 6534 >, 7510 6535 >, 7511 7511 - <T as tonic::codegen::Service< 7512 7512 - http::Request<tonic::body::BoxBody>, 7513 7513 - >>::Error: Into<StdError> + std::marker::Send + std::marker::Sync, 6536 6536 + <T as tonic::codegen::Service<http::Request<tonic::body::BoxBody>>>::Error: 6537 6537 + Into<StdError> + std::marker::Send + std::marker::Sync, 7514 6538 { 7515 6539 SoundServiceClient::new(InterceptedService::new(inner, interceptor)) 7516 6540 } ··· 7548 6572 pub async fn adjust_volume( 7549 6573 &mut self, 7550 6574 request: impl tonic::IntoRequest<super::AdjustVolumeRequest>, 7551 7551 - ) -> std::result::Result< 7552 7552 - tonic::Response<super::AdjustVolumeResponse>, 7553 7553 - tonic::Status, 7554 7554 - > { 7555 7555 - self.inner 7556 7556 - .ready() 7557 7557 - .await 7558 7558 - .map_err(|e| { 7559 7559 - tonic::Status::unknown( 7560 7560 - format!("Service was not ready: {}", e.into()), 7561 7561 - ) 7562 7562 - })?; 6575 6575 + ) -> std::result::Result<tonic::Response<super::AdjustVolumeResponse>, tonic::Status> 6576 6576 + { 6577 6577 + self.inner.ready().await.map_err(|e| { 6578 6578 + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 6579 6579 + })?; 7563 6580 let codec = tonic::codec::ProstCodec::default(); 7564 7564 - let path = http::uri::PathAndQuery::from_static( 7565 7565 - "/rockbox.v1alpha1.SoundService/AdjustVolume", 7566 7566 - ); 6581 6581 + let path = 6582 6582 + http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.SoundService/AdjustVolume"); 7567 6583 let mut req = request.into_request(); 7568 7568 - req.extensions_mut() 7569 7569 - .insert( 7570 7570 - GrpcMethod::new("rockbox.v1alpha1.SoundService", "AdjustVolume"), 7571 7571 - ); 6584 6584 + req.extensions_mut().insert(GrpcMethod::new( 6585 6585 + "rockbox.v1alpha1.SoundService", 6586 6586 + "AdjustVolume", 6587 6587 + )); 7572 6588 self.inner.unary(req, path, codec).await 7573 6589 } 7574 6590 pub async fn sound_set( 7575 6591 &mut self, 7576 6592 request: impl tonic::IntoRequest<super::SoundSetRequest>, 7577 7577 - ) -> std::result::Result< 7578 7578 - tonic::Response<super::SoundSetResponse>, 7579 7579 - tonic::Status, 7580 7580 - > { 7581 7581 - self.inner 7582 7582 - .ready() 7583 7583 - .await 7584 7584 - .map_err(|e| { 7585 7585 - tonic::Status::unknown( 7586 7586 - format!("Service was not ready: {}", e.into()), 7587 7587 - ) 7588 7588 - })?; 6593 6593 + ) -> std::result::Result<tonic::Response<super::SoundSetResponse>, tonic::Status> { 6594 6594 + self.inner.ready().await.map_err(|e| { 6595 6595 + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 6596 6596 + })?; 7589 6597 let codec = tonic::codec::ProstCodec::default(); 7590 7590 - let path = http::uri::PathAndQuery::from_static( 7591 7591 - "/rockbox.v1alpha1.SoundService/SoundSet", 7592 7592 - ); 6598 6598 + let path = 6599 6599 + http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.SoundService/SoundSet"); 7593 6600 let mut req = request.into_request(); 7594 6601 req.extensions_mut() 7595 6602 .insert(GrpcMethod::new("rockbox.v1alpha1.SoundService", "SoundSet")); ··· 7598 6605 pub async fn sound_current( 7599 6606 &mut self, 7600 6607 request: impl tonic::IntoRequest<super::SoundCurrentRequest>, 7601 7601 - ) -> std::result::Result< 7602 7602 - tonic::Response<super::SoundCurrentResponse>, 7603 7603 - tonic::Status, 7604 7604 - > { 7605 7605 - self.inner 7606 7606 - .ready() 7607 7607 - .await 7608 7608 - .map_err(|e| { 7609 7609 - tonic::Status::unknown( 7610 7610 - format!("Service was not ready: {}", e.into()), 7611 7611 - ) 7612 7612 - })?; 6608 6608 + ) -> std::result::Result<tonic::Response<super::SoundCurrentResponse>, tonic::Status> 6609 6609 + { 6610 6610 + self.inner.ready().await.map_err(|e| { 6611 6611 + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 6612 6612 + })?; 7613 6613 let codec = tonic::codec::ProstCodec::default(); 7614 7614 - let path = http::uri::PathAndQuery::from_static( 7615 7615 - "/rockbox.v1alpha1.SoundService/SoundCurrent", 7616 7616 - ); 6614 6614 + let path = 6615 6615 + http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.SoundService/SoundCurrent"); 7617 6616 let mut req = request.into_request(); 7618 7618 - req.extensions_mut() 7619 7619 - .insert( 7620 7620 - GrpcMethod::new("rockbox.v1alpha1.SoundService", "SoundCurrent"), 7621 7621 - ); 6617 6617 + req.extensions_mut().insert(GrpcMethod::new( 6618 6618 + "rockbox.v1alpha1.SoundService", 6619 6619 + "SoundCurrent", 6620 6620 + )); 7622 6621 self.inner.unary(req, path, codec).await 7623 6622 } 7624 6623 pub async fn sound_default( 7625 6624 &mut self, 7626 6625 request: impl tonic::IntoRequest<super::SoundDefaultRequest>, 7627 7627 - ) -> std::result::Result< 7628 7628 - tonic::Response<super::SoundDefaultResponse>, 7629 7629 - tonic::Status, 7630 7630 - > { 7631 7631 - self.inner 7632 7632 - .ready() 7633 7633 - .await 7634 7634 - .map_err(|e| { 7635 7635 - tonic::Status::unknown( 7636 7636 - format!("Service was not ready: {}", e.into()), 7637 7637 - ) 7638 7638 - })?; 6626 6626 + ) -> std::result::Result<tonic::Response<super::SoundDefaultResponse>, tonic::Status> 6627 6627 + { 6628 6628 + self.inner.ready().await.map_err(|e| { 6629 6629 + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 6630 6630 + })?; 7639 6631 let codec = tonic::codec::ProstCodec::default(); 7640 7640 - let path = http::uri::PathAndQuery::from_static( 7641 7641 - "/rockbox.v1alpha1.SoundService/SoundDefault", 7642 7642 - ); 6632 6632 + let path = 6633 6633 + http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.SoundService/SoundDefault"); 7643 6634 let mut req = request.into_request(); 7644 7644 - req.extensions_mut() 7645 7645 - .insert( 7646 7646 - GrpcMethod::new("rockbox.v1alpha1.SoundService", "SoundDefault"), 7647 7647 - ); 6635 6635 + req.extensions_mut().insert(GrpcMethod::new( 6636 6636 + "rockbox.v1alpha1.SoundService", 6637 6637 + "SoundDefault", 6638 6638 + )); 7648 6639 self.inner.unary(req, path, codec).await 7649 6640 } 7650 6641 pub async fn sound_min( 7651 6642 &mut self, 7652 6643 request: impl tonic::IntoRequest<super::SoundMinRequest>, 7653 7653 - ) -> std::result::Result< 7654 7654 - tonic::Response<super::SoundMinResponse>, 7655 7655 - tonic::Status, 7656 7656 - > { 7657 7657 - self.inner 7658 7658 - .ready() 7659 7659 - .await 7660 7660 - .map_err(|e| { 7661 7661 - tonic::Status::unknown( 7662 7662 - format!("Service was not ready: {}", e.into()), 7663 7663 - ) 7664 7664 - })?; 6644 6644 + ) -> std::result::Result<tonic::Response<super::SoundMinResponse>, tonic::Status> { 6645 6645 + self.inner.ready().await.map_err(|e| { 6646 6646 + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 6647 6647 + })?; 7665 6648 let codec = tonic::codec::ProstCodec::default(); 7666 7666 - let path = http::uri::PathAndQuery::from_static( 7667 7667 - "/rockbox.v1alpha1.SoundService/SoundMin", 7668 7668 - ); 6649 6649 + let path = 6650 6650 + http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.SoundService/SoundMin"); 7669 6651 let mut req = request.into_request(); 7670 6652 req.extensions_mut() 7671 6653 .insert(GrpcMethod::new("rockbox.v1alpha1.SoundService", "SoundMin")); ··· 7674 6656 pub async fn sound_max( 7675 6657 &mut self, 7676 6658 request: impl tonic::IntoRequest<super::SoundMaxRequest>, 7677 7677 - ) -> std::result::Result< 7678 7678 - tonic::Response<super::SoundMaxResponse>, 7679 7679 - tonic::Status, 7680 7680 - > { 7681 7681 - self.inner 7682 7682 - .ready() 7683 7683 - .await 7684 7684 - .map_err(|e| { 7685 7685 - tonic::Status::unknown( 7686 7686 - format!("Service was not ready: {}", e.into()), 7687 7687 - ) 7688 7688 - })?; 6659 6659 + ) -> std::result::Result<tonic::Response<super::SoundMaxResponse>, tonic::Status> { 6660 6660 + self.inner.ready().await.map_err(|e| { 6661 6661 + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 6662 6662 + })?; 7689 6663 let codec = tonic::codec::ProstCodec::default(); 7690 7690 - let path = http::uri::PathAndQuery::from_static( 7691 7691 - "/rockbox.v1alpha1.SoundService/SoundMax", 7692 7692 - ); 6664 6664 + let path = 6665 6665 + http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.SoundService/SoundMax"); 7693 6666 let mut req = request.into_request(); 7694 6667 req.extensions_mut() 7695 6668 .insert(GrpcMethod::new("rockbox.v1alpha1.SoundService", "SoundMax")); ··· 7698 6671 pub async fn sound_unit( 7699 6672 &mut self, 7700 6673 request: impl tonic::IntoRequest<super::SoundUnitRequest>, 7701 7701 - ) -> std::result::Result< 7702 7702 - tonic::Response<super::SoundUnitResponse>, 7703 7703 - tonic::Status, 7704 7704 - > { 7705 7705 - self.inner 7706 7706 - .ready() 7707 7707 - .await 7708 7708 - .map_err(|e| { 7709 7709 - tonic::Status::unknown( 7710 7710 - format!("Service was not ready: {}", e.into()), 7711 7711 - ) 7712 7712 - })?; 6674 6674 + ) -> std::result::Result<tonic::Response<super::SoundUnitResponse>, tonic::Status> { 6675 6675 + self.inner.ready().await.map_err(|e| { 6676 6676 + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 6677 6677 + })?; 7713 6678 let codec = tonic::codec::ProstCodec::default(); 7714 7714 - let path = http::uri::PathAndQuery::from_static( 7715 7715 - "/rockbox.v1alpha1.SoundService/SoundUnit", 7716 7716 - ); 6679 6679 + let path = 6680 6680 + http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.SoundService/SoundUnit"); 7717 6681 let mut req = request.into_request(); 7718 7718 - req.extensions_mut() 7719 7719 - .insert(GrpcMethod::new("rockbox.v1alpha1.SoundService", "SoundUnit")); 6682 6682 + req.extensions_mut().insert(GrpcMethod::new( 6683 6683 + "rockbox.v1alpha1.SoundService", 6684 6684 + "SoundUnit", 6685 6685 + )); 7720 6686 self.inner.unary(req, path, codec).await 7721 6687 } 7722 6688 pub async fn sound_val2_phys( 7723 6689 &mut self, 7724 6690 request: impl tonic::IntoRequest<super::SoundVal2PhysRequest>, 7725 7725 - ) -> std::result::Result< 7726 7726 - tonic::Response<super::SoundVal2PhysResponse>, 7727 7727 - tonic::Status, 7728 7728 - > { 7729 7729 - self.inner 7730 7730 - .ready() 7731 7731 - .await 7732 7732 - .map_err(|e| { 7733 7733 - tonic::Status::unknown( 7734 7734 - format!("Service was not ready: {}", e.into()), 7735 7735 - ) 7736 7736 - })?; 6691 6691 + ) -> std::result::Result<tonic::Response<super::SoundVal2PhysResponse>, tonic::Status> 6692 6692 + { 6693 6693 + self.inner.ready().await.map_err(|e| { 6694 6694 + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 6695 6695 + })?; 7737 6696 let codec = tonic::codec::ProstCodec::default(); 7738 6697 let path = http::uri::PathAndQuery::from_static( 7739 6698 "/rockbox.v1alpha1.SoundService/SoundVal2Phys", 7740 6699 ); 7741 6700 let mut req = request.into_request(); 7742 7742 - req.extensions_mut() 7743 7743 - .insert( 7744 7744 - GrpcMethod::new("rockbox.v1alpha1.SoundService", "SoundVal2Phys"), 7745 7745 - ); 6701 6701 + req.extensions_mut().insert(GrpcMethod::new( 6702 6702 + "rockbox.v1alpha1.SoundService", 6703 6703 + "SoundVal2Phys", 6704 6704 + )); 7746 6705 self.inner.unary(req, path, codec).await 7747 6706 } 7748 6707 pub async fn get_pitch( 7749 6708 &mut self, 7750 6709 request: impl tonic::IntoRequest<super::GetPitchRequest>, 7751 7751 - ) -> std::result::Result< 7752 7752 - tonic::Response<super::GetPitchResponse>, 7753 7753 - tonic::Status, 7754 7754 - > { 7755 7755 - self.inner 7756 7756 - .ready() 7757 7757 - .await 7758 7758 - .map_err(|e| { 7759 7759 - tonic::Status::unknown( 7760 7760 - format!("Service was not ready: {}", e.into()), 7761 7761 - ) 7762 7762 - })?; 6710 6710 + ) -> std::result::Result<tonic::Response<super::GetPitchResponse>, tonic::Status> { 6711 6711 + self.inner.ready().await.map_err(|e| { 6712 6712 + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 6713 6713 + })?; 7763 6714 let codec = tonic::codec::ProstCodec::default(); 7764 7764 - let path = http::uri::PathAndQuery::from_static( 7765 7765 - "/rockbox.v1alpha1.SoundService/GetPitch", 7766 7766 - ); 6715 6715 + let path = 6716 6716 + http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.SoundService/GetPitch"); 7767 6717 let mut req = request.into_request(); 7768 6718 req.extensions_mut() 7769 6719 .insert(GrpcMethod::new("rockbox.v1alpha1.SoundService", "GetPitch")); ··· 7772 6722 pub async fn set_pitch( 7773 6723 &mut self, 7774 6724 request: impl tonic::IntoRequest<super::SetPitchRequest>, 7775 7775 - ) -> std::result::Result< 7776 7776 - tonic::Response<super::SetPitchResponse>, 7777 7777 - tonic::Status, 7778 7778 - > { 7779 7779 - self.inner 7780 7780 - .ready() 7781 7781 - .await 7782 7782 - .map_err(|e| { 7783 7783 - tonic::Status::unknown( 7784 7784 - format!("Service was not ready: {}", e.into()), 7785 7785 - ) 7786 7786 - })?; 6725 6725 + ) -> std::result::Result<tonic::Response<super::SetPitchResponse>, tonic::Status> { 6726 6726 + self.inner.ready().await.map_err(|e| { 6727 6727 + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 6728 6728 + })?; 7787 6729 let codec = tonic::codec::ProstCodec::default(); 7788 7788 - let path = http::uri::PathAndQuery::from_static( 7789 7789 - "/rockbox.v1alpha1.SoundService/SetPitch", 7790 7790 - ); 6730 6730 + let path = 6731 6731 + http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.SoundService/SetPitch"); 7791 6732 let mut req = request.into_request(); 7792 6733 req.extensions_mut() 7793 6734 .insert(GrpcMethod::new("rockbox.v1alpha1.SoundService", "SetPitch")); ··· 7796 6737 pub async fn beep_play( 7797 6738 &mut self, 7798 6739 request: impl tonic::IntoRequest<super::BeepPlayRequest>, 7799 7799 - ) -> std::result::Result< 7800 7800 - tonic::Response<super::BeepPlayResponse>, 7801 7801 - tonic::Status, 7802 7802 - > { 7803 7803 - self.inner 7804 7804 - .ready() 7805 7805 - .await 7806 7806 - .map_err(|e| { 7807 7807 - tonic::Status::unknown( 7808 7808 - format!("Service was not ready: {}", e.into()), 7809 7809 - ) 7810 7810 - })?; 6740 6740 + ) -> std::result::Result<tonic::Response<super::BeepPlayResponse>, tonic::Status> { 6741 6741 + self.inner.ready().await.map_err(|e| { 6742 6742 + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 6743 6743 + })?; 7811 6744 let codec = tonic::codec::ProstCodec::default(); 7812 7812 - let path = http::uri::PathAndQuery::from_static( 7813 7813 - "/rockbox.v1alpha1.SoundService/BeepPlay", 7814 7814 - ); 6745 6745 + let path = 6746 6746 + http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.SoundService/BeepPlay"); 7815 6747 let mut req = request.into_request(); 7816 6748 req.extensions_mut() 7817 6749 .insert(GrpcMethod::new("rockbox.v1alpha1.SoundService", "BeepPlay")); ··· 7820 6752 pub async fn pcmbuf_fade( 7821 6753 &mut self, 7822 6754 request: impl tonic::IntoRequest<super::PcmbufFadeRequest>, 7823 7823 - ) -> std::result::Result< 7824 7824 - tonic::Response<super::PcmbufFadeResponse>, 7825 7825 - tonic::Status, 7826 7826 - > { 7827 7827 - self.inner 7828 7828 - .ready() 7829 7829 - .await 7830 7830 - .map_err(|e| { 7831 7831 - tonic::Status::unknown( 7832 7832 - format!("Service was not ready: {}", e.into()), 7833 7833 - ) 7834 7834 - })?; 6755 6755 + ) -> std::result::Result<tonic::Response<super::PcmbufFadeResponse>, tonic::Status> 6756 6756 + { 6757 6757 + self.inner.ready().await.map_err(|e| { 6758 6758 + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 6759 6759 + })?; 7835 6760 let codec = tonic::codec::ProstCodec::default(); 7836 7836 - let path = http::uri::PathAndQuery::from_static( 7837 7837 - "/rockbox.v1alpha1.SoundService/PcmbufFade", 7838 7838 - ); 6761 6761 + let path = 6762 6762 + http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.SoundService/PcmbufFade"); 7839 6763 let mut req = request.into_request(); 7840 7840 - req.extensions_mut() 7841 7841 - .insert(GrpcMethod::new("rockbox.v1alpha1.SoundService", "PcmbufFade")); 6764 6764 + req.extensions_mut().insert(GrpcMethod::new( 6765 6765 + "rockbox.v1alpha1.SoundService", 6766 6766 + "PcmbufFade", 6767 6767 + )); 7842 6768 self.inner.unary(req, path, codec).await 7843 6769 } 7844 6770 pub async fn pcmbuf_set_low_latency( 7845 6771 &mut self, 7846 6772 request: impl tonic::IntoRequest<super::PcmbufSetLowLatencyRequest>, 7847 7847 - ) -> std::result::Result< 7848 7848 - tonic::Response<super::PcmbufSetLowLatencyResponse>, 7849 7849 - tonic::Status, 7850 7850 - > { 7851 7851 - self.inner 7852 7852 - .ready() 7853 7853 - .await 7854 7854 - .map_err(|e| { 7855 7855 - tonic::Status::unknown( 7856 7856 - format!("Service was not ready: {}", e.into()), 7857 7857 - ) 7858 7858 - })?; 6773 6773 + ) -> std::result::Result<tonic::Response<super::PcmbufSetLowLatencyResponse>, tonic::Status> 6774 6774 + { 6775 6775 + self.inner.ready().await.map_err(|e| { 6776 6776 + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 6777 6777 + })?; 7859 6778 let codec = tonic::codec::ProstCodec::default(); 7860 6779 let path = http::uri::PathAndQuery::from_static( 7861 6780 "/rockbox.v1alpha1.SoundService/PcmbufSetLowLatency", 7862 6781 ); 7863 6782 let mut req = request.into_request(); 7864 7864 - req.extensions_mut() 7865 7865 - .insert( 7866 7866 - GrpcMethod::new( 7867 7867 - "rockbox.v1alpha1.SoundService", 7868 7868 - "PcmbufSetLowLatency", 7869 7869 - ), 7870 7870 - ); 6783 6783 + req.extensions_mut().insert(GrpcMethod::new( 6784 6784 + "rockbox.v1alpha1.SoundService", 6785 6785 + "PcmbufSetLowLatency", 6786 6786 + )); 7871 6787 self.inner.unary(req, path, codec).await 7872 6788 } 7873 6789 pub async fn system_sound_play( 7874 6790 &mut self, 7875 6791 request: impl tonic::IntoRequest<super::SystemSoundPlayRequest>, 7876 7876 - ) -> std::result::Result< 7877 7877 - tonic::Response<super::SystemSoundPlayResponse>, 7878 7878 - tonic::Status, 7879 7879 - > { 7880 7880 - self.inner 7881 7881 - .ready() 7882 7882 - .await 7883 7883 - .map_err(|e| { 7884 7884 - tonic::Status::unknown( 7885 7885 - format!("Service was not ready: {}", e.into()), 7886 7886 - ) 7887 7887 - })?; 6792 6792 + ) -> std::result::Result<tonic::Response<super::SystemSoundPlayResponse>, tonic::Status> 6793 6793 + { 6794 6794 + self.inner.ready().await.map_err(|e| { 6795 6795 + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 6796 6796 + })?; 7888 6797 let codec = tonic::codec::ProstCodec::default(); 7889 6798 let path = http::uri::PathAndQuery::from_static( 7890 6799 "/rockbox.v1alpha1.SoundService/SystemSoundPlay", 7891 6800 ); 7892 6801 let mut req = request.into_request(); 7893 7893 - req.extensions_mut() 7894 7894 - .insert( 7895 7895 - GrpcMethod::new("rockbox.v1alpha1.SoundService", "SystemSoundPlay"), 7896 7896 - ); 6802 6802 + req.extensions_mut().insert(GrpcMethod::new( 6803 6803 + "rockbox.v1alpha1.SoundService", 6804 6804 + "SystemSoundPlay", 6805 6805 + )); 7897 6806 self.inner.unary(req, path, codec).await 7898 6807 } 7899 6808 pub async fn keyclick_click( 7900 6809 &mut self, 7901 6810 request: impl tonic::IntoRequest<super::KeyclickClickRequest>, 7902 7902 - ) -> std::result::Result< 7903 7903 - tonic::Response<super::KeyclickClickResponse>, 7904 7904 - tonic::Status, 7905 7905 - > { 7906 7906 - self.inner 7907 7907 - .ready() 7908 7908 - .await 7909 7909 - .map_err(|e| { 7910 7910 - tonic::Status::unknown( 7911 7911 - format!("Service was not ready: {}", e.into()), 7912 7912 - ) 7913 7913 - })?; 6811 6811 + ) -> std::result::Result<tonic::Response<super::KeyclickClickResponse>, tonic::Status> 6812 6812 + { 6813 6813 + self.inner.ready().await.map_err(|e| { 6814 6814 + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 6815 6815 + })?; 7914 6816 let codec = tonic::codec::ProstCodec::default(); 7915 6817 let path = http::uri::PathAndQuery::from_static( 7916 6818 "/rockbox.v1alpha1.SoundService/KeyclickClick", 7917 6819 ); 7918 6820 let mut req = request.into_request(); 7919 7919 - req.extensions_mut() 7920 7920 - .insert( 7921 7921 - GrpcMethod::new("rockbox.v1alpha1.SoundService", "KeyclickClick"), 7922 7922 - ); 6821 6821 + req.extensions_mut().insert(GrpcMethod::new( 6822 6822 + "rockbox.v1alpha1.SoundService", 6823 6823 + "KeyclickClick", 6824 6824 + )); 7923 6825 self.inner.unary(req, path, codec).await 7924 6826 } 7925 6827 } ··· 7931 6833 dead_code, 7932 6834 missing_docs, 7933 6835 clippy::wildcard_imports, 7934 7934 - clippy::let_unit_value, 6836 6836 + clippy::let_unit_value 7935 6837 )] 7936 6838 use tonic::codegen::*; 7937 6839 /// Generated trait containing gRPC methods that should be implemented for use with SoundServiceServer. ··· 7940 6842 async fn adjust_volume( 7941 6843 &self, 7942 6844 request: tonic::Request<super::AdjustVolumeRequest>, 7943 7943 - ) -> std::result::Result< 7944 7944 - tonic::Response<super::AdjustVolumeResponse>, 7945 7945 - tonic::Status, 7946 7946 - >; 6845 6845 + ) -> std::result::Result<tonic::Response<super::AdjustVolumeResponse>, tonic::Status>; 7947 6846 async fn sound_set( 7948 6847 &self, 7949 6848 request: tonic::Request<super::SoundSetRequest>, 7950 7950 - ) -> std::result::Result< 7951 7951 - tonic::Response<super::SoundSetResponse>, 7952 7952 - tonic::Status, 7953 7953 - >; 6849 6849 + ) -> std::result::Result<tonic::Response<super::SoundSetResponse>, tonic::Status>; 7954 6850 async fn sound_current( 7955 6851 &self, 7956 6852 request: tonic::Request<super::SoundCurrentRequest>, 7957 7957 - ) -> std::result::Result< 7958 7958 - tonic::Response<super::SoundCurrentResponse>, 7959 7959 - tonic::Status, 7960 7960 - >; 6853 6853 + ) -> std::result::Result<tonic::Response<super::SoundCurrentResponse>, tonic::Status>; 7961 6854 async fn sound_default( 7962 6855 &self, 7963 6856 request: tonic::Request<super::SoundDefaultRequest>, 7964 7964 - ) -> std::result::Result< 7965 7965 - tonic::Response<super::SoundDefaultResponse>, 7966 7966 - tonic::Status, 7967 7967 - >; 6857 6857 + ) -> std::result::Result<tonic::Response<super::SoundDefaultResponse>, tonic::Status>; 7968 6858 async fn sound_min( 7969 6859 &self, 7970 6860 request: tonic::Request<super::SoundMinRequest>, 7971 7971 - ) -> std::result::Result< 7972 7972 - tonic::Response<super::SoundMinResponse>, 7973 7973 - tonic::Status, 7974 7974 - >; 6861 6861 + ) -> std::result::Result<tonic::Response<super::SoundMinResponse>, tonic::Status>; 7975 6862 async fn sound_max( 7976 6863 &self, 7977 6864 request: tonic::Request<super::SoundMaxRequest>, 7978 7978 - ) -> std::result::Result< 7979 7979 - tonic::Response<super::SoundMaxResponse>, 7980 7980 - tonic::Status, 7981 7981 - >; 6865 6865 + ) -> std::result::Result<tonic::Response<super::SoundMaxResponse>, tonic::Status>; 7982 6866 async fn sound_unit( 7983 6867 &self, 7984 6868 request: tonic::Request<super::SoundUnitRequest>, 7985 7985 - ) -> std::result::Result< 7986 7986 - tonic::Response<super::SoundUnitResponse>, 7987 7987 - tonic::Status, 7988 7988 - >; 6869 6869 + ) -> std::result::Result<tonic::Response<super::SoundUnitResponse>, tonic::Status>; 7989 6870 async fn sound_val2_phys( 7990 6871 &self, 7991 6872 request: tonic::Request<super::SoundVal2PhysRequest>, 7992 7992 - ) -> std::result::Result< 7993 7993 - tonic::Response<super::SoundVal2PhysResponse>, 7994 7994 - tonic::Status, 7995 7995 - >; 6873 6873 + ) -> std::result::Result<tonic::Response<super::SoundVal2PhysResponse>, tonic::Status>; 7996 6874 async fn get_pitch( 7997 6875 &self, 7998 6876 request: tonic::Request<super::GetPitchRequest>, 7999 7999 - ) -> std::result::Result< 8000 8000 - tonic::Response<super::GetPitchResponse>, 8001 8001 - tonic::Status, 8002 8002 - >; 6877 6877 + ) -> std::result::Result<tonic::Response<super::GetPitchResponse>, tonic::Status>; 8003 6878 async fn set_pitch( 8004 6879 &self, 8005 6880 request: tonic::Request<super::SetPitchRequest>, 8006 8006 - ) -> std::result::Result< 8007 8007 - tonic::Response<super::SetPitchResponse>, 8008 8008 - tonic::Status, 8009 8009 - >; 6881 6881 + ) -> std::result::Result<tonic::Response<super::SetPitchResponse>, tonic::Status>; 8010 6882 async fn beep_play( 8011 6883 &self, 8012 6884 request: tonic::Request<super::BeepPlayRequest>, 8013 8013 - ) -> std::result::Result< 8014 8014 - tonic::Response<super::BeepPlayResponse>, 8015 8015 - tonic::Status, 8016 8016 - >; 6885 6885 + ) -> std::result::Result<tonic::Response<super::BeepPlayResponse>, tonic::Status>; 8017 6886 async fn pcmbuf_fade( 8018 6887 &self, 8019 6888 request: tonic::Request<super::PcmbufFadeRequest>, 8020 8020 - ) -> std::result::Result< 8021 8021 - tonic::Response<super::PcmbufFadeResponse>, 8022 8022 - tonic::Status, 8023 8023 - >; 6889 6889 + ) -> std::result::Result<tonic::Response<super::PcmbufFadeResponse>, tonic::Status>; 8024 6890 async fn pcmbuf_set_low_latency( 8025 6891 &self, 8026 6892 request: tonic::Request<super::PcmbufSetLowLatencyRequest>, 8027 8027 - ) -> std::result::Result< 8028 8028 - tonic::Response<super::PcmbufSetLowLatencyResponse>, 8029 8029 - tonic::Status, 8030 8030 - >; 6893 6893 + ) -> std::result::Result<tonic::Response<super::PcmbufSetLowLatencyResponse>, tonic::Status>; 8031 6894 async fn system_sound_play( 8032 6895 &self, 8033 6896 request: tonic::Request<super::SystemSoundPlayRequest>, 8034 8034 - ) -> std::result::Result< 8035 8035 - tonic::Response<super::SystemSoundPlayResponse>, 8036 8036 - tonic::Status, 8037 8037 - >; 6897 6897 + ) -> std::result::Result<tonic::Response<super::SystemSoundPlayResponse>, tonic::Status>; 8038 6898 async fn keyclick_click( 8039 6899 &self, 8040 6900 request: tonic::Request<super::KeyclickClickRequest>, 8041 8041 - ) -> std::result::Result< 8042 8042 - tonic::Response<super::KeyclickClickResponse>, 8043 8043 - tonic::Status, 8044 8044 - >; 6901 6901 + ) -> std::result::Result<tonic::Response<super::KeyclickClickResponse>, tonic::Status>; 8045 6902 } 8046 6903 #[derive(Debug)] 8047 6904 pub struct SoundServiceServer<T> { ··· 8064 6921 max_encoding_message_size: None, 8065 6922 } 8066 6923 } 8067 8067 - pub fn with_interceptor<F>( 8068 8068 - inner: T, 8069 8069 - interceptor: F, 8070 8070 - ) -> InterceptedService<Self, F> 6924 6924 + pub fn with_interceptor<F>(inner: T, interceptor: F) -> InterceptedService<Self, F> 8071 6925 where 8072 6926 F: tonic::service::Interceptor, 8073 6927 { ··· 8122 6976 "/rockbox.v1alpha1.SoundService/AdjustVolume" => { 8123 6977 #[allow(non_camel_case_types)] 8124 6978 struct AdjustVolumeSvc<T: SoundService>(pub Arc<T>); 8125 8125 - impl< 8126 8126 - T: SoundService, 8127 8127 - > tonic::server::UnaryService<super::AdjustVolumeRequest> 8128 8128 - for AdjustVolumeSvc<T> { 6979 6979 + impl<T: SoundService> tonic::server::UnaryService<super::AdjustVolumeRequest> 6980 6980 + for AdjustVolumeSvc<T> 6981 6981 + { 8129 6982 type Response = super::AdjustVolumeResponse; 8130 8130 - type Future = BoxFuture< 8131 8131 - tonic::Response<Self::Response>, 8132 8132 - tonic::Status, 8133 8133 - >; 6983 6983 + type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 8134 6984 fn call( 8135 6985 &mut self, 8136 6986 request: tonic::Request<super::AdjustVolumeRequest>, ··· 8167 7017 "/rockbox.v1alpha1.SoundService/SoundSet" => { 8168 7018 #[allow(non_camel_case_types)] 8169 7019 struct SoundSetSvc<T: SoundService>(pub Arc<T>); 8170 8170 - impl< 8171 8171 - T: SoundService, 8172 8172 - > tonic::server::UnaryService<super::SoundSetRequest> 8173 8173 - for SoundSetSvc<T> { 7020 7020 + impl<T: SoundService> tonic::server::UnaryService<super::SoundSetRequest> for SoundSetSvc<T> { 8174 7021 type Response = super::SoundSetResponse; 8175 8175 - type Future = BoxFuture< 8176 8176 - tonic::Response<Self::Response>, 8177 8177 - tonic::Status, 8178 8178 - >; 7022 7022 + type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 8179 7023 fn call( 8180 7024 &mut self, 8181 7025 request: tonic::Request<super::SoundSetRequest>, ··· 8212 7056 "/rockbox.v1alpha1.SoundService/SoundCurrent" => { 8213 7057 #[allow(non_camel_case_types)] 8214 7058 struct SoundCurrentSvc<T: SoundService>(pub Arc<T>); 8215 8215 - impl< 8216 8216 - T: SoundService, 8217 8217 - > tonic::server::UnaryService<super::SoundCurrentRequest> 8218 8218 - for SoundCurrentSvc<T> { 7059 7059 + impl<T: SoundService> tonic::server::UnaryService<super::SoundCurrentRequest> 7060 7060 + for SoundCurrentSvc<T> 7061 7061 + { 8219 7062 type Response = super::SoundCurrentResponse; 8220 8220 - type Future = BoxFuture< 8221 8221 - tonic::Response<Self::Response>, 8222 8222 - tonic::Status, 8223 8223 - >; 7063 7063 + type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 8224 7064 fn call( 8225 7065 &mut self, 8226 7066 request: tonic::Request<super::SoundCurrentRequest>, ··· 8257 7097 "/rockbox.v1alpha1.SoundService/SoundDefault" => { 8258 7098 #[allow(non_camel_case_types)] 8259 7099 struct SoundDefaultSvc<T: SoundService>(pub Arc<T>); 8260 8260 - impl< 8261 8261 - T: SoundService, 8262 8262 - > tonic::server::UnaryService<super::SoundDefaultRequest> 8263 8263 - for SoundDefaultSvc<T> { 7100 7100 + impl<T: SoundService> tonic::server::UnaryService<super::SoundDefaultRequest> 7101 7101 + for SoundDefaultSvc<T> 7102 7102 + { 8264 7103 type Response = super::SoundDefaultResponse; 8265 8265 - type Future = BoxFuture< 8266 8266 - tonic::Response<Self::Response>, 8267 8267 - tonic::Status, 8268 8268 - >; 7104 7104 + type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 8269 7105 fn call( 8270 7106 &mut self, 8271 7107 request: tonic::Request<super::SoundDefaultRequest>, ··· 8302 7138 "/rockbox.v1alpha1.SoundService/SoundMin" => { 8303 7139 #[allow(non_camel_case_types)] 8304 7140 struct SoundMinSvc<T: SoundService>(pub Arc<T>); 8305 8305 - impl< 8306 8306 - T: SoundService, 8307 8307 - > tonic::server::UnaryService<super::SoundMinRequest> 8308 8308 - for SoundMinSvc<T> { 7141 7141 + impl<T: SoundService> tonic::server::UnaryService<super::SoundMinRequest> for SoundMinSvc<T> { 8309 7142 type Response = super::SoundMinResponse; 8310 8310 - type Future = BoxFuture< 8311 8311 - tonic::Response<Self::Response>, 8312 8312 - tonic::Status, 8313 8313 - >; 7143 7143 + type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 8314 7144 fn call( 8315 7145 &mut self, 8316 7146 request: tonic::Request<super::SoundMinRequest>, ··· 8347 7177 "/rockbox.v1alpha1.SoundService/SoundMax" => { 8348 7178 #[allow(non_camel_case_types)] 8349 7179 struct SoundMaxSvc<T: SoundService>(pub Arc<T>); 8350 8350 - impl< 8351 8351 - T: SoundService, 8352 8352 - > tonic::server::UnaryService<super::SoundMaxRequest> 8353 8353 - for SoundMaxSvc<T> { 7180 7180 + impl<T: SoundService> tonic::server::UnaryService<super::SoundMaxRequest> for SoundMaxSvc<T> { 8354 7181 type Response = super::SoundMaxResponse; 8355 8355 - type Future = BoxFuture< 8356 8356 - tonic::Response<Self::Response>, 8357 8357 - tonic::Status, 8358 8358 - >; 7182 7182 + type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 8359 7183 fn call( 8360 7184 &mut self, 8361 7185 request: tonic::Request<super::SoundMaxRequest>, ··· 8392 7216 "/rockbox.v1alpha1.SoundService/SoundUnit" => { 8393 7217 #[allow(non_camel_case_types)] 8394 7218 struct SoundUnitSvc<T: SoundService>(pub Arc<T>); 8395 8395 - impl< 8396 8396 - T: SoundService, 8397 8397 - > tonic::server::UnaryService<super::SoundUnitRequest> 8398 8398 - for SoundUnitSvc<T> { 7219 7219 + impl<T: SoundService> tonic::server::UnaryService<super::SoundUnitRequest> for SoundUnitSvc<T> { 8399 7220 type Response = super::SoundUnitResponse; 8400 8400 - type Future = BoxFuture< 8401 8401 - tonic::Response<Self::Response>, 8402 8402 - tonic::Status, 8403 8403 - >; 7221 7221 + type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 8404 7222 fn call( 8405 7223 &mut self, 8406 7224 request: tonic::Request<super::SoundUnitRequest>, ··· 8437 7255 "/rockbox.v1alpha1.SoundService/SoundVal2Phys" => { 8438 7256 #[allow(non_camel_case_types)] 8439 7257 struct SoundVal2PhysSvc<T: SoundService>(pub Arc<T>); 8440 8440 - impl< 8441 8441 - T: SoundService, 8442 8442 - > tonic::server::UnaryService<super::SoundVal2PhysRequest> 8443 8443 - for SoundVal2PhysSvc<T> { 7258 7258 + impl<T: SoundService> tonic::server::UnaryService<super::SoundVal2PhysRequest> 7259 7259 + for SoundVal2PhysSvc<T> 7260 7260 + { 8444 7261 type Response = super::SoundVal2PhysResponse; 8445 8445 - type Future = BoxFuture< 8446 8446 - tonic::Response<Self::Response>, 8447 8447 - tonic::Status, 8448 8448 - >; 7262 7262 + type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 8449 7263 fn call( 8450 7264 &mut self, 8451 7265 request: tonic::Request<super::SoundVal2PhysRequest>, ··· 8482 7296 "/rockbox.v1alpha1.SoundService/GetPitch" => { 8483 7297 #[allow(non_camel_case_types)] 8484 7298 struct GetPitchSvc<T: SoundService>(pub Arc<T>); 8485 8485 - impl< 8486 8486 - T: SoundService, 8487 8487 - > tonic::server::UnaryService<super::GetPitchRequest> 8488 8488 - for GetPitchSvc<T> { 7299 7299 + impl<T: SoundService> tonic::server::UnaryService<super::GetPitchRequest> for GetPitchSvc<T> { 8489 7300 type Response = super::GetPitchResponse; 8490 8490 - type Future = BoxFuture< 8491 8491 - tonic::Response<Self::Response>, 8492 8492 - tonic::Status, 8493 8493 - >; 7301 7301 + type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 8494 7302 fn call( 8495 7303 &mut self, 8496 7304 request: tonic::Request<super::GetPitchRequest>, ··· 8527 7335 "/rockbox.v1alpha1.SoundService/SetPitch" => { 8528 7336 #[allow(non_camel_case_types)] 8529 7337 struct SetPitchSvc<T: SoundService>(pub Arc<T>); 8530 8530 - impl< 8531 8531 - T: SoundService, 8532 8532 - > tonic::server::UnaryService<super::SetPitchRequest> 8533 8533 - for SetPitchSvc<T> { 7338 7338 + impl<T: SoundService> tonic::server::UnaryService<super::SetPitchRequest> for SetPitchSvc<T> { 8534 7339 type Response = super::SetPitchResponse; 8535 8535 - type Future = BoxFuture< 8536 8536 - tonic::Response<Self::Response>, 8537 8537 - tonic::Status, 8538 8538 - >; 7340 7340 + type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 8539 7341 fn call( 8540 7342 &mut self, 8541 7343 request: tonic::Request<super::SetPitchRequest>, ··· 8572 7374 "/rockbox.v1alpha1.SoundService/BeepPlay" => { 8573 7375 #[allow(non_camel_case_types)] 8574 7376 struct BeepPlaySvc<T: SoundService>(pub Arc<T>); 8575 8575 - impl< 8576 8576 - T: SoundService, 8577 8577 - > tonic::server::UnaryService<super::BeepPlayRequest> 8578 8578 - for BeepPlaySvc<T> { 7377 7377 + impl<T: SoundService> tonic::server::UnaryService<super::BeepPlayRequest> for BeepPlaySvc<T> { 8579 7378 type Response = super::BeepPlayResponse; 8580 8580 - type Future = BoxFuture< 8581 8581 - tonic::Response<Self::Response>, 8582 8582 - tonic::Status, 8583 8583 - >; 7379 7379 + type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 8584 7380 fn call( 8585 7381 &mut self, 8586 7382 request: tonic::Request<super::BeepPlayRequest>, ··· 8617 7413 "/rockbox.v1alpha1.SoundService/PcmbufFade" => { 8618 7414 #[allow(non_camel_case_types)] 8619 7415 struct PcmbufFadeSvc<T: SoundService>(pub Arc<T>); 8620 8620 - impl< 8621 8621 - T: SoundService, 8622 8622 - > tonic::server::UnaryService<super::PcmbufFadeRequest> 8623 8623 - for PcmbufFadeSvc<T> { 7416 7416 + impl<T: SoundService> tonic::server::UnaryService<super::PcmbufFadeRequest> for PcmbufFadeSvc<T> { 8624 7417 type Response = super::PcmbufFadeResponse; 8625 8625 - type Future = BoxFuture< 8626 8626 - tonic::Response<Self::Response>, 8627 8627 - tonic::Status, 8628 8628 - >; 7418 7418 + type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 8629 7419 fn call( 8630 7420 &mut self, 8631 7421 request: tonic::Request<super::PcmbufFadeRequest>, ··· 8662 7452 "/rockbox.v1alpha1.SoundService/PcmbufSetLowLatency" => { 8663 7453 #[allow(non_camel_case_types)] 8664 7454 struct PcmbufSetLowLatencySvc<T: SoundService>(pub Arc<T>); 8665 8665 - impl< 8666 8666 - T: SoundService, 8667 8667 - > tonic::server::UnaryService<super::PcmbufSetLowLatencyRequest> 8668 8668 - for PcmbufSetLowLatencySvc<T> { 7455 7455 + impl<T: SoundService> 7456 7456 + tonic::server::UnaryService<super::PcmbufSetLowLatencyRequest> 7457 7457 + for PcmbufSetLowLatencySvc<T> 7458 7458 + { 8669 7459 type Response = super::PcmbufSetLowLatencyResponse; 8670 8670 - type Future = BoxFuture< 8671 8671 - tonic::Response<Self::Response>, 8672 8672 - tonic::Status, 8673 8673 - >; 7460 7460 + type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 8674 7461 fn call( 8675 7462 &mut self, 8676 7463 request: tonic::Request<super::PcmbufSetLowLatencyRequest>, 8677 7464 ) -> Self::Future { 8678 7465 let inner = Arc::clone(&self.0); 8679 7466 let fut = async move { 8680 8680 - <T as SoundService>::pcmbuf_set_low_latency(&inner, request) 8681 8681 - .await 7467 7467 + <T as SoundService>::pcmbuf_set_low_latency(&inner, request).await 8682 7468 }; 8683 7469 Box::pin(fut) 8684 7470 } ··· 8708 7494 "/rockbox.v1alpha1.SoundService/SystemSoundPlay" => { 8709 7495 #[allow(non_camel_case_types)] 8710 7496 struct SystemSoundPlaySvc<T: SoundService>(pub Arc<T>); 8711 8711 - impl< 8712 8712 - T: SoundService, 8713 8713 - > tonic::server::UnaryService<super::SystemSoundPlayRequest> 8714 8714 - for SystemSoundPlaySvc<T> { 7497 7497 + impl<T: SoundService> tonic::server::UnaryService<super::SystemSoundPlayRequest> 7498 7498 + for SystemSoundPlaySvc<T> 7499 7499 + { 8715 7500 type Response = super::SystemSoundPlayResponse; 8716 8716 - type Future = BoxFuture< 8717 8717 - tonic::Response<Self::Response>, 8718 8718 - tonic::Status, 8719 8719 - >; 7501 7501 + type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 8720 7502 fn call( 8721 7503 &mut self, 8722 7504 request: tonic::Request<super::SystemSoundPlayRequest>, 8723 7505 ) -> Self::Future { 8724 7506 let inner = Arc::clone(&self.0); 8725 7507 let fut = async move { 8726 8726 - <T as SoundService>::system_sound_play(&inner, request) 8727 8727 - .await 7508 7508 + <T as SoundService>::system_sound_play(&inner, request).await 8728 7509 }; 8729 7510 Box::pin(fut) 8730 7511 } ··· 8754 7535 "/rockbox.v1alpha1.SoundService/KeyclickClick" => { 8755 7536 #[allow(non_camel_case_types)] 8756 7537 struct KeyclickClickSvc<T: SoundService>(pub Arc<T>); 8757 8757 - impl< 8758 8758 - T: SoundService, 8759 8759 - > tonic::server::UnaryService<super::KeyclickClickRequest> 8760 8760 - for KeyclickClickSvc<T> { 7538 7538 + impl<T: SoundService> tonic::server::UnaryService<super::KeyclickClickRequest> 7539 7539 + for KeyclickClickSvc<T> 7540 7540 + { 8761 7541 type Response = super::KeyclickClickResponse; 8762 8762 - type Future = BoxFuture< 8763 8763 - tonic::Response<Self::Response>, 8764 8764 - tonic::Status, 8765 8765 - >; 7542 7542 + type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 8766 7543 fn call( 8767 7544 &mut self, 8768 7545 request: tonic::Request<super::KeyclickClickRequest>, ··· 8796 7573 }; 8797 7574 Box::pin(fut) 8798 7575 } 8799 8799 - _ => { 8800 8800 - Box::pin(async move { 8801 8801 - let mut response = http::Response::new(empty_body()); 8802 8802 - let headers = response.headers_mut(); 8803 8803 - headers 8804 8804 - .insert( 8805 8805 - tonic::Status::GRPC_STATUS, 8806 8806 - (tonic::Code::Unimplemented as i32).into(), 8807 8807 - ); 8808 8808 - headers 8809 8809 - .insert( 8810 8810 - http::header::CONTENT_TYPE, 8811 8811 - tonic::metadata::GRPC_CONTENT_TYPE, 8812 8812 - ); 8813 8813 - Ok(response) 8814 8814 - }) 8815 8815 - } 7576 7576 + _ => Box::pin(async move { 7577 7577 + let mut response = http::Response::new(empty_body()); 7578 7578 + let headers = response.headers_mut(); 7579 7579 + headers.insert( 7580 7580 + tonic::Status::GRPC_STATUS, 7581 7581 + (tonic::Code::Unimplemented as i32).into(), 7582 7582 + ); 7583 7583 + headers.insert( 7584 7584 + http::header::CONTENT_TYPE, 7585 7585 + tonic::metadata::GRPC_CONTENT_TYPE, 7586 7586 + ); 7587 7587 + Ok(response) 7588 7588 + }), 8816 7589 } 8817 7590 } 8818 7591 } ··· 8873 7646 dead_code, 8874 7647 missing_docs, 8875 7648 clippy::wildcard_imports, 8876 8876 - clippy::let_unit_value, 7649 7649 + clippy::let_unit_value 8877 7650 )] 7651 7651 + use tonic::codegen::http::Uri; 8878 7652 use tonic::codegen::*; 8879 8879 - use tonic::codegen::http::Uri; 8880 7653 #[derive(Debug, Clone)] 8881 7654 pub struct SystemServiceClient<T> { 8882 7655 inner: tonic::client::Grpc<T>, ··· 8920 7693 <T as tonic::client::GrpcService<tonic::body::BoxBody>>::ResponseBody, 8921 7694 >, 8922 7695 >, 8923 8923 - <T as tonic::codegen::Service< 8924 8924 - http::Request<tonic::body::BoxBody>, 8925 8925 - >>::Error: Into<StdError> + std::marker::Send + std::marker::Sync, 7696 7696 + <T as tonic::codegen::Service<http::Request<tonic::body::BoxBody>>>::Error: 7697 7697 + Into<StdError> + std::marker::Send + std::marker::Sync, 8926 7698 { 8927 7699 SystemServiceClient::new(InterceptedService::new(inner, interceptor)) 8928 7700 } ··· 8960 7732 pub async fn get_rockbox_version( 8961 7733 &mut self, 8962 7734 request: impl tonic::IntoRequest<super::GetRockboxVersionRequest>, 8963 8963 - ) -> std::result::Result< 8964 8964 - tonic::Response<super::GetRockboxVersionResponse>, 8965 8965 - tonic::Status, 8966 8966 - > { 8967 8967 - self.inner 8968 8968 - .ready() 8969 8969 - .await 8970 8970 - .map_err(|e| { 8971 8971 - tonic::Status::unknown( 8972 8972 - format!("Service was not ready: {}", e.into()), 8973 8973 - ) 8974 8974 - })?; 7735 7735 + ) -> std::result::Result<tonic::Response<super::GetRockboxVersionResponse>, tonic::Status> 7736 7736 + { 7737 7737 + self.inner.ready().await.map_err(|e| { 7738 7738 + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 7739 7739 + })?; 8975 7740 let codec = tonic::codec::ProstCodec::default(); 8976 7741 let path = http::uri::PathAndQuery::from_static( 8977 7742 "/rockbox.v1alpha1.SystemService/GetRockboxVersion", 8978 7743 ); 8979 7744 let mut req = request.into_request(); 8980 8980 - req.extensions_mut() 8981 8981 - .insert( 8982 8982 - GrpcMethod::new( 8983 8983 - "rockbox.v1alpha1.SystemService", 8984 8984 - "GetRockboxVersion", 8985 8985 - ), 8986 8986 - ); 7745 7745 + req.extensions_mut().insert(GrpcMethod::new( 7746 7746 + "rockbox.v1alpha1.SystemService", 7747 7747 + "GetRockboxVersion", 7748 7748 + )); 8987 7749 self.inner.unary(req, path, codec).await 8988 7750 } 8989 7751 pub async fn get_global_status( 8990 7752 &mut self, 8991 7753 request: impl tonic::IntoRequest<super::GetGlobalStatusRequest>, 8992 8992 - ) -> std::result::Result< 8993 8993 - tonic::Response<super::GetGlobalStatusResponse>, 8994 8994 - tonic::Status, 8995 8995 - > { 8996 8996 - self.inner 8997 8997 - .ready() 8998 8998 - .await 8999 8999 - .map_err(|e| { 9000 9000 - tonic::Status::unknown( 9001 9001 - format!("Service was not ready: {}", e.into()), 9002 9002 - ) 9003 9003 - })?; 7754 7754 + ) -> std::result::Result<tonic::Response<super::GetGlobalStatusResponse>, tonic::Status> 7755 7755 + { 7756 7756 + self.inner.ready().await.map_err(|e| { 7757 7757 + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 7758 7758 + })?; 9004 7759 let codec = tonic::codec::ProstCodec::default(); 9005 7760 let path = http::uri::PathAndQuery::from_static( 9006 7761 "/rockbox.v1alpha1.SystemService/GetGlobalStatus", 9007 7762 ); 9008 7763 let mut req = request.into_request(); 9009 9009 - req.extensions_mut() 9010 9010 - .insert( 9011 9011 - GrpcMethod::new("rockbox.v1alpha1.SystemService", "GetGlobalStatus"), 9012 9012 - ); 7764 7764 + req.extensions_mut().insert(GrpcMethod::new( 7765 7765 + "rockbox.v1alpha1.SystemService", 7766 7766 + "GetGlobalStatus", 7767 7767 + )); 9013 7768 self.inner.unary(req, path, codec).await 9014 7769 } 9015 7770 } ··· 9021 7776 dead_code, 9022 7777 missing_docs, 9023 7778 clippy::wildcard_imports, 9024 9024 - clippy::let_unit_value, 7779 7779 + clippy::let_unit_value 9025 7780 )] 9026 7781 use tonic::codegen::*; 9027 7782 /// Generated trait containing gRPC methods that should be implemented for use with SystemServiceServer. ··· 9030 7785 async fn get_rockbox_version( 9031 7786 &self, 9032 7787 request: tonic::Request<super::GetRockboxVersionRequest>, 9033 9033 - ) -> std::result::Result< 9034 9034 - tonic::Response<super::GetRockboxVersionResponse>, 9035 9035 - tonic::Status, 9036 9036 - >; 7788 7788 + ) -> std::result::Result<tonic::Response<super::GetRockboxVersionResponse>, tonic::Status>; 9037 7789 async fn get_global_status( 9038 7790 &self, 9039 7791 request: tonic::Request<super::GetGlobalStatusRequest>, 9040 9040 - ) -> std::result::Result< 9041 9041 - tonic::Response<super::GetGlobalStatusResponse>, 9042 9042 - tonic::Status, 9043 9043 - >; 7792 7792 + ) -> std::result::Result<tonic::Response<super::GetGlobalStatusResponse>, tonic::Status>; 9044 7793 } 9045 7794 #[derive(Debug)] 9046 7795 pub struct SystemServiceServer<T> { ··· 9063 7812 max_encoding_message_size: None, 9064 7813 } 9065 7814 } 9066 9066 - pub fn with_interceptor<F>( 9067 9067 - inner: T, 9068 9068 - interceptor: F, 9069 9069 - ) -> InterceptedService<Self, F> 7815 7815 + pub fn with_interceptor<F>(inner: T, interceptor: F) -> InterceptedService<Self, F> 9070 7816 where 9071 7817 F: tonic::service::Interceptor, 9072 7818 { ··· 9121 7867 "/rockbox.v1alpha1.SystemService/GetRockboxVersion" => { 9122 7868 #[allow(non_camel_case_types)] 9123 7869 struct GetRockboxVersionSvc<T: SystemService>(pub Arc<T>); 9124 9124 - impl< 9125 9125 - T: SystemService, 9126 9126 - > tonic::server::UnaryService<super::GetRockboxVersionRequest> 9127 9127 - for GetRockboxVersionSvc<T> { 7870 7870 + impl<T: SystemService> 7871 7871 + tonic::server::UnaryService<super::GetRockboxVersionRequest> 7872 7872 + for GetRockboxVersionSvc<T> 7873 7873 + { 9128 7874 type Response = super::GetRockboxVersionResponse; 9129 9129 - type Future = BoxFuture< 9130 9130 - tonic::Response<Self::Response>, 9131 9131 - tonic::Status, 9132 9132 - >; 7875 7875 + type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 9133 7876 fn call( 9134 7877 &mut self, 9135 7878 request: tonic::Request<super::GetRockboxVersionRequest>, 9136 7879 ) -> Self::Future { 9137 7880 let inner = Arc::clone(&self.0); 9138 7881 let fut = async move { 9139 9139 - <T as SystemService>::get_rockbox_version(&inner, request) 9140 9140 - .await 7882 7882 + <T as SystemService>::get_rockbox_version(&inner, request).await 9141 7883 }; 9142 7884 Box::pin(fut) 9143 7885 } ··· 9167 7909 "/rockbox.v1alpha1.SystemService/GetGlobalStatus" => { 9168 7910 #[allow(non_camel_case_types)] 9169 7911 struct GetGlobalStatusSvc<T: SystemService>(pub Arc<T>); 9170 9170 - impl< 9171 9171 - T: SystemService, 9172 9172 - > tonic::server::UnaryService<super::GetGlobalStatusRequest> 9173 9173 - for GetGlobalStatusSvc<T> { 7912 7912 + impl<T: SystemService> 7913 7913 + tonic::server::UnaryService<super::GetGlobalStatusRequest> 7914 7914 + for GetGlobalStatusSvc<T> 7915 7915 + { 9174 7916 type Response = super::GetGlobalStatusResponse; 9175 9175 - type Future = BoxFuture< 9176 9176 - tonic::Response<Self::Response>, 9177 9177 - tonic::Status, 9178 9178 - >; 7917 7917 + type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 9179 7918 fn call( 9180 7919 &mut self, 9181 7920 request: tonic::Request<super::GetGlobalStatusRequest>, 9182 7921 ) -> Self::Future { 9183 7922 let inner = Arc::clone(&self.0); 9184 7923 let fut = async move { 9185 9185 - <T as SystemService>::get_global_status(&inner, request) 9186 9186 - .await 7924 7924 + <T as SystemService>::get_global_status(&inner, request).await 9187 7925 }; 9188 7926 Box::pin(fut) 9189 7927 } ··· 9210 7948 }; 9211 7949 Box::pin(fut) 9212 7950 } 9213 9213 - _ => { 9214 9214 - Box::pin(async move { 9215 9215 - let mut response = http::Response::new(empty_body()); 9216 9216 - let headers = response.headers_mut(); 9217 9217 - headers 9218 9218 - .insert( 9219 9219 - tonic::Status::GRPC_STATUS, 9220 9220 - (tonic::Code::Unimplemented as i32).into(), 9221 9221 - ); 9222 9222 - headers 9223 9223 - .insert( 9224 9224 - http::header::CONTENT_TYPE, 9225 9225 - tonic::metadata::GRPC_CONTENT_TYPE, 9226 9226 - ); 9227 9227 - Ok(response) 9228 9228 - }) 9229 9229 - } 7951 7951 + _ => Box::pin(async move { 7952 7952 + let mut response = http::Response::new(empty_body()); 7953 7953 + let headers = response.headers_mut(); 7954 7954 + headers.insert( 7955 7955 + tonic::Status::GRPC_STATUS, 7956 7956 + (tonic::Code::Unimplemented as i32).into(), 7957 7957 + ); 7958 7958 + headers.insert( 7959 7959 + http::header::CONTENT_TYPE, 7960 7960 + tonic::metadata::GRPC_CONTENT_TYPE, 7961 7961 + ); 7962 7962 + Ok(response) 7963 7963 + }), 9230 7964 } 9231 7965 } 9232 7966 }

+1316 -2649

crates/rpc/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::*; 49 48 use tonic::codegen::http::Uri; 49 49 + use tonic::codegen::*; 50 50 #[derive(Debug, Clone)] 51 51 pub struct BrowseServiceClient<T> { 52 52 inner: tonic::client::Grpc<T>, ··· 90 90 <T as tonic::client::GrpcService<tonic::body::BoxBody>>::ResponseBody, 91 91 >, 92 92 >, 93 93 - <T as tonic::codegen::Service< 94 94 - http::Request<tonic::body::BoxBody>, 95 95 - >>::Error: Into<StdError> + std::marker::Send + std::marker::Sync, 93 93 + <T as tonic::codegen::Service<http::Request<tonic::body::BoxBody>>>::Error: 94 94 + Into<StdError> + std::marker::Send + std::marker::Sync, 96 95 { 97 96 BrowseServiceClient::new(InterceptedService::new(inner, interceptor)) 98 97 } ··· 130 129 pub async fn tree_get_entries( 131 130 &mut self, 132 131 request: impl tonic::IntoRequest<super::TreeGetEntriesRequest>, 133 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 - })?; 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 + })?; 145 137 let codec = tonic::codec::ProstCodec::default(); 146 138 let path = http::uri::PathAndQuery::from_static( 147 139 "/rockbox.v1alpha1.BrowseService/TreeGetEntries", 148 140 ); 149 141 let mut req = request.into_request(); 150 150 - req.extensions_mut() 151 151 - .insert( 152 152 - GrpcMethod::new("rockbox.v1alpha1.BrowseService", "TreeGetEntries"), 153 153 - ); 142 142 + req.extensions_mut().insert(GrpcMethod::new( 143 143 + "rockbox.v1alpha1.BrowseService", 144 144 + "TreeGetEntries", 145 145 + )); 154 146 self.inner.unary(req, path, codec).await 155 147 } 156 148 } ··· 162 154 dead_code, 163 155 missing_docs, 164 156 clippy::wildcard_imports, 165 165 - clippy::let_unit_value, 157 157 + clippy::let_unit_value 166 158 )] 167 159 use tonic::codegen::*; 168 160 /// Generated trait containing gRPC methods that should be implemented for use with BrowseServiceServer. ··· 171 163 async fn tree_get_entries( 172 164 &self, 173 165 request: tonic::Request<super::TreeGetEntriesRequest>, 174 174 - ) -> std::result::Result< 175 175 - tonic::Response<super::TreeGetEntriesResponse>, 176 176 - tonic::Status, 177 177 - >; 166 166 + ) -> std::result::Result<tonic::Response<super::TreeGetEntriesResponse>, tonic::Status>; 178 167 } 179 168 #[derive(Debug)] 180 169 pub struct BrowseServiceServer<T> { ··· 197 186 max_encoding_message_size: None, 198 187 } 199 188 } 200 200 - pub fn with_interceptor<F>( 201 201 - inner: T, 202 202 - interceptor: F, 203 203 - ) -> InterceptedService<Self, F> 189 189 + pub fn with_interceptor<F>(inner: T, interceptor: F) -> InterceptedService<Self, F> 204 190 where 205 191 F: tonic::service::Interceptor, 206 192 { ··· 255 241 "/rockbox.v1alpha1.BrowseService/TreeGetEntries" => { 256 242 #[allow(non_camel_case_types)] 257 243 struct TreeGetEntriesSvc<T: BrowseService>(pub Arc<T>); 258 258 - impl< 259 259 - T: BrowseService, 260 260 - > tonic::server::UnaryService<super::TreeGetEntriesRequest> 261 261 - for TreeGetEntriesSvc<T> { 244 244 + impl<T: BrowseService> tonic::server::UnaryService<super::TreeGetEntriesRequest> 245 245 + for TreeGetEntriesSvc<T> 246 246 + { 262 247 type Response = super::TreeGetEntriesResponse; 263 263 - type Future = BoxFuture< 264 264 - tonic::Response<Self::Response>, 265 265 - tonic::Status, 266 266 - >; 248 248 + type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 267 249 fn call( 268 250 &mut self, 269 251 request: tonic::Request<super::TreeGetEntriesRequest>, 270 252 ) -> Self::Future { 271 253 let inner = Arc::clone(&self.0); 272 254 let fut = async move { 273 273 - <T as BrowseService>::tree_get_entries(&inner, request) 274 274 - .await 255 255 + <T as BrowseService>::tree_get_entries(&inner, request).await 275 256 }; 276 257 Box::pin(fut) 277 258 } ··· 298 279 }; 299 280 Box::pin(fut) 300 281 } 301 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 - } 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 + }), 318 295 } 319 296 } 320 297 } ··· 407 384 dead_code, 408 385 missing_docs, 409 386 clippy::wildcard_imports, 410 410 - clippy::let_unit_value, 387 387 + clippy::let_unit_value 411 388 )] 412 412 - use tonic::codegen::*; 413 389 use tonic::codegen::http::Uri; 390 390 + use tonic::codegen::*; 414 391 #[derive(Debug, Clone)] 415 392 pub struct DeviceServiceClient<T> { 416 393 inner: tonic::client::Grpc<T>, ··· 454 431 <T as tonic::client::GrpcService<tonic::body::BoxBody>>::ResponseBody, 455 432 >, 456 433 >, 457 457 - <T as tonic::codegen::Service< 458 458 - http::Request<tonic::body::BoxBody>, 459 459 - >>::Error: Into<StdError> + std::marker::Send + std::marker::Sync, 434 434 + <T as tonic::codegen::Service<http::Request<tonic::body::BoxBody>>>::Error: 435 435 + Into<StdError> + std::marker::Send + std::marker::Sync, 460 436 { 461 437 DeviceServiceClient::new(InterceptedService::new(inner, interceptor)) 462 438 } ··· 494 470 pub async fn get_devices( 495 471 &mut self, 496 472 request: impl tonic::IntoRequest<super::GetDevicesRequest>, 497 497 - ) -> std::result::Result< 498 498 - tonic::Response<super::GetDevicesResponse>, 499 499 - tonic::Status, 500 500 - > { 501 501 - self.inner 502 502 - .ready() 503 503 - .await 504 504 - .map_err(|e| { 505 505 - tonic::Status::unknown( 506 506 - format!("Service was not ready: {}", e.into()), 507 507 - ) 508 508 - })?; 473 473 + ) -> std::result::Result<tonic::Response<super::GetDevicesResponse>, tonic::Status> 474 474 + { 475 475 + self.inner.ready().await.map_err(|e| { 476 476 + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 477 477 + })?; 509 478 let codec = tonic::codec::ProstCodec::default(); 510 510 - let path = http::uri::PathAndQuery::from_static( 511 511 - "/rockbox.v1alpha1.DeviceService/GetDevices", 512 512 - ); 479 479 + let path = 480 480 + http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.DeviceService/GetDevices"); 513 481 let mut req = request.into_request(); 514 514 - req.extensions_mut() 515 515 - .insert(GrpcMethod::new("rockbox.v1alpha1.DeviceService", "GetDevices")); 482 482 + req.extensions_mut().insert(GrpcMethod::new( 483 483 + "rockbox.v1alpha1.DeviceService", 484 484 + "GetDevices", 485 485 + )); 516 486 self.inner.unary(req, path, codec).await 517 487 } 518 488 pub async fn get_device( 519 489 &mut self, 520 490 request: impl tonic::IntoRequest<super::GetDeviceRequest>, 521 521 - ) -> std::result::Result< 522 522 - tonic::Response<super::GetDeviceResponse>, 523 523 - tonic::Status, 524 524 - > { 525 525 - self.inner 526 526 - .ready() 527 527 - .await 528 528 - .map_err(|e| { 529 529 - tonic::Status::unknown( 530 530 - format!("Service was not ready: {}", e.into()), 531 531 - ) 532 532 - })?; 491 491 + ) -> std::result::Result<tonic::Response<super::GetDeviceResponse>, tonic::Status> { 492 492 + self.inner.ready().await.map_err(|e| { 493 493 + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 494 494 + })?; 533 495 let codec = tonic::codec::ProstCodec::default(); 534 534 - let path = http::uri::PathAndQuery::from_static( 535 535 - "/rockbox.v1alpha1.DeviceService/GetDevice", 536 536 - ); 496 496 + let path = 497 497 + http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.DeviceService/GetDevice"); 537 498 let mut req = request.into_request(); 538 538 - req.extensions_mut() 539 539 - .insert(GrpcMethod::new("rockbox.v1alpha1.DeviceService", "GetDevice")); 499 499 + req.extensions_mut().insert(GrpcMethod::new( 500 500 + "rockbox.v1alpha1.DeviceService", 501 501 + "GetDevice", 502 502 + )); 540 503 self.inner.unary(req, path, codec).await 541 504 } 542 505 pub async fn connect_device( 543 506 &mut self, 544 507 request: impl tonic::IntoRequest<super::ConnectDeviceRequest>, 545 545 - ) -> std::result::Result< 546 546 - tonic::Response<super::ConnectDeviceResponse>, 547 547 - tonic::Status, 548 548 - > { 549 549 - self.inner 550 550 - .ready() 551 551 - .await 552 552 - .map_err(|e| { 553 553 - tonic::Status::unknown( 554 554 - format!("Service was not ready: {}", e.into()), 555 555 - ) 556 556 - })?; 508 508 + ) -> std::result::Result<tonic::Response<super::ConnectDeviceResponse>, tonic::Status> 509 509 + { 510 510 + self.inner.ready().await.map_err(|e| { 511 511 + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 512 512 + })?; 557 513 let codec = tonic::codec::ProstCodec::default(); 558 514 let path = http::uri::PathAndQuery::from_static( 559 515 "/rockbox.v1alpha1.DeviceService/ConnectDevice", 560 516 ); 561 517 let mut req = request.into_request(); 562 562 - req.extensions_mut() 563 563 - .insert( 564 564 - GrpcMethod::new("rockbox.v1alpha1.DeviceService", "ConnectDevice"), 565 565 - ); 518 518 + req.extensions_mut().insert(GrpcMethod::new( 519 519 + "rockbox.v1alpha1.DeviceService", 520 520 + "ConnectDevice", 521 521 + )); 566 522 self.inner.unary(req, path, codec).await 567 523 } 568 524 pub async fn disconnect_device( 569 525 &mut self, 570 526 request: impl tonic::IntoRequest<super::DisconnectDeviceRequest>, 571 571 - ) -> std::result::Result< 572 572 - tonic::Response<super::DisconnectDeviceResponse>, 573 573 - tonic::Status, 574 574 - > { 575 575 - self.inner 576 576 - .ready() 577 577 - .await 578 578 - .map_err(|e| { 579 579 - tonic::Status::unknown( 580 580 - format!("Service was not ready: {}", e.into()), 581 581 - ) 582 582 - })?; 527 527 + ) -> std::result::Result<tonic::Response<super::DisconnectDeviceResponse>, tonic::Status> 528 528 + { 529 529 + self.inner.ready().await.map_err(|e| { 530 530 + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 531 531 + })?; 583 532 let codec = tonic::codec::ProstCodec::default(); 584 533 let path = http::uri::PathAndQuery::from_static( 585 534 "/rockbox.v1alpha1.DeviceService/DisconnectDevice", 586 535 ); 587 536 let mut req = request.into_request(); 588 588 - req.extensions_mut() 589 589 - .insert( 590 590 - GrpcMethod::new("rockbox.v1alpha1.DeviceService", "DisconnectDevice"), 591 591 - ); 537 537 + req.extensions_mut().insert(GrpcMethod::new( 538 538 + "rockbox.v1alpha1.DeviceService", 539 539 + "DisconnectDevice", 540 540 + )); 592 541 self.inner.unary(req, path, codec).await 593 542 } 594 543 } ··· 600 549 dead_code, 601 550 missing_docs, 602 551 clippy::wildcard_imports, 603 603 - clippy::let_unit_value, 552 552 + clippy::let_unit_value 604 553 )] 605 554 use tonic::codegen::*; 606 555 /// Generated trait containing gRPC methods that should be implemented for use with DeviceServiceServer. ··· 609 558 async fn get_devices( 610 559 &self, 611 560 request: tonic::Request<super::GetDevicesRequest>, 612 612 - ) -> std::result::Result< 613 613 - tonic::Response<super::GetDevicesResponse>, 614 614 - tonic::Status, 615 615 - >; 561 561 + ) -> std::result::Result<tonic::Response<super::GetDevicesResponse>, tonic::Status>; 616 562 async fn get_device( 617 563 &self, 618 564 request: tonic::Request<super::GetDeviceRequest>, 619 619 - ) -> std::result::Result< 620 620 - tonic::Response<super::GetDeviceResponse>, 621 621 - tonic::Status, 622 622 - >; 565 565 + ) -> std::result::Result<tonic::Response<super::GetDeviceResponse>, tonic::Status>; 623 566 async fn connect_device( 624 567 &self, 625 568 request: tonic::Request<super::ConnectDeviceRequest>, 626 626 - ) -> std::result::Result< 627 627 - tonic::Response<super::ConnectDeviceResponse>, 628 628 - tonic::Status, 629 629 - >; 569 569 + ) -> std::result::Result<tonic::Response<super::ConnectDeviceResponse>, tonic::Status>; 630 570 async fn disconnect_device( 631 571 &self, 632 572 request: tonic::Request<super::DisconnectDeviceRequest>, 633 633 - ) -> std::result::Result< 634 634 - tonic::Response<super::DisconnectDeviceResponse>, 635 635 - tonic::Status, 636 636 - >; 573 573 + ) -> std::result::Result<tonic::Response<super::DisconnectDeviceResponse>, tonic::Status>; 637 574 } 638 575 #[derive(Debug)] 639 576 pub struct DeviceServiceServer<T> { ··· 656 593 max_encoding_message_size: None, 657 594 } 658 595 } 659 659 - pub fn with_interceptor<F>( 660 660 - inner: T, 661 661 - interceptor: F, 662 662 - ) -> InterceptedService<Self, F> 596 596 + pub fn with_interceptor<F>(inner: T, interceptor: F) -> InterceptedService<Self, F> 663 597 where 664 598 F: tonic::service::Interceptor, 665 599 { ··· 714 648 "/rockbox.v1alpha1.DeviceService/GetDevices" => { 715 649 #[allow(non_camel_case_types)] 716 650 struct GetDevicesSvc<T: DeviceService>(pub Arc<T>); 717 717 - impl< 718 718 - T: DeviceService, 719 719 - > tonic::server::UnaryService<super::GetDevicesRequest> 720 720 - for GetDevicesSvc<T> { 651 651 + impl<T: DeviceService> tonic::server::UnaryService<super::GetDevicesRequest> for GetDevicesSvc<T> { 721 652 type Response = super::GetDevicesResponse; 722 722 - type Future = BoxFuture< 723 723 - tonic::Response<Self::Response>, 724 724 - tonic::Status, 725 725 - >; 653 653 + type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 726 654 fn call( 727 655 &mut self, 728 656 request: tonic::Request<super::GetDevicesRequest>, ··· 759 687 "/rockbox.v1alpha1.DeviceService/GetDevice" => { 760 688 #[allow(non_camel_case_types)] 761 689 struct GetDeviceSvc<T: DeviceService>(pub Arc<T>); 762 762 - impl< 763 763 - T: DeviceService, 764 764 - > tonic::server::UnaryService<super::GetDeviceRequest> 765 765 - for GetDeviceSvc<T> { 690 690 + impl<T: DeviceService> tonic::server::UnaryService<super::GetDeviceRequest> for GetDeviceSvc<T> { 766 691 type Response = super::GetDeviceResponse; 767 767 - type Future = BoxFuture< 768 768 - tonic::Response<Self::Response>, 769 769 - tonic::Status, 770 770 - >; 692 692 + type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 771 693 fn call( 772 694 &mut self, 773 695 request: tonic::Request<super::GetDeviceRequest>, ··· 804 726 "/rockbox.v1alpha1.DeviceService/ConnectDevice" => { 805 727 #[allow(non_camel_case_types)] 806 728 struct ConnectDeviceSvc<T: DeviceService>(pub Arc<T>); 807 807 - impl< 808 808 - T: DeviceService, 809 809 - > tonic::server::UnaryService<super::ConnectDeviceRequest> 810 810 - for ConnectDeviceSvc<T> { 729 729 + impl<T: DeviceService> tonic::server::UnaryService<super::ConnectDeviceRequest> 730 730 + for ConnectDeviceSvc<T> 731 731 + { 811 732 type Response = super::ConnectDeviceResponse; 812 812 - type Future = BoxFuture< 813 813 - tonic::Response<Self::Response>, 814 814 - tonic::Status, 815 815 - >; 733 733 + type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 816 734 fn call( 817 735 &mut self, 818 736 request: tonic::Request<super::ConnectDeviceRequest>, ··· 849 767 "/rockbox.v1alpha1.DeviceService/DisconnectDevice" => { 850 768 #[allow(non_camel_case_types)] 851 769 struct DisconnectDeviceSvc<T: DeviceService>(pub Arc<T>); 852 852 - impl< 853 853 - T: DeviceService, 854 854 - > tonic::server::UnaryService<super::DisconnectDeviceRequest> 855 855 - for DisconnectDeviceSvc<T> { 770 770 + impl<T: DeviceService> 771 771 + tonic::server::UnaryService<super::DisconnectDeviceRequest> 772 772 + for DisconnectDeviceSvc<T> 773 773 + { 856 774 type Response = super::DisconnectDeviceResponse; 857 857 - type Future = BoxFuture< 858 858 - tonic::Response<Self::Response>, 859 859 - tonic::Status, 860 860 - >; 775 775 + type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 861 776 fn call( 862 777 &mut self, 863 778 request: tonic::Request<super::DisconnectDeviceRequest>, 864 779 ) -> Self::Future { 865 780 let inner = Arc::clone(&self.0); 866 781 let fut = async move { 867 867 - <T as DeviceService>::disconnect_device(&inner, request) 868 868 - .await 782 782 + <T as DeviceService>::disconnect_device(&inner, request).await 869 783 }; 870 784 Box::pin(fut) 871 785 } ··· 892 806 }; 893 807 Box::pin(fut) 894 808 } 895 895 - _ => { 896 896 - Box::pin(async move { 897 897 - let mut response = http::Response::new(empty_body()); 898 898 - let headers = response.headers_mut(); 899 899 - headers 900 900 - .insert( 901 901 - tonic::Status::GRPC_STATUS, 902 902 - (tonic::Code::Unimplemented as i32).into(), 903 903 - ); 904 904 - headers 905 905 - .insert( 906 906 - http::header::CONTENT_TYPE, 907 907 - tonic::metadata::GRPC_CONTENT_TYPE, 908 908 - ); 909 909 - Ok(response) 910 910 - }) 911 911 - } 809 809 + _ => Box::pin(async move { 810 810 + let mut response = http::Response::new(empty_body()); 811 811 + let headers = response.headers_mut(); 812 812 + headers.insert( 813 813 + tonic::Status::GRPC_STATUS, 814 814 + (tonic::Code::Unimplemented as i32).into(), 815 815 + ); 816 816 + headers.insert( 817 817 + http::header::CONTENT_TYPE, 818 818 + tonic::metadata::GRPC_CONTENT_TYPE, 819 819 + ); 820 820 + Ok(response) 821 821 + }), 912 822 } 913 823 } 914 824 } ··· 1144 1054 dead_code, 1145 1055 missing_docs, 1146 1056 clippy::wildcard_imports, 1147 1147 - clippy::let_unit_value, 1057 1057 + clippy::let_unit_value 1148 1058 )] 1149 1149 - use tonic::codegen::*; 1150 1059 use tonic::codegen::http::Uri; 1060 1060 + use tonic::codegen::*; 1151 1061 #[derive(Debug, Clone)] 1152 1062 pub struct LibraryServiceClient<T> { 1153 1063 inner: tonic::client::Grpc<T>, ··· 1191 1101 <T as tonic::client::GrpcService<tonic::body::BoxBody>>::ResponseBody, 1192 1102 >, 1193 1103 >, 1194 1194 - <T as tonic::codegen::Service< 1195 1195 - http::Request<tonic::body::BoxBody>, 1196 1196 - >>::Error: Into<StdError> + std::marker::Send + std::marker::Sync, 1104 1104 + <T as tonic::codegen::Service<http::Request<tonic::body::BoxBody>>>::Error: 1105 1105 + Into<StdError> + std::marker::Send + std::marker::Sync, 1197 1106 { 1198 1107 LibraryServiceClient::new(InterceptedService::new(inner, interceptor)) 1199 1108 } ··· 1231 1140 pub async fn get_albums( 1232 1141 &mut self, 1233 1142 request: impl tonic::IntoRequest<super::GetAlbumsRequest>, 1234 1234 - ) -> std::result::Result< 1235 1235 - tonic::Response<super::GetAlbumsResponse>, 1236 1236 - tonic::Status, 1237 1237 - > { 1238 1238 - self.inner 1239 1239 - .ready() 1240 1240 - .await 1241 1241 - .map_err(|e| { 1242 1242 - tonic::Status::unknown( 1243 1243 - format!("Service was not ready: {}", e.into()), 1244 1244 - ) 1245 1245 - })?; 1143 1143 + ) -> std::result::Result<tonic::Response<super::GetAlbumsResponse>, tonic::Status> { 1144 1144 + self.inner.ready().await.map_err(|e| { 1145 1145 + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 1146 1146 + })?; 1246 1147 let codec = tonic::codec::ProstCodec::default(); 1247 1247 - let path = http::uri::PathAndQuery::from_static( 1248 1248 - "/rockbox.v1alpha1.LibraryService/GetAlbums", 1249 1249 - ); 1148 1148 + let path = 1149 1149 + http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.LibraryService/GetAlbums"); 1250 1150 let mut req = request.into_request(); 1251 1251 - req.extensions_mut() 1252 1252 - .insert(GrpcMethod::new("rockbox.v1alpha1.LibraryService", "GetAlbums")); 1151 1151 + req.extensions_mut().insert(GrpcMethod::new( 1152 1152 + "rockbox.v1alpha1.LibraryService", 1153 1153 + "GetAlbums", 1154 1154 + )); 1253 1155 self.inner.unary(req, path, codec).await 1254 1156 } 1255 1157 pub async fn get_artists( 1256 1158 &mut self, 1257 1159 request: impl tonic::IntoRequest<super::GetArtistsRequest>, 1258 1258 - ) -> std::result::Result< 1259 1259 - tonic::Response<super::GetArtistsResponse>, 1260 1260 - tonic::Status, 1261 1261 - > { 1262 1262 - self.inner 1263 1263 - .ready() 1264 1264 - .await 1265 1265 - .map_err(|e| { 1266 1266 - tonic::Status::unknown( 1267 1267 - format!("Service was not ready: {}", e.into()), 1268 1268 - ) 1269 1269 - })?; 1160 1160 + ) -> std::result::Result<tonic::Response<super::GetArtistsResponse>, tonic::Status> 1161 1161 + { 1162 1162 + self.inner.ready().await.map_err(|e| { 1163 1163 + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 1164 1164 + })?; 1270 1165 let codec = tonic::codec::ProstCodec::default(); 1271 1271 - let path = http::uri::PathAndQuery::from_static( 1272 1272 - "/rockbox.v1alpha1.LibraryService/GetArtists", 1273 1273 - ); 1166 1166 + let path = 1167 1167 + http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.LibraryService/GetArtists"); 1274 1168 let mut req = request.into_request(); 1275 1275 - req.extensions_mut() 1276 1276 - .insert( 1277 1277 - GrpcMethod::new("rockbox.v1alpha1.LibraryService", "GetArtists"), 1278 1278 - ); 1169 1169 + req.extensions_mut().insert(GrpcMethod::new( 1170 1170 + "rockbox.v1alpha1.LibraryService", 1171 1171 + "GetArtists", 1172 1172 + )); 1279 1173 self.inner.unary(req, path, codec).await 1280 1174 } 1281 1175 pub async fn get_tracks( 1282 1176 &mut self, 1283 1177 request: impl tonic::IntoRequest<super::GetTracksRequest>, 1284 1284 - ) -> std::result::Result< 1285 1285 - tonic::Response<super::GetTracksResponse>, 1286 1286 - tonic::Status, 1287 1287 - > { 1288 1288 - self.inner 1289 1289 - .ready() 1290 1290 - .await 1291 1291 - .map_err(|e| { 1292 1292 - tonic::Status::unknown( 1293 1293 - format!("Service was not ready: {}", e.into()), 1294 1294 - ) 1295 1295 - })?; 1178 1178 + ) -> std::result::Result<tonic::Response<super::GetTracksResponse>, tonic::Status> { 1179 1179 + self.inner.ready().await.map_err(|e| { 1180 1180 + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 1181 1181 + })?; 1296 1182 let codec = tonic::codec::ProstCodec::default(); 1297 1297 - let path = http::uri::PathAndQuery::from_static( 1298 1298 - "/rockbox.v1alpha1.LibraryService/GetTracks", 1299 1299 - ); 1183 1183 + let path = 1184 1184 + http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.LibraryService/GetTracks"); 1300 1185 let mut req = request.into_request(); 1301 1301 - req.extensions_mut() 1302 1302 - .insert(GrpcMethod::new("rockbox.v1alpha1.LibraryService", "GetTracks")); 1186 1186 + req.extensions_mut().insert(GrpcMethod::new( 1187 1187 + "rockbox.v1alpha1.LibraryService", 1188 1188 + "GetTracks", 1189 1189 + )); 1303 1190 self.inner.unary(req, path, codec).await 1304 1191 } 1305 1192 pub async fn get_album( 1306 1193 &mut self, 1307 1194 request: impl tonic::IntoRequest<super::GetAlbumRequest>, 1308 1308 - ) -> std::result::Result< 1309 1309 - tonic::Response<super::GetAlbumResponse>, 1310 1310 - tonic::Status, 1311 1311 - > { 1312 1312 - self.inner 1313 1313 - .ready() 1314 1314 - .await 1315 1315 - .map_err(|e| { 1316 1316 - tonic::Status::unknown( 1317 1317 - format!("Service was not ready: {}", e.into()), 1318 1318 - ) 1319 1319 - })?; 1195 1195 + ) -> std::result::Result<tonic::Response<super::GetAlbumResponse>, tonic::Status> { 1196 1196 + self.inner.ready().await.map_err(|e| { 1197 1197 + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 1198 1198 + })?; 1320 1199 let codec = tonic::codec::ProstCodec::default(); 1321 1321 - let path = http::uri::PathAndQuery::from_static( 1322 1322 - "/rockbox.v1alpha1.LibraryService/GetAlbum", 1323 1323 - ); 1200 1200 + let path = 1201 1201 + http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.LibraryService/GetAlbum"); 1324 1202 let mut req = request.into_request(); 1325 1325 - req.extensions_mut() 1326 1326 - .insert(GrpcMethod::new("rockbox.v1alpha1.LibraryService", "GetAlbum")); 1203 1203 + req.extensions_mut().insert(GrpcMethod::new( 1204 1204 + "rockbox.v1alpha1.LibraryService", 1205 1205 + "GetAlbum", 1206 1206 + )); 1327 1207 self.inner.unary(req, path, codec).await 1328 1208 } 1329 1209 pub async fn get_artist( 1330 1210 &mut self, 1331 1211 request: impl tonic::IntoRequest<super::GetArtistRequest>, 1332 1332 - ) -> std::result::Result< 1333 1333 - tonic::Response<super::GetArtistResponse>, 1334 1334 - tonic::Status, 1335 1335 - > { 1336 1336 - self.inner 1337 1337 - .ready() 1338 1338 - .await 1339 1339 - .map_err(|e| { 1340 1340 - tonic::Status::unknown( 1341 1341 - format!("Service was not ready: {}", e.into()), 1342 1342 - ) 1343 1343 - })?; 1212 1212 + ) -> std::result::Result<tonic::Response<super::GetArtistResponse>, tonic::Status> { 1213 1213 + self.inner.ready().await.map_err(|e| { 1214 1214 + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 1215 1215 + })?; 1344 1216 let codec = tonic::codec::ProstCodec::default(); 1345 1345 - let path = http::uri::PathAndQuery::from_static( 1346 1346 - "/rockbox.v1alpha1.LibraryService/GetArtist", 1347 1347 - ); 1217 1217 + let path = 1218 1218 + http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.LibraryService/GetArtist"); 1348 1219 let mut req = request.into_request(); 1349 1349 - req.extensions_mut() 1350 1350 - .insert(GrpcMethod::new("rockbox.v1alpha1.LibraryService", "GetArtist")); 1220 1220 + req.extensions_mut().insert(GrpcMethod::new( 1221 1221 + "rockbox.v1alpha1.LibraryService", 1222 1222 + "GetArtist", 1223 1223 + )); 1351 1224 self.inner.unary(req, path, codec).await 1352 1225 } 1353 1226 pub async fn get_track( 1354 1227 &mut self, 1355 1228 request: impl tonic::IntoRequest<super::GetTrackRequest>, 1356 1356 - ) -> std::result::Result< 1357 1357 - tonic::Response<super::GetTrackResponse>, 1358 1358 - tonic::Status, 1359 1359 - > { 1360 1360 - self.inner 1361 1361 - .ready() 1362 1362 - .await 1363 1363 - .map_err(|e| { 1364 1364 - tonic::Status::unknown( 1365 1365 - format!("Service was not ready: {}", e.into()), 1366 1366 - ) 1367 1367 - })?; 1229 1229 + ) -> std::result::Result<tonic::Response<super::GetTrackResponse>, tonic::Status> { 1230 1230 + self.inner.ready().await.map_err(|e| { 1231 1231 + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 1232 1232 + })?; 1368 1233 let codec = tonic::codec::ProstCodec::default(); 1369 1369 - let path = http::uri::PathAndQuery::from_static( 1370 1370 - "/rockbox.v1alpha1.LibraryService/GetTrack", 1371 1371 - ); 1234 1234 + let path = 1235 1235 + http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.LibraryService/GetTrack"); 1372 1236 let mut req = request.into_request(); 1373 1373 - req.extensions_mut() 1374 1374 - .insert(GrpcMethod::new("rockbox.v1alpha1.LibraryService", "GetTrack")); 1237 1237 + req.extensions_mut().insert(GrpcMethod::new( 1238 1238 + "rockbox.v1alpha1.LibraryService", 1239 1239 + "GetTrack", 1240 1240 + )); 1375 1241 self.inner.unary(req, path, codec).await 1376 1242 } 1377 1243 pub async fn like_track( 1378 1244 &mut self, 1379 1245 request: impl tonic::IntoRequest<super::LikeTrackRequest>, 1380 1380 - ) -> std::result::Result< 1381 1381 - tonic::Response<super::LikeTrackResponse>, 1382 1382 - tonic::Status, 1383 1383 - > { 1384 1384 - self.inner 1385 1385 - .ready() 1386 1386 - .await 1387 1387 - .map_err(|e| { 1388 1388 - tonic::Status::unknown( 1389 1389 - format!("Service was not ready: {}", e.into()), 1390 1390 - ) 1391 1391 - })?; 1246 1246 + ) -> std::result::Result<tonic::Response<super::LikeTrackResponse>, tonic::Status> { 1247 1247 + self.inner.ready().await.map_err(|e| { 1248 1248 + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 1249 1249 + })?; 1392 1250 let codec = tonic::codec::ProstCodec::default(); 1393 1393 - let path = http::uri::PathAndQuery::from_static( 1394 1394 - "/rockbox.v1alpha1.LibraryService/LikeTrack", 1395 1395 - ); 1251 1251 + let path = 1252 1252 + http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.LibraryService/LikeTrack"); 1396 1253 let mut req = request.into_request(); 1397 1397 - req.extensions_mut() 1398 1398 - .insert(GrpcMethod::new("rockbox.v1alpha1.LibraryService", "LikeTrack")); 1254 1254 + req.extensions_mut().insert(GrpcMethod::new( 1255 1255 + "rockbox.v1alpha1.LibraryService", 1256 1256 + "LikeTrack", 1257 1257 + )); 1399 1258 self.inner.unary(req, path, codec).await 1400 1259 } 1401 1260 pub async fn unlike_track( 1402 1261 &mut self, 1403 1262 request: impl tonic::IntoRequest<super::UnlikeTrackRequest>, 1404 1404 - ) -> std::result::Result< 1405 1405 - tonic::Response<super::UnlikeTrackResponse>, 1406 1406 - tonic::Status, 1407 1407 - > { 1408 1408 - self.inner 1409 1409 - .ready() 1410 1410 - .await 1411 1411 - .map_err(|e| { 1412 1412 - tonic::Status::unknown( 1413 1413 - format!("Service was not ready: {}", e.into()), 1414 1414 - ) 1415 1415 - })?; 1263 1263 + ) -> std::result::Result<tonic::Response<super::UnlikeTrackResponse>, tonic::Status> 1264 1264 + { 1265 1265 + self.inner.ready().await.map_err(|e| { 1266 1266 + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 1267 1267 + })?; 1416 1268 let codec = tonic::codec::ProstCodec::default(); 1417 1269 let path = http::uri::PathAndQuery::from_static( 1418 1270 "/rockbox.v1alpha1.LibraryService/UnlikeTrack", 1419 1271 ); 1420 1272 let mut req = request.into_request(); 1421 1421 - req.extensions_mut() 1422 1422 - .insert( 1423 1423 - GrpcMethod::new("rockbox.v1alpha1.LibraryService", "UnlikeTrack"), 1424 1424 - ); 1273 1273 + req.extensions_mut().insert(GrpcMethod::new( 1274 1274 + "rockbox.v1alpha1.LibraryService", 1275 1275 + "UnlikeTrack", 1276 1276 + )); 1425 1277 self.inner.unary(req, path, codec).await 1426 1278 } 1427 1279 pub async fn like_album( 1428 1280 &mut self, 1429 1281 request: impl tonic::IntoRequest<super::LikeAlbumRequest>, 1430 1430 - ) -> std::result::Result< 1431 1431 - tonic::Response<super::LikeAlbumResponse>, 1432 1432 - tonic::Status, 1433 1433 - > { 1434 1434 - self.inner 1435 1435 - .ready() 1436 1436 - .await 1437 1437 - .map_err(|e| { 1438 1438 - tonic::Status::unknown( 1439 1439 - format!("Service was not ready: {}", e.into()), 1440 1440 - ) 1441 1441 - })?; 1282 1282 + ) -> std::result::Result<tonic::Response<super::LikeAlbumResponse>, tonic::Status> { 1283 1283 + self.inner.ready().await.map_err(|e| { 1284 1284 + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 1285 1285 + })?; 1442 1286 let codec = tonic::codec::ProstCodec::default(); 1443 1443 - let path = http::uri::PathAndQuery::from_static( 1444 1444 - "/rockbox.v1alpha1.LibraryService/LikeAlbum", 1445 1445 - ); 1287 1287 + let path = 1288 1288 + http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.LibraryService/LikeAlbum"); 1446 1289 let mut req = request.into_request(); 1447 1447 - req.extensions_mut() 1448 1448 - .insert(GrpcMethod::new("rockbox.v1alpha1.LibraryService", "LikeAlbum")); 1290 1290 + req.extensions_mut().insert(GrpcMethod::new( 1291 1291 + "rockbox.v1alpha1.LibraryService", 1292 1292 + "LikeAlbum", 1293 1293 + )); 1449 1294 self.inner.unary(req, path, codec).await 1450 1295 } 1451 1296 pub async fn unlike_album( 1452 1297 &mut self, 1453 1298 request: impl tonic::IntoRequest<super::UnlikeAlbumRequest>, 1454 1454 - ) -> std::result::Result< 1455 1455 - tonic::Response<super::UnlikeAlbumResponse>, 1456 1456 - tonic::Status, 1457 1457 - > { 1458 1458 - self.inner 1459 1459 - .ready() 1460 1460 - .await 1461 1461 - .map_err(|e| { 1462 1462 - tonic::Status::unknown( 1463 1463 - format!("Service was not ready: {}", e.into()), 1464 1464 - ) 1465 1465 - })?; 1299 1299 + ) -> std::result::Result<tonic::Response<super::UnlikeAlbumResponse>, tonic::Status> 1300 1300 + { 1301 1301 + self.inner.ready().await.map_err(|e| { 1302 1302 + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 1303 1303 + })?; 1466 1304 let codec = tonic::codec::ProstCodec::default(); 1467 1305 let path = http::uri::PathAndQuery::from_static( 1468 1306 "/rockbox.v1alpha1.LibraryService/UnlikeAlbum", 1469 1307 ); 1470 1308 let mut req = request.into_request(); 1471 1471 - req.extensions_mut() 1472 1472 - .insert( 1473 1473 - GrpcMethod::new("rockbox.v1alpha1.LibraryService", "UnlikeAlbum"), 1474 1474 - ); 1309 1309 + req.extensions_mut().insert(GrpcMethod::new( 1310 1310 + "rockbox.v1alpha1.LibraryService", 1311 1311 + "UnlikeAlbum", 1312 1312 + )); 1475 1313 self.inner.unary(req, path, codec).await 1476 1314 } 1477 1315 pub async fn get_liked_tracks( 1478 1316 &mut self, 1479 1317 request: impl tonic::IntoRequest<super::GetLikedTracksRequest>, 1480 1480 - ) -> std::result::Result< 1481 1481 - tonic::Response<super::GetLikedTracksResponse>, 1482 1482 - tonic::Status, 1483 1483 - > { 1484 1484 - self.inner 1485 1485 - .ready() 1486 1486 - .await 1487 1487 - .map_err(|e| { 1488 1488 - tonic::Status::unknown( 1489 1489 - format!("Service was not ready: {}", e.into()), 1490 1490 - ) 1491 1491 - })?; 1318 1318 + ) -> std::result::Result<tonic::Response<super::GetLikedTracksResponse>, tonic::Status> 1319 1319 + { 1320 1320 + self.inner.ready().await.map_err(|e| { 1321 1321 + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 1322 1322 + })?; 1492 1323 let codec = tonic::codec::ProstCodec::default(); 1493 1324 let path = http::uri::PathAndQuery::from_static( 1494 1325 "/rockbox.v1alpha1.LibraryService/GetLikedTracks", 1495 1326 ); 1496 1327 let mut req = request.into_request(); 1497 1497 - req.extensions_mut() 1498 1498 - .insert( 1499 1499 - GrpcMethod::new("rockbox.v1alpha1.LibraryService", "GetLikedTracks"), 1500 1500 - ); 1328 1328 + req.extensions_mut().insert(GrpcMethod::new( 1329 1329 + "rockbox.v1alpha1.LibraryService", 1330 1330 + "GetLikedTracks", 1331 1331 + )); 1501 1332 self.inner.unary(req, path, codec).await 1502 1333 } 1503 1334 pub async fn get_liked_albums( 1504 1335 &mut self, 1505 1336 request: impl tonic::IntoRequest<super::GetLikedAlbumsRequest>, 1506 1506 - ) -> std::result::Result< 1507 1507 - tonic::Response<super::GetLikedAlbumsResponse>, 1508 1508 - tonic::Status, 1509 1509 - > { 1510 1510 - self.inner 1511 1511 - .ready() 1512 1512 - .await 1513 1513 - .map_err(|e| { 1514 1514 - tonic::Status::unknown( 1515 1515 - format!("Service was not ready: {}", e.into()), 1516 1516 - ) 1517 1517 - })?; 1337 1337 + ) -> std::result::Result<tonic::Response<super::GetLikedAlbumsResponse>, tonic::Status> 1338 1338 + { 1339 1339 + self.inner.ready().await.map_err(|e| { 1340 1340 + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 1341 1341 + })?; 1518 1342 let codec = tonic::codec::ProstCodec::default(); 1519 1343 let path = http::uri::PathAndQuery::from_static( 1520 1344 "/rockbox.v1alpha1.LibraryService/GetLikedAlbums", 1521 1345 ); 1522 1346 let mut req = request.into_request(); 1523 1523 - req.extensions_mut() 1524 1524 - .insert( 1525 1525 - GrpcMethod::new("rockbox.v1alpha1.LibraryService", "GetLikedAlbums"), 1526 1526 - ); 1347 1347 + req.extensions_mut().insert(GrpcMethod::new( 1348 1348 + "rockbox.v1alpha1.LibraryService", 1349 1349 + "GetLikedAlbums", 1350 1350 + )); 1527 1351 self.inner.unary(req, path, codec).await 1528 1352 } 1529 1353 pub async fn scan_library( 1530 1354 &mut self, 1531 1355 request: impl tonic::IntoRequest<super::ScanLibraryRequest>, 1532 1532 - ) -> std::result::Result< 1533 1533 - tonic::Response<super::ScanLibraryResponse>, 1534 1534 - tonic::Status, 1535 1535 - > { 1536 1536 - self.inner 1537 1537 - .ready() 1538 1538 - .await 1539 1539 - .map_err(|e| { 1540 1540 - tonic::Status::unknown( 1541 1541 - format!("Service was not ready: {}", e.into()), 1542 1542 - ) 1543 1543 - })?; 1356 1356 + ) -> std::result::Result<tonic::Response<super::ScanLibraryResponse>, tonic::Status> 1357 1357 + { 1358 1358 + self.inner.ready().await.map_err(|e| { 1359 1359 + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 1360 1360 + })?; 1544 1361 let codec = tonic::codec::ProstCodec::default(); 1545 1362 let path = http::uri::PathAndQuery::from_static( 1546 1363 "/rockbox.v1alpha1.LibraryService/ScanLibrary", 1547 1364 ); 1548 1365 let mut req = request.into_request(); 1549 1549 - req.extensions_mut() 1550 1550 - .insert( 1551 1551 - GrpcMethod::new("rockbox.v1alpha1.LibraryService", "ScanLibrary"), 1552 1552 - ); 1366 1366 + req.extensions_mut().insert(GrpcMethod::new( 1367 1367 + "rockbox.v1alpha1.LibraryService", 1368 1368 + "ScanLibrary", 1369 1369 + )); 1553 1370 self.inner.unary(req, path, codec).await 1554 1371 } 1555 1372 pub async fn search( 1556 1373 &mut self, 1557 1374 request: impl tonic::IntoRequest<super::SearchRequest>, 1558 1375 ) -> std::result::Result<tonic::Response<super::SearchResponse>, tonic::Status> { 1559 1559 - self.inner 1560 1560 - .ready() 1561 1561 - .await 1562 1562 - .map_err(|e| { 1563 1563 - tonic::Status::unknown( 1564 1564 - format!("Service was not ready: {}", e.into()), 1565 1565 - ) 1566 1566 - })?; 1376 1376 + self.inner.ready().await.map_err(|e| { 1377 1377 + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 1378 1378 + })?; 1567 1379 let codec = tonic::codec::ProstCodec::default(); 1568 1568 - let path = http::uri::PathAndQuery::from_static( 1569 1569 - "/rockbox.v1alpha1.LibraryService/Search", 1570 1570 - ); 1380 1380 + let path = 1381 1381 + http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.LibraryService/Search"); 1571 1382 let mut req = request.into_request(); 1572 1383 req.extensions_mut() 1573 1384 .insert(GrpcMethod::new("rockbox.v1alpha1.LibraryService", "Search")); ··· 1582 1393 dead_code, 1583 1394 missing_docs, 1584 1395 clippy::wildcard_imports, 1585 1585 - clippy::let_unit_value, 1396 1396 + clippy::let_unit_value 1586 1397 )] 1587 1398 use tonic::codegen::*; 1588 1399 /// Generated trait containing gRPC methods that should be implemented for use with LibraryServiceServer. ··· 1591 1402 async fn get_albums( 1592 1403 &self, 1593 1404 request: tonic::Request<super::GetAlbumsRequest>, 1594 1594 - ) -> std::result::Result< 1595 1595 - tonic::Response<super::GetAlbumsResponse>, 1596 1596 - tonic::Status, 1597 1597 - >; 1405 1405 + ) -> std::result::Result<tonic::Response<super::GetAlbumsResponse>, tonic::Status>; 1598 1406 async fn get_artists( 1599 1407 &self, 1600 1408 request: tonic::Request<super::GetArtistsRequest>, 1601 1601 - ) -> std::result::Result< 1602 1602 - tonic::Response<super::GetArtistsResponse>, 1603 1603 - tonic::Status, 1604 1604 - >; 1409 1409 + ) -> std::result::Result<tonic::Response<super::GetArtistsResponse>, tonic::Status>; 1605 1410 async fn get_tracks( 1606 1411 &self, 1607 1412 request: tonic::Request<super::GetTracksRequest>, 1608 1608 - ) -> std::result::Result< 1609 1609 - tonic::Response<super::GetTracksResponse>, 1610 1610 - tonic::Status, 1611 1611 - >; 1413 1413 + ) -> std::result::Result<tonic::Response<super::GetTracksResponse>, tonic::Status>; 1612 1414 async fn get_album( 1613 1415 &self, 1614 1416 request: tonic::Request<super::GetAlbumRequest>, 1615 1615 - ) -> std::result::Result< 1616 1616 - tonic::Response<super::GetAlbumResponse>, 1617 1617 - tonic::Status, 1618 1618 - >; 1417 1417 + ) -> std::result::Result<tonic::Response<super::GetAlbumResponse>, tonic::Status>; 1619 1418 async fn get_artist( 1620 1419 &self, 1621 1420 request: tonic::Request<super::GetArtistRequest>, 1622 1622 - ) -> std::result::Result< 1623 1623 - tonic::Response<super::GetArtistResponse>, 1624 1624 - tonic::Status, 1625 1625 - >; 1421 1421 + ) -> std::result::Result<tonic::Response<super::GetArtistResponse>, tonic::Status>; 1626 1422 async fn get_track( 1627 1423 &self, 1628 1424 request: tonic::Request<super::GetTrackRequest>, 1629 1629 - ) -> std::result::Result< 1630 1630 - tonic::Response<super::GetTrackResponse>, 1631 1631 - tonic::Status, 1632 1632 - >; 1425 1425 + ) -> std::result::Result<tonic::Response<super::GetTrackResponse>, tonic::Status>; 1633 1426 async fn like_track( 1634 1427 &self, 1635 1428 request: tonic::Request<super::LikeTrackRequest>, 1636 1636 - ) -> std::result::Result< 1637 1637 - tonic::Response<super::LikeTrackResponse>, 1638 1638 - tonic::Status, 1639 1639 - >; 1429 1429 + ) -> std::result::Result<tonic::Response<super::LikeTrackResponse>, tonic::Status>; 1640 1430 async fn unlike_track( 1641 1431 &self, 1642 1432 request: tonic::Request<super::UnlikeTrackRequest>, 1643 1643 - ) -> std::result::Result< 1644 1644 - tonic::Response<super::UnlikeTrackResponse>, 1645 1645 - tonic::Status, 1646 1646 - >; 1433 1433 + ) -> std::result::Result<tonic::Response<super::UnlikeTrackResponse>, tonic::Status>; 1647 1434 async fn like_album( 1648 1435 &self, 1649 1436 request: tonic::Request<super::LikeAlbumRequest>, 1650 1650 - ) -> std::result::Result< 1651 1651 - tonic::Response<super::LikeAlbumResponse>, 1652 1652 - tonic::Status, 1653 1653 - >; 1437 1437 + ) -> std::result::Result<tonic::Response<super::LikeAlbumResponse>, tonic::Status>; 1654 1438 async fn unlike_album( 1655 1439 &self, 1656 1440 request: tonic::Request<super::UnlikeAlbumRequest>, 1657 1657 - ) -> std::result::Result< 1658 1658 - tonic::Response<super::UnlikeAlbumResponse>, 1659 1659 - tonic::Status, 1660 1660 - >; 1441 1441 + ) -> std::result::Result<tonic::Response<super::UnlikeAlbumResponse>, tonic::Status>; 1661 1442 async fn get_liked_tracks( 1662 1443 &self, 1663 1444 request: tonic::Request<super::GetLikedTracksRequest>, 1664 1664 - ) -> std::result::Result< 1665 1665 - tonic::Response<super::GetLikedTracksResponse>, 1666 1666 - tonic::Status, 1667 1667 - >; 1445 1445 + ) -> std::result::Result<tonic::Response<super::GetLikedTracksResponse>, tonic::Status>; 1668 1446 async fn get_liked_albums( 1669 1447 &self, 1670 1448 request: tonic::Request<super::GetLikedAlbumsRequest>, 1671 1671 - ) -> std::result::Result< 1672 1672 - tonic::Response<super::GetLikedAlbumsResponse>, 1673 1673 - tonic::Status, 1674 1674 - >; 1449 1449 + ) -> std::result::Result<tonic::Response<super::GetLikedAlbumsResponse>, tonic::Status>; 1675 1450 async fn scan_library( 1676 1451 &self, 1677 1452 request: tonic::Request<super::ScanLibraryRequest>, 1678 1678 - ) -> std::result::Result< 1679 1679 - tonic::Response<super::ScanLibraryResponse>, 1680 1680 - tonic::Status, 1681 1681 - >; 1453 1453 + ) -> std::result::Result<tonic::Response<super::ScanLibraryResponse>, tonic::Status>; 1682 1454 async fn search( 1683 1455 &self, 1684 1456 request: tonic::Request<super::SearchRequest>, ··· 1705 1477 max_encoding_message_size: None, 1706 1478 } 1707 1479 } 1708 1708 - pub fn with_interceptor<F>( 1709 1709 - inner: T, 1710 1710 - interceptor: F, 1711 1711 - ) -> InterceptedService<Self, F> 1480 1480 + pub fn with_interceptor<F>(inner: T, interceptor: F) -> InterceptedService<Self, F> 1712 1481 where 1713 1482 F: tonic::service::Interceptor, 1714 1483 { ··· 1763 1532 "/rockbox.v1alpha1.LibraryService/GetAlbums" => { 1764 1533 #[allow(non_camel_case_types)] 1765 1534 struct GetAlbumsSvc<T: LibraryService>(pub Arc<T>); 1766 1766 - impl< 1767 1767 - T: LibraryService, 1768 1768 - > tonic::server::UnaryService<super::GetAlbumsRequest> 1769 1769 - for GetAlbumsSvc<T> { 1535 1535 + impl<T: LibraryService> tonic::server::UnaryService<super::GetAlbumsRequest> for GetAlbumsSvc<T> { 1770 1536 type Response = super::GetAlbumsResponse; 1771 1771 - type Future = BoxFuture< 1772 1772 - tonic::Response<Self::Response>, 1773 1773 - tonic::Status, 1774 1774 - >; 1537 1537 + type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 1775 1538 fn call( 1776 1539 &mut self, 1777 1540 request: tonic::Request<super::GetAlbumsRequest>, ··· 1808 1571 "/rockbox.v1alpha1.LibraryService/GetArtists" => { 1809 1572 #[allow(non_camel_case_types)] 1810 1573 struct GetArtistsSvc<T: LibraryService>(pub Arc<T>); 1811 1811 - impl< 1812 1812 - T: LibraryService, 1813 1813 - > tonic::server::UnaryService<super::GetArtistsRequest> 1814 1814 - for GetArtistsSvc<T> { 1574 1574 + impl<T: LibraryService> tonic::server::UnaryService<super::GetArtistsRequest> for GetArtistsSvc<T> { 1815 1575 type Response = super::GetArtistsResponse; 1816 1816 - type Future = BoxFuture< 1817 1817 - tonic::Response<Self::Response>, 1818 1818 - tonic::Status, 1819 1819 - >; 1576 1576 + type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 1820 1577 fn call( 1821 1578 &mut self, 1822 1579 request: tonic::Request<super::GetArtistsRequest>, ··· 1853 1610 "/rockbox.v1alpha1.LibraryService/GetTracks" => { 1854 1611 #[allow(non_camel_case_types)] 1855 1612 struct GetTracksSvc<T: LibraryService>(pub Arc<T>); 1856 1856 - impl< 1857 1857 - T: LibraryService, 1858 1858 - > tonic::server::UnaryService<super::GetTracksRequest> 1859 1859 - for GetTracksSvc<T> { 1613 1613 + impl<T: LibraryService> tonic::server::UnaryService<super::GetTracksRequest> for GetTracksSvc<T> { 1860 1614 type Response = super::GetTracksResponse; 1861 1861 - type Future = BoxFuture< 1862 1862 - tonic::Response<Self::Response>, 1863 1863 - tonic::Status, 1864 1864 - >; 1615 1615 + type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 1865 1616 fn call( 1866 1617 &mut self, 1867 1618 request: tonic::Request<super::GetTracksRequest>, ··· 1898 1649 "/rockbox.v1alpha1.LibraryService/GetAlbum" => { 1899 1650 #[allow(non_camel_case_types)] 1900 1651 struct GetAlbumSvc<T: LibraryService>(pub Arc<T>); 1901 1901 - impl< 1902 1902 - T: LibraryService, 1903 1903 - > tonic::server::UnaryService<super::GetAlbumRequest> 1904 1904 - for GetAlbumSvc<T> { 1652 1652 + impl<T: LibraryService> tonic::server::UnaryService<super::GetAlbumRequest> for GetAlbumSvc<T> { 1905 1653 type Response = super::GetAlbumResponse; 1906 1906 - type Future = BoxFuture< 1907 1907 - tonic::Response<Self::Response>, 1908 1908 - tonic::Status, 1909 1909 - >; 1654 1654 + type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 1910 1655 fn call( 1911 1656 &mut self, 1912 1657 request: tonic::Request<super::GetAlbumRequest>, ··· 1943 1688 "/rockbox.v1alpha1.LibraryService/GetArtist" => { 1944 1689 #[allow(non_camel_case_types)] 1945 1690 struct GetArtistSvc<T: LibraryService>(pub Arc<T>); 1946 1946 - impl< 1947 1947 - T: LibraryService, 1948 1948 - > tonic::server::UnaryService<super::GetArtistRequest> 1949 1949 - for GetArtistSvc<T> { 1691 1691 + impl<T: LibraryService> tonic::server::UnaryService<super::GetArtistRequest> for GetArtistSvc<T> { 1950 1692 type Response = super::GetArtistResponse; 1951 1951 - type Future = BoxFuture< 1952 1952 - tonic::Response<Self::Response>, 1953 1953 - tonic::Status, 1954 1954 - >; 1693 1693 + type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 1955 1694 fn call( 1956 1695 &mut self, 1957 1696 request: tonic::Request<super::GetArtistRequest>, ··· 1988 1727 "/rockbox.v1alpha1.LibraryService/GetTrack" => { 1989 1728 #[allow(non_camel_case_types)] 1990 1729 struct GetTrackSvc<T: LibraryService>(pub Arc<T>); 1991 1991 - impl< 1992 1992 - T: LibraryService, 1993 1993 - > tonic::server::UnaryService<super::GetTrackRequest> 1994 1994 - for GetTrackSvc<T> { 1730 1730 + impl<T: LibraryService> tonic::server::UnaryService<super::GetTrackRequest> for GetTrackSvc<T> { 1995 1731 type Response = super::GetTrackResponse; 1996 1996 - type Future = BoxFuture< 1997 1997 - tonic::Response<Self::Response>, 1998 1998 - tonic::Status, 1999 1999 - >; 1732 1732 + type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 2000 1733 fn call( 2001 1734 &mut self, 2002 1735 request: tonic::Request<super::GetTrackRequest>, ··· 2033 1766 "/rockbox.v1alpha1.LibraryService/LikeTrack" => { 2034 1767 #[allow(non_camel_case_types)] 2035 1768 struct LikeTrackSvc<T: LibraryService>(pub Arc<T>); 2036 2036 - impl< 2037 2037 - T: LibraryService, 2038 2038 - > tonic::server::UnaryService<super::LikeTrackRequest> 2039 2039 - for LikeTrackSvc<T> { 1769 1769 + impl<T: LibraryService> tonic::server::UnaryService<super::LikeTrackRequest> for LikeTrackSvc<T> { 2040 1770 type Response = super::LikeTrackResponse; 2041 2041 - type Future = BoxFuture< 2042 2042 - tonic::Response<Self::Response>, 2043 2043 - tonic::Status, 2044 2044 - >; 1771 1771 + type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 2045 1772 fn call( 2046 1773 &mut self, 2047 1774 request: tonic::Request<super::LikeTrackRequest>, ··· 2078 1805 "/rockbox.v1alpha1.LibraryService/UnlikeTrack" => { 2079 1806 #[allow(non_camel_case_types)] 2080 1807 struct UnlikeTrackSvc<T: LibraryService>(pub Arc<T>); 2081 2081 - impl< 2082 2082 - T: LibraryService, 2083 2083 - > tonic::server::UnaryService<super::UnlikeTrackRequest> 2084 2084 - for UnlikeTrackSvc<T> { 1808 1808 + impl<T: LibraryService> tonic::server::UnaryService<super::UnlikeTrackRequest> 1809 1809 + for UnlikeTrackSvc<T> 1810 1810 + { 2085 1811 type Response = super::UnlikeTrackResponse; 2086 2086 - type Future = BoxFuture< 2087 2087 - tonic::Response<Self::Response>, 2088 2088 - tonic::Status, 2089 2089 - >; 1812 1812 + type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 2090 1813 fn call( 2091 1814 &mut self, 2092 1815 request: tonic::Request<super::UnlikeTrackRequest>, ··· 2123 1846 "/rockbox.v1alpha1.LibraryService/LikeAlbum" => { 2124 1847 #[allow(non_camel_case_types)] 2125 1848 struct LikeAlbumSvc<T: LibraryService>(pub Arc<T>); 2126 2126 - impl< 2127 2127 - T: LibraryService, 2128 2128 - > tonic::server::UnaryService<super::LikeAlbumRequest> 2129 2129 - for LikeAlbumSvc<T> { 1849 1849 + impl<T: LibraryService> tonic::server::UnaryService<super::LikeAlbumRequest> for LikeAlbumSvc<T> { 2130 1850 type Response = super::LikeAlbumResponse; 2131 2131 - type Future = BoxFuture< 2132 2132 - tonic::Response<Self::Response>, 2133 2133 - tonic::Status, 2134 2134 - >; 1851 1851 + type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 2135 1852 fn call( 2136 1853 &mut self, 2137 1854 request: tonic::Request<super::LikeAlbumRequest>, ··· 2168 1885 "/rockbox.v1alpha1.LibraryService/UnlikeAlbum" => { 2169 1886 #[allow(non_camel_case_types)] 2170 1887 struct UnlikeAlbumSvc<T: LibraryService>(pub Arc<T>); 2171 2171 - impl< 2172 2172 - T: LibraryService, 2173 2173 - > tonic::server::UnaryService<super::UnlikeAlbumRequest> 2174 2174 - for UnlikeAlbumSvc<T> { 1888 1888 + impl<T: LibraryService> tonic::server::UnaryService<super::UnlikeAlbumRequest> 1889 1889 + for UnlikeAlbumSvc<T> 1890 1890 + { 2175 1891 type Response = super::UnlikeAlbumResponse; 2176 2176 - type Future = BoxFuture< 2177 2177 - tonic::Response<Self::Response>, 2178 2178 - tonic::Status, 2179 2179 - >; 1892 1892 + type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 2180 1893 fn call( 2181 1894 &mut self, 2182 1895 request: tonic::Request<super::UnlikeAlbumRequest>, ··· 2213 1926 "/rockbox.v1alpha1.LibraryService/GetLikedTracks" => { 2214 1927 #[allow(non_camel_case_types)] 2215 1928 struct GetLikedTracksSvc<T: LibraryService>(pub Arc<T>); 2216 2216 - impl< 2217 2217 - T: LibraryService, 2218 2218 - > tonic::server::UnaryService<super::GetLikedTracksRequest> 2219 2219 - for GetLikedTracksSvc<T> { 1929 1929 + impl<T: LibraryService> 1930 1930 + tonic::server::UnaryService<super::GetLikedTracksRequest> 1931 1931 + for GetLikedTracksSvc<T> 1932 1932 + { 2220 1933 type Response = super::GetLikedTracksResponse; 2221 2221 - type Future = BoxFuture< 2222 2222 - tonic::Response<Self::Response>, 2223 2223 - tonic::Status, 2224 2224 - >; 1934 1934 + type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 2225 1935 fn call( 2226 1936 &mut self, 2227 1937 request: tonic::Request<super::GetLikedTracksRequest>, 2228 1938 ) -> Self::Future { 2229 1939 let inner = Arc::clone(&self.0); 2230 1940 let fut = async move { 2231 2231 - <T as LibraryService>::get_liked_tracks(&inner, request) 2232 2232 - .await 1941 1941 + <T as LibraryService>::get_liked_tracks(&inner, request).await 2233 1942 }; 2234 1943 Box::pin(fut) 2235 1944 } ··· 2259 1968 "/rockbox.v1alpha1.LibraryService/GetLikedAlbums" => { 2260 1969 #[allow(non_camel_case_types)] 2261 1970 struct GetLikedAlbumsSvc<T: LibraryService>(pub Arc<T>); 2262 2262 - impl< 2263 2263 - T: LibraryService, 2264 2264 - > tonic::server::UnaryService<super::GetLikedAlbumsRequest> 2265 2265 - for GetLikedAlbumsSvc<T> { 1971 1971 + impl<T: LibraryService> 1972 1972 + tonic::server::UnaryService<super::GetLikedAlbumsRequest> 1973 1973 + for GetLikedAlbumsSvc<T> 1974 1974 + { 2266 1975 type Response = super::GetLikedAlbumsResponse; 2267 2267 - type Future = BoxFuture< 2268 2268 - tonic::Response<Self::Response>, 2269 2269 - tonic::Status, 2270 2270 - >; 1976 1976 + type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 2271 1977 fn call( 2272 1978 &mut self, 2273 1979 request: tonic::Request<super::GetLikedAlbumsRequest>, 2274 1980 ) -> Self::Future { 2275 1981 let inner = Arc::clone(&self.0); 2276 1982 let fut = async move { 2277 2277 - <T as LibraryService>::get_liked_albums(&inner, request) 2278 2278 - .await 1983 1983 + <T as LibraryService>::get_liked_albums(&inner, request).await 2279 1984 }; 2280 1985 Box::pin(fut) 2281 1986 } ··· 2305 2010 "/rockbox.v1alpha1.LibraryService/ScanLibrary" => { 2306 2011 #[allow(non_camel_case_types)] 2307 2012 struct ScanLibrarySvc<T: LibraryService>(pub Arc<T>); 2308 2308 - impl< 2309 2309 - T: LibraryService, 2310 2310 - > tonic::server::UnaryService<super::ScanLibraryRequest> 2311 2311 - for ScanLibrarySvc<T> { 2013 2013 + impl<T: LibraryService> tonic::server::UnaryService<super::ScanLibraryRequest> 2014 2014 + for ScanLibrarySvc<T> 2015 2015 + { 2312 2016 type Response = super::ScanLibraryResponse; 2313 2313 - type Future = BoxFuture< 2314 2314 - tonic::Response<Self::Response>, 2315 2315 - tonic::Status, 2316 2316 - >; 2017 2017 + type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 2317 2018 fn call( 2318 2019 &mut self, 2319 2020 request: tonic::Request<super::ScanLibraryRequest>, ··· 2350 2051 "/rockbox.v1alpha1.LibraryService/Search" => { 2351 2052 #[allow(non_camel_case_types)] 2352 2053 struct SearchSvc<T: LibraryService>(pub Arc<T>); 2353 2353 - impl< 2354 2354 - T: LibraryService, 2355 2355 - > tonic::server::UnaryService<super::SearchRequest> 2356 2356 - for SearchSvc<T> { 2054 2054 + impl<T: LibraryService> tonic::server::UnaryService<super::SearchRequest> for SearchSvc<T> { 2357 2055 type Response = super::SearchResponse; 2358 2358 - type Future = BoxFuture< 2359 2359 - tonic::Response<Self::Response>, 2360 2360 - tonic::Status, 2361 2361 - >; 2056 2056 + type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 2362 2057 fn call( 2363 2058 &mut self, 2364 2059 request: tonic::Request<super::SearchRequest>, 2365 2060 ) -> Self::Future { 2366 2061 let inner = Arc::clone(&self.0); 2367 2367 - let fut = async move { 2368 2368 - <T as LibraryService>::search(&inner, request).await 2369 2369 - }; 2062 2062 + let fut = 2063 2063 + async move { <T as LibraryService>::search(&inner, request).await }; 2370 2064 Box::pin(fut) 2371 2065 } 2372 2066 } ··· 2392 2086 }; 2393 2087 Box::pin(fut) 2394 2088 } 2395 2395 - _ => { 2396 2396 - Box::pin(async move { 2397 2397 - let mut response = http::Response::new(empty_body()); 2398 2398 - let headers = response.headers_mut(); 2399 2399 - headers 2400 2400 - .insert( 2401 2401 - tonic::Status::GRPC_STATUS, 2402 2402 - (tonic::Code::Unimplemented as i32).into(), 2403 2403 - ); 2404 2404 - headers 2405 2405 - .insert( 2406 2406 - http::header::CONTENT_TYPE, 2407 2407 - tonic::metadata::GRPC_CONTENT_TYPE, 2408 2408 - ); 2409 2409 - Ok(response) 2410 2410 - }) 2411 2411 - } 2089 2089 + _ => Box::pin(async move { 2090 2090 + let mut response = http::Response::new(empty_body()); 2091 2091 + let headers = response.headers_mut(); 2092 2092 + headers.insert( 2093 2093 + tonic::Status::GRPC_STATUS, 2094 2094 + (tonic::Code::Unimplemented as i32).into(), 2095 2095 + ); 2096 2096 + headers.insert( 2097 2097 + http::header::CONTENT_TYPE, 2098 2098 + tonic::metadata::GRPC_CONTENT_TYPE, 2099 2099 + ); 2100 2100 + Ok(response) 2101 2101 + }), 2412 2102 } 2413 2103 } 2414 2104 } ··· 2437 2127 dead_code, 2438 2128 missing_docs, 2439 2129 clippy::wildcard_imports, 2440 2440 - clippy::let_unit_value, 2130 2130 + clippy::let_unit_value 2441 2131 )] 2132 2132 + use tonic::codegen::http::Uri; 2442 2133 use tonic::codegen::*; 2443 2443 - use tonic::codegen::http::Uri; 2444 2134 #[derive(Debug, Clone)] 2445 2135 pub struct MetadataServiceClient<T> { 2446 2136 inner: tonic::client::Grpc<T>, ··· 2484 2174 <T as tonic::client::GrpcService<tonic::body::BoxBody>>::ResponseBody, 2485 2175 >, 2486 2176 >, 2487 2487 - <T as tonic::codegen::Service< 2488 2488 - http::Request<tonic::body::BoxBody>, 2489 2489 - >>::Error: Into<StdError> + std::marker::Send + std::marker::Sync, 2177 2177 + <T as tonic::codegen::Service<http::Request<tonic::body::BoxBody>>>::Error: 2178 2178 + Into<StdError> + std::marker::Send + std::marker::Sync, 2490 2179 { 2491 2180 MetadataServiceClient::new(InterceptedService::new(inner, interceptor)) 2492 2181 } ··· 2530 2219 dead_code, 2531 2220 missing_docs, 2532 2221 clippy::wildcard_imports, 2533 2533 - clippy::let_unit_value, 2222 2222 + clippy::let_unit_value 2534 2223 )] 2535 2224 use tonic::codegen::*; 2536 2225 /// Generated trait containing gRPC methods that should be implemented for use with MetadataServiceServer. ··· 2557 2246 max_encoding_message_size: None, 2558 2247 } 2559 2248 } 2560 2560 - pub fn with_interceptor<F>( 2561 2561 - inner: T, 2562 2562 - interceptor: F, 2563 2563 - ) -> InterceptedService<Self, F> 2249 2249 + pub fn with_interceptor<F>(inner: T, interceptor: F) -> InterceptedService<Self, F> 2564 2250 where 2565 2251 F: tonic::service::Interceptor, 2566 2252 { ··· 2612 2298 } 2613 2299 fn call(&mut self, req: http::Request<B>) -> Self::Future { 2614 2300 match req.uri().path() { 2615 2615 - _ => { 2616 2616 - Box::pin(async move { 2617 2617 - let mut response = http::Response::new(empty_body()); 2618 2618 - let headers = response.headers_mut(); 2619 2619 - headers 2620 2620 - .insert( 2621 2621 - tonic::Status::GRPC_STATUS, 2622 2622 - (tonic::Code::Unimplemented as i32).into(), 2623 2623 - ); 2624 2624 - headers 2625 2625 - .insert( 2626 2626 - http::header::CONTENT_TYPE, 2627 2627 - tonic::metadata::GRPC_CONTENT_TYPE, 2628 2628 - ); 2629 2629 - Ok(response) 2630 2630 - }) 2631 2631 - } 2301 2301 + _ => Box::pin(async move { 2302 2302 + let mut response = http::Response::new(empty_body()); 2303 2303 + let headers = response.headers_mut(); 2304 2304 + headers.insert( 2305 2305 + tonic::Status::GRPC_STATUS, 2306 2306 + (tonic::Code::Unimplemented as i32).into(), 2307 2307 + ); 2308 2308 + headers.insert( 2309 2309 + http::header::CONTENT_TYPE, 2310 2310 + tonic::metadata::GRPC_CONTENT_TYPE, 2311 2311 + ); 2312 2312 + Ok(response) 2313 2313 + }), 2632 2314 } 2633 2315 } 2634 2316 } ··· 2912 2594 dead_code, 2913 2595 missing_docs, 2914 2596 clippy::wildcard_imports, 2915 2915 - clippy::let_unit_value, 2597 2597 + clippy::let_unit_value 2916 2598 )] 2917 2917 - use tonic::codegen::*; 2918 2599 use tonic::codegen::http::Uri; 2600 2600 + use tonic::codegen::*; 2919 2601 #[derive(Debug, Clone)] 2920 2602 pub struct PlaybackServiceClient<T> { 2921 2603 inner: tonic::client::Grpc<T>, ··· 2959 2641 <T as tonic::client::GrpcService<tonic::body::BoxBody>>::ResponseBody, 2960 2642 >, 2961 2643 >, 2962 2962 - <T as tonic::codegen::Service< 2963 2963 - http::Request<tonic::body::BoxBody>, 2964 2964 - >>::Error: Into<StdError> + std::marker::Send + std::marker::Sync, 2644 2644 + <T as tonic::codegen::Service<http::Request<tonic::body::BoxBody>>>::Error: 2645 2645 + Into<StdError> + std::marker::Send + std::marker::Sync, 2965 2646 { 2966 2647 PlaybackServiceClient::new(InterceptedService::new(inner, interceptor)) 2967 2648 } ··· 3000 2681 &mut self, 3001 2682 request: impl tonic::IntoRequest<super::PlayRequest>, 3002 2683 ) -> std::result::Result<tonic::Response<super::PlayResponse>, tonic::Status> { 3003 3003 - self.inner 3004 3004 - .ready() 3005 3005 - .await 3006 3006 - .map_err(|e| { 3007 3007 - tonic::Status::unknown( 3008 3008 - format!("Service was not ready: {}", e.into()), 3009 3009 - ) 3010 3010 - })?; 2684 2684 + self.inner.ready().await.map_err(|e| { 2685 2685 + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 2686 2686 + })?; 3011 2687 let codec = tonic::codec::ProstCodec::default(); 3012 3012 - let path = http::uri::PathAndQuery::from_static( 3013 3013 - "/rockbox.v1alpha1.PlaybackService/Play", 3014 3014 - ); 2688 2688 + let path = 2689 2689 + http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.PlaybackService/Play"); 3015 2690 let mut req = request.into_request(); 3016 2691 req.extensions_mut() 3017 2692 .insert(GrpcMethod::new("rockbox.v1alpha1.PlaybackService", "Play")); ··· 3021 2696 &mut self, 3022 2697 request: impl tonic::IntoRequest<super::PauseRequest>, 3023 2698 ) -> std::result::Result<tonic::Response<super::PauseResponse>, tonic::Status> { 3024 3024 - self.inner 3025 3025 - .ready() 3026 3026 - .await 3027 3027 - .map_err(|e| { 3028 3028 - tonic::Status::unknown( 3029 3029 - format!("Service was not ready: {}", e.into()), 3030 3030 - ) 3031 3031 - })?; 2699 2699 + self.inner.ready().await.map_err(|e| { 2700 2700 + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 2701 2701 + })?; 3032 2702 let codec = tonic::codec::ProstCodec::default(); 3033 3033 - let path = http::uri::PathAndQuery::from_static( 3034 3034 - "/rockbox.v1alpha1.PlaybackService/Pause", 3035 3035 - ); 2703 2703 + let path = 2704 2704 + http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.PlaybackService/Pause"); 3036 2705 let mut req = request.into_request(); 3037 2706 req.extensions_mut() 3038 2707 .insert(GrpcMethod::new("rockbox.v1alpha1.PlaybackService", "Pause")); ··· 3041 2710 pub async fn play_or_pause( 3042 2711 &mut self, 3043 2712 request: impl tonic::IntoRequest<super::PlayOrPauseRequest>, 3044 3044 - ) -> std::result::Result< 3045 3045 - tonic::Response<super::PlayOrPauseResponse>, 3046 3046 - tonic::Status, 3047 3047 - > { 3048 3048 - self.inner 3049 3049 - .ready() 3050 3050 - .await 3051 3051 - .map_err(|e| { 3052 3052 - tonic::Status::unknown( 3053 3053 - format!("Service was not ready: {}", e.into()), 3054 3054 - ) 3055 3055 - })?; 2713 2713 + ) -> std::result::Result<tonic::Response<super::PlayOrPauseResponse>, tonic::Status> 2714 2714 + { 2715 2715 + self.inner.ready().await.map_err(|e| { 2716 2716 + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 2717 2717 + })?; 3056 2718 let codec = tonic::codec::ProstCodec::default(); 3057 2719 let path = http::uri::PathAndQuery::from_static( 3058 2720 "/rockbox.v1alpha1.PlaybackService/PlayOrPause", 3059 2721 ); 3060 2722 let mut req = request.into_request(); 3061 3061 - req.extensions_mut() 3062 3062 - .insert( 3063 3063 - GrpcMethod::new("rockbox.v1alpha1.PlaybackService", "PlayOrPause"), 3064 3064 - ); 2723 2723 + req.extensions_mut().insert(GrpcMethod::new( 2724 2724 + "rockbox.v1alpha1.PlaybackService", 2725 2725 + "PlayOrPause", 2726 2726 + )); 3065 2727 self.inner.unary(req, path, codec).await 3066 2728 } 3067 2729 pub async fn resume( 3068 2730 &mut self, 3069 2731 request: impl tonic::IntoRequest<super::ResumeRequest>, 3070 2732 ) -> std::result::Result<tonic::Response<super::ResumeResponse>, tonic::Status> { 3071 3071 - self.inner 3072 3072 - .ready() 3073 3073 - .await 3074 3074 - .map_err(|e| { 3075 3075 - tonic::Status::unknown( 3076 3076 - format!("Service was not ready: {}", e.into()), 3077 3077 - ) 3078 3078 - })?; 2733 2733 + self.inner.ready().await.map_err(|e| { 2734 2734 + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 2735 2735 + })?; 3079 2736 let codec = tonic::codec::ProstCodec::default(); 3080 3080 - let path = http::uri::PathAndQuery::from_static( 3081 3081 - "/rockbox.v1alpha1.PlaybackService/Resume", 3082 3082 - ); 2737 2737 + let path = 2738 2738 + http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.PlaybackService/Resume"); 3083 2739 let mut req = request.into_request(); 3084 3084 - req.extensions_mut() 3085 3085 - .insert(GrpcMethod::new("rockbox.v1alpha1.PlaybackService", "Resume")); 2740 2740 + req.extensions_mut().insert(GrpcMethod::new( 2741 2741 + "rockbox.v1alpha1.PlaybackService", 2742 2742 + "Resume", 2743 2743 + )); 3086 2744 self.inner.unary(req, path, codec).await 3087 2745 } 3088 2746 pub async fn next( 3089 2747 &mut self, 3090 2748 request: impl tonic::IntoRequest<super::NextRequest>, 3091 2749 ) -> std::result::Result<tonic::Response<super::NextResponse>, tonic::Status> { 3092 3092 - self.inner 3093 3093 - .ready() 3094 3094 - .await 3095 3095 - .map_err(|e| { 3096 3096 - tonic::Status::unknown( 3097 3097 - format!("Service was not ready: {}", e.into()), 3098 3098 - ) 3099 3099 - })?; 2750 2750 + self.inner.ready().await.map_err(|e| { 2751 2751 + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 2752 2752 + })?; 3100 2753 let codec = tonic::codec::ProstCodec::default(); 3101 3101 - let path = http::uri::PathAndQuery::from_static( 3102 3102 - "/rockbox.v1alpha1.PlaybackService/Next", 3103 3103 - ); 2754 2754 + let path = 2755 2755 + http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.PlaybackService/Next"); 3104 2756 let mut req = request.into_request(); 3105 2757 req.extensions_mut() 3106 2758 .insert(GrpcMethod::new("rockbox.v1alpha1.PlaybackService", "Next")); ··· 3109 2761 pub async fn previous( 3110 2762 &mut self, 3111 2763 request: impl tonic::IntoRequest<super::PreviousRequest>, 3112 3112 - ) -> std::result::Result< 3113 3113 - tonic::Response<super::PreviousResponse>, 3114 3114 - tonic::Status, 3115 3115 - > { 3116 3116 - self.inner 3117 3117 - .ready() 3118 3118 - .await 3119 3119 - .map_err(|e| { 3120 3120 - tonic::Status::unknown( 3121 3121 - format!("Service was not ready: {}", e.into()), 3122 3122 - ) 3123 3123 - })?; 2764 2764 + ) -> std::result::Result<tonic::Response<super::PreviousResponse>, tonic::Status> { 2765 2765 + self.inner.ready().await.map_err(|e| { 2766 2766 + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 2767 2767 + })?; 3124 2768 let codec = tonic::codec::ProstCodec::default(); 3125 3125 - let path = http::uri::PathAndQuery::from_static( 3126 3126 - "/rockbox.v1alpha1.PlaybackService/Previous", 3127 3127 - ); 2769 2769 + let path = 2770 2770 + http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.PlaybackService/Previous"); 3128 2771 let mut req = request.into_request(); 3129 3129 - req.extensions_mut() 3130 3130 - .insert(GrpcMethod::new("rockbox.v1alpha1.PlaybackService", "Previous")); 2772 2772 + req.extensions_mut().insert(GrpcMethod::new( 2773 2773 + "rockbox.v1alpha1.PlaybackService", 2774 2774 + "Previous", 2775 2775 + )); 3131 2776 self.inner.unary(req, path, codec).await 3132 2777 } 3133 2778 pub async fn fast_forward_rewind( 3134 2779 &mut self, 3135 2780 request: impl tonic::IntoRequest<super::FastForwardRewindRequest>, 3136 3136 - ) -> std::result::Result< 3137 3137 - tonic::Response<super::FastForwardRewindResponse>, 3138 3138 - tonic::Status, 3139 3139 - > { 3140 3140 - self.inner 3141 3141 - .ready() 3142 3142 - .await 3143 3143 - .map_err(|e| { 3144 3144 - tonic::Status::unknown( 3145 3145 - format!("Service was not ready: {}", e.into()), 3146 3146 - ) 3147 3147 - })?; 2781 2781 + ) -> std::result::Result<tonic::Response<super::FastForwardRewindResponse>, tonic::Status> 2782 2782 + { 2783 2783 + self.inner.ready().await.map_err(|e| { 2784 2784 + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 2785 2785 + })?; 3148 2786 let codec = tonic::codec::ProstCodec::default(); 3149 2787 let path = http::uri::PathAndQuery::from_static( 3150 2788 "/rockbox.v1alpha1.PlaybackService/FastForwardRewind", 3151 2789 ); 3152 2790 let mut req = request.into_request(); 3153 3153 - req.extensions_mut() 3154 3154 - .insert( 3155 3155 - GrpcMethod::new( 3156 3156 - "rockbox.v1alpha1.PlaybackService", 3157 3157 - "FastForwardRewind", 3158 3158 - ), 3159 3159 - ); 2791 2791 + req.extensions_mut().insert(GrpcMethod::new( 2792 2792 + "rockbox.v1alpha1.PlaybackService", 2793 2793 + "FastForwardRewind", 2794 2794 + )); 3160 2795 self.inner.unary(req, path, codec).await 3161 2796 } 3162 2797 pub async fn status( 3163 2798 &mut self, 3164 2799 request: impl tonic::IntoRequest<super::StatusRequest>, 3165 2800 ) -> std::result::Result<tonic::Response<super::StatusResponse>, tonic::Status> { 3166 3166 - self.inner 3167 3167 - .ready() 3168 3168 - .await 3169 3169 - .map_err(|e| { 3170 3170 - tonic::Status::unknown( 3171 3171 - format!("Service was not ready: {}", e.into()), 3172 3172 - ) 3173 3173 - })?; 2801 2801 + self.inner.ready().await.map_err(|e| { 2802 2802 + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 2803 2803 + })?; 3174 2804 let codec = tonic::codec::ProstCodec::default(); 3175 3175 - let path = http::uri::PathAndQuery::from_static( 3176 3176 - "/rockbox.v1alpha1.PlaybackService/Status", 3177 3177 - ); 2805 2805 + let path = 2806 2806 + http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.PlaybackService/Status"); 3178 2807 let mut req = request.into_request(); 3179 3179 - req.extensions_mut() 3180 3180 - .insert(GrpcMethod::new("rockbox.v1alpha1.PlaybackService", "Status")); 2808 2808 + req.extensions_mut().insert(GrpcMethod::new( 2809 2809 + "rockbox.v1alpha1.PlaybackService", 2810 2810 + "Status", 2811 2811 + )); 3181 2812 self.inner.unary(req, path, codec).await 3182 2813 } 3183 2814 pub async fn current_track( 3184 2815 &mut self, 3185 2816 request: impl tonic::IntoRequest<super::CurrentTrackRequest>, 3186 3186 - ) -> std::result::Result< 3187 3187 - tonic::Response<super::CurrentTrackResponse>, 3188 3188 - tonic::Status, 3189 3189 - > { 3190 3190 - self.inner 3191 3191 - .ready() 3192 3192 - .await 3193 3193 - .map_err(|e| { 3194 3194 - tonic::Status::unknown( 3195 3195 - format!("Service was not ready: {}", e.into()), 3196 3196 - ) 3197 3197 - })?; 2817 2817 + ) -> std::result::Result<tonic::Response<super::CurrentTrackResponse>, tonic::Status> 2818 2818 + { 2819 2819 + self.inner.ready().await.map_err(|e| { 2820 2820 + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 2821 2821 + })?; 3198 2822 let codec = tonic::codec::ProstCodec::default(); 3199 2823 let path = http::uri::PathAndQuery::from_static( 3200 2824 "/rockbox.v1alpha1.PlaybackService/CurrentTrack", 3201 2825 ); 3202 2826 let mut req = request.into_request(); 3203 3203 - req.extensions_mut() 3204 3204 - .insert( 3205 3205 - GrpcMethod::new("rockbox.v1alpha1.PlaybackService", "CurrentTrack"), 3206 3206 - ); 2827 2827 + req.extensions_mut().insert(GrpcMethod::new( 2828 2828 + "rockbox.v1alpha1.PlaybackService", 2829 2829 + "CurrentTrack", 2830 2830 + )); 3207 2831 self.inner.unary(req, path, codec).await 3208 2832 } 3209 2833 pub async fn next_track( 3210 2834 &mut self, 3211 2835 request: impl tonic::IntoRequest<super::NextTrackRequest>, 3212 3212 - ) -> std::result::Result< 3213 3213 - tonic::Response<super::NextTrackResponse>, 3214 3214 - tonic::Status, 3215 3215 - > { 3216 3216 - self.inner 3217 3217 - .ready() 3218 3218 - .await 3219 3219 - .map_err(|e| { 3220 3220 - tonic::Status::unknown( 3221 3221 - format!("Service was not ready: {}", e.into()), 3222 3222 - ) 3223 3223 - })?; 2836 2836 + ) -> std::result::Result<tonic::Response<super::NextTrackResponse>, tonic::Status> { 2837 2837 + self.inner.ready().await.map_err(|e| { 2838 2838 + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 2839 2839 + })?; 3224 2840 let codec = tonic::codec::ProstCodec::default(); 3225 3225 - let path = http::uri::PathAndQuery::from_static( 3226 3226 - "/rockbox.v1alpha1.PlaybackService/NextTrack", 3227 3227 - ); 2841 2841 + let path = 2842 2842 + http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.PlaybackService/NextTrack"); 3228 2843 let mut req = request.into_request(); 3229 3229 - req.extensions_mut() 3230 3230 - .insert( 3231 3231 - GrpcMethod::new("rockbox.v1alpha1.PlaybackService", "NextTrack"), 3232 3232 - ); 2844 2844 + req.extensions_mut().insert(GrpcMethod::new( 2845 2845 + "rockbox.v1alpha1.PlaybackService", 2846 2846 + "NextTrack", 2847 2847 + )); 3233 2848 self.inner.unary(req, path, codec).await 3234 2849 } 3235 2850 pub async fn flush_and_reload_tracks( 3236 2851 &mut self, 3237 2852 request: impl tonic::IntoRequest<super::FlushAndReloadTracksRequest>, 3238 3238 - ) -> std::result::Result< 3239 3239 - tonic::Response<super::FlushAndReloadTracksResponse>, 3240 3240 - tonic::Status, 3241 3241 - > { 3242 3242 - self.inner 3243 3243 - .ready() 3244 3244 - .await 3245 3245 - .map_err(|e| { 3246 3246 - tonic::Status::unknown( 3247 3247 - format!("Service was not ready: {}", e.into()), 3248 3248 - ) 3249 3249 - })?; 2853 2853 + ) -> std::result::Result<tonic::Response<super::FlushAndReloadTracksResponse>, tonic::Status> 2854 2854 + { 2855 2855 + self.inner.ready().await.map_err(|e| { 2856 2856 + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 2857 2857 + })?; 3250 2858 let codec = tonic::codec::ProstCodec::default(); 3251 2859 let path = http::uri::PathAndQuery::from_static( 3252 2860 "/rockbox.v1alpha1.PlaybackService/FlushAndReloadTracks", 3253 2861 ); 3254 2862 let mut req = request.into_request(); 3255 3255 - req.extensions_mut() 3256 3256 - .insert( 3257 3257 - GrpcMethod::new( 3258 3258 - "rockbox.v1alpha1.PlaybackService", 3259 3259 - "FlushAndReloadTracks", 3260 3260 - ), 3261 3261 - ); 2863 2863 + req.extensions_mut().insert(GrpcMethod::new( 2864 2864 + "rockbox.v1alpha1.PlaybackService", 2865 2865 + "FlushAndReloadTracks", 2866 2866 + )); 3262 2867 self.inner.unary(req, path, codec).await 3263 2868 } 3264 2869 pub async fn get_file_position( 3265 2870 &mut self, 3266 2871 request: impl tonic::IntoRequest<super::GetFilePositionRequest>, 3267 3267 - ) -> std::result::Result< 3268 3268 - tonic::Response<super::GetFilePositionResponse>, 3269 3269 - tonic::Status, 3270 3270 - > { 3271 3271 - self.inner 3272 3272 - .ready() 3273 3273 - .await 3274 3274 - .map_err(|e| { 3275 3275 - tonic::Status::unknown( 3276 3276 - format!("Service was not ready: {}", e.into()), 3277 3277 - ) 3278 3278 - })?; 2872 2872 + ) -> std::result::Result<tonic::Response<super::GetFilePositionResponse>, tonic::Status> 2873 2873 + { 2874 2874 + self.inner.ready().await.map_err(|e| { 2875 2875 + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 2876 2876 + })?; 3279 2877 let codec = tonic::codec::ProstCodec::default(); 3280 2878 let path = http::uri::PathAndQuery::from_static( 3281 2879 "/rockbox.v1alpha1.PlaybackService/GetFilePosition", 3282 2880 ); 3283 2881 let mut req = request.into_request(); 3284 3284 - req.extensions_mut() 3285 3285 - .insert( 3286 3286 - GrpcMethod::new( 3287 3287 - "rockbox.v1alpha1.PlaybackService", 3288 3288 - "GetFilePosition", 3289 3289 - ), 3290 3290 - ); 2882 2882 + req.extensions_mut().insert(GrpcMethod::new( 2883 2883 + "rockbox.v1alpha1.PlaybackService", 2884 2884 + "GetFilePosition", 2885 2885 + )); 3291 2886 self.inner.unary(req, path, codec).await 3292 2887 } 3293 2888 pub async fn hard_stop( 3294 2889 &mut self, 3295 2890 request: impl tonic::IntoRequest<super::HardStopRequest>, 3296 3296 - ) -> std::result::Result< 3297 3297 - tonic::Response<super::HardStopResponse>, 3298 3298 - tonic::Status, 3299 3299 - > { 3300 3300 - self.inner 3301 3301 - .ready() 3302 3302 - .await 3303 3303 - .map_err(|e| { 3304 3304 - tonic::Status::unknown( 3305 3305 - format!("Service was not ready: {}", e.into()), 3306 3306 - ) 3307 3307 - })?; 2891 2891 + ) -> std::result::Result<tonic::Response<super::HardStopResponse>, tonic::Status> { 2892 2892 + self.inner.ready().await.map_err(|e| { 2893 2893 + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 2894 2894 + })?; 3308 2895 let codec = tonic::codec::ProstCodec::default(); 3309 3309 - let path = http::uri::PathAndQuery::from_static( 3310 3310 - "/rockbox.v1alpha1.PlaybackService/HardStop", 3311 3311 - ); 2896 2896 + let path = 2897 2897 + http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.PlaybackService/HardStop"); 3312 2898 let mut req = request.into_request(); 3313 3313 - req.extensions_mut() 3314 3314 - .insert(GrpcMethod::new("rockbox.v1alpha1.PlaybackService", "HardStop")); 2899 2899 + req.extensions_mut().insert(GrpcMethod::new( 2900 2900 + "rockbox.v1alpha1.PlaybackService", 2901 2901 + "HardStop", 2902 2902 + )); 3315 2903 self.inner.unary(req, path, codec).await 3316 2904 } 3317 2905 pub async fn play_album( 3318 2906 &mut self, 3319 2907 request: impl tonic::IntoRequest<super::PlayAlbumRequest>, 3320 3320 - ) -> std::result::Result< 3321 3321 - tonic::Response<super::PlayAlbumResponse>, 3322 3322 - tonic::Status, 3323 3323 - > { 3324 3324 - self.inner 3325 3325 - .ready() 3326 3326 - .await 3327 3327 - .map_err(|e| { 3328 3328 - tonic::Status::unknown( 3329 3329 - format!("Service was not ready: {}", e.into()), 3330 3330 - ) 3331 3331 - })?; 2908 2908 + ) -> std::result::Result<tonic::Response<super::PlayAlbumResponse>, tonic::Status> { 2909 2909 + self.inner.ready().await.map_err(|e| { 2910 2910 + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 2911 2911 + })?; 3332 2912 let codec = tonic::codec::ProstCodec::default(); 3333 3333 - let path = http::uri::PathAndQuery::from_static( 3334 3334 - "/rockbox.v1alpha1.PlaybackService/PlayAlbum", 3335 3335 - ); 2913 2913 + let path = 2914 2914 + http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.PlaybackService/PlayAlbum"); 3336 2915 let mut req = request.into_request(); 3337 3337 - req.extensions_mut() 3338 3338 - .insert( 3339 3339 - GrpcMethod::new("rockbox.v1alpha1.PlaybackService", "PlayAlbum"), 3340 3340 - ); 2916 2916 + req.extensions_mut().insert(GrpcMethod::new( 2917 2917 + "rockbox.v1alpha1.PlaybackService", 2918 2918 + "PlayAlbum", 2919 2919 + )); 3341 2920 self.inner.unary(req, path, codec).await 3342 2921 } 3343 2922 pub async fn play_artist_tracks( 3344 2923 &mut self, 3345 2924 request: impl tonic::IntoRequest<super::PlayArtistTracksRequest>, 3346 3346 - ) -> std::result::Result< 3347 3347 - tonic::Response<super::PlayArtistTracksResponse>, 3348 3348 - tonic::Status, 3349 3349 - > { 3350 3350 - self.inner 3351 3351 - .ready() 3352 3352 - .await 3353 3353 - .map_err(|e| { 3354 3354 - tonic::Status::unknown( 3355 3355 - format!("Service was not ready: {}", e.into()), 3356 3356 - ) 3357 3357 - })?; 2925 2925 + ) -> std::result::Result<tonic::Response<super::PlayArtistTracksResponse>, tonic::Status> 2926 2926 + { 2927 2927 + self.inner.ready().await.map_err(|e| { 2928 2928 + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 2929 2929 + })?; 3358 2930 let codec = tonic::codec::ProstCodec::default(); 3359 2931 let path = http::uri::PathAndQuery::from_static( 3360 2932 "/rockbox.v1alpha1.PlaybackService/PlayArtistTracks", 3361 2933 ); 3362 2934 let mut req = request.into_request(); 3363 3363 - req.extensions_mut() 3364 3364 - .insert( 3365 3365 - GrpcMethod::new( 3366 3366 - "rockbox.v1alpha1.PlaybackService", 3367 3367 - "PlayArtistTracks", 3368 3368 - ), 3369 3369 - ); 2935 2935 + req.extensions_mut().insert(GrpcMethod::new( 2936 2936 + "rockbox.v1alpha1.PlaybackService", 2937 2937 + "PlayArtistTracks", 2938 2938 + )); 3370 2939 self.inner.unary(req, path, codec).await 3371 2940 } 3372 2941 pub async fn play_playlist( 3373 2942 &mut self, 3374 2943 request: impl tonic::IntoRequest<super::PlayPlaylistRequest>, 3375 3375 - ) -> std::result::Result< 3376 3376 - tonic::Response<super::PlayPlaylistResponse>, 3377 3377 - tonic::Status, 3378 3378 - > { 3379 3379 - self.inner 3380 3380 - .ready() 3381 3381 - .await 3382 3382 - .map_err(|e| { 3383 3383 - tonic::Status::unknown( 3384 3384 - format!("Service was not ready: {}", e.into()), 3385 3385 - ) 3386 3386 - })?; 2944 2944 + ) -> std::result::Result<tonic::Response<super::PlayPlaylistResponse>, tonic::Status> 2945 2945 + { 2946 2946 + self.inner.ready().await.map_err(|e| { 2947 2947 + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 2948 2948 + })?; 3387 2949 let codec = tonic::codec::ProstCodec::default(); 3388 2950 let path = http::uri::PathAndQuery::from_static( 3389 2951 "/rockbox.v1alpha1.PlaybackService/PlayPlaylist", 3390 2952 ); 3391 2953 let mut req = request.into_request(); 3392 3392 - req.extensions_mut() 3393 3393 - .insert( 3394 3394 - GrpcMethod::new("rockbox.v1alpha1.PlaybackService", "PlayPlaylist"), 3395 3395 - ); 2954 2954 + req.extensions_mut().insert(GrpcMethod::new( 2955 2955 + "rockbox.v1alpha1.PlaybackService", 2956 2956 + "PlayPlaylist", 2957 2957 + )); 3396 2958 self.inner.unary(req, path, codec).await 3397 2959 } 3398 2960 pub async fn play_directory( 3399 2961 &mut self, 3400 2962 request: impl tonic::IntoRequest<super::PlayDirectoryRequest>, 3401 3401 - ) -> std::result::Result< 3402 3402 - tonic::Response<super::PlayDirectoryResponse>, 3403 3403 - tonic::Status, 3404 3404 - > { 3405 3405 - self.inner 3406 3406 - .ready() 3407 3407 - .await 3408 3408 - .map_err(|e| { 3409 3409 - tonic::Status::unknown( 3410 3410 - format!("Service was not ready: {}", e.into()), 3411 3411 - ) 3412 3412 - })?; 2963 2963 + ) -> std::result::Result<tonic::Response<super::PlayDirectoryResponse>, tonic::Status> 2964 2964 + { 2965 2965 + self.inner.ready().await.map_err(|e| { 2966 2966 + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 2967 2967 + })?; 3413 2968 let codec = tonic::codec::ProstCodec::default(); 3414 2969 let path = http::uri::PathAndQuery::from_static( 3415 2970 "/rockbox.v1alpha1.PlaybackService/PlayDirectory", 3416 2971 ); 3417 2972 let mut req = request.into_request(); 3418 3418 - req.extensions_mut() 3419 3419 - .insert( 3420 3420 - GrpcMethod::new("rockbox.v1alpha1.PlaybackService", "PlayDirectory"), 3421 3421 - ); 2973 2973 + req.extensions_mut().insert(GrpcMethod::new( 2974 2974 + "rockbox.v1alpha1.PlaybackService", 2975 2975 + "PlayDirectory", 2976 2976 + )); 3422 2977 self.inner.unary(req, path, codec).await 3423 2978 } 3424 2979 pub async fn play_music_directory( 3425 2980 &mut self, 3426 2981 request: impl tonic::IntoRequest<super::PlayMusicDirectoryRequest>, 3427 3427 - ) -> std::result::Result< 3428 3428 - tonic::Response<super::PlayMusicDirectoryResponse>, 3429 3429 - tonic::Status, 3430 3430 - > { 3431 3431 - self.inner 3432 3432 - .ready() 3433 3433 - .await 3434 3434 - .map_err(|e| { 3435 3435 - tonic::Status::unknown( 3436 3436 - format!("Service was not ready: {}", e.into()), 3437 3437 - ) 3438 3438 - })?; 2982 2982 + ) -> std::result::Result<tonic::Response<super::PlayMusicDirectoryResponse>, tonic::Status> 2983 2983 + { 2984 2984 + self.inner.ready().await.map_err(|e| { 2985 2985 + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 2986 2986 + })?; 3439 2987 let codec = tonic::codec::ProstCodec::default(); 3440 2988 let path = http::uri::PathAndQuery::from_static( 3441 2989 "/rockbox.v1alpha1.PlaybackService/PlayMusicDirectory", 3442 2990 ); 3443 2991 let mut req = request.into_request(); 3444 3444 - req.extensions_mut() 3445 3445 - .insert( 3446 3446 - GrpcMethod::new( 3447 3447 - "rockbox.v1alpha1.PlaybackService", 3448 3448 - "PlayMusicDirectory", 3449 3449 - ), 3450 3450 - ); 2992 2992 + req.extensions_mut().insert(GrpcMethod::new( 2993 2993 + "rockbox.v1alpha1.PlaybackService", 2994 2994 + "PlayMusicDirectory", 2995 2995 + )); 3451 2996 self.inner.unary(req, path, codec).await 3452 2997 } 3453 2998 pub async fn play_track( 3454 2999 &mut self, 3455 3000 request: impl tonic::IntoRequest<super::PlayTrackRequest>, 3456 3456 - ) -> std::result::Result< 3457 3457 - tonic::Response<super::PlayTrackResponse>, 3458 3458 - tonic::Status, 3459 3459 - > { 3460 3460 - self.inner 3461 3461 - .ready() 3462 3462 - .await 3463 3463 - .map_err(|e| { 3464 3464 - tonic::Status::unknown( 3465 3465 - format!("Service was not ready: {}", e.into()), 3466 3466 - ) 3467 3467 - })?; 3001 3001 + ) -> std::result::Result<tonic::Response<super::PlayTrackResponse>, tonic::Status> { 3002 3002 + self.inner.ready().await.map_err(|e| { 3003 3003 + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 3004 3004 + })?; 3468 3005 let codec = tonic::codec::ProstCodec::default(); 3469 3469 - let path = http::uri::PathAndQuery::from_static( 3470 3470 - "/rockbox.v1alpha1.PlaybackService/PlayTrack", 3471 3471 - ); 3006 3006 + let path = 3007 3007 + http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.PlaybackService/PlayTrack"); 3472 3008 let mut req = request.into_request(); 3473 3473 - req.extensions_mut() 3474 3474 - .insert( 3475 3475 - GrpcMethod::new("rockbox.v1alpha1.PlaybackService", "PlayTrack"), 3476 3476 - ); 3009 3009 + req.extensions_mut().insert(GrpcMethod::new( 3010 3010 + "rockbox.v1alpha1.PlaybackService", 3011 3011 + "PlayTrack", 3012 3012 + )); 3477 3013 self.inner.unary(req, path, codec).await 3478 3014 } 3479 3015 pub async fn play_liked_tracks( 3480 3016 &mut self, 3481 3017 request: impl tonic::IntoRequest<super::PlayLikedTracksRequest>, 3482 3482 - ) -> std::result::Result< 3483 3483 - tonic::Response<super::PlayLikedTracksResponse>, 3484 3484 - tonic::Status, 3485 3485 - > { 3486 3486 - self.inner 3487 3487 - .ready() 3488 3488 - .await 3489 3489 - .map_err(|e| { 3490 3490 - tonic::Status::unknown( 3491 3491 - format!("Service was not ready: {}", e.into()), 3492 3492 - ) 3493 3493 - })?; 3018 3018 + ) -> std::result::Result<tonic::Response<super::PlayLikedTracksResponse>, tonic::Status> 3019 3019 + { 3020 3020 + self.inner.ready().await.map_err(|e| { 3021 3021 + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 3022 3022 + })?; 3494 3023 let codec = tonic::codec::ProstCodec::default(); 3495 3024 let path = http::uri::PathAndQuery::from_static( 3496 3025 "/rockbox.v1alpha1.PlaybackService/PlayLikedTracks", 3497 3026 ); 3498 3027 let mut req = request.into_request(); 3499 3499 - req.extensions_mut() 3500 3500 - .insert( 3501 3501 - GrpcMethod::new( 3502 3502 - "rockbox.v1alpha1.PlaybackService", 3503 3503 - "PlayLikedTracks", 3504 3504 - ), 3505 3505 - ); 3028 3028 + req.extensions_mut().insert(GrpcMethod::new( 3029 3029 + "rockbox.v1alpha1.PlaybackService", 3030 3030 + "PlayLikedTracks", 3031 3031 + )); 3506 3032 self.inner.unary(req, path, codec).await 3507 3033 } 3508 3034 pub async fn play_all_tracks( 3509 3035 &mut self, 3510 3036 request: impl tonic::IntoRequest<super::PlayAllTracksRequest>, 3511 3511 - ) -> std::result::Result< 3512 3512 - tonic::Response<super::PlayAllTracksResponse>, 3513 3513 - tonic::Status, 3514 3514 - > { 3515 3515 - self.inner 3516 3516 - .ready() 3517 3517 - .await 3518 3518 - .map_err(|e| { 3519 3519 - tonic::Status::unknown( 3520 3520 - format!("Service was not ready: {}", e.into()), 3521 3521 - ) 3522 3522 - })?; 3037 3037 + ) -> std::result::Result<tonic::Response<super::PlayAllTracksResponse>, tonic::Status> 3038 3038 + { 3039 3039 + self.inner.ready().await.map_err(|e| { 3040 3040 + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 3041 3041 + })?; 3523 3042 let codec = tonic::codec::ProstCodec::default(); 3524 3043 let path = http::uri::PathAndQuery::from_static( 3525 3044 "/rockbox.v1alpha1.PlaybackService/PlayAllTracks", 3526 3045 ); 3527 3046 let mut req = request.into_request(); 3528 3528 - req.extensions_mut() 3529 3529 - .insert( 3530 3530 - GrpcMethod::new("rockbox.v1alpha1.PlaybackService", "PlayAllTracks"), 3531 3531 - ); 3047 3047 + req.extensions_mut().insert(GrpcMethod::new( 3048 3048 + "rockbox.v1alpha1.PlaybackService", 3049 3049 + "PlayAllTracks", 3050 3050 + )); 3532 3051 self.inner.unary(req, path, codec).await 3533 3052 } 3534 3053 pub async fn stream_current_track( ··· 3538 3057 tonic::Response<tonic::codec::Streaming<super::CurrentTrackResponse>>, 3539 3058 tonic::Status, 3540 3059 > { 3541 3541 - self.inner 3542 3542 - .ready() 3543 3543 - .await 3544 3544 - .map_err(|e| { 3545 3545 - tonic::Status::unknown( 3546 3546 - format!("Service was not ready: {}", e.into()), 3547 3547 - ) 3548 3548 - })?; 3060 3060 + self.inner.ready().await.map_err(|e| { 3061 3061 + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 3062 3062 + })?; 3549 3063 let codec = tonic::codec::ProstCodec::default(); 3550 3064 let path = http::uri::PathAndQuery::from_static( 3551 3065 "/rockbox.v1alpha1.PlaybackService/StreamCurrentTrack", 3552 3066 ); 3553 3067 let mut req = request.into_request(); 3554 3554 - req.extensions_mut() 3555 3555 - .insert( 3556 3556 - GrpcMethod::new( 3557 3557 - "rockbox.v1alpha1.PlaybackService", 3558 3558 - "StreamCurrentTrack", 3559 3559 - ), 3560 3560 - ); 3068 3068 + req.extensions_mut().insert(GrpcMethod::new( 3069 3069 + "rockbox.v1alpha1.PlaybackService", 3070 3070 + "StreamCurrentTrack", 3071 3071 + )); 3561 3072 self.inner.server_streaming(req, path, codec).await 3562 3073 } 3563 3074 pub async fn stream_status( ··· 3567 3078 tonic::Response<tonic::codec::Streaming<super::StatusResponse>>, 3568 3079 tonic::Status, 3569 3080 > { 3570 3570 - self.inner 3571 3571 - .ready() 3572 3572 - .await 3573 3573 - .map_err(|e| { 3574 3574 - tonic::Status::unknown( 3575 3575 - format!("Service was not ready: {}", e.into()), 3576 3576 - ) 3577 3577 - })?; 3081 3081 + self.inner.ready().await.map_err(|e| { 3082 3082 + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 3083 3083 + })?; 3578 3084 let codec = tonic::codec::ProstCodec::default(); 3579 3085 let path = http::uri::PathAndQuery::from_static( 3580 3086 "/rockbox.v1alpha1.PlaybackService/StreamStatus", 3581 3087 ); 3582 3088 let mut req = request.into_request(); 3583 3583 - req.extensions_mut() 3584 3584 - .insert( 3585 3585 - GrpcMethod::new("rockbox.v1alpha1.PlaybackService", "StreamStatus"), 3586 3586 - ); 3089 3089 + req.extensions_mut().insert(GrpcMethod::new( 3090 3090 + "rockbox.v1alpha1.PlaybackService", 3091 3091 + "StreamStatus", 3092 3092 + )); 3587 3093 self.inner.server_streaming(req, path, codec).await 3588 3094 } 3589 3095 pub async fn stream_playlist( ··· 3593 3099 tonic::Response<tonic::codec::Streaming<super::PlaylistResponse>>, 3594 3100 tonic::Status, 3595 3101 > { 3596 3596 - self.inner 3597 3597 - .ready() 3598 3598 - .await 3599 3599 - .map_err(|e| { 3600 3600 - tonic::Status::unknown( 3601 3601 - format!("Service was not ready: {}", e.into()), 3602 3602 - ) 3603 3603 - })?; 3102 3102 + self.inner.ready().await.map_err(|e| { 3103 3103 + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 3104 3104 + })?; 3604 3105 let codec = tonic::codec::ProstCodec::default(); 3605 3106 let path = http::uri::PathAndQuery::from_static( 3606 3107 "/rockbox.v1alpha1.PlaybackService/StreamPlaylist", 3607 3108 ); 3608 3109 let mut req = request.into_request(); 3609 3609 - req.extensions_mut() 3610 3610 - .insert( 3611 3611 - GrpcMethod::new("rockbox.v1alpha1.PlaybackService", "StreamPlaylist"), 3612 3612 - ); 3110 3110 + req.extensions_mut().insert(GrpcMethod::new( 3111 3111 + "rockbox.v1alpha1.PlaybackService", 3112 3112 + "StreamPlaylist", 3113 3113 + )); 3613 3114 self.inner.server_streaming(req, path, codec).await 3614 3115 } 3615 3116 } ··· 3621 3122 dead_code, 3622 3123 missing_docs, 3623 3124 clippy::wildcard_imports, 3624 3624 - clippy::let_unit_value, 3125 3125 + clippy::let_unit_value 3625 3126 )] 3626 3127 use tonic::codegen::*; 3627 3128 /// Generated trait containing gRPC methods that should be implemented for use with PlaybackServiceServer. ··· 3638 3139 async fn play_or_pause( 3639 3140 &self, 3640 3141 request: tonic::Request<super::PlayOrPauseRequest>, 3641 3641 - ) -> std::result::Result< 3642 3642 - tonic::Response<super::PlayOrPauseResponse>, 3643 3643 - tonic::Status, 3644 3644 - >; 3142 3142 + ) -> std::result::Result<tonic::Response<super::PlayOrPauseResponse>, tonic::Status>; 3645 3143 async fn resume( 3646 3144 &self, 3647 3145 request: tonic::Request<super::ResumeRequest>, ··· 3653 3151 async fn previous( 3654 3152 &self, 3655 3153 request: tonic::Request<super::PreviousRequest>, 3656 3656 - ) -> std::result::Result< 3657 3657 - tonic::Response<super::PreviousResponse>, 3658 3658 - tonic::Status, 3659 3659 - >; 3154 3154 + ) -> std::result::Result<tonic::Response<super::PreviousResponse>, tonic::Status>; 3660 3155 async fn fast_forward_rewind( 3661 3156 &self, 3662 3157 request: tonic::Request<super::FastForwardRewindRequest>, 3663 3663 - ) -> std::result::Result< 3664 3664 - tonic::Response<super::FastForwardRewindResponse>, 3665 3665 - tonic::Status, 3666 3666 - >; 3158 3158 + ) -> std::result::Result<tonic::Response<super::FastForwardRewindResponse>, tonic::Status>; 3667 3159 async fn status( 3668 3160 &self, 3669 3161 request: tonic::Request<super::StatusRequest>, ··· 3671 3163 async fn current_track( 3672 3164 &self, 3673 3165 request: tonic::Request<super::CurrentTrackRequest>, 3674 3674 - ) -> std::result::Result< 3675 3675 - tonic::Response<super::CurrentTrackResponse>, 3676 3676 - tonic::Status, 3677 3677 - >; 3166 3166 + ) -> std::result::Result<tonic::Response<super::CurrentTrackResponse>, tonic::Status>; 3678 3167 async fn next_track( 3679 3168 &self, 3680 3169 request: tonic::Request<super::NextTrackRequest>, 3681 3681 - ) -> std::result::Result< 3682 3682 - tonic::Response<super::NextTrackResponse>, 3683 3683 - tonic::Status, 3684 3684 - >; 3170 3170 + ) -> std::result::Result<tonic::Response<super::NextTrackResponse>, tonic::Status>; 3685 3171 async fn flush_and_reload_tracks( 3686 3172 &self, 3687 3173 request: tonic::Request<super::FlushAndReloadTracksRequest>, 3688 3688 - ) -> std::result::Result< 3689 3689 - tonic::Response<super::FlushAndReloadTracksResponse>, 3690 3690 - tonic::Status, 3691 3691 - >; 3174 3174 + ) -> std::result::Result<tonic::Response<super::FlushAndReloadTracksResponse>, tonic::Status>; 3692 3175 async fn get_file_position( 3693 3176 &self, 3694 3177 request: tonic::Request<super::GetFilePositionRequest>, 3695 3695 - ) -> std::result::Result< 3696 3696 - tonic::Response<super::GetFilePositionResponse>, 3697 3697 - tonic::Status, 3698 3698 - >; 3178 3178 + ) -> std::result::Result<tonic::Response<super::GetFilePositionResponse>, tonic::Status>; 3699 3179 async fn hard_stop( 3700 3180 &self, 3701 3181 request: tonic::Request<super::HardStopRequest>, 3702 3702 - ) -> std::result::Result< 3703 3703 - tonic::Response<super::HardStopResponse>, 3704 3704 - tonic::Status, 3705 3705 - >; 3182 3182 + ) -> std::result::Result<tonic::Response<super::HardStopResponse>, tonic::Status>; 3706 3183 async fn play_album( 3707 3184 &self, 3708 3185 request: tonic::Request<super::PlayAlbumRequest>, 3709 3709 - ) -> std::result::Result< 3710 3710 - tonic::Response<super::PlayAlbumResponse>, 3711 3711 - tonic::Status, 3712 3712 - >; 3186 3186 + ) -> std::result::Result<tonic::Response<super::PlayAlbumResponse>, tonic::Status>; 3713 3187 async fn play_artist_tracks( 3714 3188 &self, 3715 3189 request: tonic::Request<super::PlayArtistTracksRequest>, 3716 3716 - ) -> std::result::Result< 3717 3717 - tonic::Response<super::PlayArtistTracksResponse>, 3718 3718 - tonic::Status, 3719 3719 - >; 3190 3190 + ) -> std::result::Result<tonic::Response<super::PlayArtistTracksResponse>, tonic::Status>; 3720 3191 async fn play_playlist( 3721 3192 &self, 3722 3193 request: tonic::Request<super::PlayPlaylistRequest>, 3723 3723 - ) -> std::result::Result< 3724 3724 - tonic::Response<super::PlayPlaylistResponse>, 3725 3725 - tonic::Status, 3726 3726 - >; 3194 3194 + ) -> std::result::Result<tonic::Response<super::PlayPlaylistResponse>, tonic::Status>; 3727 3195 async fn play_directory( 3728 3196 &self, 3729 3197 request: tonic::Request<super::PlayDirectoryRequest>, 3730 3730 - ) -> std::result::Result< 3731 3731 - tonic::Response<super::PlayDirectoryResponse>, 3732 3732 - tonic::Status, 3733 3733 - >; 3198 3198 + ) -> std::result::Result<tonic::Response<super::PlayDirectoryResponse>, tonic::Status>; 3734 3199 async fn play_music_directory( 3735 3200 &self, 3736 3201 request: tonic::Request<super::PlayMusicDirectoryRequest>, 3737 3737 - ) -> std::result::Result< 3738 3738 - tonic::Response<super::PlayMusicDirectoryResponse>, 3739 3739 - tonic::Status, 3740 3740 - >; 3202 3202 + ) -> std::result::Result<tonic::Response<super::PlayMusicDirectoryResponse>, tonic::Status>; 3741 3203 async fn play_track( 3742 3204 &self, 3743 3205 request: tonic::Request<super::PlayTrackRequest>, 3744 3744 - ) -> std::result::Result< 3745 3745 - tonic::Response<super::PlayTrackResponse>, 3746 3746 - tonic::Status, 3747 3747 - >; 3206 3206 + ) -> std::result::Result<tonic::Response<super::PlayTrackResponse>, tonic::Status>; 3748 3207 async fn play_liked_tracks( 3749 3208 &self, 3750 3209 request: tonic::Request<super::PlayLikedTracksRequest>, 3751 3751 - ) -> std::result::Result< 3752 3752 - tonic::Response<super::PlayLikedTracksResponse>, 3753 3753 - tonic::Status, 3754 3754 - >; 3210 3210 + ) -> std::result::Result<tonic::Response<super::PlayLikedTracksResponse>, tonic::Status>; 3755 3211 async fn play_all_tracks( 3756 3212 &self, 3757 3213 request: tonic::Request<super::PlayAllTracksRequest>, 3758 3758 - ) -> std::result::Result< 3759 3759 - tonic::Response<super::PlayAllTracksResponse>, 3760 3760 - tonic::Status, 3761 3761 - >; 3214 3214 + ) -> std::result::Result<tonic::Response<super::PlayAllTracksResponse>, tonic::Status>; 3762 3215 /// Server streaming response type for the StreamCurrentTrack method. 3763 3216 type StreamCurrentTrackStream: tonic::codegen::tokio_stream::Stream< 3764 3217 Item = std::result::Result<super::CurrentTrackResponse, tonic::Status>, 3765 3765 - > 3766 3766 - + std::marker::Send 3218 3218 + > + std::marker::Send 3767 3219 + 'static; 3768 3220 async fn stream_current_track( 3769 3221 &self, 3770 3222 request: tonic::Request<super::StreamCurrentTrackRequest>, 3771 3771 - ) -> std::result::Result< 3772 3772 - tonic::Response<Self::StreamCurrentTrackStream>, 3773 3773 - tonic::Status, 3774 3774 - >; 3223 3223 + ) -> std::result::Result<tonic::Response<Self::StreamCurrentTrackStream>, tonic::Status>; 3775 3224 /// Server streaming response type for the StreamStatus method. 3776 3225 type StreamStatusStream: tonic::codegen::tokio_stream::Stream< 3777 3226 Item = std::result::Result<super::StatusResponse, tonic::Status>, 3778 3778 - > 3779 3779 - + std::marker::Send 3227 3227 + > + std::marker::Send 3780 3228 + 'static; 3781 3229 async fn stream_status( 3782 3230 &self, 3783 3231 request: tonic::Request<super::StreamStatusRequest>, 3784 3784 - ) -> std::result::Result< 3785 3785 - tonic::Response<Self::StreamStatusStream>, 3786 3786 - tonic::Status, 3787 3787 - >; 3232 3232 + ) -> std::result::Result<tonic::Response<Self::StreamStatusStream>, tonic::Status>; 3788 3233 /// Server streaming response type for the StreamPlaylist method. 3789 3234 type StreamPlaylistStream: tonic::codegen::tokio_stream::Stream< 3790 3235 Item = std::result::Result<super::PlaylistResponse, tonic::Status>, 3791 3791 - > 3792 3792 - + std::marker::Send 3236 3236 + > + std::marker::Send 3793 3237 + 'static; 3794 3238 async fn stream_playlist( 3795 3239 &self, 3796 3240 request: tonic::Request<super::StreamPlaylistRequest>, 3797 3797 - ) -> std::result::Result< 3798 3798 - tonic::Response<Self::StreamPlaylistStream>, 3799 3799 - tonic::Status, 3800 3800 - >; 3241 3241 + ) -> std::result::Result<tonic::Response<Self::StreamPlaylistStream>, tonic::Status>; 3801 3242 } 3802 3243 #[derive(Debug)] 3803 3244 pub struct PlaybackServiceServer<T> { ··· 3820 3261 max_encoding_message_size: None, 3821 3262 } 3822 3263 } 3823 3823 - pub fn with_interceptor<F>( 3824 3824 - inner: T, 3825 3825 - interceptor: F, 3826 3826 - ) -> InterceptedService<Self, F> 3264 3264 + pub fn with_interceptor<F>(inner: T, interceptor: F) -> InterceptedService<Self, F> 3827 3265 where 3828 3266 F: tonic::service::Interceptor, 3829 3267 { ··· 3878 3316 "/rockbox.v1alpha1.PlaybackService/Play" => { 3879 3317 #[allow(non_camel_case_types)] 3880 3318 struct PlaySvc<T: PlaybackService>(pub Arc<T>); 3881 3881 - impl< 3882 3882 - T: PlaybackService, 3883 3883 - > tonic::server::UnaryService<super::PlayRequest> for PlaySvc<T> { 3319 3319 + impl<T: PlaybackService> tonic::server::UnaryService<super::PlayRequest> for PlaySvc<T> { 3884 3320 type Response = super::PlayResponse; 3885 3885 - type Future = BoxFuture< 3886 3886 - tonic::Response<Self::Response>, 3887 3887 - tonic::Status, 3888 3888 - >; 3321 3321 + type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 3889 3322 fn call( 3890 3323 &mut self, 3891 3324 request: tonic::Request<super::PlayRequest>, 3892 3325 ) -> Self::Future { 3893 3326 let inner = Arc::clone(&self.0); 3894 3894 - let fut = async move { 3895 3895 - <T as PlaybackService>::play(&inner, request).await 3896 3896 - }; 3327 3327 + let fut = 3328 3328 + async move { <T as PlaybackService>::play(&inner, request).await }; 3897 3329 Box::pin(fut) 3898 3330 } 3899 3331 } ··· 3922 3354 "/rockbox.v1alpha1.PlaybackService/Pause" => { 3923 3355 #[allow(non_camel_case_types)] 3924 3356 struct PauseSvc<T: PlaybackService>(pub Arc<T>); 3925 3925 - impl< 3926 3926 - T: PlaybackService, 3927 3927 - > tonic::server::UnaryService<super::PauseRequest> for PauseSvc<T> { 3357 3357 + impl<T: PlaybackService> tonic::server::UnaryService<super::PauseRequest> for PauseSvc<T> { 3928 3358 type Response = super::PauseResponse; 3929 3929 - type Future = BoxFuture< 3930 3930 - tonic::Response<Self::Response>, 3931 3931 - tonic::Status, 3932 3932 - >; 3359 3359 + type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 3933 3360 fn call( 3934 3361 &mut self, 3935 3362 request: tonic::Request<super::PauseRequest>, 3936 3363 ) -> Self::Future { 3937 3364 let inner = Arc::clone(&self.0); 3938 3938 - let fut = async move { 3939 3939 - <T as PlaybackService>::pause(&inner, request).await 3940 3940 - }; 3365 3365 + let fut = 3366 3366 + async move { <T as PlaybackService>::pause(&inner, request).await }; 3941 3367 Box::pin(fut) 3942 3368 } 3943 3369 } ··· 3966 3392 "/rockbox.v1alpha1.PlaybackService/PlayOrPause" => { 3967 3393 #[allow(non_camel_case_types)] 3968 3394 struct PlayOrPauseSvc<T: PlaybackService>(pub Arc<T>); 3969 3969 - impl< 3970 3970 - T: PlaybackService, 3971 3971 - > tonic::server::UnaryService<super::PlayOrPauseRequest> 3972 3972 - for PlayOrPauseSvc<T> { 3395 3395 + impl<T: PlaybackService> tonic::server::UnaryService<super::PlayOrPauseRequest> 3396 3396 + for PlayOrPauseSvc<T> 3397 3397 + { 3973 3398 type Response = super::PlayOrPauseResponse; 3974 3974 - type Future = BoxFuture< 3975 3975 - tonic::Response<Self::Response>, 3976 3976 - tonic::Status, 3977 3977 - >; 3399 3399 + type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 3978 3400 fn call( 3979 3401 &mut self, 3980 3402 request: tonic::Request<super::PlayOrPauseRequest>, ··· 4011 3433 "/rockbox.v1alpha1.PlaybackService/Resume" => { 4012 3434 #[allow(non_camel_case_types)] 4013 3435 struct ResumeSvc<T: PlaybackService>(pub Arc<T>); 4014 4014 - impl< 4015 4015 - T: PlaybackService, 4016 4016 - > tonic::server::UnaryService<super::ResumeRequest> 4017 4017 - for ResumeSvc<T> { 3436 3436 + impl<T: PlaybackService> tonic::server::UnaryService<super::ResumeRequest> for ResumeSvc<T> { 4018 3437 type Response = super::ResumeResponse; 4019 4019 - type Future = BoxFuture< 4020 4020 - tonic::Response<Self::Response>, 4021 4021 - tonic::Status, 4022 4022 - >; 3438 3438 + type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 4023 3439 fn call( 4024 3440 &mut self, 4025 3441 request: tonic::Request<super::ResumeRequest>, ··· 4056 3472 "/rockbox.v1alpha1.PlaybackService/Next" => { 4057 3473 #[allow(non_camel_case_types)] 4058 3474 struct NextSvc<T: PlaybackService>(pub Arc<T>); 4059 4059 - impl< 4060 4060 - T: PlaybackService, 4061 4061 - > tonic::server::UnaryService<super::NextRequest> for NextSvc<T> { 3475 3475 + impl<T: PlaybackService> tonic::server::UnaryService<super::NextRequest> for NextSvc<T> { 4062 3476 type Response = super::NextResponse; 4063 4063 - type Future = BoxFuture< 4064 4064 - tonic::Response<Self::Response>, 4065 4065 - tonic::Status, 4066 4066 - >; 3477 3477 + type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 4067 3478 fn call( 4068 3479 &mut self, 4069 3480 request: tonic::Request<super::NextRequest>, 4070 3481 ) -> Self::Future { 4071 3482 let inner = Arc::clone(&self.0); 4072 4072 - let fut = async move { 4073 4073 - <T as PlaybackService>::next(&inner, request).await 4074 4074 - }; 3483 3483 + let fut = 3484 3484 + async move { <T as PlaybackService>::next(&inner, request).await }; 4075 3485 Box::pin(fut) 4076 3486 } 4077 3487 } ··· 4100 3510 "/rockbox.v1alpha1.PlaybackService/Previous" => { 4101 3511 #[allow(non_camel_case_types)] 4102 3512 struct PreviousSvc<T: PlaybackService>(pub Arc<T>); 4103 4103 - impl< 4104 4104 - T: PlaybackService, 4105 4105 - > tonic::server::UnaryService<super::PreviousRequest> 4106 4106 - for PreviousSvc<T> { 3513 3513 + impl<T: PlaybackService> tonic::server::UnaryService<super::PreviousRequest> for PreviousSvc<T> { 4107 3514 type Response = super::PreviousResponse; 4108 4108 - type Future = BoxFuture< 4109 4109 - tonic::Response<Self::Response>, 4110 4110 - tonic::Status, 4111 4111 - >; 3515 3515 + type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 4112 3516 fn call( 4113 3517 &mut self, 4114 3518 request: tonic::Request<super::PreviousRequest>, ··· 4145 3549 "/rockbox.v1alpha1.PlaybackService/FastForwardRewind" => { 4146 3550 #[allow(non_camel_case_types)] 4147 3551 struct FastForwardRewindSvc<T: PlaybackService>(pub Arc<T>); 4148 4148 - impl< 4149 4149 - T: PlaybackService, 4150 4150 - > tonic::server::UnaryService<super::FastForwardRewindRequest> 4151 4151 - for FastForwardRewindSvc<T> { 3552 3552 + impl<T: PlaybackService> 3553 3553 + tonic::server::UnaryService<super::FastForwardRewindRequest> 3554 3554 + for FastForwardRewindSvc<T> 3555 3555 + { 4152 3556 type Response = super::FastForwardRewindResponse; 4153 4153 - type Future = BoxFuture< 4154 4154 - tonic::Response<Self::Response>, 4155 4155 - tonic::Status, 4156 4156 - >; 3557 3557 + type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 4157 3558 fn call( 4158 3559 &mut self, 4159 3560 request: tonic::Request<super::FastForwardRewindRequest>, 4160 3561 ) -> Self::Future { 4161 3562 let inner = Arc::clone(&self.0); 4162 3563 let fut = async move { 4163 4163 - <T as PlaybackService>::fast_forward_rewind(&inner, request) 4164 4164 - .await 3564 3564 + <T as PlaybackService>::fast_forward_rewind(&inner, request).await 4165 3565 }; 4166 3566 Box::pin(fut) 4167 3567 } ··· 4191 3591 "/rockbox.v1alpha1.PlaybackService/Status" => { 4192 3592 #[allow(non_camel_case_types)] 4193 3593 struct StatusSvc<T: PlaybackService>(pub Arc<T>); 4194 4194 - impl< 4195 4195 - T: PlaybackService, 4196 4196 - > tonic::server::UnaryService<super::StatusRequest> 4197 4197 - for StatusSvc<T> { 3594 3594 + impl<T: PlaybackService> tonic::server::UnaryService<super::StatusRequest> for StatusSvc<T> { 4198 3595 type Response = super::StatusResponse; 4199 4199 - type Future = BoxFuture< 4200 4200 - tonic::Response<Self::Response>, 4201 4201 - tonic::Status, 4202 4202 - >; 3596 3596 + type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 4203 3597 fn call( 4204 3598 &mut self, 4205 3599 request: tonic::Request<super::StatusRequest>, ··· 4236 3630 "/rockbox.v1alpha1.PlaybackService/CurrentTrack" => { 4237 3631 #[allow(non_camel_case_types)] 4238 3632 struct CurrentTrackSvc<T: PlaybackService>(pub Arc<T>); 4239 4239 - impl< 4240 4240 - T: PlaybackService, 4241 4241 - > tonic::server::UnaryService<super::CurrentTrackRequest> 4242 4242 - for CurrentTrackSvc<T> { 3633 3633 + impl<T: PlaybackService> tonic::server::UnaryService<super::CurrentTrackRequest> 3634 3634 + for CurrentTrackSvc<T> 3635 3635 + { 4243 3636 type Response = super::CurrentTrackResponse; 4244 4244 - type Future = BoxFuture< 4245 4245 - tonic::Response<Self::Response>, 4246 4246 - tonic::Status, 4247 4247 - >; 3637 3637 + type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 4248 3638 fn call( 4249 3639 &mut self, 4250 3640 request: tonic::Request<super::CurrentTrackRequest>, ··· 4281 3671 "/rockbox.v1alpha1.PlaybackService/NextTrack" => { 4282 3672 #[allow(non_camel_case_types)] 4283 3673 struct NextTrackSvc<T: PlaybackService>(pub Arc<T>); 4284 4284 - impl< 4285 4285 - T: PlaybackService, 4286 4286 - > tonic::server::UnaryService<super::NextTrackRequest> 4287 4287 - for NextTrackSvc<T> { 3674 3674 + impl<T: PlaybackService> tonic::server::UnaryService<super::NextTrackRequest> for NextTrackSvc<T> { 4288 3675 type Response = super::NextTrackResponse; 4289 4289 - type Future = BoxFuture< 4290 4290 - tonic::Response<Self::Response>, 4291 4291 - tonic::Status, 4292 4292 - >; 3676 3676 + type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 4293 3677 fn call( 4294 3678 &mut self, 4295 3679 request: tonic::Request<super::NextTrackRequest>, ··· 4326 3710 "/rockbox.v1alpha1.PlaybackService/FlushAndReloadTracks" => { 4327 3711 #[allow(non_camel_case_types)] 4328 3712 struct FlushAndReloadTracksSvc<T: PlaybackService>(pub Arc<T>); 4329 4329 - impl< 4330 4330 - T: PlaybackService, 4331 4331 - > tonic::server::UnaryService<super::FlushAndReloadTracksRequest> 4332 4332 - for FlushAndReloadTracksSvc<T> { 3713 3713 + impl<T: PlaybackService> 3714 3714 + tonic::server::UnaryService<super::FlushAndReloadTracksRequest> 3715 3715 + for FlushAndReloadTracksSvc<T> 3716 3716 + { 4333 3717 type Response = super::FlushAndReloadTracksResponse; 4334 4334 - type Future = BoxFuture< 4335 4335 - tonic::Response<Self::Response>, 4336 4336 - tonic::Status, 4337 4337 - >; 3718 3718 + type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 4338 3719 fn call( 4339 3720 &mut self, 4340 3721 request: tonic::Request<super::FlushAndReloadTracksRequest>, 4341 3722 ) -> Self::Future { 4342 3723 let inner = Arc::clone(&self.0); 4343 3724 let fut = async move { 4344 4344 - <T as PlaybackService>::flush_and_reload_tracks( 4345 4345 - &inner, 4346 4346 - request, 4347 4347 - ) 3725 3725 + <T as PlaybackService>::flush_and_reload_tracks(&inner, request) 4348 3726 .await 4349 3727 }; 4350 3728 Box::pin(fut) ··· 4375 3753 "/rockbox.v1alpha1.PlaybackService/GetFilePosition" => { 4376 3754 #[allow(non_camel_case_types)] 4377 3755 struct GetFilePositionSvc<T: PlaybackService>(pub Arc<T>); 4378 4378 - impl< 4379 4379 - T: PlaybackService, 4380 4380 - > tonic::server::UnaryService<super::GetFilePositionRequest> 4381 4381 - for GetFilePositionSvc<T> { 3756 3756 + impl<T: PlaybackService> 3757 3757 + tonic::server::UnaryService<super::GetFilePositionRequest> 3758 3758 + for GetFilePositionSvc<T> 3759 3759 + { 4382 3760 type Response = super::GetFilePositionResponse; 4383 4383 - type Future = BoxFuture< 4384 4384 - tonic::Response<Self::Response>, 4385 4385 - tonic::Status, 4386 4386 - >; 3761 3761 + type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 4387 3762 fn call( 4388 3763 &mut self, 4389 3764 request: tonic::Request<super::GetFilePositionRequest>, 4390 3765 ) -> Self::Future { 4391 3766 let inner = Arc::clone(&self.0); 4392 3767 let fut = async move { 4393 4393 - <T as PlaybackService>::get_file_position(&inner, request) 4394 4394 - .await 3768 3768 + <T as PlaybackService>::get_file_position(&inner, request).await 4395 3769 }; 4396 3770 Box::pin(fut) 4397 3771 } ··· 4421 3795 "/rockbox.v1alpha1.PlaybackService/HardStop" => { 4422 3796 #[allow(non_camel_case_types)] 4423 3797 struct HardStopSvc<T: PlaybackService>(pub Arc<T>); 4424 4424 - impl< 4425 4425 - T: PlaybackService, 4426 4426 - > tonic::server::UnaryService<super::HardStopRequest> 4427 4427 - for HardStopSvc<T> { 3798 3798 + impl<T: PlaybackService> tonic::server::UnaryService<super::HardStopRequest> for HardStopSvc<T> { 4428 3799 type Response = super::HardStopResponse; 4429 4429 - type Future = BoxFuture< 4430 4430 - tonic::Response<Self::Response>, 4431 4431 - tonic::Status, 4432 4432 - >; 3800 3800 + type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 4433 3801 fn call( 4434 3802 &mut self, 4435 3803 request: tonic::Request<super::HardStopRequest>, ··· 4466 3834 "/rockbox.v1alpha1.PlaybackService/PlayAlbum" => { 4467 3835 #[allow(non_camel_case_types)] 4468 3836 struct PlayAlbumSvc<T: PlaybackService>(pub Arc<T>); 4469 4469 - impl< 4470 4470 - T: PlaybackService, 4471 4471 - > tonic::server::UnaryService<super::PlayAlbumRequest> 4472 4472 - for PlayAlbumSvc<T> { 3837 3837 + impl<T: PlaybackService> tonic::server::UnaryService<super::PlayAlbumRequest> for PlayAlbumSvc<T> { 4473 3838 type Response = super::PlayAlbumResponse; 4474 4474 - type Future = BoxFuture< 4475 4475 - tonic::Response<Self::Response>, 4476 4476 - tonic::Status, 4477 4477 - >; 3839 3839 + type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 4478 3840 fn call( 4479 3841 &mut self, 4480 3842 request: tonic::Request<super::PlayAlbumRequest>, ··· 4511 3873 "/rockbox.v1alpha1.PlaybackService/PlayArtistTracks" => { 4512 3874 #[allow(non_camel_case_types)] 4513 3875 struct PlayArtistTracksSvc<T: PlaybackService>(pub Arc<T>); 4514 4514 - impl< 4515 4515 - T: PlaybackService, 4516 4516 - > tonic::server::UnaryService<super::PlayArtistTracksRequest> 4517 4517 - for PlayArtistTracksSvc<T> { 3876 3876 + impl<T: PlaybackService> 3877 3877 + tonic::server::UnaryService<super::PlayArtistTracksRequest> 3878 3878 + for PlayArtistTracksSvc<T> 3879 3879 + { 4518 3880 type Response = super::PlayArtistTracksResponse; 4519 4519 - type Future = BoxFuture< 4520 4520 - tonic::Response<Self::Response>, 4521 4521 - tonic::Status, 4522 4522 - >; 3881 3881 + type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 4523 3882 fn call( 4524 3883 &mut self, 4525 3884 request: tonic::Request<super::PlayArtistTracksRequest>, 4526 3885 ) -> Self::Future { 4527 3886 let inner = Arc::clone(&self.0); 4528 3887 let fut = async move { 4529 4529 - <T as PlaybackService>::play_artist_tracks(&inner, request) 4530 4530 - .await 3888 3888 + <T as PlaybackService>::play_artist_tracks(&inner, request).await 4531 3889 }; 4532 3890 Box::pin(fut) 4533 3891 } ··· 4557 3915 "/rockbox.v1alpha1.PlaybackService/PlayPlaylist" => { 4558 3916 #[allow(non_camel_case_types)] 4559 3917 struct PlayPlaylistSvc<T: PlaybackService>(pub Arc<T>); 4560 4560 - impl< 4561 4561 - T: PlaybackService, 4562 4562 - > tonic::server::UnaryService<super::PlayPlaylistRequest> 4563 4563 - for PlayPlaylistSvc<T> { 3918 3918 + impl<T: PlaybackService> tonic::server::UnaryService<super::PlayPlaylistRequest> 3919 3919 + for PlayPlaylistSvc<T> 3920 3920 + { 4564 3921 type Response = super::PlayPlaylistResponse; 4565 4565 - type Future = BoxFuture< 4566 4566 - tonic::Response<Self::Response>, 4567 4567 - tonic::Status, 4568 4568 - >; 3922 3922 + type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 4569 3923 fn call( 4570 3924 &mut self, 4571 3925 request: tonic::Request<super::PlayPlaylistRequest>, ··· 4602 3956 "/rockbox.v1alpha1.PlaybackService/PlayDirectory" => { 4603 3957 #[allow(non_camel_case_types)] 4604 3958 struct PlayDirectorySvc<T: PlaybackService>(pub Arc<T>); 4605 4605 - impl< 4606 4606 - T: PlaybackService, 4607 4607 - > tonic::server::UnaryService<super::PlayDirectoryRequest> 4608 4608 - for PlayDirectorySvc<T> { 3959 3959 + impl<T: PlaybackService> 3960 3960 + tonic::server::UnaryService<super::PlayDirectoryRequest> 3961 3961 + for PlayDirectorySvc<T> 3962 3962 + { 4609 3963 type Response = super::PlayDirectoryResponse; 4610 4610 - type Future = BoxFuture< 4611 4611 - tonic::Response<Self::Response>, 4612 4612 - tonic::Status, 4613 4613 - >; 3964 3964 + type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 4614 3965 fn call( 4615 3966 &mut self, 4616 3967 request: tonic::Request<super::PlayDirectoryRequest>, 4617 3968 ) -> Self::Future { 4618 3969 let inner = Arc::clone(&self.0); 4619 3970 let fut = async move { 4620 4620 - <T as PlaybackService>::play_directory(&inner, request) 4621 4621 - .await 3971 3971 + <T as PlaybackService>::play_directory(&inner, request).await 4622 3972 }; 4623 3973 Box::pin(fut) 4624 3974 } ··· 4648 3998 "/rockbox.v1alpha1.PlaybackService/PlayMusicDirectory" => { 4649 3999 #[allow(non_camel_case_types)] 4650 4000 struct PlayMusicDirectorySvc<T: PlaybackService>(pub Arc<T>); 4651 4651 - impl< 4652 4652 - T: PlaybackService, 4653 4653 - > tonic::server::UnaryService<super::PlayMusicDirectoryRequest> 4654 4654 - for PlayMusicDirectorySvc<T> { 4001 4001 + impl<T: PlaybackService> 4002 4002 + tonic::server::UnaryService<super::PlayMusicDirectoryRequest> 4003 4003 + for PlayMusicDirectorySvc<T> 4004 4004 + { 4655 4005 type Response = super::PlayMusicDirectoryResponse; 4656 4656 - type Future = BoxFuture< 4657 4657 - tonic::Response<Self::Response>, 4658 4658 - tonic::Status, 4659 4659 - >; 4006 4006 + type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 4660 4007 fn call( 4661 4008 &mut self, 4662 4009 request: tonic::Request<super::PlayMusicDirectoryRequest>, 4663 4010 ) -> Self::Future { 4664 4011 let inner = Arc::clone(&self.0); 4665 4012 let fut = async move { 4666 4666 - <T as PlaybackService>::play_music_directory( 4667 4667 - &inner, 4668 4668 - request, 4669 4669 - ) 4670 4670 - .await 4013 4013 + <T as PlaybackService>::play_music_directory(&inner, request).await 4671 4014 }; 4672 4015 Box::pin(fut) 4673 4016 } ··· 4697 4040 "/rockbox.v1alpha1.PlaybackService/PlayTrack" => { 4698 4041 #[allow(non_camel_case_types)] 4699 4042 struct PlayTrackSvc<T: PlaybackService>(pub Arc<T>); 4700 4700 - impl< 4701 4701 - T: PlaybackService, 4702 4702 - > tonic::server::UnaryService<super::PlayTrackRequest> 4703 4703 - for PlayTrackSvc<T> { 4043 4043 + impl<T: PlaybackService> tonic::server::UnaryService<super::PlayTrackRequest> for PlayTrackSvc<T> { 4704 4044 type Response = super::PlayTrackResponse; 4705 4705 - type Future = BoxFuture< 4706 4706 - tonic::Response<Self::Response>, 4707 4707 - tonic::Status, 4708 4708 - >; 4045 4045 + type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 4709 4046 fn call( 4710 4047 &mut self, 4711 4048 request: tonic::Request<super::PlayTrackRequest>, ··· 4742 4079 "/rockbox.v1alpha1.PlaybackService/PlayLikedTracks" => { 4743 4080 #[allow(non_camel_case_types)] 4744 4081 struct PlayLikedTracksSvc<T: PlaybackService>(pub Arc<T>); 4745 4745 - impl< 4746 4746 - T: PlaybackService, 4747 4747 - > tonic::server::UnaryService<super::PlayLikedTracksRequest> 4748 4748 - for PlayLikedTracksSvc<T> { 4082 4082 + impl<T: PlaybackService> 4083 4083 + tonic::server::UnaryService<super::PlayLikedTracksRequest> 4084 4084 + for PlayLikedTracksSvc<T> 4085 4085 + { 4749 4086 type Response = super::PlayLikedTracksResponse; 4750 4750 - type Future = BoxFuture< 4751 4751 - tonic::Response<Self::Response>, 4752 4752 - tonic::Status, 4753 4753 - >; 4087 4087 + type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 4754 4088 fn call( 4755 4089 &mut self, 4756 4090 request: tonic::Request<super::PlayLikedTracksRequest>, 4757 4091 ) -> Self::Future { 4758 4092 let inner = Arc::clone(&self.0); 4759 4093 let fut = async move { 4760 4760 - <T as PlaybackService>::play_liked_tracks(&inner, request) 4761 4761 - .await 4094 4094 + <T as PlaybackService>::play_liked_tracks(&inner, request).await 4762 4095 }; 4763 4096 Box::pin(fut) 4764 4097 } ··· 4788 4121 "/rockbox.v1alpha1.PlaybackService/PlayAllTracks" => { 4789 4122 #[allow(non_camel_case_types)] 4790 4123 struct PlayAllTracksSvc<T: PlaybackService>(pub Arc<T>); 4791 4791 - impl< 4792 4792 - T: PlaybackService, 4793 4793 - > tonic::server::UnaryService<super::PlayAllTracksRequest> 4794 4794 - for PlayAllTracksSvc<T> { 4124 4124 + impl<T: PlaybackService> 4125 4125 + tonic::server::UnaryService<super::PlayAllTracksRequest> 4126 4126 + for PlayAllTracksSvc<T> 4127 4127 + { 4795 4128 type Response = super::PlayAllTracksResponse; 4796 4796 - type Future = BoxFuture< 4797 4797 - tonic::Response<Self::Response>, 4798 4798 - tonic::Status, 4799 4799 - >; 4129 4129 + type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 4800 4130 fn call( 4801 4131 &mut self, 4802 4132 request: tonic::Request<super::PlayAllTracksRequest>, 4803 4133 ) -> Self::Future { 4804 4134 let inner = Arc::clone(&self.0); 4805 4135 let fut = async move { 4806 4806 - <T as PlaybackService>::play_all_tracks(&inner, request) 4807 4807 - .await 4136 4136 + <T as PlaybackService>::play_all_tracks(&inner, request).await 4808 4137 }; 4809 4138 Box::pin(fut) 4810 4139 } ··· 4834 4163 "/rockbox.v1alpha1.PlaybackService/StreamCurrentTrack" => { 4835 4164 #[allow(non_camel_case_types)] 4836 4165 struct StreamCurrentTrackSvc<T: PlaybackService>(pub Arc<T>); 4837 4837 - impl< 4838 4838 - T: PlaybackService, 4839 4839 - > tonic::server::ServerStreamingService< 4840 4840 - super::StreamCurrentTrackRequest, 4841 4841 - > for StreamCurrentTrackSvc<T> { 4166 4166 + impl<T: PlaybackService> 4167 4167 + tonic::server::ServerStreamingService<super::StreamCurrentTrackRequest> 4168 4168 + for StreamCurrentTrackSvc<T> 4169 4169 + { 4842 4170 type Response = super::CurrentTrackResponse; 4843 4171 type ResponseStream = T::StreamCurrentTrackStream; 4844 4844 - type Future = BoxFuture< 4845 4845 - tonic::Response<Self::ResponseStream>, 4846 4846 - tonic::Status, 4847 4847 - >; 4172 4172 + type Future = 4173 4173 + BoxFuture<tonic::Response<Self::ResponseStream>, tonic::Status>; 4848 4174 fn call( 4849 4175 &mut self, 4850 4176 request: tonic::Request<super::StreamCurrentTrackRequest>, 4851 4177 ) -> Self::Future { 4852 4178 let inner = Arc::clone(&self.0); 4853 4179 let fut = async move { 4854 4854 - <T as PlaybackService>::stream_current_track( 4855 4855 - &inner, 4856 4856 - request, 4857 4857 - ) 4858 4858 - .await 4180 4180 + <T as PlaybackService>::stream_current_track(&inner, request).await 4859 4181 }; 4860 4182 Box::pin(fut) 4861 4183 } ··· 4885 4207 "/rockbox.v1alpha1.PlaybackService/StreamStatus" => { 4886 4208 #[allow(non_camel_case_types)] 4887 4209 struct StreamStatusSvc<T: PlaybackService>(pub Arc<T>); 4888 4888 - impl< 4889 4889 - T: PlaybackService, 4890 4890 - > tonic::server::ServerStreamingService<super::StreamStatusRequest> 4891 4891 - for StreamStatusSvc<T> { 4210 4210 + impl<T: PlaybackService> 4211 4211 + tonic::server::ServerStreamingService<super::StreamStatusRequest> 4212 4212 + for StreamStatusSvc<T> 4213 4213 + { 4892 4214 type Response = super::StatusResponse; 4893 4215 type ResponseStream = T::StreamStatusStream; 4894 4894 - type Future = BoxFuture< 4895 4895 - tonic::Response<Self::ResponseStream>, 4896 4896 - tonic::Status, 4897 4897 - >; 4216 4216 + type Future = 4217 4217 + BoxFuture<tonic::Response<Self::ResponseStream>, tonic::Status>; 4898 4218 fn call( 4899 4219 &mut self, 4900 4220 request: tonic::Request<super::StreamStatusRequest>, ··· 4931 4251 "/rockbox.v1alpha1.PlaybackService/StreamPlaylist" => { 4932 4252 #[allow(non_camel_case_types)] 4933 4253 struct StreamPlaylistSvc<T: PlaybackService>(pub Arc<T>); 4934 4934 - impl< 4935 4935 - T: PlaybackService, 4936 4936 - > tonic::server::ServerStreamingService<super::StreamPlaylistRequest> 4937 4937 - for StreamPlaylistSvc<T> { 4254 4254 + impl<T: PlaybackService> 4255 4255 + tonic::server::ServerStreamingService<super::StreamPlaylistRequest> 4256 4256 + for StreamPlaylistSvc<T> 4257 4257 + { 4938 4258 type Response = super::PlaylistResponse; 4939 4259 type ResponseStream = T::StreamPlaylistStream; 4940 4940 - type Future = BoxFuture< 4941 4941 - tonic::Response<Self::ResponseStream>, 4942 4942 - tonic::Status, 4943 4943 - >; 4260 4260 + type Future = 4261 4261 + BoxFuture<tonic::Response<Self::ResponseStream>, tonic::Status>; 4944 4262 fn call( 4945 4263 &mut self, 4946 4264 request: tonic::Request<super::StreamPlaylistRequest>, 4947 4265 ) -> Self::Future { 4948 4266 let inner = Arc::clone(&self.0); 4949 4267 let fut = async move { 4950 4950 - <T as PlaybackService>::stream_playlist(&inner, request) 4951 4951 - .await 4268 4268 + <T as PlaybackService>::stream_playlist(&inner, request).await 4952 4269 }; 4953 4270 Box::pin(fut) 4954 4271 } ··· 4975 4292 }; 4976 4293 Box::pin(fut) 4977 4294 } 4978 4978 - _ => { 4979 4979 - Box::pin(async move { 4980 4980 - let mut response = http::Response::new(empty_body()); 4981 4981 - let headers = response.headers_mut(); 4982 4982 - headers 4983 4983 - .insert( 4984 4984 - tonic::Status::GRPC_STATUS, 4985 4985 - (tonic::Code::Unimplemented as i32).into(), 4986 4986 - ); 4987 4987 - headers 4988 4988 - .insert( 4989 4989 - http::header::CONTENT_TYPE, 4990 4990 - tonic::metadata::GRPC_CONTENT_TYPE, 4991 4991 - ); 4992 4992 - Ok(response) 4993 4993 - }) 4994 4994 - } 4295 4295 + _ => Box::pin(async move { 4296 4296 + let mut response = http::Response::new(empty_body()); 4297 4297 + let headers = response.headers_mut(); 4298 4298 + headers.insert( 4299 4299 + tonic::Status::GRPC_STATUS, 4300 4300 + (tonic::Code::Unimplemented as i32).into(), 4301 4301 + ); 4302 4302 + headers.insert( 4303 4303 + http::header::CONTENT_TYPE, 4304 4304 + tonic::metadata::GRPC_CONTENT_TYPE, 4305 4305 + ); 4306 4306 + Ok(response) 4307 4307 + }), 4995 4308 } 4996 4309 } 4997 4310 } ··· 5198 4511 dead_code, 5199 4512 missing_docs, 5200 4513 clippy::wildcard_imports, 5201 5201 - clippy::let_unit_value, 4514 4514 + clippy::let_unit_value 5202 4515 )] 5203 5203 - use tonic::codegen::*; 5204 4516 use tonic::codegen::http::Uri; 4517 4517 + use tonic::codegen::*; 5205 4518 #[derive(Debug, Clone)] 5206 4519 pub struct PlaylistServiceClient<T> { 5207 4520 inner: tonic::client::Grpc<T>, ··· 5245 4558 <T as tonic::client::GrpcService<tonic::body::BoxBody>>::ResponseBody, 5246 4559 >, 5247 4560 >, 5248 5248 - <T as tonic::codegen::Service< 5249 5249 - http::Request<tonic::body::BoxBody>, 5250 5250 - >>::Error: Into<StdError> + std::marker::Send + std::marker::Sync, 4561 4561 + <T as tonic::codegen::Service<http::Request<tonic::body::BoxBody>>>::Error: 4562 4562 + Into<StdError> + std::marker::Send + std::marker::Sync, 5251 4563 { 5252 4564 PlaylistServiceClient::new(InterceptedService::new(inner, interceptor)) 5253 4565 } ··· 5285 4597 pub async fn get_current( 5286 4598 &mut self, 5287 4599 request: impl tonic::IntoRequest<super::GetCurrentRequest>, 5288 5288 - ) -> std::result::Result< 5289 5289 - tonic::Response<super::GetCurrentResponse>, 5290 5290 - tonic::Status, 5291 5291 - > { 5292 5292 - self.inner 5293 5293 - .ready() 5294 5294 - .await 5295 5295 - .map_err(|e| { 5296 5296 - tonic::Status::unknown( 5297 5297 - format!("Service was not ready: {}", e.into()), 5298 5298 - ) 5299 5299 - })?; 4600 4600 + ) -> std::result::Result<tonic::Response<super::GetCurrentResponse>, tonic::Status> 4601 4601 + { 4602 4602 + self.inner.ready().await.map_err(|e| { 4603 4603 + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 4604 4604 + })?; 5300 4605 let codec = tonic::codec::ProstCodec::default(); 5301 4606 let path = http::uri::PathAndQuery::from_static( 5302 4607 "/rockbox.v1alpha1.PlaylistService/GetCurrent", 5303 4608 ); 5304 4609 let mut req = request.into_request(); 5305 5305 - req.extensions_mut() 5306 5306 - .insert( 5307 5307 - GrpcMethod::new("rockbox.v1alpha1.PlaylistService", "GetCurrent"), 5308 5308 - ); 4610 4610 + req.extensions_mut().insert(GrpcMethod::new( 4611 4611 + "rockbox.v1alpha1.PlaylistService", 4612 4612 + "GetCurrent", 4613 4613 + )); 5309 4614 self.inner.unary(req, path, codec).await 5310 4615 } 5311 4616 pub async fn get_resume_info( 5312 4617 &mut self, 5313 4618 request: impl tonic::IntoRequest<super::GetResumeInfoRequest>, 5314 5314 - ) -> std::result::Result< 5315 5315 - tonic::Response<super::GetResumeInfoResponse>, 5316 5316 - tonic::Status, 5317 5317 - > { 5318 5318 - self.inner 5319 5319 - .ready() 5320 5320 - .await 5321 5321 - .map_err(|e| { 5322 5322 - tonic::Status::unknown( 5323 5323 - format!("Service was not ready: {}", e.into()), 5324 5324 - ) 5325 5325 - })?; 4619 4619 + ) -> std::result::Result<tonic::Response<super::GetResumeInfoResponse>, tonic::Status> 4620 4620 + { 4621 4621 + self.inner.ready().await.map_err(|e| { 4622 4622 + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 4623 4623 + })?; 5326 4624 let codec = tonic::codec::ProstCodec::default(); 5327 4625 let path = http::uri::PathAndQuery::from_static( 5328 4626 "/rockbox.v1alpha1.PlaylistService/GetResumeInfo", 5329 4627 ); 5330 4628 let mut req = request.into_request(); 5331 5331 - req.extensions_mut() 5332 5332 - .insert( 5333 5333 - GrpcMethod::new("rockbox.v1alpha1.PlaylistService", "GetResumeInfo"), 5334 5334 - ); 4629 4629 + req.extensions_mut().insert(GrpcMethod::new( 4630 4630 + "rockbox.v1alpha1.PlaylistService", 4631 4631 + "GetResumeInfo", 4632 4632 + )); 5335 4633 self.inner.unary(req, path, codec).await 5336 4634 } 5337 4635 pub async fn get_track_info( 5338 4636 &mut self, 5339 4637 request: impl tonic::IntoRequest<super::GetTrackInfoRequest>, 5340 5340 - ) -> std::result::Result< 5341 5341 - tonic::Response<super::GetTrackInfoResponse>, 5342 5342 - tonic::Status, 5343 5343 - > { 5344 5344 - self.inner 5345 5345 - .ready() 5346 5346 - .await 5347 5347 - .map_err(|e| { 5348 5348 - tonic::Status::unknown( 5349 5349 - format!("Service was not ready: {}", e.into()), 5350 5350 - ) 5351 5351 - })?; 4638 4638 + ) -> std::result::Result<tonic::Response<super::GetTrackInfoResponse>, tonic::Status> 4639 4639 + { 4640 4640 + self.inner.ready().await.map_err(|e| { 4641 4641 + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 4642 4642 + })?; 5352 4643 let codec = tonic::codec::ProstCodec::default(); 5353 4644 let path = http::uri::PathAndQuery::from_static( 5354 4645 "/rockbox.v1alpha1.PlaylistService/GetTrackInfo", 5355 4646 ); 5356 4647 let mut req = request.into_request(); 5357 5357 - req.extensions_mut() 5358 5358 - .insert( 5359 5359 - GrpcMethod::new("rockbox.v1alpha1.PlaylistService", "GetTrackInfo"), 5360 5360 - ); 4648 4648 + req.extensions_mut().insert(GrpcMethod::new( 4649 4649 + "rockbox.v1alpha1.PlaylistService", 4650 4650 + "GetTrackInfo", 4651 4651 + )); 5361 4652 self.inner.unary(req, path, codec).await 5362 4653 } 5363 4654 pub async fn get_first_index( 5364 4655 &mut self, 5365 4656 request: impl tonic::IntoRequest<super::GetFirstIndexRequest>, 5366 5366 - ) -> std::result::Result< 5367 5367 - tonic::Response<super::GetFirstIndexResponse>, 5368 5368 - tonic::Status, 5369 5369 - > { 5370 5370 - self.inner 5371 5371 - .ready() 5372 5372 - .await 5373 5373 - .map_err(|e| { 5374 5374 - tonic::Status::unknown( 5375 5375 - format!("Service was not ready: {}", e.into()), 5376 5376 - ) 5377 5377 - })?; 4657 4657 + ) -> std::result::Result<tonic::Response<super::GetFirstIndexResponse>, tonic::Status> 4658 4658 + { 4659 4659 + self.inner.ready().await.map_err(|e| { 4660 4660 + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 4661 4661 + })?; 5378 4662 let codec = tonic::codec::ProstCodec::default(); 5379 4663 let path = http::uri::PathAndQuery::from_static( 5380 4664 "/rockbox.v1alpha1.PlaylistService/GetFirstIndex", 5381 4665 ); 5382 4666 let mut req = request.into_request(); 5383 5383 - req.extensions_mut() 5384 5384 - .insert( 5385 5385 - GrpcMethod::new("rockbox.v1alpha1.PlaylistService", "GetFirstIndex"), 5386 5386 - ); 4667 4667 + req.extensions_mut().insert(GrpcMethod::new( 4668 4668 + "rockbox.v1alpha1.PlaylistService", 4669 4669 + "GetFirstIndex", 4670 4670 + )); 5387 4671 self.inner.unary(req, path, codec).await 5388 4672 } 5389 4673 pub async fn get_display_index( 5390 4674 &mut self, 5391 4675 request: impl tonic::IntoRequest<super::GetDisplayIndexRequest>, 5392 5392 - ) -> std::result::Result< 5393 5393 - tonic::Response<super::GetDisplayIndexResponse>, 5394 5394 - tonic::Status, 5395 5395 - > { 5396 5396 - self.inner 5397 5397 - .ready() 5398 5398 - .await 5399 5399 - .map_err(|e| { 5400 5400 - tonic::Status::unknown( 5401 5401 - format!("Service was not ready: {}", e.into()), 5402 5402 - ) 5403 5403 - })?; 4676 4676 + ) -> std::result::Result<tonic::Response<super::GetDisplayIndexResponse>, tonic::Status> 4677 4677 + { 4678 4678 + self.inner.ready().await.map_err(|e| { 4679 4679 + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 4680 4680 + })?; 5404 4681 let codec = tonic::codec::ProstCodec::default(); 5405 4682 let path = http::uri::PathAndQuery::from_static( 5406 4683 "/rockbox.v1alpha1.PlaylistService/GetDisplayIndex", 5407 4684 ); 5408 4685 let mut req = request.into_request(); 5409 5409 - req.extensions_mut() 5410 5410 - .insert( 5411 5411 - GrpcMethod::new( 5412 5412 - "rockbox.v1alpha1.PlaylistService", 5413 5413 - "GetDisplayIndex", 5414 5414 - ), 5415 5415 - ); 4686 4686 + req.extensions_mut().insert(GrpcMethod::new( 4687 4687 + "rockbox.v1alpha1.PlaylistService", 4688 4688 + "GetDisplayIndex", 4689 4689 + )); 5416 4690 self.inner.unary(req, path, codec).await 5417 4691 } 5418 4692 pub async fn amount( 5419 4693 &mut self, 5420 4694 request: impl tonic::IntoRequest<super::AmountRequest>, 5421 4695 ) -> std::result::Result<tonic::Response<super::AmountResponse>, tonic::Status> { 5422 5422 - self.inner 5423 5423 - .ready() 5424 5424 - .await 5425 5425 - .map_err(|e| { 5426 5426 - tonic::Status::unknown( 5427 5427 - format!("Service was not ready: {}", e.into()), 5428 5428 - ) 5429 5429 - })?; 4696 4696 + self.inner.ready().await.map_err(|e| { 4697 4697 + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 4698 4698 + })?; 5430 4699 let codec = tonic::codec::ProstCodec::default(); 5431 5431 - let path = http::uri::PathAndQuery::from_static( 5432 5432 - "/rockbox.v1alpha1.PlaylistService/Amount", 5433 5433 - ); 4700 4700 + let path = 4701 4701 + http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.PlaylistService/Amount"); 5434 4702 let mut req = request.into_request(); 5435 5435 - req.extensions_mut() 5436 5436 - .insert(GrpcMethod::new("rockbox.v1alpha1.PlaylistService", "Amount")); 4703 4703 + req.extensions_mut().insert(GrpcMethod::new( 4704 4704 + "rockbox.v1alpha1.PlaylistService", 4705 4705 + "Amount", 4706 4706 + )); 5437 4707 self.inner.unary(req, path, codec).await 5438 4708 } 5439 4709 pub async fn playlist_resume( 5440 4710 &mut self, 5441 4711 request: impl tonic::IntoRequest<super::PlaylistResumeRequest>, 5442 5442 - ) -> std::result::Result< 5443 5443 - tonic::Response<super::PlaylistResumeResponse>, 5444 5444 - tonic::Status, 5445 5445 - > { 5446 5446 - self.inner 5447 5447 - .ready() 5448 5448 - .await 5449 5449 - .map_err(|e| { 5450 5450 - tonic::Status::unknown( 5451 5451 - format!("Service was not ready: {}", e.into()), 5452 5452 - ) 5453 5453 - })?; 4712 4712 + ) -> std::result::Result<tonic::Response<super::PlaylistResumeResponse>, tonic::Status> 4713 4713 + { 4714 4714 + self.inner.ready().await.map_err(|e| { 4715 4715 + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 4716 4716 + })?; 5454 4717 let codec = tonic::codec::ProstCodec::default(); 5455 4718 let path = http::uri::PathAndQuery::from_static( 5456 4719 "/rockbox.v1alpha1.PlaylistService/PlaylistResume", 5457 4720 ); 5458 4721 let mut req = request.into_request(); 5459 5459 - req.extensions_mut() 5460 5460 - .insert( 5461 5461 - GrpcMethod::new("rockbox.v1alpha1.PlaylistService", "PlaylistResume"), 5462 5462 - ); 4722 4722 + req.extensions_mut().insert(GrpcMethod::new( 4723 4723 + "rockbox.v1alpha1.PlaylistService", 4724 4724 + "PlaylistResume", 4725 4725 + )); 5463 4726 self.inner.unary(req, path, codec).await 5464 4727 } 5465 4728 pub async fn resume_track( 5466 4729 &mut self, 5467 4730 request: impl tonic::IntoRequest<super::ResumeTrackRequest>, 5468 5468 - ) -> std::result::Result< 5469 5469 - tonic::Response<super::ResumeTrackResponse>, 5470 5470 - tonic::Status, 5471 5471 - > { 5472 5472 - self.inner 5473 5473 - .ready() 5474 5474 - .await 5475 5475 - .map_err(|e| { 5476 5476 - tonic::Status::unknown( 5477 5477 - format!("Service was not ready: {}", e.into()), 5478 5478 - ) 5479 5479 - })?; 4731 4731 + ) -> std::result::Result<tonic::Response<super::ResumeTrackResponse>, tonic::Status> 4732 4732 + { 4733 4733 + self.inner.ready().await.map_err(|e| { 4734 4734 + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 4735 4735 + })?; 5480 4736 let codec = tonic::codec::ProstCodec::default(); 5481 4737 let path = http::uri::PathAndQuery::from_static( 5482 4738 "/rockbox.v1alpha1.PlaylistService/ResumeTrack", 5483 4739 ); 5484 4740 let mut req = request.into_request(); 5485 5485 - req.extensions_mut() 5486 5486 - .insert( 5487 5487 - GrpcMethod::new("rockbox.v1alpha1.PlaylistService", "ResumeTrack"), 5488 5488 - ); 4741 4741 + req.extensions_mut().insert(GrpcMethod::new( 4742 4742 + "rockbox.v1alpha1.PlaylistService", 4743 4743 + "ResumeTrack", 4744 4744 + )); 5489 4745 self.inner.unary(req, path, codec).await 5490 4746 } 5491 4747 pub async fn set_modified( 5492 4748 &mut self, 5493 4749 request: impl tonic::IntoRequest<super::SetModifiedRequest>, 5494 5494 - ) -> std::result::Result< 5495 5495 - tonic::Response<super::SetModifiedResponse>, 5496 5496 - tonic::Status, 5497 5497 - > { 5498 5498 - self.inner 5499 5499 - .ready() 5500 5500 - .await 5501 5501 - .map_err(|e| { 5502 5502 - tonic::Status::unknown( 5503 5503 - format!("Service was not ready: {}", e.into()), 5504 5504 - ) 5505 5505 - })?; 4750 4750 + ) -> std::result::Result<tonic::Response<super::SetModifiedResponse>, tonic::Status> 4751 4751 + { 4752 4752 + self.inner.ready().await.map_err(|e| { 4753 4753 + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 4754 4754 + })?; 5506 4755 let codec = tonic::codec::ProstCodec::default(); 5507 4756 let path = http::uri::PathAndQuery::from_static( 5508 4757 "/rockbox.v1alpha1.PlaylistService/SetModified", 5509 4758 ); 5510 4759 let mut req = request.into_request(); 5511 5511 - req.extensions_mut() 5512 5512 - .insert( 5513 5513 - GrpcMethod::new("rockbox.v1alpha1.PlaylistService", "SetModified"), 5514 5514 - ); 4760 4760 + req.extensions_mut().insert(GrpcMethod::new( 4761 4761 + "rockbox.v1alpha1.PlaylistService", 4762 4762 + "SetModified", 4763 4763 + )); 5515 4764 self.inner.unary(req, path, codec).await 5516 4765 } 5517 4766 pub async fn start( 5518 4767 &mut self, 5519 4768 request: impl tonic::IntoRequest<super::StartRequest>, 5520 4769 ) -> std::result::Result<tonic::Response<super::StartResponse>, tonic::Status> { 5521 5521 - self.inner 5522 5522 - .ready() 5523 5523 - .await 5524 5524 - .map_err(|e| { 5525 5525 - tonic::Status::unknown( 5526 5526 - format!("Service was not ready: {}", e.into()), 5527 5527 - ) 5528 5528 - })?; 4770 4770 + self.inner.ready().await.map_err(|e| { 4771 4771 + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 4772 4772 + })?; 5529 4773 let codec = tonic::codec::ProstCodec::default(); 5530 5530 - let path = http::uri::PathAndQuery::from_static( 5531 5531 - "/rockbox.v1alpha1.PlaylistService/Start", 5532 5532 - ); 4774 4774 + let path = 4775 4775 + http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.PlaylistService/Start"); 5533 4776 let mut req = request.into_request(); 5534 4777 req.extensions_mut() 5535 4778 .insert(GrpcMethod::new("rockbox.v1alpha1.PlaylistService", "Start")); ··· 5539 4782 &mut self, 5540 4783 request: impl tonic::IntoRequest<super::SyncRequest>, 5541 4784 ) -> std::result::Result<tonic::Response<super::SyncResponse>, tonic::Status> { 5542 5542 - self.inner 5543 5543 - .ready() 5544 5544 - .await 5545 5545 - .map_err(|e| { 5546 5546 - tonic::Status::unknown( 5547 5547 - format!("Service was not ready: {}", e.into()), 5548 5548 - ) 5549 5549 - })?; 4785 4785 + self.inner.ready().await.map_err(|e| { 4786 4786 + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 4787 4787 + })?; 5550 4788 let codec = tonic::codec::ProstCodec::default(); 5551 5551 - let path = http::uri::PathAndQuery::from_static( 5552 5552 - "/rockbox.v1alpha1.PlaylistService/Sync", 5553 5553 - ); 4789 4789 + let path = 4790 4790 + http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.PlaylistService/Sync"); 5554 4791 let mut req = request.into_request(); 5555 4792 req.extensions_mut() 5556 4793 .insert(GrpcMethod::new("rockbox.v1alpha1.PlaylistService", "Sync")); ··· 5559 4796 pub async fn remove_all_tracks( 5560 4797 &mut self, 5561 4798 request: impl tonic::IntoRequest<super::RemoveAllTracksRequest>, 5562 5562 - ) -> std::result::Result< 5563 5563 - tonic::Response<super::RemoveAllTracksResponse>, 5564 5564 - tonic::Status, 5565 5565 - > { 5566 5566 - self.inner 5567 5567 - .ready() 5568 5568 - .await 5569 5569 - .map_err(|e| { 5570 5570 - tonic::Status::unknown( 5571 5571 - format!("Service was not ready: {}", e.into()), 5572 5572 - ) 5573 5573 - })?; 4799 4799 + ) -> std::result::Result<tonic::Response<super::RemoveAllTracksResponse>, tonic::Status> 4800 4800 + { 4801 4801 + self.inner.ready().await.map_err(|e| { 4802 4802 + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 4803 4803 + })?; 5574 4804 let codec = tonic::codec::ProstCodec::default(); 5575 4805 let path = http::uri::PathAndQuery::from_static( 5576 4806 "/rockbox.v1alpha1.PlaylistService/RemoveAllTracks", 5577 4807 ); 5578 4808 let mut req = request.into_request(); 5579 5579 - req.extensions_mut() 5580 5580 - .insert( 5581 5581 - GrpcMethod::new( 5582 5582 - "rockbox.v1alpha1.PlaylistService", 5583 5583 - "RemoveAllTracks", 5584 5584 - ), 5585 5585 - ); 4809 4809 + req.extensions_mut().insert(GrpcMethod::new( 4810 4810 + "rockbox.v1alpha1.PlaylistService", 4811 4811 + "RemoveAllTracks", 4812 4812 + )); 5586 4813 self.inner.unary(req, path, codec).await 5587 4814 } 5588 4815 pub async fn remove_tracks( 5589 4816 &mut self, 5590 4817 request: impl tonic::IntoRequest<super::RemoveTracksRequest>, 5591 5591 - ) -> std::result::Result< 5592 5592 - tonic::Response<super::RemoveTracksResponse>, 5593 5593 - tonic::Status, 5594 5594 - > { 5595 5595 - self.inner 5596 5596 - .ready() 5597 5597 - .await 5598 5598 - .map_err(|e| { 5599 5599 - tonic::Status::unknown( 5600 5600 - format!("Service was not ready: {}", e.into()), 5601 5601 - ) 5602 5602 - })?; 4818 4818 + ) -> std::result::Result<tonic::Response<super::RemoveTracksResponse>, tonic::Status> 4819 4819 + { 4820 4820 + self.inner.ready().await.map_err(|e| { 4821 4821 + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 4822 4822 + })?; 5603 4823 let codec = tonic::codec::ProstCodec::default(); 5604 4824 let path = http::uri::PathAndQuery::from_static( 5605 4825 "/rockbox.v1alpha1.PlaylistService/RemoveTracks", 5606 4826 ); 5607 4827 let mut req = request.into_request(); 5608 5608 - req.extensions_mut() 5609 5609 - .insert( 5610 5610 - GrpcMethod::new("rockbox.v1alpha1.PlaylistService", "RemoveTracks"), 5611 5611 - ); 4828 4828 + req.extensions_mut().insert(GrpcMethod::new( 4829 4829 + "rockbox.v1alpha1.PlaylistService", 4830 4830 + "RemoveTracks", 4831 4831 + )); 5612 4832 self.inner.unary(req, path, codec).await 5613 4833 } 5614 4834 pub async fn create_playlist( 5615 4835 &mut self, 5616 4836 request: impl tonic::IntoRequest<super::CreatePlaylistRequest>, 5617 5617 - ) -> std::result::Result< 5618 5618 - tonic::Response<super::CreatePlaylistResponse>, 5619 5619 - tonic::Status, 5620 5620 - > { 5621 5621 - self.inner 5622 5622 - .ready() 5623 5623 - .await 5624 5624 - .map_err(|e| { 5625 5625 - tonic::Status::unknown( 5626 5626 - format!("Service was not ready: {}", e.into()), 5627 5627 - ) 5628 5628 - })?; 4837 4837 + ) -> std::result::Result<tonic::Response<super::CreatePlaylistResponse>, tonic::Status> 4838 4838 + { 4839 4839 + self.inner.ready().await.map_err(|e| { 4840 4840 + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 4841 4841 + })?; 5629 4842 let codec = tonic::codec::ProstCodec::default(); 5630 4843 let path = http::uri::PathAndQuery::from_static( 5631 4844 "/rockbox.v1alpha1.PlaylistService/CreatePlaylist", 5632 4845 ); 5633 4846 let mut req = request.into_request(); 5634 5634 - req.extensions_mut() 5635 5635 - .insert( 5636 5636 - GrpcMethod::new("rockbox.v1alpha1.PlaylistService", "CreatePlaylist"), 5637 5637 - ); 4847 4847 + req.extensions_mut().insert(GrpcMethod::new( 4848 4848 + "rockbox.v1alpha1.PlaylistService", 4849 4849 + "CreatePlaylist", 4850 4850 + )); 5638 4851 self.inner.unary(req, path, codec).await 5639 4852 } 5640 4853 pub async fn insert_tracks( 5641 4854 &mut self, 5642 4855 request: impl tonic::IntoRequest<super::InsertTracksRequest>, 5643 5643 - ) -> std::result::Result< 5644 5644 - tonic::Response<super::InsertTracksResponse>, 5645 5645 - tonic::Status, 5646 5646 - > { 5647 5647 - self.inner 5648 5648 - .ready() 5649 5649 - .await 5650 5650 - .map_err(|e| { 5651 5651 - tonic::Status::unknown( 5652 5652 - format!("Service was not ready: {}", e.into()), 5653 5653 - ) 5654 5654 - })?; 4856 4856 + ) -> std::result::Result<tonic::Response<super::InsertTracksResponse>, tonic::Status> 4857 4857 + { 4858 4858 + self.inner.ready().await.map_err(|e| { 4859 4859 + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 4860 4860 + })?; 5655 4861 let codec = tonic::codec::ProstCodec::default(); 5656 4862 let path = http::uri::PathAndQuery::from_static( 5657 4863 "/rockbox.v1alpha1.PlaylistService/InsertTracks", 5658 4864 ); 5659 4865 let mut req = request.into_request(); 5660 5660 - req.extensions_mut() 5661 5661 - .insert( 5662 5662 - GrpcMethod::new("rockbox.v1alpha1.PlaylistService", "InsertTracks"), 5663 5663 - ); 4866 4866 + req.extensions_mut().insert(GrpcMethod::new( 4867 4867 + "rockbox.v1alpha1.PlaylistService", 4868 4868 + "InsertTracks", 4869 4869 + )); 5664 4870 self.inner.unary(req, path, codec).await 5665 4871 } 5666 4872 pub async fn insert_directory( 5667 4873 &mut self, 5668 4874 request: impl tonic::IntoRequest<super::InsertDirectoryRequest>, 5669 5669 - ) -> std::result::Result< 5670 5670 - tonic::Response<super::InsertDirectoryResponse>, 5671 5671 - tonic::Status, 5672 5672 - > { 5673 5673 - self.inner 5674 5674 - .ready() 5675 5675 - .await 5676 5676 - .map_err(|e| { 5677 5677 - tonic::Status::unknown( 5678 5678 - format!("Service was not ready: {}", e.into()), 5679 5679 - ) 5680 5680 - })?; 4875 4875 + ) -> std::result::Result<tonic::Response<super::InsertDirectoryResponse>, tonic::Status> 4876 4876 + { 4877 4877 + self.inner.ready().await.map_err(|e| { 4878 4878 + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 4879 4879 + })?; 5681 4880 let codec = tonic::codec::ProstCodec::default(); 5682 4881 let path = http::uri::PathAndQuery::from_static( 5683 4882 "/rockbox.v1alpha1.PlaylistService/InsertDirectory", 5684 4883 ); 5685 4884 let mut req = request.into_request(); 5686 5686 - req.extensions_mut() 5687 5687 - .insert( 5688 5688 - GrpcMethod::new( 5689 5689 - "rockbox.v1alpha1.PlaylistService", 5690 5690 - "InsertDirectory", 5691 5691 - ), 5692 5692 - ); 4885 4885 + req.extensions_mut().insert(GrpcMethod::new( 4886 4886 + "rockbox.v1alpha1.PlaylistService", 4887 4887 + "InsertDirectory", 4888 4888 + )); 5693 4889 self.inner.unary(req, path, codec).await 5694 4890 } 5695 4891 pub async fn insert_playlist( 5696 4892 &mut self, 5697 4893 request: impl tonic::IntoRequest<super::InsertPlaylistRequest>, 5698 5698 - ) -> std::result::Result< 5699 5699 - tonic::Response<super::InsertPlaylistResponse>, 5700 5700 - tonic::Status, 5701 5701 - > { 5702 5702 - self.inner 5703 5703 - .ready() 5704 5704 - .await 5705 5705 - .map_err(|e| { 5706 5706 - tonic::Status::unknown( 5707 5707 - format!("Service was not ready: {}", e.into()), 5708 5708 - ) 5709 5709 - })?; 4894 4894 + ) -> std::result::Result<tonic::Response<super::InsertPlaylistResponse>, tonic::Status> 4895 4895 + { 4896 4896 + self.inner.ready().await.map_err(|e| { 4897 4897 + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 4898 4898 + })?; 5710 4899 let codec = tonic::codec::ProstCodec::default(); 5711 4900 let path = http::uri::PathAndQuery::from_static( 5712 4901 "/rockbox.v1alpha1.PlaylistService/InsertPlaylist", 5713 4902 ); 5714 4903 let mut req = request.into_request(); 5715 5715 - req.extensions_mut() 5716 5716 - .insert( 5717 5717 - GrpcMethod::new("rockbox.v1alpha1.PlaylistService", "InsertPlaylist"), 5718 5718 - ); 4904 4904 + req.extensions_mut().insert(GrpcMethod::new( 4905 4905 + "rockbox.v1alpha1.PlaylistService", 4906 4906 + "InsertPlaylist", 4907 4907 + )); 5719 4908 self.inner.unary(req, path, codec).await 5720 4909 } 5721 4910 pub async fn insert_album( 5722 4911 &mut self, 5723 4912 request: impl tonic::IntoRequest<super::InsertAlbumRequest>, 5724 5724 - ) -> std::result::Result< 5725 5725 - tonic::Response<super::InsertAlbumResponse>, 5726 5726 - tonic::Status, 5727 5727 - > { 5728 5728 - self.inner 5729 5729 - .ready() 5730 5730 - .await 5731 5731 - .map_err(|e| { 5732 5732 - tonic::Status::unknown( 5733 5733 - format!("Service was not ready: {}", e.into()), 5734 5734 - ) 5735 5735 - })?; 4913 4913 + ) -> std::result::Result<tonic::Response<super::InsertAlbumResponse>, tonic::Status> 4914 4914 + { 4915 4915 + self.inner.ready().await.map_err(|e| { 4916 4916 + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 4917 4917 + })?; 5736 4918 let codec = tonic::codec::ProstCodec::default(); 5737 4919 let path = http::uri::PathAndQuery::from_static( 5738 4920 "/rockbox.v1alpha1.PlaylistService/InsertAlbum", 5739 4921 ); 5740 4922 let mut req = request.into_request(); 5741 5741 - req.extensions_mut() 5742 5742 - .insert( 5743 5743 - GrpcMethod::new("rockbox.v1alpha1.PlaylistService", "InsertAlbum"), 5744 5744 - ); 4923 4923 + req.extensions_mut().insert(GrpcMethod::new( 4924 4924 + "rockbox.v1alpha1.PlaylistService", 4925 4925 + "InsertAlbum", 4926 4926 + )); 5745 4927 self.inner.unary(req, path, codec).await 5746 4928 } 5747 4929 pub async fn insert_artist_tracks( 5748 4930 &mut self, 5749 4931 request: impl tonic::IntoRequest<super::InsertArtistTracksRequest>, 5750 5750 - ) -> std::result::Result< 5751 5751 - tonic::Response<super::InsertArtistTracksResponse>, 5752 5752 - tonic::Status, 5753 5753 - > { 5754 5754 - self.inner 5755 5755 - .ready() 5756 5756 - .await 5757 5757 - .map_err(|e| { 5758 5758 - tonic::Status::unknown( 5759 5759 - format!("Service was not ready: {}", e.into()), 5760 5760 - ) 5761 5761 - })?; 4932 4932 + ) -> std::result::Result<tonic::Response<super::InsertArtistTracksResponse>, tonic::Status> 4933 4933 + { 4934 4934 + self.inner.ready().await.map_err(|e| { 4935 4935 + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 4936 4936 + })?; 5762 4937 let codec = tonic::codec::ProstCodec::default(); 5763 4938 let path = http::uri::PathAndQuery::from_static( 5764 4939 "/rockbox.v1alpha1.PlaylistService/InsertArtistTracks", 5765 4940 ); 5766 4941 let mut req = request.into_request(); 5767 5767 - req.extensions_mut() 5768 5768 - .insert( 5769 5769 - GrpcMethod::new( 5770 5770 - "rockbox.v1alpha1.PlaylistService", 5771 5771 - "InsertArtistTracks", 5772 5772 - ), 5773 5773 - ); 4942 4942 + req.extensions_mut().insert(GrpcMethod::new( 4943 4943 + "rockbox.v1alpha1.PlaylistService", 4944 4944 + "InsertArtistTracks", 4945 4945 + )); 5774 4946 self.inner.unary(req, path, codec).await 5775 4947 } 5776 4948 pub async fn shuffle_playlist( 5777 4949 &mut self, 5778 4950 request: impl tonic::IntoRequest<super::ShufflePlaylistRequest>, 5779 5779 - ) -> std::result::Result< 5780 5780 - tonic::Response<super::ShufflePlaylistResponse>, 5781 5781 - tonic::Status, 5782 5782 - > { 5783 5783 - self.inner 5784 5784 - .ready() 5785 5785 - .await 5786 5786 - .map_err(|e| { 5787 5787 - tonic::Status::unknown( 5788 5788 - format!("Service was not ready: {}", e.into()), 5789 5789 - ) 5790 5790 - })?; 4951 4951 + ) -> std::result::Result<tonic::Response<super::ShufflePlaylistResponse>, tonic::Status> 4952 4952 + { 4953 4953 + self.inner.ready().await.map_err(|e| { 4954 4954 + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 4955 4955 + })?; 5791 4956 let codec = tonic::codec::ProstCodec::default(); 5792 4957 let path = http::uri::PathAndQuery::from_static( 5793 4958 "/rockbox.v1alpha1.PlaylistService/ShufflePlaylist", 5794 4959 ); 5795 4960 let mut req = request.into_request(); 5796 5796 - req.extensions_mut() 5797 5797 - .insert( 5798 5798 - GrpcMethod::new( 5799 5799 - "rockbox.v1alpha1.PlaylistService", 5800 5800 - "ShufflePlaylist", 5801 5801 - ), 5802 5802 - ); 4961 4961 + req.extensions_mut().insert(GrpcMethod::new( 4962 4962 + "rockbox.v1alpha1.PlaylistService", 4963 4963 + "ShufflePlaylist", 4964 4964 + )); 5803 4965 self.inner.unary(req, path, codec).await 5804 4966 } 5805 4967 } ··· 5811 4973 dead_code, 5812 4974 missing_docs, 5813 4975 clippy::wildcard_imports, 5814 5814 - clippy::let_unit_value, 4976 4976 + clippy::let_unit_value 5815 4977 )] 5816 4978 use tonic::codegen::*; 5817 4979 /// Generated trait containing gRPC methods that should be implemented for use with PlaylistServiceServer. ··· 5820 4982 async fn get_current( 5821 4983 &self, 5822 4984 request: tonic::Request<super::GetCurrentRequest>, 5823 5823 - ) -> std::result::Result< 5824 5824 - tonic::Response<super::GetCurrentResponse>, 5825 5825 - tonic::Status, 5826 5826 - >; 4985 4985 + ) -> std::result::Result<tonic::Response<super::GetCurrentResponse>, tonic::Status>; 5827 4986 async fn get_resume_info( 5828 4987 &self, 5829 4988 request: tonic::Request<super::GetResumeInfoRequest>, 5830 5830 - ) -> std::result::Result< 5831 5831 - tonic::Response<super::GetResumeInfoResponse>, 5832 5832 - tonic::Status, 5833 5833 - >; 4989 4989 + ) -> std::result::Result<tonic::Response<super::GetResumeInfoResponse>, tonic::Status>; 5834 4990 async fn get_track_info( 5835 4991 &self, 5836 4992 request: tonic::Request<super::GetTrackInfoRequest>, 5837 5837 - ) -> std::result::Result< 5838 5838 - tonic::Response<super::GetTrackInfoResponse>, 5839 5839 - tonic::Status, 5840 5840 - >; 4993 4993 + ) -> std::result::Result<tonic::Response<super::GetTrackInfoResponse>, tonic::Status>; 5841 4994 async fn get_first_index( 5842 4995 &self, 5843 4996 request: tonic::Request<super::GetFirstIndexRequest>, 5844 5844 - ) -> std::result::Result< 5845 5845 - tonic::Response<super::GetFirstIndexResponse>, 5846 5846 - tonic::Status, 5847 5847 - >; 4997 4997 + ) -> std::result::Result<tonic::Response<super::GetFirstIndexResponse>, tonic::Status>; 5848 4998 async fn get_display_index( 5849 4999 &self, 5850 5000 request: tonic::Request<super::GetDisplayIndexRequest>, 5851 5851 - ) -> std::result::Result< 5852 5852 - tonic::Response<super::GetDisplayIndexResponse>, 5853 5853 - tonic::Status, 5854 5854 - >; 5001 5001 + ) -> std::result::Result<tonic::Response<super::GetDisplayIndexResponse>, tonic::Status>; 5855 5002 async fn amount( 5856 5003 &self, 5857 5004 request: tonic::Request<super::AmountRequest>, ··· 5859 5006 async fn playlist_resume( 5860 5007 &self, 5861 5008 request: tonic::Request<super::PlaylistResumeRequest>, 5862 5862 - ) -> std::result::Result< 5863 5863 - tonic::Response<super::PlaylistResumeResponse>, 5864 5864 - tonic::Status, 5865 5865 - >; 5009 5009 + ) -> std::result::Result<tonic::Response<super::PlaylistResumeResponse>, tonic::Status>; 5866 5010 async fn resume_track( 5867 5011 &self, 5868 5012 request: tonic::Request<super::ResumeTrackRequest>, 5869 5869 - ) -> std::result::Result< 5870 5870 - tonic::Response<super::ResumeTrackResponse>, 5871 5871 - tonic::Status, 5872 5872 - >; 5013 5013 + ) -> std::result::Result<tonic::Response<super::ResumeTrackResponse>, tonic::Status>; 5873 5014 async fn set_modified( 5874 5015 &self, 5875 5016 request: tonic::Request<super::SetModifiedRequest>, 5876 5876 - ) -> std::result::Result< 5877 5877 - tonic::Response<super::SetModifiedResponse>, 5878 5878 - tonic::Status, 5879 5879 - >; 5017 5017 + ) -> std::result::Result<tonic::Response<super::SetModifiedResponse>, tonic::Status>; 5880 5018 async fn start( 5881 5019 &self, 5882 5020 request: tonic::Request<super::StartRequest>, ··· 5888 5026 async fn remove_all_tracks( 5889 5027 &self, 5890 5028 request: tonic::Request<super::RemoveAllTracksRequest>, 5891 5891 - ) -> std::result::Result< 5892 5892 - tonic::Response<super::RemoveAllTracksResponse>, 5893 5893 - tonic::Status, 5894 5894 - >; 5029 5029 + ) -> std::result::Result<tonic::Response<super::RemoveAllTracksResponse>, tonic::Status>; 5895 5030 async fn remove_tracks( 5896 5031 &self, 5897 5032 request: tonic::Request<super::RemoveTracksRequest>, 5898 5898 - ) -> std::result::Result< 5899 5899 - tonic::Response<super::RemoveTracksResponse>, 5900 5900 - tonic::Status, 5901 5901 - >; 5033 5033 + ) -> std::result::Result<tonic::Response<super::RemoveTracksResponse>, tonic::Status>; 5902 5034 async fn create_playlist( 5903 5035 &self, 5904 5036 request: tonic::Request<super::CreatePlaylistRequest>, 5905 5905 - ) -> std::result::Result< 5906 5906 - tonic::Response<super::CreatePlaylistResponse>, 5907 5907 - tonic::Status, 5908 5908 - >; 5037 5037 + ) -> std::result::Result<tonic::Response<super::CreatePlaylistResponse>, tonic::Status>; 5909 5038 async fn insert_tracks( 5910 5039 &self, 5911 5040 request: tonic::Request<super::InsertTracksRequest>, 5912 5912 - ) -> std::result::Result< 5913 5913 - tonic::Response<super::InsertTracksResponse>, 5914 5914 - tonic::Status, 5915 5915 - >; 5041 5041 + ) -> std::result::Result<tonic::Response<super::InsertTracksResponse>, tonic::Status>; 5916 5042 async fn insert_directory( 5917 5043 &self, 5918 5044 request: tonic::Request<super::InsertDirectoryRequest>, 5919 5919 - ) -> std::result::Result< 5920 5920 - tonic::Response<super::InsertDirectoryResponse>, 5921 5921 - tonic::Status, 5922 5922 - >; 5045 5045 + ) -> std::result::Result<tonic::Response<super::InsertDirectoryResponse>, tonic::Status>; 5923 5046 async fn insert_playlist( 5924 5047 &self, 5925 5048 request: tonic::Request<super::InsertPlaylistRequest>, 5926 5926 - ) -> std::result::Result< 5927 5927 - tonic::Response<super::InsertPlaylistResponse>, 5928 5928 - tonic::Status, 5929 5929 - >; 5049 5049 + ) -> std::result::Result<tonic::Response<super::InsertPlaylistResponse>, tonic::Status>; 5930 5050 async fn insert_album( 5931 5051 &self, 5932 5052 request: tonic::Request<super::InsertAlbumRequest>, 5933 5933 - ) -> std::result::Result< 5934 5934 - tonic::Response<super::InsertAlbumResponse>, 5935 5935 - tonic::Status, 5936 5936 - >; 5053 5053 + ) -> std::result::Result<tonic::Response<super::InsertAlbumResponse>, tonic::Status>; 5937 5054 async fn insert_artist_tracks( 5938 5055 &self, 5939 5056 request: tonic::Request<super::InsertArtistTracksRequest>, 5940 5940 - ) -> std::result::Result< 5941 5941 - tonic::Response<super::InsertArtistTracksResponse>, 5942 5942 - tonic::Status, 5943 5943 - >; 5057 5057 + ) -> std::result::Result<tonic::Response<super::InsertArtistTracksResponse>, tonic::Status>; 5944 5058 async fn shuffle_playlist( 5945 5059 &self, 5946 5060 request: tonic::Request<super::ShufflePlaylistRequest>, 5947 5947 - ) -> std::result::Result< 5948 5948 - tonic::Response<super::ShufflePlaylistResponse>, 5949 5949 - tonic::Status, 5950 5950 - >; 5061 5061 + ) -> std::result::Result<tonic::Response<super::ShufflePlaylistResponse>, tonic::Status>; 5951 5062 } 5952 5063 #[derive(Debug)] 5953 5064 pub struct PlaylistServiceServer<T> { ··· 5970 5081 max_encoding_message_size: None, 5971 5082 } 5972 5083 } 5973 5973 - pub fn with_interceptor<F>( 5974 5974 - inner: T, 5975 5975 - interceptor: F, 5976 5976 - ) -> InterceptedService<Self, F> 5084 5084 + pub fn with_interceptor<F>(inner: T, interceptor: F) -> InterceptedService<Self, F> 5977 5085 where 5978 5086 F: tonic::service::Interceptor, 5979 5087 { ··· 6028 5136 "/rockbox.v1alpha1.PlaylistService/GetCurrent" => { 6029 5137 #[allow(non_camel_case_types)] 6030 5138 struct GetCurrentSvc<T: PlaylistService>(pub Arc<T>); 6031 6031 - impl< 6032 6032 - T: PlaylistService, 6033 6033 - > tonic::server::UnaryService<super::GetCurrentRequest> 6034 6034 - for GetCurrentSvc<T> { 5139 5139 + impl<T: PlaylistService> tonic::server::UnaryService<super::GetCurrentRequest> 5140 5140 + for GetCurrentSvc<T> 5141 5141 + { 6035 5142 type Response = super::GetCurrentResponse; 6036 6036 - type Future = BoxFuture< 6037 6037 - tonic::Response<Self::Response>, 6038 6038 - tonic::Status, 6039 6039 - >; 5143 5143 + type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 6040 5144 fn call( 6041 5145 &mut self, 6042 5146 request: tonic::Request<super::GetCurrentRequest>, ··· 6073 5177 "/rockbox.v1alpha1.PlaylistService/GetResumeInfo" => { 6074 5178 #[allow(non_camel_case_types)] 6075 5179 struct GetResumeInfoSvc<T: PlaylistService>(pub Arc<T>); 6076 6076 - impl< 6077 6077 - T: PlaylistService, 6078 6078 - > tonic::server::UnaryService<super::GetResumeInfoRequest> 6079 6079 - for GetResumeInfoSvc<T> { 5180 5180 + impl<T: PlaylistService> 5181 5181 + tonic::server::UnaryService<super::GetResumeInfoRequest> 5182 5182 + for GetResumeInfoSvc<T> 5183 5183 + { 6080 5184 type Response = super::GetResumeInfoResponse; 6081 6081 - type Future = BoxFuture< 6082 6082 - tonic::Response<Self::Response>, 6083 6083 - tonic::Status, 6084 6084 - >; 5185 5185 + type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 6085 5186 fn call( 6086 5187 &mut self, 6087 5188 request: tonic::Request<super::GetResumeInfoRequest>, 6088 5189 ) -> Self::Future { 6089 5190 let inner = Arc::clone(&self.0); 6090 5191 let fut = async move { 6091 6091 - <T as PlaylistService>::get_resume_info(&inner, request) 6092 6092 - .await 5192 5192 + <T as PlaylistService>::get_resume_info(&inner, request).await 6093 5193 }; 6094 5194 Box::pin(fut) 6095 5195 } ··· 6119 5219 "/rockbox.v1alpha1.PlaylistService/GetTrackInfo" => { 6120 5220 #[allow(non_camel_case_types)] 6121 5221 struct GetTrackInfoSvc<T: PlaylistService>(pub Arc<T>); 6122 6122 - impl< 6123 6123 - T: PlaylistService, 6124 6124 - > tonic::server::UnaryService<super::GetTrackInfoRequest> 6125 6125 - for GetTrackInfoSvc<T> { 5222 5222 + impl<T: PlaylistService> tonic::server::UnaryService<super::GetTrackInfoRequest> 5223 5223 + for GetTrackInfoSvc<T> 5224 5224 + { 6126 5225 type Response = super::GetTrackInfoResponse; 6127 6127 - type Future = BoxFuture< 6128 6128 - tonic::Response<Self::Response>, 6129 6129 - tonic::Status, 6130 6130 - >; 5226 5226 + type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 6131 5227 fn call( 6132 5228 &mut self, 6133 5229 request: tonic::Request<super::GetTrackInfoRequest>, 6134 5230 ) -> Self::Future { 6135 5231 let inner = Arc::clone(&self.0); 6136 5232 let fut = async move { 6137 6137 - <T as PlaylistService>::get_track_info(&inner, request) 6138 6138 - .await 5233 5233 + <T as PlaylistService>::get_track_info(&inner, request).await 6139 5234 }; 6140 5235 Box::pin(fut) 6141 5236 } ··· 6165 5260 "/rockbox.v1alpha1.PlaylistService/GetFirstIndex" => { 6166 5261 #[allow(non_camel_case_types)] 6167 5262 struct GetFirstIndexSvc<T: PlaylistService>(pub Arc<T>); 6168 6168 - impl< 6169 6169 - T: PlaylistService, 6170 6170 - > tonic::server::UnaryService<super::GetFirstIndexRequest> 6171 6171 - for GetFirstIndexSvc<T> { 5263 5263 + impl<T: PlaylistService> 5264 5264 + tonic::server::UnaryService<super::GetFirstIndexRequest> 5265 5265 + for GetFirstIndexSvc<T> 5266 5266 + { 6172 5267 type Response = super::GetFirstIndexResponse; 6173 6173 - type Future = BoxFuture< 6174 6174 - tonic::Response<Self::Response>, 6175 6175 - tonic::Status, 6176 6176 - >; 5268 5268 + type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 6177 5269 fn call( 6178 5270 &mut self, 6179 5271 request: tonic::Request<super::GetFirstIndexRequest>, 6180 5272 ) -> Self::Future { 6181 5273 let inner = Arc::clone(&self.0); 6182 5274 let fut = async move { 6183 6183 - <T as PlaylistService>::get_first_index(&inner, request) 6184 6184 - .await 5275 5275 + <T as PlaylistService>::get_first_index(&inner, request).await 6185 5276 }; 6186 5277 Box::pin(fut) 6187 5278 } ··· 6211 5302 "/rockbox.v1alpha1.PlaylistService/GetDisplayIndex" => { 6212 5303 #[allow(non_camel_case_types)] 6213 5304 struct GetDisplayIndexSvc<T: PlaylistService>(pub Arc<T>); 6214 6214 - impl< 6215 6215 - T: PlaylistService, 6216 6216 - > tonic::server::UnaryService<super::GetDisplayIndexRequest> 6217 6217 - for GetDisplayIndexSvc<T> { 5305 5305 + impl<T: PlaylistService> 5306 5306 + tonic::server::UnaryService<super::GetDisplayIndexRequest> 5307 5307 + for GetDisplayIndexSvc<T> 5308 5308 + { 6218 5309 type Response = super::GetDisplayIndexResponse; 6219 6219 - type Future = BoxFuture< 6220 6220 - tonic::Response<Self::Response>, 6221 6221 - tonic::Status, 6222 6222 - >; 5310 5310 + type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 6223 5311 fn call( 6224 5312 &mut self, 6225 5313 request: tonic::Request<super::GetDisplayIndexRequest>, 6226 5314 ) -> Self::Future { 6227 5315 let inner = Arc::clone(&self.0); 6228 5316 let fut = async move { 6229 6229 - <T as PlaylistService>::get_display_index(&inner, request) 6230 6230 - .await 5317 5317 + <T as PlaylistService>::get_display_index(&inner, request).await 6231 5318 }; 6232 5319 Box::pin(fut) 6233 5320 } ··· 6257 5344 "/rockbox.v1alpha1.PlaylistService/Amount" => { 6258 5345 #[allow(non_camel_case_types)] 6259 5346 struct AmountSvc<T: PlaylistService>(pub Arc<T>); 6260 6260 - impl< 6261 6261 - T: PlaylistService, 6262 6262 - > tonic::server::UnaryService<super::AmountRequest> 6263 6263 - for AmountSvc<T> { 5347 5347 + impl<T: PlaylistService> tonic::server::UnaryService<super::AmountRequest> for AmountSvc<T> { 6264 5348 type Response = super::AmountResponse; 6265 6265 - type Future = BoxFuture< 6266 6266 - tonic::Response<Self::Response>, 6267 6267 - tonic::Status, 6268 6268 - >; 5349 5349 + type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 6269 5350 fn call( 6270 5351 &mut self, 6271 5352 request: tonic::Request<super::AmountRequest>, ··· 6302 5383 "/rockbox.v1alpha1.PlaylistService/PlaylistResume" => { 6303 5384 #[allow(non_camel_case_types)] 6304 5385 struct PlaylistResumeSvc<T: PlaylistService>(pub Arc<T>); 6305 6305 - impl< 6306 6306 - T: PlaylistService, 6307 6307 - > tonic::server::UnaryService<super::PlaylistResumeRequest> 6308 6308 - for PlaylistResumeSvc<T> { 5386 5386 + impl<T: PlaylistService> 5387 5387 + tonic::server::UnaryService<super::PlaylistResumeRequest> 5388 5388 + for PlaylistResumeSvc<T> 5389 5389 + { 6309 5390 type Response = super::PlaylistResumeResponse; 6310 6310 - type Future = BoxFuture< 6311 6311 - tonic::Response<Self::Response>, 6312 6312 - tonic::Status, 6313 6313 - >; 5391 5391 + type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 6314 5392 fn call( 6315 5393 &mut self, 6316 5394 request: tonic::Request<super::PlaylistResumeRequest>, 6317 5395 ) -> Self::Future { 6318 5396 let inner = Arc::clone(&self.0); 6319 5397 let fut = async move { 6320 6320 - <T as PlaylistService>::playlist_resume(&inner, request) 6321 6321 - .await 5398 5398 + <T as PlaylistService>::playlist_resume(&inner, request).await 6322 5399 }; 6323 5400 Box::pin(fut) 6324 5401 } ··· 6348 5425 "/rockbox.v1alpha1.PlaylistService/ResumeTrack" => { 6349 5426 #[allow(non_camel_case_types)] 6350 5427 struct ResumeTrackSvc<T: PlaylistService>(pub Arc<T>); 6351 6351 - impl< 6352 6352 - T: PlaylistService, 6353 6353 - > tonic::server::UnaryService<super::ResumeTrackRequest> 6354 6354 - for ResumeTrackSvc<T> { 5428 5428 + impl<T: PlaylistService> tonic::server::UnaryService<super::ResumeTrackRequest> 5429 5429 + for ResumeTrackSvc<T> 5430 5430 + { 6355 5431 type Response = super::ResumeTrackResponse; 6356 6356 - type Future = BoxFuture< 6357 6357 - tonic::Response<Self::Response>, 6358 6358 - tonic::Status, 6359 6359 - >; 5432 5432 + type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 6360 5433 fn call( 6361 5434 &mut self, 6362 5435 request: tonic::Request<super::ResumeTrackRequest>, ··· 6393 5466 "/rockbox.v1alpha1.PlaylistService/SetModified" => { 6394 5467 #[allow(non_camel_case_types)] 6395 5468 struct SetModifiedSvc<T: PlaylistService>(pub Arc<T>); 6396 6396 - impl< 6397 6397 - T: PlaylistService, 6398 6398 - > tonic::server::UnaryService<super::SetModifiedRequest> 6399 6399 - for SetModifiedSvc<T> { 5469 5469 + impl<T: PlaylistService> tonic::server::UnaryService<super::SetModifiedRequest> 5470 5470 + for SetModifiedSvc<T> 5471 5471 + { 6400 5472 type Response = super::SetModifiedResponse; 6401 6401 - type Future = BoxFuture< 6402 6402 - tonic::Response<Self::Response>, 6403 6403 - tonic::Status, 6404 6404 - >; 5473 5473 + type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 6405 5474 fn call( 6406 5475 &mut self, 6407 5476 request: tonic::Request<super::SetModifiedRequest>, ··· 6438 5507 "/rockbox.v1alpha1.PlaylistService/Start" => { 6439 5508 #[allow(non_camel_case_types)] 6440 5509 struct StartSvc<T: PlaylistService>(pub Arc<T>); 6441 6441 - impl< 6442 6442 - T: PlaylistService, 6443 6443 - > tonic::server::UnaryService<super::StartRequest> for StartSvc<T> { 5510 5510 + impl<T: PlaylistService> tonic::server::UnaryService<super::StartRequest> for StartSvc<T> { 6444 5511 type Response = super::StartResponse; 6445 6445 - type Future = BoxFuture< 6446 6446 - tonic::Response<Self::Response>, 6447 6447 - tonic::Status, 6448 6448 - >; 5512 5512 + type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 6449 5513 fn call( 6450 5514 &mut self, 6451 5515 request: tonic::Request<super::StartRequest>, 6452 5516 ) -> Self::Future { 6453 5517 let inner = Arc::clone(&self.0); 6454 6454 - let fut = async move { 6455 6455 - <T as PlaylistService>::start(&inner, request).await 6456 6456 - }; 5518 5518 + let fut = 5519 5519 + async move { <T as PlaylistService>::start(&inner, request).await }; 6457 5520 Box::pin(fut) 6458 5521 } 6459 5522 } ··· 6482 5545 "/rockbox.v1alpha1.PlaylistService/Sync" => { 6483 5546 #[allow(non_camel_case_types)] 6484 5547 struct SyncSvc<T: PlaylistService>(pub Arc<T>); 6485 6485 - impl< 6486 6486 - T: PlaylistService, 6487 6487 - > tonic::server::UnaryService<super::SyncRequest> for SyncSvc<T> { 5548 5548 + impl<T: PlaylistService> tonic::server::UnaryService<super::SyncRequest> for SyncSvc<T> { 6488 5549 type Response = super::SyncResponse; 6489 6489 - type Future = BoxFuture< 6490 6490 - tonic::Response<Self::Response>, 6491 6491 - tonic::Status, 6492 6492 - >; 5550 5550 + type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 6493 5551 fn call( 6494 5552 &mut self, 6495 5553 request: tonic::Request<super::SyncRequest>, 6496 5554 ) -> Self::Future { 6497 5555 let inner = Arc::clone(&self.0); 6498 6498 - let fut = async move { 6499 6499 - <T as PlaylistService>::sync(&inner, request).await 6500 6500 - }; 5556 5556 + let fut = 5557 5557 + async move { <T as PlaylistService>::sync(&inner, request).await }; 6501 5558 Box::pin(fut) 6502 5559 } 6503 5560 } ··· 6526 5583 "/rockbox.v1alpha1.PlaylistService/RemoveAllTracks" => { 6527 5584 #[allow(non_camel_case_types)] 6528 5585 struct RemoveAllTracksSvc<T: PlaylistService>(pub Arc<T>); 6529 6529 - impl< 6530 6530 - T: PlaylistService, 6531 6531 - > tonic::server::UnaryService<super::RemoveAllTracksRequest> 6532 6532 - for RemoveAllTracksSvc<T> { 5586 5586 + impl<T: PlaylistService> 5587 5587 + tonic::server::UnaryService<super::RemoveAllTracksRequest> 5588 5588 + for RemoveAllTracksSvc<T> 5589 5589 + { 6533 5590 type Response = super::RemoveAllTracksResponse; 6534 6534 - type Future = BoxFuture< 6535 6535 - tonic::Response<Self::Response>, 6536 6536 - tonic::Status, 6537 6537 - >; 5591 5591 + type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 6538 5592 fn call( 6539 5593 &mut self, 6540 5594 request: tonic::Request<super::RemoveAllTracksRequest>, 6541 5595 ) -> Self::Future { 6542 5596 let inner = Arc::clone(&self.0); 6543 5597 let fut = async move { 6544 6544 - <T as PlaylistService>::remove_all_tracks(&inner, request) 6545 6545 - .await 5598 5598 + <T as PlaylistService>::remove_all_tracks(&inner, request).await 6546 5599 }; 6547 5600 Box::pin(fut) 6548 5601 } ··· 6572 5625 "/rockbox.v1alpha1.PlaylistService/RemoveTracks" => { 6573 5626 #[allow(non_camel_case_types)] 6574 5627 struct RemoveTracksSvc<T: PlaylistService>(pub Arc<T>); 6575 6575 - impl< 6576 6576 - T: PlaylistService, 6577 6577 - > tonic::server::UnaryService<super::RemoveTracksRequest> 6578 6578 - for RemoveTracksSvc<T> { 5628 5628 + impl<T: PlaylistService> tonic::server::UnaryService<super::RemoveTracksRequest> 5629 5629 + for RemoveTracksSvc<T> 5630 5630 + { 6579 5631 type Response = super::RemoveTracksResponse; 6580 6580 - type Future = BoxFuture< 6581 6581 - tonic::Response<Self::Response>, 6582 6582 - tonic::Status, 6583 6583 - >; 5632 5632 + type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 6584 5633 fn call( 6585 5634 &mut self, 6586 5635 request: tonic::Request<super::RemoveTracksRequest>, ··· 6617 5666 "/rockbox.v1alpha1.PlaylistService/CreatePlaylist" => { 6618 5667 #[allow(non_camel_case_types)] 6619 5668 struct CreatePlaylistSvc<T: PlaylistService>(pub Arc<T>); 6620 6620 - impl< 6621 6621 - T: PlaylistService, 6622 6622 - > tonic::server::UnaryService<super::CreatePlaylistRequest> 6623 6623 - for CreatePlaylistSvc<T> { 5669 5669 + impl<T: PlaylistService> 5670 5670 + tonic::server::UnaryService<super::CreatePlaylistRequest> 5671 5671 + for CreatePlaylistSvc<T> 5672 5672 + { 6624 5673 type Response = super::CreatePlaylistResponse; 6625 6625 - type Future = BoxFuture< 6626 6626 - tonic::Response<Self::Response>, 6627 6627 - tonic::Status, 6628 6628 - >; 5674 5674 + type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 6629 5675 fn call( 6630 5676 &mut self, 6631 5677 request: tonic::Request<super::CreatePlaylistRequest>, 6632 5678 ) -> Self::Future { 6633 5679 let inner = Arc::clone(&self.0); 6634 5680 let fut = async move { 6635 6635 - <T as PlaylistService>::create_playlist(&inner, request) 6636 6636 - .await 5681 5681 + <T as PlaylistService>::create_playlist(&inner, request).await 6637 5682 }; 6638 5683 Box::pin(fut) 6639 5684 } ··· 6663 5708 "/rockbox.v1alpha1.PlaylistService/InsertTracks" => { 6664 5709 #[allow(non_camel_case_types)] 6665 5710 struct InsertTracksSvc<T: PlaylistService>(pub Arc<T>); 6666 6666 - impl< 6667 6667 - T: PlaylistService, 6668 6668 - > tonic::server::UnaryService<super::InsertTracksRequest> 6669 6669 - for InsertTracksSvc<T> { 5711 5711 + impl<T: PlaylistService> tonic::server::UnaryService<super::InsertTracksRequest> 5712 5712 + for InsertTracksSvc<T> 5713 5713 + { 6670 5714 type Response = super::InsertTracksResponse; 6671 6671 - type Future = BoxFuture< 6672 6672 - tonic::Response<Self::Response>, 6673 6673 - tonic::Status, 6674 6674 - >; 5715 5715 + type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 6675 5716 fn call( 6676 5717 &mut self, 6677 5718 request: tonic::Request<super::InsertTracksRequest>, ··· 6708 5749 "/rockbox.v1alpha1.PlaylistService/InsertDirectory" => { 6709 5750 #[allow(non_camel_case_types)] 6710 5751 struct InsertDirectorySvc<T: PlaylistService>(pub Arc<T>); 6711 6711 - impl< 6712 6712 - T: PlaylistService, 6713 6713 - > tonic::server::UnaryService<super::InsertDirectoryRequest> 6714 6714 - for InsertDirectorySvc<T> { 5752 5752 + impl<T: PlaylistService> 5753 5753 + tonic::server::UnaryService<super::InsertDirectoryRequest> 5754 5754 + for InsertDirectorySvc<T> 5755 5755 + { 6715 5756 type Response = super::InsertDirectoryResponse; 6716 6716 - type Future = BoxFuture< 6717 6717 - tonic::Response<Self::Response>, 6718 6718 - tonic::Status, 6719 6719 - >; 5757 5757 + type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 6720 5758 fn call( 6721 5759 &mut self, 6722 5760 request: tonic::Request<super::InsertDirectoryRequest>, 6723 5761 ) -> Self::Future { 6724 5762 let inner = Arc::clone(&self.0); 6725 5763 let fut = async move { 6726 6726 - <T as PlaylistService>::insert_directory(&inner, request) 6727 6727 - .await 5764 5764 + <T as PlaylistService>::insert_directory(&inner, request).await 6728 5765 }; 6729 5766 Box::pin(fut) 6730 5767 } ··· 6754 5791 "/rockbox.v1alpha1.PlaylistService/InsertPlaylist" => { 6755 5792 #[allow(non_camel_case_types)] 6756 5793 struct InsertPlaylistSvc<T: PlaylistService>(pub Arc<T>); 6757 6757 - impl< 6758 6758 - T: PlaylistService, 6759 6759 - > tonic::server::UnaryService<super::InsertPlaylistRequest> 6760 6760 - for InsertPlaylistSvc<T> { 5794 5794 + impl<T: PlaylistService> 5795 5795 + tonic::server::UnaryService<super::InsertPlaylistRequest> 5796 5796 + for InsertPlaylistSvc<T> 5797 5797 + { 6761 5798 type Response = super::InsertPlaylistResponse; 6762 6762 - type Future = BoxFuture< 6763 6763 - tonic::Response<Self::Response>, 6764 6764 - tonic::Status, 6765 6765 - >; 5799 5799 + type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 6766 5800 fn call( 6767 5801 &mut self, 6768 5802 request: tonic::Request<super::InsertPlaylistRequest>, 6769 5803 ) -> Self::Future { 6770 5804 let inner = Arc::clone(&self.0); 6771 5805 let fut = async move { 6772 6772 - <T as PlaylistService>::insert_playlist(&inner, request) 6773 6773 - .await 5806 5806 + <T as PlaylistService>::insert_playlist(&inner, request).await 6774 5807 }; 6775 5808 Box::pin(fut) 6776 5809 } ··· 6800 5833 "/rockbox.v1alpha1.PlaylistService/InsertAlbum" => { 6801 5834 #[allow(non_camel_case_types)] 6802 5835 struct InsertAlbumSvc<T: PlaylistService>(pub Arc<T>); 6803 6803 - impl< 6804 6804 - T: PlaylistService, 6805 6805 - > tonic::server::UnaryService<super::InsertAlbumRequest> 6806 6806 - for InsertAlbumSvc<T> { 5836 5836 + impl<T: PlaylistService> tonic::server::UnaryService<super::InsertAlbumRequest> 5837 5837 + for InsertAlbumSvc<T> 5838 5838 + { 6807 5839 type Response = super::InsertAlbumResponse; 6808 6808 - type Future = BoxFuture< 6809 6809 - tonic::Response<Self::Response>, 6810 6810 - tonic::Status, 6811 6811 - >; 5840 5840 + type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 6812 5841 fn call( 6813 5842 &mut self, 6814 5843 request: tonic::Request<super::InsertAlbumRequest>, ··· 6845 5874 "/rockbox.v1alpha1.PlaylistService/InsertArtistTracks" => { 6846 5875 #[allow(non_camel_case_types)] 6847 5876 struct InsertArtistTracksSvc<T: PlaylistService>(pub Arc<T>); 6848 6848 - impl< 6849 6849 - T: PlaylistService, 6850 6850 - > tonic::server::UnaryService<super::InsertArtistTracksRequest> 6851 6851 - for InsertArtistTracksSvc<T> { 5877 5877 + impl<T: PlaylistService> 5878 5878 + tonic::server::UnaryService<super::InsertArtistTracksRequest> 5879 5879 + for InsertArtistTracksSvc<T> 5880 5880 + { 6852 5881 type Response = super::InsertArtistTracksResponse; 6853 6853 - type Future = BoxFuture< 6854 6854 - tonic::Response<Self::Response>, 6855 6855 - tonic::Status, 6856 6856 - >; 5882 5882 + type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 6857 5883 fn call( 6858 5884 &mut self, 6859 5885 request: tonic::Request<super::InsertArtistTracksRequest>, 6860 5886 ) -> Self::Future { 6861 5887 let inner = Arc::clone(&self.0); 6862 5888 let fut = async move { 6863 6863 - <T as PlaylistService>::insert_artist_tracks( 6864 6864 - &inner, 6865 6865 - request, 6866 6866 - ) 6867 6867 - .await 5889 5889 + <T as PlaylistService>::insert_artist_tracks(&inner, request).await 6868 5890 }; 6869 5891 Box::pin(fut) 6870 5892 } ··· 6894 5916 "/rockbox.v1alpha1.PlaylistService/ShufflePlaylist" => { 6895 5917 #[allow(non_camel_case_types)] 6896 5918 struct ShufflePlaylistSvc<T: PlaylistService>(pub Arc<T>); 6897 6897 - impl< 6898 6898 - T: PlaylistService, 6899 6899 - > tonic::server::UnaryService<super::ShufflePlaylistRequest> 6900 6900 - for ShufflePlaylistSvc<T> { 5919 5919 + impl<T: PlaylistService> 5920 5920 + tonic::server::UnaryService<super::ShufflePlaylistRequest> 5921 5921 + for ShufflePlaylistSvc<T> 5922 5922 + { 6901 5923 type Response = super::ShufflePlaylistResponse; 6902 6902 - type Future = BoxFuture< 6903 6903 - tonic::Response<Self::Response>, 6904 6904 - tonic::Status, 6905 6905 - >; 5924 5924 + type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 6906 5925 fn call( 6907 5926 &mut self, 6908 5927 request: tonic::Request<super::ShufflePlaylistRequest>, 6909 5928 ) -> Self::Future { 6910 5929 let inner = Arc::clone(&self.0); 6911 5930 let fut = async move { 6912 6912 - <T as PlaylistService>::shuffle_playlist(&inner, request) 6913 6913 - .await 5931 5931 + <T as PlaylistService>::shuffle_playlist(&inner, request).await 6914 5932 }; 6915 5933 Box::pin(fut) 6916 5934 } ··· 6937 5955 }; 6938 5956 Box::pin(fut) 6939 5957 } 6940 6940 - _ => { 6941 6941 - Box::pin(async move { 6942 6942 - let mut response = http::Response::new(empty_body()); 6943 6943 - let headers = response.headers_mut(); 6944 6944 - headers 6945 6945 - .insert( 6946 6946 - tonic::Status::GRPC_STATUS, 6947 6947 - (tonic::Code::Unimplemented as i32).into(), 6948 6948 - ); 6949 6949 - headers 6950 6950 - .insert( 6951 6951 - http::header::CONTENT_TYPE, 6952 6952 - tonic::metadata::GRPC_CONTENT_TYPE, 6953 6953 - ); 6954 6954 - Ok(response) 6955 6955 - }) 6956 6956 - } 5958 5958 + _ => Box::pin(async move { 5959 5959 + let mut response = http::Response::new(empty_body()); 5960 5960 + let headers = response.headers_mut(); 5961 5961 + headers.insert( 5962 5962 + tonic::Status::GRPC_STATUS, 5963 5963 + (tonic::Code::Unimplemented as i32).into(), 5964 5964 + ); 5965 5965 + headers.insert( 5966 5966 + http::header::CONTENT_TYPE, 5967 5967 + tonic::metadata::GRPC_CONTENT_TYPE, 5968 5968 + ); 5969 5969 + Ok(response) 5970 5970 + }), 6957 5971 } 6958 5972 } 6959 5973 } ··· 7463 6477 dead_code, 7464 6478 missing_docs, 7465 6479 clippy::wildcard_imports, 7466 7466 - clippy::let_unit_value, 6480 6480 + clippy::let_unit_value 7467 6481 )] 7468 7468 - use tonic::codegen::*; 7469 6482 use tonic::codegen::http::Uri; 6483 6483 + use tonic::codegen::*; 7470 6484 #[derive(Debug, Clone)] 7471 6485 pub struct SettingsServiceClient<T> { 7472 6486 inner: tonic::client::Grpc<T>, ··· 7510 6524 <T as tonic::client::GrpcService<tonic::body::BoxBody>>::ResponseBody, 7511 6525 >, 7512 6526 >, 7513 7513 - <T as tonic::codegen::Service< 7514 7514 - http::Request<tonic::body::BoxBody>, 7515 7515 - >>::Error: Into<StdError> + std::marker::Send + std::marker::Sync, 6527 6527 + <T as tonic::codegen::Service<http::Request<tonic::body::BoxBody>>>::Error: 6528 6528 + Into<StdError> + std::marker::Send + std::marker::Sync, 7516 6529 { 7517 6530 SettingsServiceClient::new(InterceptedService::new(inner, interceptor)) 7518 6531 } ··· 7550 6563 pub async fn get_settings_list( 7551 6564 &mut self, 7552 6565 request: impl tonic::IntoRequest<super::GetSettingsListRequest>, 7553 7553 - ) -> std::result::Result< 7554 7554 - tonic::Response<super::GetSettingsListResponse>, 7555 7555 - tonic::Status, 7556 7556 - > { 7557 7557 - self.inner 7558 7558 - .ready() 7559 7559 - .await 7560 7560 - .map_err(|e| { 7561 7561 - tonic::Status::unknown( 7562 7562 - format!("Service was not ready: {}", e.into()), 7563 7563 - ) 7564 7564 - })?; 6566 6566 + ) -> std::result::Result<tonic::Response<super::GetSettingsListResponse>, tonic::Status> 6567 6567 + { 6568 6568 + self.inner.ready().await.map_err(|e| { 6569 6569 + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 6570 6570 + })?; 7565 6571 let codec = tonic::codec::ProstCodec::default(); 7566 6572 let path = http::uri::PathAndQuery::from_static( 7567 6573 "/rockbox.v1alpha1.SettingsService/GetSettingsList", 7568 6574 ); 7569 6575 let mut req = request.into_request(); 7570 7570 - req.extensions_mut() 7571 7571 - .insert( 7572 7572 - GrpcMethod::new( 7573 7573 - "rockbox.v1alpha1.SettingsService", 7574 7574 - "GetSettingsList", 7575 7575 - ), 7576 7576 - ); 6576 6576 + req.extensions_mut().insert(GrpcMethod::new( 6577 6577 + "rockbox.v1alpha1.SettingsService", 6578 6578 + "GetSettingsList", 6579 6579 + )); 7577 6580 self.inner.unary(req, path, codec).await 7578 6581 } 7579 6582 pub async fn get_global_settings( 7580 6583 &mut self, 7581 6584 request: impl tonic::IntoRequest<super::GetGlobalSettingsRequest>, 7582 7582 - ) -> std::result::Result< 7583 7583 - tonic::Response<super::GetGlobalSettingsResponse>, 7584 7584 - tonic::Status, 7585 7585 - > { 7586 7586 - self.inner 7587 7587 - .ready() 7588 7588 - .await 7589 7589 - .map_err(|e| { 7590 7590 - tonic::Status::unknown( 7591 7591 - format!("Service was not ready: {}", e.into()), 7592 7592 - ) 7593 7593 - })?; 6585 6585 + ) -> std::result::Result<tonic::Response<super::GetGlobalSettingsResponse>, tonic::Status> 6586 6586 + { 6587 6587 + self.inner.ready().await.map_err(|e| { 6588 6588 + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 6589 6589 + })?; 7594 6590 let codec = tonic::codec::ProstCodec::default(); 7595 6591 let path = http::uri::PathAndQuery::from_static( 7596 6592 "/rockbox.v1alpha1.SettingsService/GetGlobalSettings", 7597 6593 ); 7598 6594 let mut req = request.into_request(); 7599 7599 - req.extensions_mut() 7600 7600 - .insert( 7601 7601 - GrpcMethod::new( 7602 7602 - "rockbox.v1alpha1.SettingsService", 7603 7603 - "GetGlobalSettings", 7604 7604 - ), 7605 7605 - ); 6595 6595 + req.extensions_mut().insert(GrpcMethod::new( 6596 6596 + "rockbox.v1alpha1.SettingsService", 6597 6597 + "GetGlobalSettings", 6598 6598 + )); 7606 6599 self.inner.unary(req, path, codec).await 7607 6600 } 7608 6601 pub async fn save_settings( 7609 6602 &mut self, 7610 6603 request: impl tonic::IntoRequest<super::SaveSettingsRequest>, 7611 7611 - ) -> std::result::Result< 7612 7612 - tonic::Response<super::SaveSettingsResponse>, 7613 7613 - tonic::Status, 7614 7614 - > { 7615 7615 - self.inner 7616 7616 - .ready() 7617 7617 - .await 7618 7618 - .map_err(|e| { 7619 7619 - tonic::Status::unknown( 7620 7620 - format!("Service was not ready: {}", e.into()), 7621 7621 - ) 7622 7622 - })?; 6604 6604 + ) -> std::result::Result<tonic::Response<super::SaveSettingsResponse>, tonic::Status> 6605 6605 + { 6606 6606 + self.inner.ready().await.map_err(|e| { 6607 6607 + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 6608 6608 + })?; 7623 6609 let codec = tonic::codec::ProstCodec::default(); 7624 6610 let path = http::uri::PathAndQuery::from_static( 7625 6611 "/rockbox.v1alpha1.SettingsService/SaveSettings", 7626 6612 ); 7627 6613 let mut req = request.into_request(); 7628 7628 - req.extensions_mut() 7629 7629 - .insert( 7630 7630 - GrpcMethod::new("rockbox.v1alpha1.SettingsService", "SaveSettings"), 7631 7631 - ); 6614 6614 + req.extensions_mut().insert(GrpcMethod::new( 6615 6615 + "rockbox.v1alpha1.SettingsService", 6616 6616 + "SaveSettings", 6617 6617 + )); 7632 6618 self.inner.unary(req, path, codec).await 7633 6619 } 7634 6620 } ··· 7640 6626 dead_code, 7641 6627 missing_docs, 7642 6628 clippy::wildcard_imports, 7643 7643 - clippy::let_unit_value, 6629 6629 + clippy::let_unit_value 7644 6630 )] 7645 6631 use tonic::codegen::*; 7646 6632 /// Generated trait containing gRPC methods that should be implemented for use with SettingsServiceServer. ··· 7649 6635 async fn get_settings_list( 7650 6636 &self, 7651 6637 request: tonic::Request<super::GetSettingsListRequest>, 7652 7652 - ) -> std::result::Result< 7653 7653 - tonic::Response<super::GetSettingsListResponse>, 7654 7654 - tonic::Status, 7655 7655 - >; 6638 6638 + ) -> std::result::Result<tonic::Response<super::GetSettingsListResponse>, tonic::Status>; 7656 6639 async fn get_global_settings( 7657 6640 &self, 7658 6641 request: tonic::Request<super::GetGlobalSettingsRequest>, 7659 7659 - ) -> std::result::Result< 7660 7660 - tonic::Response<super::GetGlobalSettingsResponse>, 7661 7661 - tonic::Status, 7662 7662 - >; 6642 6642 + ) -> std::result::Result<tonic::Response<super::GetGlobalSettingsResponse>, tonic::Status>; 7663 6643 async fn save_settings( 7664 6644 &self, 7665 6645 request: tonic::Request<super::SaveSettingsRequest>, 7666 7666 - ) -> std::result::Result< 7667 7667 - tonic::Response<super::SaveSettingsResponse>, 7668 7668 - tonic::Status, 7669 7669 - >; 6646 6646 + ) -> std::result::Result<tonic::Response<super::SaveSettingsResponse>, tonic::Status>; 7670 6647 } 7671 6648 #[derive(Debug)] 7672 6649 pub struct SettingsServiceServer<T> { ··· 7689 6666 max_encoding_message_size: None, 7690 6667 } 7691 6668 } 7692 7692 - pub fn with_interceptor<F>( 7693 7693 - inner: T, 7694 7694 - interceptor: F, 7695 7695 - ) -> InterceptedService<Self, F> 6669 6669 + pub fn with_interceptor<F>(inner: T, interceptor: F) -> InterceptedService<Self, F> 7696 6670 where 7697 6671 F: tonic::service::Interceptor, 7698 6672 { ··· 7747 6721 "/rockbox.v1alpha1.SettingsService/GetSettingsList" => { 7748 6722 #[allow(non_camel_case_types)] 7749 6723 struct GetSettingsListSvc<T: SettingsService>(pub Arc<T>); 7750 7750 - impl< 7751 7751 - T: SettingsService, 7752 7752 - > tonic::server::UnaryService<super::GetSettingsListRequest> 7753 7753 - for GetSettingsListSvc<T> { 6724 6724 + impl<T: SettingsService> 6725 6725 + tonic::server::UnaryService<super::GetSettingsListRequest> 6726 6726 + for GetSettingsListSvc<T> 6727 6727 + { 7754 6728 type Response = super::GetSettingsListResponse; 7755 7755 - type Future = BoxFuture< 7756 7756 - tonic::Response<Self::Response>, 7757 7757 - tonic::Status, 7758 7758 - >; 6729 6729 + type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 7759 6730 fn call( 7760 6731 &mut self, 7761 6732 request: tonic::Request<super::GetSettingsListRequest>, 7762 6733 ) -> Self::Future { 7763 6734 let inner = Arc::clone(&self.0); 7764 6735 let fut = async move { 7765 7765 - <T as SettingsService>::get_settings_list(&inner, request) 7766 7766 - .await 6736 6736 + <T as SettingsService>::get_settings_list(&inner, request).await 7767 6737 }; 7768 6738 Box::pin(fut) 7769 6739 } ··· 7793 6763 "/rockbox.v1alpha1.SettingsService/GetGlobalSettings" => { 7794 6764 #[allow(non_camel_case_types)] 7795 6765 struct GetGlobalSettingsSvc<T: SettingsService>(pub Arc<T>); 7796 7796 - impl< 7797 7797 - T: SettingsService, 7798 7798 - > tonic::server::UnaryService<super::GetGlobalSettingsRequest> 7799 7799 - for GetGlobalSettingsSvc<T> { 6766 6766 + impl<T: SettingsService> 6767 6767 + tonic::server::UnaryService<super::GetGlobalSettingsRequest> 6768 6768 + for GetGlobalSettingsSvc<T> 6769 6769 + { 7800 6770 type Response = super::GetGlobalSettingsResponse; 7801 7801 - type Future = BoxFuture< 7802 7802 - tonic::Response<Self::Response>, 7803 7803 - tonic::Status, 7804 7804 - >; 6771 6771 + type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 7805 6772 fn call( 7806 6773 &mut self, 7807 6774 request: tonic::Request<super::GetGlobalSettingsRequest>, 7808 6775 ) -> Self::Future { 7809 6776 let inner = Arc::clone(&self.0); 7810 6777 let fut = async move { 7811 7811 - <T as SettingsService>::get_global_settings(&inner, request) 7812 7812 - .await 6778 6778 + <T as SettingsService>::get_global_settings(&inner, request).await 7813 6779 }; 7814 6780 Box::pin(fut) 7815 6781 } ··· 7839 6805 "/rockbox.v1alpha1.SettingsService/SaveSettings" => { 7840 6806 #[allow(non_camel_case_types)] 7841 6807 struct SaveSettingsSvc<T: SettingsService>(pub Arc<T>); 7842 7842 - impl< 7843 7843 - T: SettingsService, 7844 7844 - > tonic::server::UnaryService<super::SaveSettingsRequest> 7845 7845 - for SaveSettingsSvc<T> { 6808 6808 + impl<T: SettingsService> tonic::server::UnaryService<super::SaveSettingsRequest> 6809 6809 + for SaveSettingsSvc<T> 6810 6810 + { 7846 6811 type Response = super::SaveSettingsResponse; 7847 7847 - type Future = BoxFuture< 7848 7848 - tonic::Response<Self::Response>, 7849 7849 - tonic::Status, 7850 7850 - >; 6812 6812 + type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 7851 6813 fn call( 7852 6814 &mut self, 7853 6815 request: tonic::Request<super::SaveSettingsRequest>, ··· 7881 6843 }; 7882 6844 Box::pin(fut) 7883 6845 } 7884 7884 - _ => { 7885 7885 - Box::pin(async move { 7886 7886 - let mut response = http::Response::new(empty_body()); 7887 7887 - let headers = response.headers_mut(); 7888 7888 - headers 7889 7889 - .insert( 7890 7890 - tonic::Status::GRPC_STATUS, 7891 7891 - (tonic::Code::Unimplemented as i32).into(), 7892 7892 - ); 7893 7893 - headers 7894 7894 - .insert( 7895 7895 - http::header::CONTENT_TYPE, 7896 7896 - tonic::metadata::GRPC_CONTENT_TYPE, 7897 7897 - ); 7898 7898 - Ok(response) 7899 7899 - }) 7900 7900 - } 6846 6846 + _ => Box::pin(async move { 6847 6847 + let mut response = http::Response::new(empty_body()); 6848 6848 + let headers = response.headers_mut(); 6849 6849 + headers.insert( 6850 6850 + tonic::Status::GRPC_STATUS, 6851 6851 + (tonic::Code::Unimplemented as i32).into(), 6852 6852 + ); 6853 6853 + headers.insert( 6854 6854 + http::header::CONTENT_TYPE, 6855 6855 + tonic::metadata::GRPC_CONTENT_TYPE, 6856 6856 + ); 6857 6857 + Ok(response) 6858 6858 + }), 7901 6859 } 7902 6860 } 7903 6861 } ··· 8055 7013 dead_code, 8056 7014 missing_docs, 8057 7015 clippy::wildcard_imports, 8058 8058 - clippy::let_unit_value, 7016 7016 + clippy::let_unit_value 8059 7017 )] 8060 8060 - use tonic::codegen::*; 8061 7018 use tonic::codegen::http::Uri; 7019 7019 + use tonic::codegen::*; 8062 7020 #[derive(Debug, Clone)] 8063 7021 pub struct SoundServiceClient<T> { 8064 7022 inner: tonic::client::Grpc<T>, ··· 8102 7060 <T as tonic::client::GrpcService<tonic::body::BoxBody>>::ResponseBody, 8103 7061 >, 8104 7062 >, 8105 8105 - <T as tonic::codegen::Service< 8106 8106 - http::Request<tonic::body::BoxBody>, 8107 8107 - >>::Error: Into<StdError> + std::marker::Send + std::marker::Sync, 7063 7063 + <T as tonic::codegen::Service<http::Request<tonic::body::BoxBody>>>::Error: 7064 7064 + Into<StdError> + std::marker::Send + std::marker::Sync, 8108 7065 { 8109 7066 SoundServiceClient::new(InterceptedService::new(inner, interceptor)) 8110 7067 } ··· 8142 7099 pub async fn adjust_volume( 8143 7100 &mut self, 8144 7101 request: impl tonic::IntoRequest<super::AdjustVolumeRequest>, 8145 8145 - ) -> std::result::Result< 8146 8146 - tonic::Response<super::AdjustVolumeResponse>, 8147 8147 - tonic::Status, 8148 8148 - > { 8149 8149 - self.inner 8150 8150 - .ready() 8151 8151 - .await 8152 8152 - .map_err(|e| { 8153 8153 - tonic::Status::unknown( 8154 8154 - format!("Service was not ready: {}", e.into()), 8155 8155 - ) 8156 8156 - })?; 7102 7102 + ) -> std::result::Result<tonic::Response<super::AdjustVolumeResponse>, tonic::Status> 7103 7103 + { 7104 7104 + self.inner.ready().await.map_err(|e| { 7105 7105 + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 7106 7106 + })?; 8157 7107 let codec = tonic::codec::ProstCodec::default(); 8158 8158 - let path = http::uri::PathAndQuery::from_static( 8159 8159 - "/rockbox.v1alpha1.SoundService/AdjustVolume", 8160 8160 - ); 7108 7108 + let path = 7109 7109 + http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.SoundService/AdjustVolume"); 8161 7110 let mut req = request.into_request(); 8162 8162 - req.extensions_mut() 8163 8163 - .insert( 8164 8164 - GrpcMethod::new("rockbox.v1alpha1.SoundService", "AdjustVolume"), 8165 8165 - ); 7111 7111 + req.extensions_mut().insert(GrpcMethod::new( 7112 7112 + "rockbox.v1alpha1.SoundService", 7113 7113 + "AdjustVolume", 7114 7114 + )); 8166 7115 self.inner.unary(req, path, codec).await 8167 7116 } 8168 7117 pub async fn sound_set( 8169 7118 &mut self, 8170 7119 request: impl tonic::IntoRequest<super::SoundSetRequest>, 8171 8171 - ) -> std::result::Result< 8172 8172 - tonic::Response<super::SoundSetResponse>, 8173 8173 - tonic::Status, 8174 8174 - > { 8175 8175 - self.inner 8176 8176 - .ready() 8177 8177 - .await 8178 8178 - .map_err(|e| { 8179 8179 - tonic::Status::unknown( 8180 8180 - format!("Service was not ready: {}", e.into()), 8181 8181 - ) 8182 8182 - })?; 7120 7120 + ) -> std::result::Result<tonic::Response<super::SoundSetResponse>, tonic::Status> { 7121 7121 + self.inner.ready().await.map_err(|e| { 7122 7122 + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 7123 7123 + })?; 8183 7124 let codec = tonic::codec::ProstCodec::default(); 8184 8184 - let path = http::uri::PathAndQuery::from_static( 8185 8185 - "/rockbox.v1alpha1.SoundService/SoundSet", 8186 8186 - ); 7125 7125 + let path = 7126 7126 + http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.SoundService/SoundSet"); 8187 7127 let mut req = request.into_request(); 8188 7128 req.extensions_mut() 8189 7129 .insert(GrpcMethod::new("rockbox.v1alpha1.SoundService", "SoundSet")); ··· 8192 7132 pub async fn sound_current( 8193 7133 &mut self, 8194 7134 request: impl tonic::IntoRequest<super::SoundCurrentRequest>, 8195 8195 - ) -> std::result::Result< 8196 8196 - tonic::Response<super::SoundCurrentResponse>, 8197 8197 - tonic::Status, 8198 8198 - > { 8199 8199 - self.inner 8200 8200 - .ready() 8201 8201 - .await 8202 8202 - .map_err(|e| { 8203 8203 - tonic::Status::unknown( 8204 8204 - format!("Service was not ready: {}", e.into()), 8205 8205 - ) 8206 8206 - })?; 7135 7135 + ) -> std::result::Result<tonic::Response<super::SoundCurrentResponse>, tonic::Status> 7136 7136 + { 7137 7137 + self.inner.ready().await.map_err(|e| { 7138 7138 + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 7139 7139 + })?; 8207 7140 let codec = tonic::codec::ProstCodec::default(); 8208 8208 - let path = http::uri::PathAndQuery::from_static( 8209 8209 - "/rockbox.v1alpha1.SoundService/SoundCurrent", 8210 8210 - ); 7141 7141 + let path = 7142 7142 + http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.SoundService/SoundCurrent"); 8211 7143 let mut req = request.into_request(); 8212 8212 - req.extensions_mut() 8213 8213 - .insert( 8214 8214 - GrpcMethod::new("rockbox.v1alpha1.SoundService", "SoundCurrent"), 8215 8215 - ); 7144 7144 + req.extensions_mut().insert(GrpcMethod::new( 7145 7145 + "rockbox.v1alpha1.SoundService", 7146 7146 + "SoundCurrent", 7147 7147 + )); 8216 7148 self.inner.unary(req, path, codec).await 8217 7149 } 8218 7150 pub async fn sound_default( 8219 7151 &mut self, 8220 7152 request: impl tonic::IntoRequest<super::SoundDefaultRequest>, 8221 8221 - ) -> std::result::Result< 8222 8222 - tonic::Response<super::SoundDefaultResponse>, 8223 8223 - tonic::Status, 8224 8224 - > { 8225 8225 - self.inner 8226 8226 - .ready() 8227 8227 - .await 8228 8228 - .map_err(|e| { 8229 8229 - tonic::Status::unknown( 8230 8230 - format!("Service was not ready: {}", e.into()), 8231 8231 - ) 8232 8232 - })?; 7153 7153 + ) -> std::result::Result<tonic::Response<super::SoundDefaultResponse>, tonic::Status> 7154 7154 + { 7155 7155 + self.inner.ready().await.map_err(|e| { 7156 7156 + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 7157 7157 + })?; 8233 7158 let codec = tonic::codec::ProstCodec::default(); 8234 8234 - let path = http::uri::PathAndQuery::from_static( 8235 8235 - "/rockbox.v1alpha1.SoundService/SoundDefault", 8236 8236 - ); 7159 7159 + let path = 7160 7160 + http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.SoundService/SoundDefault"); 8237 7161 let mut req = request.into_request(); 8238 8238 - req.extensions_mut() 8239 8239 - .insert( 8240 8240 - GrpcMethod::new("rockbox.v1alpha1.SoundService", "SoundDefault"), 8241 8241 - ); 7162 7162 + req.extensions_mut().insert(GrpcMethod::new( 7163 7163 + "rockbox.v1alpha1.SoundService", 7164 7164 + "SoundDefault", 7165 7165 + )); 8242 7166 self.inner.unary(req, path, codec).await 8243 7167 } 8244 7168 pub async fn sound_min( 8245 7169 &mut self, 8246 7170 request: impl tonic::IntoRequest<super::SoundMinRequest>, 8247 8247 - ) -> std::result::Result< 8248 8248 - tonic::Response<super::SoundMinResponse>, 8249 8249 - tonic::Status, 8250 8250 - > { 8251 8251 - self.inner 8252 8252 - .ready() 8253 8253 - .await 8254 8254 - .map_err(|e| { 8255 8255 - tonic::Status::unknown( 8256 8256 - format!("Service was not ready: {}", e.into()), 8257 8257 - ) 8258 8258 - })?; 7171 7171 + ) -> std::result::Result<tonic::Response<super::SoundMinResponse>, tonic::Status> { 7172 7172 + self.inner.ready().await.map_err(|e| { 7173 7173 + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 7174 7174 + })?; 8259 7175 let codec = tonic::codec::ProstCodec::default(); 8260 8260 - let path = http::uri::PathAndQuery::from_static( 8261 8261 - "/rockbox.v1alpha1.SoundService/SoundMin", 8262 8262 - ); 7176 7176 + let path = 7177 7177 + http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.SoundService/SoundMin"); 8263 7178 let mut req = request.into_request(); 8264 7179 req.extensions_mut() 8265 7180 .insert(GrpcMethod::new("rockbox.v1alpha1.SoundService", "SoundMin")); ··· 8268 7183 pub async fn sound_max( 8269 7184 &mut self, 8270 7185 request: impl tonic::IntoRequest<super::SoundMaxRequest>, 8271 8271 - ) -> std::result::Result< 8272 8272 - tonic::Response<super::SoundMaxResponse>, 8273 8273 - tonic::Status, 8274 8274 - > { 8275 8275 - self.inner 8276 8276 - .ready() 8277 8277 - .await 8278 8278 - .map_err(|e| { 8279 8279 - tonic::Status::unknown( 8280 8280 - format!("Service was not ready: {}", e.into()), 8281 8281 - ) 8282 8282 - })?; 7186 7186 + ) -> std::result::Result<tonic::Response<super::SoundMaxResponse>, tonic::Status> { 7187 7187 + self.inner.ready().await.map_err(|e| { 7188 7188 + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 7189 7189 + })?; 8283 7190 let codec = tonic::codec::ProstCodec::default(); 8284 8284 - let path = http::uri::PathAndQuery::from_static( 8285 8285 - "/rockbox.v1alpha1.SoundService/SoundMax", 8286 8286 - ); 7191 7191 + let path = 7192 7192 + http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.SoundService/SoundMax"); 8287 7193 let mut req = request.into_request(); 8288 7194 req.extensions_mut() 8289 7195 .insert(GrpcMethod::new("rockbox.v1alpha1.SoundService", "SoundMax")); ··· 8292 7198 pub async fn sound_unit( 8293 7199 &mut self, 8294 7200 request: impl tonic::IntoRequest<super::SoundUnitRequest>, 8295 8295 - ) -> std::result::Result< 8296 8296 - tonic::Response<super::SoundUnitResponse>, 8297 8297 - tonic::Status, 8298 8298 - > { 8299 8299 - self.inner 8300 8300 - .ready() 8301 8301 - .await 8302 8302 - .map_err(|e| { 8303 8303 - tonic::Status::unknown( 8304 8304 - format!("Service was not ready: {}", e.into()), 8305 8305 - ) 8306 8306 - })?; 7201 7201 + ) -> std::result::Result<tonic::Response<super::SoundUnitResponse>, tonic::Status> { 7202 7202 + self.inner.ready().await.map_err(|e| { 7203 7203 + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 7204 7204 + })?; 8307 7205 let codec = tonic::codec::ProstCodec::default(); 8308 8308 - let path = http::uri::PathAndQuery::from_static( 8309 8309 - "/rockbox.v1alpha1.SoundService/SoundUnit", 8310 8310 - ); 7206 7206 + let path = 7207 7207 + http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.SoundService/SoundUnit"); 8311 7208 let mut req = request.into_request(); 8312 8312 - req.extensions_mut() 8313 8313 - .insert(GrpcMethod::new("rockbox.v1alpha1.SoundService", "SoundUnit")); 7209 7209 + req.extensions_mut().insert(GrpcMethod::new( 7210 7210 + "rockbox.v1alpha1.SoundService", 7211 7211 + "SoundUnit", 7212 7212 + )); 8314 7213 self.inner.unary(req, path, codec).await 8315 7214 } 8316 7215 pub async fn sound_val2_phys( 8317 7216 &mut self, 8318 7217 request: impl tonic::IntoRequest<super::SoundVal2PhysRequest>, 8319 8319 - ) -> std::result::Result< 8320 8320 - tonic::Response<super::SoundVal2PhysResponse>, 8321 8321 - tonic::Status, 8322 8322 - > { 8323 8323 - self.inner 8324 8324 - .ready() 8325 8325 - .await 8326 8326 - .map_err(|e| { 8327 8327 - tonic::Status::unknown( 8328 8328 - format!("Service was not ready: {}", e.into()), 8329 8329 - ) 8330 8330 - })?; 7218 7218 + ) -> std::result::Result<tonic::Response<super::SoundVal2PhysResponse>, tonic::Status> 7219 7219 + { 7220 7220 + self.inner.ready().await.map_err(|e| { 7221 7221 + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 7222 7222 + })?; 8331 7223 let codec = tonic::codec::ProstCodec::default(); 8332 7224 let path = http::uri::PathAndQuery::from_static( 8333 7225 "/rockbox.v1alpha1.SoundService/SoundVal2Phys", 8334 7226 ); 8335 7227 let mut req = request.into_request(); 8336 8336 - req.extensions_mut() 8337 8337 - .insert( 8338 8338 - GrpcMethod::new("rockbox.v1alpha1.SoundService", "SoundVal2Phys"), 8339 8339 - ); 7228 7228 + req.extensions_mut().insert(GrpcMethod::new( 7229 7229 + "rockbox.v1alpha1.SoundService", 7230 7230 + "SoundVal2Phys", 7231 7231 + )); 8340 7232 self.inner.unary(req, path, codec).await 8341 7233 } 8342 7234 pub async fn get_pitch( 8343 7235 &mut self, 8344 7236 request: impl tonic::IntoRequest<super::GetPitchRequest>, 8345 8345 - ) -> std::result::Result< 8346 8346 - tonic::Response<super::GetPitchResponse>, 8347 8347 - tonic::Status, 8348 8348 - > { 8349 8349 - self.inner 8350 8350 - .ready() 8351 8351 - .await 8352 8352 - .map_err(|e| { 8353 8353 - tonic::Status::unknown( 8354 8354 - format!("Service was not ready: {}", e.into()), 8355 8355 - ) 8356 8356 - })?; 7237 7237 + ) -> std::result::Result<tonic::Response<super::GetPitchResponse>, tonic::Status> { 7238 7238 + self.inner.ready().await.map_err(|e| { 7239 7239 + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 7240 7240 + })?; 8357 7241 let codec = tonic::codec::ProstCodec::default(); 8358 8358 - let path = http::uri::PathAndQuery::from_static( 8359 8359 - "/rockbox.v1alpha1.SoundService/GetPitch", 8360 8360 - ); 7242 7242 + let path = 7243 7243 + http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.SoundService/GetPitch"); 8361 7244 let mut req = request.into_request(); 8362 7245 req.extensions_mut() 8363 7246 .insert(GrpcMethod::new("rockbox.v1alpha1.SoundService", "GetPitch")); ··· 8366 7249 pub async fn set_pitch( 8367 7250 &mut self, 8368 7251 request: impl tonic::IntoRequest<super::SetPitchRequest>, 8369 8369 - ) -> std::result::Result< 8370 8370 - tonic::Response<super::SetPitchResponse>, 8371 8371 - tonic::Status, 8372 8372 - > { 8373 8373 - self.inner 8374 8374 - .ready() 8375 8375 - .await 8376 8376 - .map_err(|e| { 8377 8377 - tonic::Status::unknown( 8378 8378 - format!("Service was not ready: {}", e.into()), 8379 8379 - ) 8380 8380 - })?; 7252 7252 + ) -> std::result::Result<tonic::Response<super::SetPitchResponse>, tonic::Status> { 7253 7253 + self.inner.ready().await.map_err(|e| { 7254 7254 + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 7255 7255 + })?; 8381 7256 let codec = tonic::codec::ProstCodec::default(); 8382 8382 - let path = http::uri::PathAndQuery::from_static( 8383 8383 - "/rockbox.v1alpha1.SoundService/SetPitch", 8384 8384 - ); 7257 7257 + let path = 7258 7258 + http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.SoundService/SetPitch"); 8385 7259 let mut req = request.into_request(); 8386 7260 req.extensions_mut() 8387 7261 .insert(GrpcMethod::new("rockbox.v1alpha1.SoundService", "SetPitch")); ··· 8390 7264 pub async fn beep_play( 8391 7265 &mut self, 8392 7266 request: impl tonic::IntoRequest<super::BeepPlayRequest>, 8393 8393 - ) -> std::result::Result< 8394 8394 - tonic::Response<super::BeepPlayResponse>, 8395 8395 - tonic::Status, 8396 8396 - > { 8397 8397 - self.inner 8398 8398 - .ready() 8399 8399 - .await 8400 8400 - .map_err(|e| { 8401 8401 - tonic::Status::unknown( 8402 8402 - format!("Service was not ready: {}", e.into()), 8403 8403 - ) 8404 8404 - })?; 7267 7267 + ) -> std::result::Result<tonic::Response<super::BeepPlayResponse>, tonic::Status> { 7268 7268 + self.inner.ready().await.map_err(|e| { 7269 7269 + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 7270 7270 + })?; 8405 7271 let codec = tonic::codec::ProstCodec::default(); 8406 8406 - let path = http::uri::PathAndQuery::from_static( 8407 8407 - "/rockbox.v1alpha1.SoundService/BeepPlay", 8408 8408 - ); 7272 7272 + let path = 7273 7273 + http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.SoundService/BeepPlay"); 8409 7274 let mut req = request.into_request(); 8410 7275 req.extensions_mut() 8411 7276 .insert(GrpcMethod::new("rockbox.v1alpha1.SoundService", "BeepPlay")); ··· 8414 7279 pub async fn pcmbuf_fade( 8415 7280 &mut self, 8416 7281 request: impl tonic::IntoRequest<super::PcmbufFadeRequest>, 8417 8417 - ) -> std::result::Result< 8418 8418 - tonic::Response<super::PcmbufFadeResponse>, 8419 8419 - tonic::Status, 8420 8420 - > { 8421 8421 - self.inner 8422 8422 - .ready() 8423 8423 - .await 8424 8424 - .map_err(|e| { 8425 8425 - tonic::Status::unknown( 8426 8426 - format!("Service was not ready: {}", e.into()), 8427 8427 - ) 8428 8428 - })?; 7282 7282 + ) -> std::result::Result<tonic::Response<super::PcmbufFadeResponse>, tonic::Status> 7283 7283 + { 7284 7284 + self.inner.ready().await.map_err(|e| { 7285 7285 + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 7286 7286 + })?; 8429 7287 let codec = tonic::codec::ProstCodec::default(); 8430 8430 - let path = http::uri::PathAndQuery::from_static( 8431 8431 - "/rockbox.v1alpha1.SoundService/PcmbufFade", 8432 8432 - ); 7288 7288 + let path = 7289 7289 + http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.SoundService/PcmbufFade"); 8433 7290 let mut req = request.into_request(); 8434 8434 - req.extensions_mut() 8435 8435 - .insert(GrpcMethod::new("rockbox.v1alpha1.SoundService", "PcmbufFade")); 7291 7291 + req.extensions_mut().insert(GrpcMethod::new( 7292 7292 + "rockbox.v1alpha1.SoundService", 7293 7293 + "PcmbufFade", 7294 7294 + )); 8436 7295 self.inner.unary(req, path, codec).await 8437 7296 } 8438 7297 pub async fn pcmbuf_set_low_latency( 8439 7298 &mut self, 8440 7299 request: impl tonic::IntoRequest<super::PcmbufSetLowLatencyRequest>, 8441 8441 - ) -> std::result::Result< 8442 8442 - tonic::Response<super::PcmbufSetLowLatencyResponse>, 8443 8443 - tonic::Status, 8444 8444 - > { 8445 8445 - self.inner 8446 8446 - .ready() 8447 8447 - .await 8448 8448 - .map_err(|e| { 8449 8449 - tonic::Status::unknown( 8450 8450 - format!("Service was not ready: {}", e.into()), 8451 8451 - ) 8452 8452 - })?; 7300 7300 + ) -> std::result::Result<tonic::Response<super::PcmbufSetLowLatencyResponse>, tonic::Status> 7301 7301 + { 7302 7302 + self.inner.ready().await.map_err(|e| { 7303 7303 + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 7304 7304 + })?; 8453 7305 let codec = tonic::codec::ProstCodec::default(); 8454 7306 let path = http::uri::PathAndQuery::from_static( 8455 7307 "/rockbox.v1alpha1.SoundService/PcmbufSetLowLatency", 8456 7308 ); 8457 7309 let mut req = request.into_request(); 8458 8458 - req.extensions_mut() 8459 8459 - .insert( 8460 8460 - GrpcMethod::new( 8461 8461 - "rockbox.v1alpha1.SoundService", 8462 8462 - "PcmbufSetLowLatency", 8463 8463 - ), 8464 8464 - ); 7310 7310 + req.extensions_mut().insert(GrpcMethod::new( 7311 7311 + "rockbox.v1alpha1.SoundService", 7312 7312 + "PcmbufSetLowLatency", 7313 7313 + )); 8465 7314 self.inner.unary(req, path, codec).await 8466 7315 } 8467 7316 pub async fn system_sound_play( 8468 7317 &mut self, 8469 7318 request: impl tonic::IntoRequest<super::SystemSoundPlayRequest>, 8470 8470 - ) -> std::result::Result< 8471 8471 - tonic::Response<super::SystemSoundPlayResponse>, 8472 8472 - tonic::Status, 8473 8473 - > { 8474 8474 - self.inner 8475 8475 - .ready() 8476 8476 - .await 8477 8477 - .map_err(|e| { 8478 8478 - tonic::Status::unknown( 8479 8479 - format!("Service was not ready: {}", e.into()), 8480 8480 - ) 8481 8481 - })?; 7319 7319 + ) -> std::result::Result<tonic::Response<super::SystemSoundPlayResponse>, tonic::Status> 7320 7320 + { 7321 7321 + self.inner.ready().await.map_err(|e| { 7322 7322 + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 7323 7323 + })?; 8482 7324 let codec = tonic::codec::ProstCodec::default(); 8483 7325 let path = http::uri::PathAndQuery::from_static( 8484 7326 "/rockbox.v1alpha1.SoundService/SystemSoundPlay", 8485 7327 ); 8486 7328 let mut req = request.into_request(); 8487 8487 - req.extensions_mut() 8488 8488 - .insert( 8489 8489 - GrpcMethod::new("rockbox.v1alpha1.SoundService", "SystemSoundPlay"), 8490 8490 - ); 7329 7329 + req.extensions_mut().insert(GrpcMethod::new( 7330 7330 + "rockbox.v1alpha1.SoundService", 7331 7331 + "SystemSoundPlay", 7332 7332 + )); 8491 7333 self.inner.unary(req, path, codec).await 8492 7334 } 8493 7335 pub async fn keyclick_click( 8494 7336 &mut self, 8495 7337 request: impl tonic::IntoRequest<super::KeyclickClickRequest>, 8496 8496 - ) -> std::result::Result< 8497 8497 - tonic::Response<super::KeyclickClickResponse>, 8498 8498 - tonic::Status, 8499 8499 - > { 8500 8500 - self.inner 8501 8501 - .ready() 8502 8502 - .await 8503 8503 - .map_err(|e| { 8504 8504 - tonic::Status::unknown( 8505 8505 - format!("Service was not ready: {}", e.into()), 8506 8506 - ) 8507 8507 - })?; 7338 7338 + ) -> std::result::Result<tonic::Response<super::KeyclickClickResponse>, tonic::Status> 7339 7339 + { 7340 7340 + self.inner.ready().await.map_err(|e| { 7341 7341 + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 7342 7342 + })?; 8508 7343 let codec = tonic::codec::ProstCodec::default(); 8509 7344 let path = http::uri::PathAndQuery::from_static( 8510 7345 "/rockbox.v1alpha1.SoundService/KeyclickClick", 8511 7346 ); 8512 7347 let mut req = request.into_request(); 8513 8513 - req.extensions_mut() 8514 8514 - .insert( 8515 8515 - GrpcMethod::new("rockbox.v1alpha1.SoundService", "KeyclickClick"), 8516 8516 - ); 7348 7348 + req.extensions_mut().insert(GrpcMethod::new( 7349 7349 + "rockbox.v1alpha1.SoundService", 7350 7350 + "KeyclickClick", 7351 7351 + )); 8517 7352 self.inner.unary(req, path, codec).await 8518 7353 } 8519 7354 } ··· 8525 7360 dead_code, 8526 7361 missing_docs, 8527 7362 clippy::wildcard_imports, 8528 8528 - clippy::let_unit_value, 7363 7363 + clippy::let_unit_value 8529 7364 )] 8530 7365 use tonic::codegen::*; 8531 7366 /// Generated trait containing gRPC methods that should be implemented for use with SoundServiceServer. ··· 8534 7369 async fn adjust_volume( 8535 7370 &self, 8536 7371 request: tonic::Request<super::AdjustVolumeRequest>, 8537 8537 - ) -> std::result::Result< 8538 8538 - tonic::Response<super::AdjustVolumeResponse>, 8539 8539 - tonic::Status, 8540 8540 - >; 7372 7372 + ) -> std::result::Result<tonic::Response<super::AdjustVolumeResponse>, tonic::Status>; 8541 7373 async fn sound_set( 8542 7374 &self, 8543 7375 request: tonic::Request<super::SoundSetRequest>, 8544 8544 - ) -> std::result::Result< 8545 8545 - tonic::Response<super::SoundSetResponse>, 8546 8546 - tonic::Status, 8547 8547 - >; 7376 7376 + ) -> std::result::Result<tonic::Response<super::SoundSetResponse>, tonic::Status>; 8548 7377 async fn sound_current( 8549 7378 &self, 8550 7379 request: tonic::Request<super::SoundCurrentRequest>, 8551 8551 - ) -> std::result::Result< 8552 8552 - tonic::Response<super::SoundCurrentResponse>, 8553 8553 - tonic::Status, 8554 8554 - >; 7380 7380 + ) -> std::result::Result<tonic::Response<super::SoundCurrentResponse>, tonic::Status>; 8555 7381 async fn sound_default( 8556 7382 &self, 8557 7383 request: tonic::Request<super::SoundDefaultRequest>, 8558 8558 - ) -> std::result::Result< 8559 8559 - tonic::Response<super::SoundDefaultResponse>, 8560 8560 - tonic::Status, 8561 8561 - >; 7384 7384 + ) -> std::result::Result<tonic::Response<super::SoundDefaultResponse>, tonic::Status>; 8562 7385 async fn sound_min( 8563 7386 &self, 8564 7387 request: tonic::Request<super::SoundMinRequest>, 8565 8565 - ) -> std::result::Result< 8566 8566 - tonic::Response<super::SoundMinResponse>, 8567 8567 - tonic::Status, 8568 8568 - >; 7388 7388 + ) -> std::result::Result<tonic::Response<super::SoundMinResponse>, tonic::Status>; 8569 7389 async fn sound_max( 8570 7390 &self, 8571 7391 request: tonic::Request<super::SoundMaxRequest>, 8572 8572 - ) -> std::result::Result< 8573 8573 - tonic::Response<super::SoundMaxResponse>, 8574 8574 - tonic::Status, 8575 8575 - >; 7392 7392 + ) -> std::result::Result<tonic::Response<super::SoundMaxResponse>, tonic::Status>; 8576 7393 async fn sound_unit( 8577 7394 &self, 8578 7395 request: tonic::Request<super::SoundUnitRequest>, 8579 8579 - ) -> std::result::Result< 8580 8580 - tonic::Response<super::SoundUnitResponse>, 8581 8581 - tonic::Status, 8582 8582 - >; 7396 7396 + ) -> std::result::Result<tonic::Response<super::SoundUnitResponse>, tonic::Status>; 8583 7397 async fn sound_val2_phys( 8584 7398 &self, 8585 7399 request: tonic::Request<super::SoundVal2PhysRequest>, 8586 8586 - ) -> std::result::Result< 8587 8587 - tonic::Response<super::SoundVal2PhysResponse>, 8588 8588 - tonic::Status, 8589 8589 - >; 7400 7400 + ) -> std::result::Result<tonic::Response<super::SoundVal2PhysResponse>, tonic::Status>; 8590 7401 async fn get_pitch( 8591 7402 &self, 8592 7403 request: tonic::Request<super::GetPitchRequest>, 8593 8593 - ) -> std::result::Result< 8594 8594 - tonic::Response<super::GetPitchResponse>, 8595 8595 - tonic::Status, 8596 8596 - >; 7404 7404 + ) -> std::result::Result<tonic::Response<super::GetPitchResponse>, tonic::Status>; 8597 7405 async fn set_pitch( 8598 7406 &self, 8599 7407 request: tonic::Request<super::SetPitchRequest>, 8600 8600 - ) -> std::result::Result< 8601 8601 - tonic::Response<super::SetPitchResponse>, 8602 8602 - tonic::Status, 8603 8603 - >; 7408 7408 + ) -> std::result::Result<tonic::Response<super::SetPitchResponse>, tonic::Status>; 8604 7409 async fn beep_play( 8605 7410 &self, 8606 7411 request: tonic::Request<super::BeepPlayRequest>, 8607 8607 - ) -> std::result::Result< 8608 8608 - tonic::Response<super::BeepPlayResponse>, 8609 8609 - tonic::Status, 8610 8610 - >; 7412 7412 + ) -> std::result::Result<tonic::Response<super::BeepPlayResponse>, tonic::Status>; 8611 7413 async fn pcmbuf_fade( 8612 7414 &self, 8613 7415 request: tonic::Request<super::PcmbufFadeRequest>, 8614 8614 - ) -> std::result::Result< 8615 8615 - tonic::Response<super::PcmbufFadeResponse>, 8616 8616 - tonic::Status, 8617 8617 - >; 7416 7416 + ) -> std::result::Result<tonic::Response<super::PcmbufFadeResponse>, tonic::Status>; 8618 7417 async fn pcmbuf_set_low_latency( 8619 7418 &self, 8620 7419 request: tonic::Request<super::PcmbufSetLowLatencyRequest>, 8621 8621 - ) -> std::result::Result< 8622 8622 - tonic::Response<super::PcmbufSetLowLatencyResponse>, 8623 8623 - tonic::Status, 8624 8624 - >; 7420 7420 + ) -> std::result::Result<tonic::Response<super::PcmbufSetLowLatencyResponse>, tonic::Status>; 8625 7421 async fn system_sound_play( 8626 7422 &self, 8627 7423 request: tonic::Request<super::SystemSoundPlayRequest>, 8628 8628 - ) -> std::result::Result< 8629 8629 - tonic::Response<super::SystemSoundPlayResponse>, 8630 8630 - tonic::Status, 8631 8631 - >; 7424 7424 + ) -> std::result::Result<tonic::Response<super::SystemSoundPlayResponse>, tonic::Status>; 8632 7425 async fn keyclick_click( 8633 7426 &self, 8634 7427 request: tonic::Request<super::KeyclickClickRequest>, 8635 8635 - ) -> std::result::Result< 8636 8636 - tonic::Response<super::KeyclickClickResponse>, 8637 8637 - tonic::Status, 8638 8638 - >; 7428 7428 + ) -> std::result::Result<tonic::Response<super::KeyclickClickResponse>, tonic::Status>; 8639 7429 } 8640 7430 #[derive(Debug)] 8641 7431 pub struct SoundServiceServer<T> { ··· 8658 7448 max_encoding_message_size: None, 8659 7449 } 8660 7450 } 8661 8661 - pub fn with_interceptor<F>( 8662 8662 - inner: T, 8663 8663 - interceptor: F, 8664 8664 - ) -> InterceptedService<Self, F> 7451 7451 + pub fn with_interceptor<F>(inner: T, interceptor: F) -> InterceptedService<Self, F> 8665 7452 where 8666 7453 F: tonic::service::Interceptor, 8667 7454 { ··· 8716 7503 "/rockbox.v1alpha1.SoundService/AdjustVolume" => { 8717 7504 #[allow(non_camel_case_types)] 8718 7505 struct AdjustVolumeSvc<T: SoundService>(pub Arc<T>); 8719 8719 - impl< 8720 8720 - T: SoundService, 8721 8721 - > tonic::server::UnaryService<super::AdjustVolumeRequest> 8722 8722 - for AdjustVolumeSvc<T> { 7506 7506 + impl<T: SoundService> tonic::server::UnaryService<super::AdjustVolumeRequest> 7507 7507 + for AdjustVolumeSvc<T> 7508 7508 + { 8723 7509 type Response = super::AdjustVolumeResponse; 8724 8724 - type Future = BoxFuture< 8725 8725 - tonic::Response<Self::Response>, 8726 8726 - tonic::Status, 8727 8727 - >; 7510 7510 + type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 8728 7511 fn call( 8729 7512 &mut self, 8730 7513 request: tonic::Request<super::AdjustVolumeRequest>, ··· 8761 7544 "/rockbox.v1alpha1.SoundService/SoundSet" => { 8762 7545 #[allow(non_camel_case_types)] 8763 7546 struct SoundSetSvc<T: SoundService>(pub Arc<T>); 8764 8764 - impl< 8765 8765 - T: SoundService, 8766 8766 - > tonic::server::UnaryService<super::SoundSetRequest> 8767 8767 - for SoundSetSvc<T> { 7547 7547 + impl<T: SoundService> tonic::server::UnaryService<super::SoundSetRequest> for SoundSetSvc<T> { 8768 7548 type Response = super::SoundSetResponse; 8769 8769 - type Future = BoxFuture< 8770 8770 - tonic::Response<Self::Response>, 8771 8771 - tonic::Status, 8772 8772 - >; 7549 7549 + type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 8773 7550 fn call( 8774 7551 &mut self, 8775 7552 request: tonic::Request<super::SoundSetRequest>, ··· 8806 7583 "/rockbox.v1alpha1.SoundService/SoundCurrent" => { 8807 7584 #[allow(non_camel_case_types)] 8808 7585 struct SoundCurrentSvc<T: SoundService>(pub Arc<T>); 8809 8809 - impl< 8810 8810 - T: SoundService, 8811 8811 - > tonic::server::UnaryService<super::SoundCurrentRequest> 8812 8812 - for SoundCurrentSvc<T> { 7586 7586 + impl<T: SoundService> tonic::server::UnaryService<super::SoundCurrentRequest> 7587 7587 + for SoundCurrentSvc<T> 7588 7588 + { 8813 7589 type Response = super::SoundCurrentResponse; 8814 8814 - type Future = BoxFuture< 8815 8815 - tonic::Response<Self::Response>, 8816 8816 - tonic::Status, 8817 8817 - >; 7590 7590 + type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 8818 7591 fn call( 8819 7592 &mut self, 8820 7593 request: tonic::Request<super::SoundCurrentRequest>, ··· 8851 7624 "/rockbox.v1alpha1.SoundService/SoundDefault" => { 8852 7625 #[allow(non_camel_case_types)] 8853 7626 struct SoundDefaultSvc<T: SoundService>(pub Arc<T>); 8854 8854 - impl< 8855 8855 - T: SoundService, 8856 8856 - > tonic::server::UnaryService<super::SoundDefaultRequest> 8857 8857 - for SoundDefaultSvc<T> { 7627 7627 + impl<T: SoundService> tonic::server::UnaryService<super::SoundDefaultRequest> 7628 7628 + for SoundDefaultSvc<T> 7629 7629 + { 8858 7630 type Response = super::SoundDefaultResponse; 8859 8859 - type Future = BoxFuture< 8860 8860 - tonic::Response<Self::Response>, 8861 8861 - tonic::Status, 8862 8862 - >; 7631 7631 + type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 8863 7632 fn call( 8864 7633 &mut self, 8865 7634 request: tonic::Request<super::SoundDefaultRequest>, ··· 8896 7665 "/rockbox.v1alpha1.SoundService/SoundMin" => { 8897 7666 #[allow(non_camel_case_types)] 8898 7667 struct SoundMinSvc<T: SoundService>(pub Arc<T>); 8899 8899 - impl< 8900 8900 - T: SoundService, 8901 8901 - > tonic::server::UnaryService<super::SoundMinRequest> 8902 8902 - for SoundMinSvc<T> { 7668 7668 + impl<T: SoundService> tonic::server::UnaryService<super::SoundMinRequest> for SoundMinSvc<T> { 8903 7669 type Response = super::SoundMinResponse; 8904 8904 - type Future = BoxFuture< 8905 8905 - tonic::Response<Self::Response>, 8906 8906 - tonic::Status, 8907 8907 - >; 7670 7670 + type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 8908 7671 fn call( 8909 7672 &mut self, 8910 7673 request: tonic::Request<super::SoundMinRequest>, ··· 8941 7704 "/rockbox.v1alpha1.SoundService/SoundMax" => { 8942 7705 #[allow(non_camel_case_types)] 8943 7706 struct SoundMaxSvc<T: SoundService>(pub Arc<T>); 8944 8944 - impl< 8945 8945 - T: SoundService, 8946 8946 - > tonic::server::UnaryService<super::SoundMaxRequest> 8947 8947 - for SoundMaxSvc<T> { 7707 7707 + impl<T: SoundService> tonic::server::UnaryService<super::SoundMaxRequest> for SoundMaxSvc<T> { 8948 7708 type Response = super::SoundMaxResponse; 8949 8949 - type Future = BoxFuture< 8950 8950 - tonic::Response<Self::Response>, 8951 8951 - tonic::Status, 8952 8952 - >; 7709 7709 + type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 8953 7710 fn call( 8954 7711 &mut self, 8955 7712 request: tonic::Request<super::SoundMaxRequest>, ··· 8986 7743 "/rockbox.v1alpha1.SoundService/SoundUnit" => { 8987 7744 #[allow(non_camel_case_types)] 8988 7745 struct SoundUnitSvc<T: SoundService>(pub Arc<T>); 8989 8989 - impl< 8990 8990 - T: SoundService, 8991 8991 - > tonic::server::UnaryService<super::SoundUnitRequest> 8992 8992 - for SoundUnitSvc<T> { 7746 7746 + impl<T: SoundService> tonic::server::UnaryService<super::SoundUnitRequest> for SoundUnitSvc<T> { 8993 7747 type Response = super::SoundUnitResponse; 8994 8994 - type Future = BoxFuture< 8995 8995 - tonic::Response<Self::Response>, 8996 8996 - tonic::Status, 8997 8997 - >; 7748 7748 + type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 8998 7749 fn call( 8999 7750 &mut self, 9000 7751 request: tonic::Request<super::SoundUnitRequest>, ··· 9031 7782 "/rockbox.v1alpha1.SoundService/SoundVal2Phys" => { 9032 7783 #[allow(non_camel_case_types)] 9033 7784 struct SoundVal2PhysSvc<T: SoundService>(pub Arc<T>); 9034 9034 - impl< 9035 9035 - T: SoundService, 9036 9036 - > tonic::server::UnaryService<super::SoundVal2PhysRequest> 9037 9037 - for SoundVal2PhysSvc<T> { 7785 7785 + impl<T: SoundService> tonic::server::UnaryService<super::SoundVal2PhysRequest> 7786 7786 + for SoundVal2PhysSvc<T> 7787 7787 + { 9038 7788 type Response = super::SoundVal2PhysResponse; 9039 9039 - type Future = BoxFuture< 9040 9040 - tonic::Response<Self::Response>, 9041 9041 - tonic::Status, 9042 9042 - >; 7789 7789 + type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 9043 7790 fn call( 9044 7791 &mut self, 9045 7792 request: tonic::Request<super::SoundVal2PhysRequest>, ··· 9076 7823 "/rockbox.v1alpha1.SoundService/GetPitch" => { 9077 7824 #[allow(non_camel_case_types)] 9078 7825 struct GetPitchSvc<T: SoundService>(pub Arc<T>); 9079 9079 - impl< 9080 9080 - T: SoundService, 9081 9081 - > tonic::server::UnaryService<super::GetPitchRequest> 9082 9082 - for GetPitchSvc<T> { 7826 7826 + impl<T: SoundService> tonic::server::UnaryService<super::GetPitchRequest> for GetPitchSvc<T> { 9083 7827 type Response = super::GetPitchResponse; 9084 9084 - type Future = BoxFuture< 9085 9085 - tonic::Response<Self::Response>, 9086 9086 - tonic::Status, 9087 9087 - >; 7828 7828 + type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 9088 7829 fn call( 9089 7830 &mut self, 9090 7831 request: tonic::Request<super::GetPitchRequest>, ··· 9121 7862 "/rockbox.v1alpha1.SoundService/SetPitch" => { 9122 7863 #[allow(non_camel_case_types)] 9123 7864 struct SetPitchSvc<T: SoundService>(pub Arc<T>); 9124 9124 - impl< 9125 9125 - T: SoundService, 9126 9126 - > tonic::server::UnaryService<super::SetPitchRequest> 9127 9127 - for SetPitchSvc<T> { 7865 7865 + impl<T: SoundService> tonic::server::UnaryService<super::SetPitchRequest> for SetPitchSvc<T> { 9128 7866 type Response = super::SetPitchResponse; 9129 9129 - type Future = BoxFuture< 9130 9130 - tonic::Response<Self::Response>, 9131 9131 - tonic::Status, 9132 9132 - >; 7867 7867 + type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 9133 7868 fn call( 9134 7869 &mut self, 9135 7870 request: tonic::Request<super::SetPitchRequest>, ··· 9166 7901 "/rockbox.v1alpha1.SoundService/BeepPlay" => { 9167 7902 #[allow(non_camel_case_types)] 9168 7903 struct BeepPlaySvc<T: SoundService>(pub Arc<T>); 9169 9169 - impl< 9170 9170 - T: SoundService, 9171 9171 - > tonic::server::UnaryService<super::BeepPlayRequest> 9172 9172 - for BeepPlaySvc<T> { 7904 7904 + impl<T: SoundService> tonic::server::UnaryService<super::BeepPlayRequest> for BeepPlaySvc<T> { 9173 7905 type Response = super::BeepPlayResponse; 9174 9174 - type Future = BoxFuture< 9175 9175 - tonic::Response<Self::Response>, 9176 9176 - tonic::Status, 9177 9177 - >; 7906 7906 + type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 9178 7907 fn call( 9179 7908 &mut self, 9180 7909 request: tonic::Request<super::BeepPlayRequest>, ··· 9211 7940 "/rockbox.v1alpha1.SoundService/PcmbufFade" => { 9212 7941 #[allow(non_camel_case_types)] 9213 7942 struct PcmbufFadeSvc<T: SoundService>(pub Arc<T>); 9214 9214 - impl< 9215 9215 - T: SoundService, 9216 9216 - > tonic::server::UnaryService<super::PcmbufFadeRequest> 9217 9217 - for PcmbufFadeSvc<T> { 7943 7943 + impl<T: SoundService> tonic::server::UnaryService<super::PcmbufFadeRequest> for PcmbufFadeSvc<T> { 9218 7944 type Response = super::PcmbufFadeResponse; 9219 9219 - type Future = BoxFuture< 9220 9220 - tonic::Response<Self::Response>, 9221 9221 - tonic::Status, 9222 9222 - >; 7945 7945 + type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 9223 7946 fn call( 9224 7947 &mut self, 9225 7948 request: tonic::Request<super::PcmbufFadeRequest>, ··· 9256 7979 "/rockbox.v1alpha1.SoundService/PcmbufSetLowLatency" => { 9257 7980 #[allow(non_camel_case_types)] 9258 7981 struct PcmbufSetLowLatencySvc<T: SoundService>(pub Arc<T>); 9259 9259 - impl< 9260 9260 - T: SoundService, 9261 9261 - > tonic::server::UnaryService<super::PcmbufSetLowLatencyRequest> 9262 9262 - for PcmbufSetLowLatencySvc<T> { 7982 7982 + impl<T: SoundService> 7983 7983 + tonic::server::UnaryService<super::PcmbufSetLowLatencyRequest> 7984 7984 + for PcmbufSetLowLatencySvc<T> 7985 7985 + { 9263 7986 type Response = super::PcmbufSetLowLatencyResponse; 9264 9264 - type Future = BoxFuture< 9265 9265 - tonic::Response<Self::Response>, 9266 9266 - tonic::Status, 9267 9267 - >; 7987 7987 + type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 9268 7988 fn call( 9269 7989 &mut self, 9270 7990 request: tonic::Request<super::PcmbufSetLowLatencyRequest>, 9271 7991 ) -> Self::Future { 9272 7992 let inner = Arc::clone(&self.0); 9273 7993 let fut = async move { 9274 9274 - <T as SoundService>::pcmbuf_set_low_latency(&inner, request) 9275 9275 - .await 7994 7994 + <T as SoundService>::pcmbuf_set_low_latency(&inner, request).await 9276 7995 }; 9277 7996 Box::pin(fut) 9278 7997 } ··· 9302 8021 "/rockbox.v1alpha1.SoundService/SystemSoundPlay" => { 9303 8022 #[allow(non_camel_case_types)] 9304 8023 struct SystemSoundPlaySvc<T: SoundService>(pub Arc<T>); 9305 9305 - impl< 9306 9306 - T: SoundService, 9307 9307 - > tonic::server::UnaryService<super::SystemSoundPlayRequest> 9308 9308 - for SystemSoundPlaySvc<T> { 8024 8024 + impl<T: SoundService> tonic::server::UnaryService<super::SystemSoundPlayRequest> 8025 8025 + for SystemSoundPlaySvc<T> 8026 8026 + { 9309 8027 type Response = super::SystemSoundPlayResponse; 9310 9310 - type Future = BoxFuture< 9311 9311 - tonic::Response<Self::Response>, 9312 9312 - tonic::Status, 9313 9313 - >; 8028 8028 + type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 9314 8029 fn call( 9315 8030 &mut self, 9316 8031 request: tonic::Request<super::SystemSoundPlayRequest>, 9317 8032 ) -> Self::Future { 9318 8033 let inner = Arc::clone(&self.0); 9319 8034 let fut = async move { 9320 9320 - <T as SoundService>::system_sound_play(&inner, request) 9321 9321 - .await 8035 8035 + <T as SoundService>::system_sound_play(&inner, request).await 9322 8036 }; 9323 8037 Box::pin(fut) 9324 8038 } ··· 9348 8062 "/rockbox.v1alpha1.SoundService/KeyclickClick" => { 9349 8063 #[allow(non_camel_case_types)] 9350 8064 struct KeyclickClickSvc<T: SoundService>(pub Arc<T>); 9351 9351 - impl< 9352 9352 - T: SoundService, 9353 9353 - > tonic::server::UnaryService<super::KeyclickClickRequest> 9354 9354 - for KeyclickClickSvc<T> { 8065 8065 + impl<T: SoundService> tonic::server::UnaryService<super::KeyclickClickRequest> 8066 8066 + for KeyclickClickSvc<T> 8067 8067 + { 9355 8068 type Response = super::KeyclickClickResponse; 9356 9356 - type Future = BoxFuture< 9357 9357 - tonic::Response<Self::Response>, 9358 9358 - tonic::Status, 9359 9359 - >; 8069 8069 + type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 9360 8070 fn call( 9361 8071 &mut self, 9362 8072 request: tonic::Request<super::KeyclickClickRequest>, ··· 9390 8100 }; 9391 8101 Box::pin(fut) 9392 8102 } 9393 9393 - _ => { 9394 9394 - Box::pin(async move { 9395 9395 - let mut response = http::Response::new(empty_body()); 9396 9396 - let headers = response.headers_mut(); 9397 9397 - headers 9398 9398 - .insert( 9399 9399 - tonic::Status::GRPC_STATUS, 9400 9400 - (tonic::Code::Unimplemented as i32).into(), 9401 9401 - ); 9402 9402 - headers 9403 9403 - .insert( 9404 9404 - http::header::CONTENT_TYPE, 9405 9405 - tonic::metadata::GRPC_CONTENT_TYPE, 9406 9406 - ); 9407 9407 - Ok(response) 9408 9408 - }) 9409 9409 - } 8103 8103 + _ => Box::pin(async move { 8104 8104 + let mut response = http::Response::new(empty_body()); 8105 8105 + let headers = response.headers_mut(); 8106 8106 + headers.insert( 8107 8107 + tonic::Status::GRPC_STATUS, 8108 8108 + (tonic::Code::Unimplemented as i32).into(), 8109 8109 + ); 8110 8110 + headers.insert( 8111 8111 + http::header::CONTENT_TYPE, 8112 8112 + tonic::metadata::GRPC_CONTENT_TYPE, 8113 8113 + ); 8114 8114 + Ok(response) 8115 8115 + }), 9410 8116 } 9411 8117 } 9412 8118 } ··· 9467 8173 dead_code, 9468 8174 missing_docs, 9469 8175 clippy::wildcard_imports, 9470 9470 - clippy::let_unit_value, 8176 8176 + clippy::let_unit_value 9471 8177 )] 8178 8178 + use tonic::codegen::http::Uri; 9472 8179 use tonic::codegen::*; 9473 9473 - use tonic::codegen::http::Uri; 9474 8180 #[derive(Debug, Clone)] 9475 8181 pub struct SystemServiceClient<T> { 9476 8182 inner: tonic::client::Grpc<T>, ··· 9514 8220 <T as tonic::client::GrpcService<tonic::body::BoxBody>>::ResponseBody, 9515 8221 >, 9516 8222 >, 9517 9517 - <T as tonic::codegen::Service< 9518 9518 - http::Request<tonic::body::BoxBody>, 9519 9519 - >>::Error: Into<StdError> + std::marker::Send + std::marker::Sync, 8223 8223 + <T as tonic::codegen::Service<http::Request<tonic::body::BoxBody>>>::Error: 8224 8224 + Into<StdError> + std::marker::Send + std::marker::Sync, 9520 8225 { 9521 8226 SystemServiceClient::new(InterceptedService::new(inner, interceptor)) 9522 8227 } ··· 9554 8259 pub async fn get_rockbox_version( 9555 8260 &mut self, 9556 8261 request: impl tonic::IntoRequest<super::GetRockboxVersionRequest>, 9557 9557 - ) -> std::result::Result< 9558 9558 - tonic::Response<super::GetRockboxVersionResponse>, 9559 9559 - tonic::Status, 9560 9560 - > { 9561 9561 - self.inner 9562 9562 - .ready() 9563 9563 - .await 9564 9564 - .map_err(|e| { 9565 9565 - tonic::Status::unknown( 9566 9566 - format!("Service was not ready: {}", e.into()), 9567 9567 - ) 9568 9568 - })?; 8262 8262 + ) -> std::result::Result<tonic::Response<super::GetRockboxVersionResponse>, tonic::Status> 8263 8263 + { 8264 8264 + self.inner.ready().await.map_err(|e| { 8265 8265 + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 8266 8266 + })?; 9569 8267 let codec = tonic::codec::ProstCodec::default(); 9570 8268 let path = http::uri::PathAndQuery::from_static( 9571 8269 "/rockbox.v1alpha1.SystemService/GetRockboxVersion", 9572 8270 ); 9573 8271 let mut req = request.into_request(); 9574 9574 - req.extensions_mut() 9575 9575 - .insert( 9576 9576 - GrpcMethod::new( 9577 9577 - "rockbox.v1alpha1.SystemService", 9578 9578 - "GetRockboxVersion", 9579 9579 - ), 9580 9580 - ); 8272 8272 + req.extensions_mut().insert(GrpcMethod::new( 8273 8273 + "rockbox.v1alpha1.SystemService", 8274 8274 + "GetRockboxVersion", 8275 8275 + )); 9581 8276 self.inner.unary(req, path, codec).await 9582 8277 } 9583 8278 pub async fn get_global_status( 9584 8279 &mut self, 9585 8280 request: impl tonic::IntoRequest<super::GetGlobalStatusRequest>, 9586 9586 - ) -> std::result::Result< 9587 9587 - tonic::Response<super::GetGlobalStatusResponse>, 9588 9588 - tonic::Status, 9589 9589 - > { 9590 9590 - self.inner 9591 9591 - .ready() 9592 9592 - .await 9593 9593 - .map_err(|e| { 9594 9594 - tonic::Status::unknown( 9595 9595 - format!("Service was not ready: {}", e.into()), 9596 9596 - ) 9597 9597 - })?; 8281 8281 + ) -> std::result::Result<tonic::Response<super::GetGlobalStatusResponse>, tonic::Status> 8282 8282 + { 8283 8283 + self.inner.ready().await.map_err(|e| { 8284 8284 + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 8285 8285 + })?; 9598 8286 let codec = tonic::codec::ProstCodec::default(); 9599 8287 let path = http::uri::PathAndQuery::from_static( 9600 8288 "/rockbox.v1alpha1.SystemService/GetGlobalStatus", 9601 8289 ); 9602 8290 let mut req = request.into_request(); 9603 9603 - req.extensions_mut() 9604 9604 - .insert( 9605 9605 - GrpcMethod::new("rockbox.v1alpha1.SystemService", "GetGlobalStatus"), 9606 9606 - ); 8291 8291 + req.extensions_mut().insert(GrpcMethod::new( 8292 8292 + "rockbox.v1alpha1.SystemService", 8293 8293 + "GetGlobalStatus", 8294 8294 + )); 9607 8295 self.inner.unary(req, path, codec).await 9608 8296 } 9609 8297 } ··· 9615 8303 dead_code, 9616 8304 missing_docs, 9617 8305 clippy::wildcard_imports, 9618 9618 - clippy::let_unit_value, 8306 8306 + clippy::let_unit_value 9619 8307 )] 9620 8308 use tonic::codegen::*; 9621 8309 /// Generated trait containing gRPC methods that should be implemented for use with SystemServiceServer. ··· 9624 8312 async fn get_rockbox_version( 9625 8313 &self, 9626 8314 request: tonic::Request<super::GetRockboxVersionRequest>, 9627 9627 - ) -> std::result::Result< 9628 9628 - tonic::Response<super::GetRockboxVersionResponse>, 9629 9629 - tonic::Status, 9630 9630 - >; 8315 8315 + ) -> std::result::Result<tonic::Response<super::GetRockboxVersionResponse>, tonic::Status>; 9631 8316 async fn get_global_status( 9632 8317 &self, 9633 8318 request: tonic::Request<super::GetGlobalStatusRequest>, 9634 9634 - ) -> std::result::Result< 9635 9635 - tonic::Response<super::GetGlobalStatusResponse>, 9636 9636 - tonic::Status, 9637 9637 - >; 8319 8319 + ) -> std::result::Result<tonic::Response<super::GetGlobalStatusResponse>, tonic::Status>; 9638 8320 } 9639 8321 #[derive(Debug)] 9640 8322 pub struct SystemServiceServer<T> { ··· 9657 8339 max_encoding_message_size: None, 9658 8340 } 9659 8341 } 9660 9660 - pub fn with_interceptor<F>( 9661 9661 - inner: T, 9662 9662 - interceptor: F, 9663 9663 - ) -> InterceptedService<Self, F> 8342 8342 + pub fn with_interceptor<F>(inner: T, interceptor: F) -> InterceptedService<Self, F> 9664 8343 where 9665 8344 F: tonic::service::Interceptor, 9666 8345 { ··· 9715 8394 "/rockbox.v1alpha1.SystemService/GetRockboxVersion" => { 9716 8395 #[allow(non_camel_case_types)] 9717 8396 struct GetRockboxVersionSvc<T: SystemService>(pub Arc<T>); 9718 9718 - impl< 9719 9719 - T: SystemService, 9720 9720 - > tonic::server::UnaryService<super::GetRockboxVersionRequest> 9721 9721 - for GetRockboxVersionSvc<T> { 8397 8397 + impl<T: SystemService> 8398 8398 + tonic::server::UnaryService<super::GetRockboxVersionRequest> 8399 8399 + for GetRockboxVersionSvc<T> 8400 8400 + { 9722 8401 type Response = super::GetRockboxVersionResponse; 9723 9723 - type Future = BoxFuture< 9724 9724 - tonic::Response<Self::Response>, 9725 9725 - tonic::Status, 9726 9726 - >; 8402 8402 + type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 9727 8403 fn call( 9728 8404 &mut self, 9729 8405 request: tonic::Request<super::GetRockboxVersionRequest>, 9730 8406 ) -> Self::Future { 9731 8407 let inner = Arc::clone(&self.0); 9732 8408 let fut = async move { 9733 9733 - <T as SystemService>::get_rockbox_version(&inner, request) 9734 9734 - .await 8409 8409 + <T as SystemService>::get_rockbox_version(&inner, request).await 9735 8410 }; 9736 8411 Box::pin(fut) 9737 8412 } ··· 9761 8436 "/rockbox.v1alpha1.SystemService/GetGlobalStatus" => { 9762 8437 #[allow(non_camel_case_types)] 9763 8438 struct GetGlobalStatusSvc<T: SystemService>(pub Arc<T>); 9764 9764 - impl< 9765 9765 - T: SystemService, 9766 9766 - > tonic::server::UnaryService<super::GetGlobalStatusRequest> 9767 9767 - for GetGlobalStatusSvc<T> { 8439 8439 + impl<T: SystemService> 8440 8440 + tonic::server::UnaryService<super::GetGlobalStatusRequest> 8441 8441 + for GetGlobalStatusSvc<T> 8442 8442 + { 9768 8443 type Response = super::GetGlobalStatusResponse; 9769 9769 - type Future = BoxFuture< 9770 9770 - tonic::Response<Self::Response>, 9771 9771 - tonic::Status, 9772 9772 - >; 8444 8444 + type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 9773 8445 fn call( 9774 8446 &mut self, 9775 8447 request: tonic::Request<super::GetGlobalStatusRequest>, 9776 8448 ) -> Self::Future { 9777 8449 let inner = Arc::clone(&self.0); 9778 8450 let fut = async move { 9779 9779 - <T as SystemService>::get_global_status(&inner, request) 9780 9780 - .await 8451 8451 + <T as SystemService>::get_global_status(&inner, request).await 9781 8452 }; 9782 8453 Box::pin(fut) 9783 8454 } ··· 9804 8475 }; 9805 8476 Box::pin(fut) 9806 8477 } 9807 9807 - _ => { 9808 9808 - Box::pin(async move { 9809 9809 - let mut response = http::Response::new(empty_body()); 9810 9810 - let headers = response.headers_mut(); 9811 9811 - headers 9812 9812 - .insert( 9813 9813 - tonic::Status::GRPC_STATUS, 9814 9814 - (tonic::Code::Unimplemented as i32).into(), 9815 9815 - ); 9816 9816 - headers 9817 9817 - .insert( 9818 9818 - http::header::CONTENT_TYPE, 9819 9819 - tonic::metadata::GRPC_CONTENT_TYPE, 9820 9820 - ); 9821 9821 - Ok(response) 9822 9822 - }) 9823 9823 - } 8478 8478 + _ => Box::pin(async move { 8479 8479 + let mut response = http::Response::new(empty_body()); 8480 8480 + let headers = response.headers_mut(); 8481 8481 + headers.insert( 8482 8482 + tonic::Status::GRPC_STATUS, 8483 8483 + (tonic::Code::Unimplemented as i32).into(), 8484 8484 + ); 8485 8485 + headers.insert( 8486 8486 + http::header::CONTENT_TYPE, 8487 8487 + tonic::metadata::GRPC_CONTENT_TYPE, 8488 8488 + ); 8489 8489 + Ok(response) 8490 8490 + }), 9824 8491 } 9825 8492 } 9826 8493 }

+1 -1

gpui/src/ui/components/miniplayer.rs

reviewed

··· 184 184 .flex() 185 185 .items_center() 186 186 .gap_x_2() 187 187 - .w(px(320.0)) 187 187 + .w(px(420.0)) 188 188 .child( 189 189 div() 190 190 .text_xs()