+5

apps/SOURCES

reviewed

··· 308 308 #elif CONFIG_KEYPAD == CTRU_PAD 309 309 keymaps/keymap-ctru.c 310 310 #endif 311 311 + 312 312 + #ifdef CONFIG_SERVER 313 313 + server_thread.c 314 314 + broker_thread.c 315 315 + #endif

+2470 -1224

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::http::Uri; 49 48 use tonic::codegen::*; 49 49 + use tonic::codegen::http::Uri; 50 50 #[derive(Debug, Clone)] 51 51 pub struct BrowseServiceClient<T> { 52 52 inner: tonic::client::Grpc<T>, ··· 90 90 <T as tonic::client::GrpcService<tonic::body::BoxBody>>::ResponseBody, 91 91 >, 92 92 >, 93 93 - <T as tonic::codegen::Service<http::Request<tonic::body::BoxBody>>>::Error: 94 94 - Into<StdError> + std::marker::Send + std::marker::Sync, 93 93 + <T as tonic::codegen::Service< 94 94 + http::Request<tonic::body::BoxBody>, 95 95 + >>::Error: Into<StdError> + std::marker::Send + std::marker::Sync, 95 96 { 96 97 BrowseServiceClient::new(InterceptedService::new(inner, interceptor)) 97 98 } ··· 129 130 pub async fn tree_get_entries( 130 131 &mut self, 131 132 request: impl tonic::IntoRequest<super::TreeGetEntriesRequest>, 132 132 - ) -> std::result::Result<tonic::Response<super::TreeGetEntriesResponse>, tonic::Status> 133 133 - { 134 134 - self.inner.ready().await.map_err(|e| { 135 135 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 136 136 - })?; 133 133 + ) -> std::result::Result< 134 134 + tonic::Response<super::TreeGetEntriesResponse>, 135 135 + tonic::Status, 136 136 + > { 137 137 + self.inner 138 138 + .ready() 139 139 + .await 140 140 + .map_err(|e| { 141 141 + tonic::Status::unknown( 142 142 + format!("Service was not ready: {}", e.into()), 143 143 + ) 144 144 + })?; 137 145 let codec = tonic::codec::ProstCodec::default(); 138 146 let path = http::uri::PathAndQuery::from_static( 139 147 "/rockbox.v1alpha1.BrowseService/TreeGetEntries", 140 148 ); 141 149 let mut req = request.into_request(); 142 142 - req.extensions_mut().insert(GrpcMethod::new( 143 143 - "rockbox.v1alpha1.BrowseService", 144 144 - "TreeGetEntries", 145 145 - )); 150 150 + req.extensions_mut() 151 151 + .insert( 152 152 + GrpcMethod::new("rockbox.v1alpha1.BrowseService", "TreeGetEntries"), 153 153 + ); 146 154 self.inner.unary(req, path, codec).await 147 155 } 148 156 } ··· 154 162 dead_code, 155 163 missing_docs, 156 164 clippy::wildcard_imports, 157 157 - clippy::let_unit_value 165 165 + clippy::let_unit_value, 158 166 )] 159 167 use tonic::codegen::*; 160 168 /// Generated trait containing gRPC methods that should be implemented for use with BrowseServiceServer. ··· 163 171 async fn tree_get_entries( 164 172 &self, 165 173 request: tonic::Request<super::TreeGetEntriesRequest>, 166 166 - ) -> std::result::Result<tonic::Response<super::TreeGetEntriesResponse>, tonic::Status>; 174 174 + ) -> std::result::Result< 175 175 + tonic::Response<super::TreeGetEntriesResponse>, 176 176 + tonic::Status, 177 177 + >; 167 178 } 168 179 #[derive(Debug)] 169 180 pub struct BrowseServiceServer<T> { ··· 186 197 max_encoding_message_size: None, 187 198 } 188 199 } 189 189 - pub fn with_interceptor<F>(inner: T, interceptor: F) -> InterceptedService<Self, F> 200 200 + pub fn with_interceptor<F>( 201 201 + inner: T, 202 202 + interceptor: F, 203 203 + ) -> InterceptedService<Self, F> 190 204 where 191 205 F: tonic::service::Interceptor, 192 206 { ··· 241 255 "/rockbox.v1alpha1.BrowseService/TreeGetEntries" => { 242 256 #[allow(non_camel_case_types)] 243 257 struct TreeGetEntriesSvc<T: BrowseService>(pub Arc<T>); 244 244 - impl<T: BrowseService> tonic::server::UnaryService<super::TreeGetEntriesRequest> 245 245 - for TreeGetEntriesSvc<T> 246 246 - { 258 258 + impl< 259 259 + T: BrowseService, 260 260 + > tonic::server::UnaryService<super::TreeGetEntriesRequest> 261 261 + for TreeGetEntriesSvc<T> { 247 262 type Response = super::TreeGetEntriesResponse; 248 248 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 263 263 + type Future = BoxFuture< 264 264 + tonic::Response<Self::Response>, 265 265 + tonic::Status, 266 266 + >; 249 267 fn call( 250 268 &mut self, 251 269 request: tonic::Request<super::TreeGetEntriesRequest>, 252 270 ) -> Self::Future { 253 271 let inner = Arc::clone(&self.0); 254 272 let fut = async move { 255 255 - <T as BrowseService>::tree_get_entries(&inner, request).await 273 273 + <T as BrowseService>::tree_get_entries(&inner, request) 274 274 + .await 256 275 }; 257 276 Box::pin(fut) 258 277 } ··· 279 298 }; 280 299 Box::pin(fut) 281 300 } 282 282 - _ => Box::pin(async move { 283 283 - let mut response = http::Response::new(empty_body()); 284 284 - let headers = response.headers_mut(); 285 285 - headers.insert( 286 286 - tonic::Status::GRPC_STATUS, 287 287 - (tonic::Code::Unimplemented as i32).into(), 288 288 - ); 289 289 - headers.insert( 290 290 - http::header::CONTENT_TYPE, 291 291 - tonic::metadata::GRPC_CONTENT_TYPE, 292 292 - ); 293 293 - Ok(response) 294 294 - }), 301 301 + _ => { 302 302 + Box::pin(async move { 303 303 + let mut response = http::Response::new(empty_body()); 304 304 + let headers = response.headers_mut(); 305 305 + headers 306 306 + .insert( 307 307 + tonic::Status::GRPC_STATUS, 308 308 + (tonic::Code::Unimplemented as i32).into(), 309 309 + ); 310 310 + headers 311 311 + .insert( 312 312 + http::header::CONTENT_TYPE, 313 313 + tonic::metadata::GRPC_CONTENT_TYPE, 314 314 + ); 315 315 + Ok(response) 316 316 + }) 317 317 + } 295 318 } 296 319 } 297 320 } ··· 519 542 dead_code, 520 543 missing_docs, 521 544 clippy::wildcard_imports, 522 522 - clippy::let_unit_value 545 545 + clippy::let_unit_value, 523 546 )] 524 524 - use tonic::codegen::http::Uri; 525 547 use tonic::codegen::*; 548 548 + use tonic::codegen::http::Uri; 526 549 #[derive(Debug, Clone)] 527 550 pub struct LibraryServiceClient<T> { 528 551 inner: tonic::client::Grpc<T>, ··· 566 589 <T as tonic::client::GrpcService<tonic::body::BoxBody>>::ResponseBody, 567 590 >, 568 591 >, 569 569 - <T as tonic::codegen::Service<http::Request<tonic::body::BoxBody>>>::Error: 570 570 - Into<StdError> + std::marker::Send + std::marker::Sync, 592 592 + <T as tonic::codegen::Service< 593 593 + http::Request<tonic::body::BoxBody>, 594 594 + >>::Error: Into<StdError> + std::marker::Send + std::marker::Sync, 571 595 { 572 596 LibraryServiceClient::new(InterceptedService::new(inner, interceptor)) 573 597 } ··· 605 629 pub async fn get_albums( 606 630 &mut self, 607 631 request: impl tonic::IntoRequest<super::GetAlbumsRequest>, 608 608 - ) -> std::result::Result<tonic::Response<super::GetAlbumsResponse>, tonic::Status> { 609 609 - self.inner.ready().await.map_err(|e| { 610 610 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 611 611 - })?; 632 632 + ) -> std::result::Result< 633 633 + tonic::Response<super::GetAlbumsResponse>, 634 634 + tonic::Status, 635 635 + > { 636 636 + self.inner 637 637 + .ready() 638 638 + .await 639 639 + .map_err(|e| { 640 640 + tonic::Status::unknown( 641 641 + format!("Service was not ready: {}", e.into()), 642 642 + ) 643 643 + })?; 612 644 let codec = tonic::codec::ProstCodec::default(); 613 613 - let path = 614 614 - http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.LibraryService/GetAlbums"); 645 645 + let path = http::uri::PathAndQuery::from_static( 646 646 + "/rockbox.v1alpha1.LibraryService/GetAlbums", 647 647 + ); 615 648 let mut req = request.into_request(); 616 616 - req.extensions_mut().insert(GrpcMethod::new( 617 617 - "rockbox.v1alpha1.LibraryService", 618 618 - "GetAlbums", 619 619 - )); 649 649 + req.extensions_mut() 650 650 + .insert(GrpcMethod::new("rockbox.v1alpha1.LibraryService", "GetAlbums")); 620 651 self.inner.unary(req, path, codec).await 621 652 } 622 653 pub async fn get_artists( 623 654 &mut self, 624 655 request: impl tonic::IntoRequest<super::GetArtistsRequest>, 625 625 - ) -> std::result::Result<tonic::Response<super::GetArtistsResponse>, tonic::Status> 626 626 - { 627 627 - self.inner.ready().await.map_err(|e| { 628 628 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 629 629 - })?; 656 656 + ) -> std::result::Result< 657 657 + tonic::Response<super::GetArtistsResponse>, 658 658 + tonic::Status, 659 659 + > { 660 660 + self.inner 661 661 + .ready() 662 662 + .await 663 663 + .map_err(|e| { 664 664 + tonic::Status::unknown( 665 665 + format!("Service was not ready: {}", e.into()), 666 666 + ) 667 667 + })?; 630 668 let codec = tonic::codec::ProstCodec::default(); 631 631 - let path = 632 632 - http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.LibraryService/GetArtists"); 669 669 + let path = http::uri::PathAndQuery::from_static( 670 670 + "/rockbox.v1alpha1.LibraryService/GetArtists", 671 671 + ); 633 672 let mut req = request.into_request(); 634 634 - req.extensions_mut().insert(GrpcMethod::new( 635 635 - "rockbox.v1alpha1.LibraryService", 636 636 - "GetArtists", 637 637 - )); 673 673 + req.extensions_mut() 674 674 + .insert( 675 675 + GrpcMethod::new("rockbox.v1alpha1.LibraryService", "GetArtists"), 676 676 + ); 638 677 self.inner.unary(req, path, codec).await 639 678 } 640 679 pub async fn get_tracks( 641 680 &mut self, 642 681 request: impl tonic::IntoRequest<super::GetTracksRequest>, 643 643 - ) -> std::result::Result<tonic::Response<super::GetTracksResponse>, tonic::Status> { 644 644 - self.inner.ready().await.map_err(|e| { 645 645 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 646 646 - })?; 682 682 + ) -> std::result::Result< 683 683 + tonic::Response<super::GetTracksResponse>, 684 684 + tonic::Status, 685 685 + > { 686 686 + self.inner 687 687 + .ready() 688 688 + .await 689 689 + .map_err(|e| { 690 690 + tonic::Status::unknown( 691 691 + format!("Service was not ready: {}", e.into()), 692 692 + ) 693 693 + })?; 647 694 let codec = tonic::codec::ProstCodec::default(); 648 648 - let path = 649 649 - http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.LibraryService/GetTracks"); 695 695 + let path = http::uri::PathAndQuery::from_static( 696 696 + "/rockbox.v1alpha1.LibraryService/GetTracks", 697 697 + ); 650 698 let mut req = request.into_request(); 651 651 - req.extensions_mut().insert(GrpcMethod::new( 652 652 - "rockbox.v1alpha1.LibraryService", 653 653 - "GetTracks", 654 654 - )); 699 699 + req.extensions_mut() 700 700 + .insert(GrpcMethod::new("rockbox.v1alpha1.LibraryService", "GetTracks")); 655 701 self.inner.unary(req, path, codec).await 656 702 } 657 703 pub async fn get_album( 658 704 &mut self, 659 705 request: impl tonic::IntoRequest<super::GetAlbumRequest>, 660 660 - ) -> std::result::Result<tonic::Response<super::GetAlbumResponse>, tonic::Status> { 661 661 - self.inner.ready().await.map_err(|e| { 662 662 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 663 663 - })?; 706 706 + ) -> std::result::Result< 707 707 + tonic::Response<super::GetAlbumResponse>, 708 708 + tonic::Status, 709 709 + > { 710 710 + self.inner 711 711 + .ready() 712 712 + .await 713 713 + .map_err(|e| { 714 714 + tonic::Status::unknown( 715 715 + format!("Service was not ready: {}", e.into()), 716 716 + ) 717 717 + })?; 664 718 let codec = tonic::codec::ProstCodec::default(); 665 665 - let path = 666 666 - http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.LibraryService/GetAlbum"); 719 719 + let path = http::uri::PathAndQuery::from_static( 720 720 + "/rockbox.v1alpha1.LibraryService/GetAlbum", 721 721 + ); 667 722 let mut req = request.into_request(); 668 668 - req.extensions_mut().insert(GrpcMethod::new( 669 669 - "rockbox.v1alpha1.LibraryService", 670 670 - "GetAlbum", 671 671 - )); 723 723 + req.extensions_mut() 724 724 + .insert(GrpcMethod::new("rockbox.v1alpha1.LibraryService", "GetAlbum")); 672 725 self.inner.unary(req, path, codec).await 673 726 } 674 727 pub async fn get_artist( 675 728 &mut self, 676 729 request: impl tonic::IntoRequest<super::GetArtistRequest>, 677 677 - ) -> std::result::Result<tonic::Response<super::GetArtistResponse>, tonic::Status> { 678 678 - self.inner.ready().await.map_err(|e| { 679 679 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 680 680 - })?; 730 730 + ) -> std::result::Result< 731 731 + tonic::Response<super::GetArtistResponse>, 732 732 + tonic::Status, 733 733 + > { 734 734 + self.inner 735 735 + .ready() 736 736 + .await 737 737 + .map_err(|e| { 738 738 + tonic::Status::unknown( 739 739 + format!("Service was not ready: {}", e.into()), 740 740 + ) 741 741 + })?; 681 742 let codec = tonic::codec::ProstCodec::default(); 682 682 - let path = 683 683 - http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.LibraryService/GetArtist"); 743 743 + let path = http::uri::PathAndQuery::from_static( 744 744 + "/rockbox.v1alpha1.LibraryService/GetArtist", 745 745 + ); 684 746 let mut req = request.into_request(); 685 685 - req.extensions_mut().insert(GrpcMethod::new( 686 686 - "rockbox.v1alpha1.LibraryService", 687 687 - "GetArtist", 688 688 - )); 747 747 + req.extensions_mut() 748 748 + .insert(GrpcMethod::new("rockbox.v1alpha1.LibraryService", "GetArtist")); 689 749 self.inner.unary(req, path, codec).await 690 750 } 691 751 pub async fn get_track( 692 752 &mut self, 693 753 request: impl tonic::IntoRequest<super::GetTrackRequest>, 694 694 - ) -> std::result::Result<tonic::Response<super::GetTrackResponse>, tonic::Status> { 695 695 - self.inner.ready().await.map_err(|e| { 696 696 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 697 697 - })?; 754 754 + ) -> std::result::Result< 755 755 + tonic::Response<super::GetTrackResponse>, 756 756 + tonic::Status, 757 757 + > { 758 758 + self.inner 759 759 + .ready() 760 760 + .await 761 761 + .map_err(|e| { 762 762 + tonic::Status::unknown( 763 763 + format!("Service was not ready: {}", e.into()), 764 764 + ) 765 765 + })?; 698 766 let codec = tonic::codec::ProstCodec::default(); 699 699 - let path = 700 700 - http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.LibraryService/GetTrack"); 767 767 + let path = http::uri::PathAndQuery::from_static( 768 768 + "/rockbox.v1alpha1.LibraryService/GetTrack", 769 769 + ); 701 770 let mut req = request.into_request(); 702 702 - req.extensions_mut().insert(GrpcMethod::new( 703 703 - "rockbox.v1alpha1.LibraryService", 704 704 - "GetTrack", 705 705 - )); 771 771 + req.extensions_mut() 772 772 + .insert(GrpcMethod::new("rockbox.v1alpha1.LibraryService", "GetTrack")); 706 773 self.inner.unary(req, path, codec).await 707 774 } 708 775 pub async fn like_track( 709 776 &mut self, 710 777 request: impl tonic::IntoRequest<super::LikeTrackRequest>, 711 711 - ) -> std::result::Result<tonic::Response<super::LikeTrackResponse>, tonic::Status> { 712 712 - self.inner.ready().await.map_err(|e| { 713 713 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 714 714 - })?; 778 778 + ) -> std::result::Result< 779 779 + tonic::Response<super::LikeTrackResponse>, 780 780 + tonic::Status, 781 781 + > { 782 782 + self.inner 783 783 + .ready() 784 784 + .await 785 785 + .map_err(|e| { 786 786 + tonic::Status::unknown( 787 787 + format!("Service was not ready: {}", e.into()), 788 788 + ) 789 789 + })?; 715 790 let codec = tonic::codec::ProstCodec::default(); 716 716 - let path = 717 717 - http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.LibraryService/LikeTrack"); 791 791 + let path = http::uri::PathAndQuery::from_static( 792 792 + "/rockbox.v1alpha1.LibraryService/LikeTrack", 793 793 + ); 718 794 let mut req = request.into_request(); 719 719 - req.extensions_mut().insert(GrpcMethod::new( 720 720 - "rockbox.v1alpha1.LibraryService", 721 721 - "LikeTrack", 722 722 - )); 795 795 + req.extensions_mut() 796 796 + .insert(GrpcMethod::new("rockbox.v1alpha1.LibraryService", "LikeTrack")); 723 797 self.inner.unary(req, path, codec).await 724 798 } 725 799 pub async fn unlike_track( 726 800 &mut self, 727 801 request: impl tonic::IntoRequest<super::UnlikeTrackRequest>, 728 728 - ) -> std::result::Result<tonic::Response<super::UnlikeTrackResponse>, tonic::Status> 729 729 - { 730 730 - self.inner.ready().await.map_err(|e| { 731 731 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 732 732 - })?; 802 802 + ) -> std::result::Result< 803 803 + tonic::Response<super::UnlikeTrackResponse>, 804 804 + tonic::Status, 805 805 + > { 806 806 + self.inner 807 807 + .ready() 808 808 + .await 809 809 + .map_err(|e| { 810 810 + tonic::Status::unknown( 811 811 + format!("Service was not ready: {}", e.into()), 812 812 + ) 813 813 + })?; 733 814 let codec = tonic::codec::ProstCodec::default(); 734 815 let path = http::uri::PathAndQuery::from_static( 735 816 "/rockbox.v1alpha1.LibraryService/UnlikeTrack", 736 817 ); 737 818 let mut req = request.into_request(); 738 738 - req.extensions_mut().insert(GrpcMethod::new( 739 739 - "rockbox.v1alpha1.LibraryService", 740 740 - "UnlikeTrack", 741 741 - )); 819 819 + req.extensions_mut() 820 820 + .insert( 821 821 + GrpcMethod::new("rockbox.v1alpha1.LibraryService", "UnlikeTrack"), 822 822 + ); 742 823 self.inner.unary(req, path, codec).await 743 824 } 744 825 pub async fn like_album( 745 826 &mut self, 746 827 request: impl tonic::IntoRequest<super::LikeAlbumRequest>, 747 747 - ) -> std::result::Result<tonic::Response<super::LikeAlbumResponse>, tonic::Status> { 748 748 - self.inner.ready().await.map_err(|e| { 749 749 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 750 750 - })?; 828 828 + ) -> std::result::Result< 829 829 + tonic::Response<super::LikeAlbumResponse>, 830 830 + tonic::Status, 831 831 + > { 832 832 + self.inner 833 833 + .ready() 834 834 + .await 835 835 + .map_err(|e| { 836 836 + tonic::Status::unknown( 837 837 + format!("Service was not ready: {}", e.into()), 838 838 + ) 839 839 + })?; 751 840 let codec = tonic::codec::ProstCodec::default(); 752 752 - let path = 753 753 - http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.LibraryService/LikeAlbum"); 841 841 + let path = http::uri::PathAndQuery::from_static( 842 842 + "/rockbox.v1alpha1.LibraryService/LikeAlbum", 843 843 + ); 754 844 let mut req = request.into_request(); 755 755 - req.extensions_mut().insert(GrpcMethod::new( 756 756 - "rockbox.v1alpha1.LibraryService", 757 757 - "LikeAlbum", 758 758 - )); 845 845 + req.extensions_mut() 846 846 + .insert(GrpcMethod::new("rockbox.v1alpha1.LibraryService", "LikeAlbum")); 759 847 self.inner.unary(req, path, codec).await 760 848 } 761 849 pub async fn unlike_album( 762 850 &mut self, 763 851 request: impl tonic::IntoRequest<super::UnlikeAlbumRequest>, 764 764 - ) -> std::result::Result<tonic::Response<super::UnlikeAlbumResponse>, tonic::Status> 765 765 - { 766 766 - self.inner.ready().await.map_err(|e| { 767 767 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 768 768 - })?; 852 852 + ) -> std::result::Result< 853 853 + tonic::Response<super::UnlikeAlbumResponse>, 854 854 + tonic::Status, 855 855 + > { 856 856 + self.inner 857 857 + .ready() 858 858 + .await 859 859 + .map_err(|e| { 860 860 + tonic::Status::unknown( 861 861 + format!("Service was not ready: {}", e.into()), 862 862 + ) 863 863 + })?; 769 864 let codec = tonic::codec::ProstCodec::default(); 770 865 let path = http::uri::PathAndQuery::from_static( 771 866 "/rockbox.v1alpha1.LibraryService/UnlikeAlbum", 772 867 ); 773 868 let mut req = request.into_request(); 774 774 - req.extensions_mut().insert(GrpcMethod::new( 775 775 - "rockbox.v1alpha1.LibraryService", 776 776 - "UnlikeAlbum", 777 777 - )); 869 869 + req.extensions_mut() 870 870 + .insert( 871 871 + GrpcMethod::new("rockbox.v1alpha1.LibraryService", "UnlikeAlbum"), 872 872 + ); 778 873 self.inner.unary(req, path, codec).await 779 874 } 780 875 pub async fn get_liked_tracks( 781 876 &mut self, 782 877 request: impl tonic::IntoRequest<super::GetLikedTracksRequest>, 783 783 - ) -> std::result::Result<tonic::Response<super::GetLikedTracksResponse>, tonic::Status> 784 784 - { 785 785 - self.inner.ready().await.map_err(|e| { 786 786 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 787 787 - })?; 878 878 + ) -> std::result::Result< 879 879 + tonic::Response<super::GetLikedTracksResponse>, 880 880 + tonic::Status, 881 881 + > { 882 882 + self.inner 883 883 + .ready() 884 884 + .await 885 885 + .map_err(|e| { 886 886 + tonic::Status::unknown( 887 887 + format!("Service was not ready: {}", e.into()), 888 888 + ) 889 889 + })?; 788 890 let codec = tonic::codec::ProstCodec::default(); 789 891 let path = http::uri::PathAndQuery::from_static( 790 892 "/rockbox.v1alpha1.LibraryService/GetLikedTracks", 791 893 ); 792 894 let mut req = request.into_request(); 793 793 - req.extensions_mut().insert(GrpcMethod::new( 794 794 - "rockbox.v1alpha1.LibraryService", 795 795 - "GetLikedTracks", 796 796 - )); 895 895 + req.extensions_mut() 896 896 + .insert( 897 897 + GrpcMethod::new("rockbox.v1alpha1.LibraryService", "GetLikedTracks"), 898 898 + ); 797 899 self.inner.unary(req, path, codec).await 798 900 } 799 901 pub async fn get_liked_albums( 800 902 &mut self, 801 903 request: impl tonic::IntoRequest<super::GetLikedAlbumsRequest>, 802 802 - ) -> std::result::Result<tonic::Response<super::GetLikedAlbumsResponse>, tonic::Status> 803 803 - { 804 804 - self.inner.ready().await.map_err(|e| { 805 805 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 806 806 - })?; 904 904 + ) -> std::result::Result< 905 905 + tonic::Response<super::GetLikedAlbumsResponse>, 906 906 + tonic::Status, 907 907 + > { 908 908 + self.inner 909 909 + .ready() 910 910 + .await 911 911 + .map_err(|e| { 912 912 + tonic::Status::unknown( 913 913 + format!("Service was not ready: {}", e.into()), 914 914 + ) 915 915 + })?; 807 916 let codec = tonic::codec::ProstCodec::default(); 808 917 let path = http::uri::PathAndQuery::from_static( 809 918 "/rockbox.v1alpha1.LibraryService/GetLikedAlbums", 810 919 ); 811 920 let mut req = request.into_request(); 812 812 - req.extensions_mut().insert(GrpcMethod::new( 813 813 - "rockbox.v1alpha1.LibraryService", 814 814 - "GetLikedAlbums", 815 815 - )); 921 921 + req.extensions_mut() 922 922 + .insert( 923 923 + GrpcMethod::new("rockbox.v1alpha1.LibraryService", "GetLikedAlbums"), 924 924 + ); 816 925 self.inner.unary(req, path, codec).await 817 926 } 818 927 pub async fn scan_library( 819 928 &mut self, 820 929 request: impl tonic::IntoRequest<super::ScanLibraryRequest>, 821 821 - ) -> std::result::Result<tonic::Response<super::ScanLibraryResponse>, tonic::Status> 822 822 - { 823 823 - self.inner.ready().await.map_err(|e| { 824 824 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 825 825 - })?; 930 930 + ) -> std::result::Result< 931 931 + tonic::Response<super::ScanLibraryResponse>, 932 932 + tonic::Status, 933 933 + > { 934 934 + self.inner 935 935 + .ready() 936 936 + .await 937 937 + .map_err(|e| { 938 938 + tonic::Status::unknown( 939 939 + format!("Service was not ready: {}", e.into()), 940 940 + ) 941 941 + })?; 826 942 let codec = tonic::codec::ProstCodec::default(); 827 943 let path = http::uri::PathAndQuery::from_static( 828 944 "/rockbox.v1alpha1.LibraryService/ScanLibrary", 829 945 ); 830 946 let mut req = request.into_request(); 831 831 - req.extensions_mut().insert(GrpcMethod::new( 832 832 - "rockbox.v1alpha1.LibraryService", 833 833 - "ScanLibrary", 834 834 - )); 947 947 + req.extensions_mut() 948 948 + .insert( 949 949 + GrpcMethod::new("rockbox.v1alpha1.LibraryService", "ScanLibrary"), 950 950 + ); 835 951 self.inner.unary(req, path, codec).await 836 952 } 837 953 pub async fn search( 838 954 &mut self, 839 955 request: impl tonic::IntoRequest<super::SearchRequest>, 840 956 ) -> std::result::Result<tonic::Response<super::SearchResponse>, tonic::Status> { 841 841 - self.inner.ready().await.map_err(|e| { 842 842 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 843 843 - })?; 957 957 + self.inner 958 958 + .ready() 959 959 + .await 960 960 + .map_err(|e| { 961 961 + tonic::Status::unknown( 962 962 + format!("Service was not ready: {}", e.into()), 963 963 + ) 964 964 + })?; 844 965 let codec = tonic::codec::ProstCodec::default(); 845 845 - let path = 846 846 - http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.LibraryService/Search"); 966 966 + let path = http::uri::PathAndQuery::from_static( 967 967 + "/rockbox.v1alpha1.LibraryService/Search", 968 968 + ); 847 969 let mut req = request.into_request(); 848 970 req.extensions_mut() 849 971 .insert(GrpcMethod::new("rockbox.v1alpha1.LibraryService", "Search")); ··· 858 980 dead_code, 859 981 missing_docs, 860 982 clippy::wildcard_imports, 861 861 - clippy::let_unit_value 983 983 + clippy::let_unit_value, 862 984 )] 863 985 use tonic::codegen::*; 864 986 /// Generated trait containing gRPC methods that should be implemented for use with LibraryServiceServer. ··· 867 989 async fn get_albums( 868 990 &self, 869 991 request: tonic::Request<super::GetAlbumsRequest>, 870 870 - ) -> std::result::Result<tonic::Response<super::GetAlbumsResponse>, tonic::Status>; 992 992 + ) -> std::result::Result< 993 993 + tonic::Response<super::GetAlbumsResponse>, 994 994 + tonic::Status, 995 995 + >; 871 996 async fn get_artists( 872 997 &self, 873 998 request: tonic::Request<super::GetArtistsRequest>, 874 874 - ) -> std::result::Result<tonic::Response<super::GetArtistsResponse>, tonic::Status>; 999 999 + ) -> std::result::Result< 1000 1000 + tonic::Response<super::GetArtistsResponse>, 1001 1001 + tonic::Status, 1002 1002 + >; 875 1003 async fn get_tracks( 876 1004 &self, 877 1005 request: tonic::Request<super::GetTracksRequest>, 878 878 - ) -> std::result::Result<tonic::Response<super::GetTracksResponse>, tonic::Status>; 1006 1006 + ) -> std::result::Result< 1007 1007 + tonic::Response<super::GetTracksResponse>, 1008 1008 + tonic::Status, 1009 1009 + >; 879 1010 async fn get_album( 880 1011 &self, 881 1012 request: tonic::Request<super::GetAlbumRequest>, 882 882 - ) -> std::result::Result<tonic::Response<super::GetAlbumResponse>, tonic::Status>; 1013 1013 + ) -> std::result::Result< 1014 1014 + tonic::Response<super::GetAlbumResponse>, 1015 1015 + tonic::Status, 1016 1016 + >; 883 1017 async fn get_artist( 884 1018 &self, 885 1019 request: tonic::Request<super::GetArtistRequest>, 886 886 - ) -> std::result::Result<tonic::Response<super::GetArtistResponse>, tonic::Status>; 1020 1020 + ) -> std::result::Result< 1021 1021 + tonic::Response<super::GetArtistResponse>, 1022 1022 + tonic::Status, 1023 1023 + >; 887 1024 async fn get_track( 888 1025 &self, 889 1026 request: tonic::Request<super::GetTrackRequest>, 890 890 - ) -> std::result::Result<tonic::Response<super::GetTrackResponse>, tonic::Status>; 1027 1027 + ) -> std::result::Result< 1028 1028 + tonic::Response<super::GetTrackResponse>, 1029 1029 + tonic::Status, 1030 1030 + >; 891 1031 async fn like_track( 892 1032 &self, 893 1033 request: tonic::Request<super::LikeTrackRequest>, 894 894 - ) -> std::result::Result<tonic::Response<super::LikeTrackResponse>, tonic::Status>; 1034 1034 + ) -> std::result::Result< 1035 1035 + tonic::Response<super::LikeTrackResponse>, 1036 1036 + tonic::Status, 1037 1037 + >; 895 1038 async fn unlike_track( 896 1039 &self, 897 1040 request: tonic::Request<super::UnlikeTrackRequest>, 898 898 - ) -> std::result::Result<tonic::Response<super::UnlikeTrackResponse>, tonic::Status>; 1041 1041 + ) -> std::result::Result< 1042 1042 + tonic::Response<super::UnlikeTrackResponse>, 1043 1043 + tonic::Status, 1044 1044 + >; 899 1045 async fn like_album( 900 1046 &self, 901 1047 request: tonic::Request<super::LikeAlbumRequest>, 902 902 - ) -> std::result::Result<tonic::Response<super::LikeAlbumResponse>, tonic::Status>; 1048 1048 + ) -> std::result::Result< 1049 1049 + tonic::Response<super::LikeAlbumResponse>, 1050 1050 + tonic::Status, 1051 1051 + >; 903 1052 async fn unlike_album( 904 1053 &self, 905 1054 request: tonic::Request<super::UnlikeAlbumRequest>, 906 906 - ) -> std::result::Result<tonic::Response<super::UnlikeAlbumResponse>, tonic::Status>; 1055 1055 + ) -> std::result::Result< 1056 1056 + tonic::Response<super::UnlikeAlbumResponse>, 1057 1057 + tonic::Status, 1058 1058 + >; 907 1059 async fn get_liked_tracks( 908 1060 &self, 909 1061 request: tonic::Request<super::GetLikedTracksRequest>, 910 910 - ) -> std::result::Result<tonic::Response<super::GetLikedTracksResponse>, tonic::Status>; 1062 1062 + ) -> std::result::Result< 1063 1063 + tonic::Response<super::GetLikedTracksResponse>, 1064 1064 + tonic::Status, 1065 1065 + >; 911 1066 async fn get_liked_albums( 912 1067 &self, 913 1068 request: tonic::Request<super::GetLikedAlbumsRequest>, 914 914 - ) -> std::result::Result<tonic::Response<super::GetLikedAlbumsResponse>, tonic::Status>; 1069 1069 + ) -> std::result::Result< 1070 1070 + tonic::Response<super::GetLikedAlbumsResponse>, 1071 1071 + tonic::Status, 1072 1072 + >; 915 1073 async fn scan_library( 916 1074 &self, 917 1075 request: tonic::Request<super::ScanLibraryRequest>, 918 918 - ) -> std::result::Result<tonic::Response<super::ScanLibraryResponse>, tonic::Status>; 1076 1076 + ) -> std::result::Result< 1077 1077 + tonic::Response<super::ScanLibraryResponse>, 1078 1078 + tonic::Status, 1079 1079 + >; 919 1080 async fn search( 920 1081 &self, 921 1082 request: tonic::Request<super::SearchRequest>, ··· 942 1103 max_encoding_message_size: None, 943 1104 } 944 1105 } 945 945 - pub fn with_interceptor<F>(inner: T, interceptor: F) -> InterceptedService<Self, F> 1106 1106 + pub fn with_interceptor<F>( 1107 1107 + inner: T, 1108 1108 + interceptor: F, 1109 1109 + ) -> InterceptedService<Self, F> 946 1110 where 947 1111 F: tonic::service::Interceptor, 948 1112 { ··· 997 1161 "/rockbox.v1alpha1.LibraryService/GetAlbums" => { 998 1162 #[allow(non_camel_case_types)] 999 1163 struct GetAlbumsSvc<T: LibraryService>(pub Arc<T>); 1000 1000 - impl<T: LibraryService> tonic::server::UnaryService<super::GetAlbumsRequest> for GetAlbumsSvc<T> { 1164 1164 + impl< 1165 1165 + T: LibraryService, 1166 1166 + > tonic::server::UnaryService<super::GetAlbumsRequest> 1167 1167 + for GetAlbumsSvc<T> { 1001 1168 type Response = super::GetAlbumsResponse; 1002 1002 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 1169 1169 + type Future = BoxFuture< 1170 1170 + tonic::Response<Self::Response>, 1171 1171 + tonic::Status, 1172 1172 + >; 1003 1173 fn call( 1004 1174 &mut self, 1005 1175 request: tonic::Request<super::GetAlbumsRequest>, ··· 1036 1206 "/rockbox.v1alpha1.LibraryService/GetArtists" => { 1037 1207 #[allow(non_camel_case_types)] 1038 1208 struct GetArtistsSvc<T: LibraryService>(pub Arc<T>); 1039 1039 - impl<T: LibraryService> tonic::server::UnaryService<super::GetArtistsRequest> for GetArtistsSvc<T> { 1209 1209 + impl< 1210 1210 + T: LibraryService, 1211 1211 + > tonic::server::UnaryService<super::GetArtistsRequest> 1212 1212 + for GetArtistsSvc<T> { 1040 1213 type Response = super::GetArtistsResponse; 1041 1041 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 1214 1214 + type Future = BoxFuture< 1215 1215 + tonic::Response<Self::Response>, 1216 1216 + tonic::Status, 1217 1217 + >; 1042 1218 fn call( 1043 1219 &mut self, 1044 1220 request: tonic::Request<super::GetArtistsRequest>, ··· 1075 1251 "/rockbox.v1alpha1.LibraryService/GetTracks" => { 1076 1252 #[allow(non_camel_case_types)] 1077 1253 struct GetTracksSvc<T: LibraryService>(pub Arc<T>); 1078 1078 - impl<T: LibraryService> tonic::server::UnaryService<super::GetTracksRequest> for GetTracksSvc<T> { 1254 1254 + impl< 1255 1255 + T: LibraryService, 1256 1256 + > tonic::server::UnaryService<super::GetTracksRequest> 1257 1257 + for GetTracksSvc<T> { 1079 1258 type Response = super::GetTracksResponse; 1080 1080 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 1259 1259 + type Future = BoxFuture< 1260 1260 + tonic::Response<Self::Response>, 1261 1261 + tonic::Status, 1262 1262 + >; 1081 1263 fn call( 1082 1264 &mut self, 1083 1265 request: tonic::Request<super::GetTracksRequest>, ··· 1114 1296 "/rockbox.v1alpha1.LibraryService/GetAlbum" => { 1115 1297 #[allow(non_camel_case_types)] 1116 1298 struct GetAlbumSvc<T: LibraryService>(pub Arc<T>); 1117 1117 - impl<T: LibraryService> tonic::server::UnaryService<super::GetAlbumRequest> for GetAlbumSvc<T> { 1299 1299 + impl< 1300 1300 + T: LibraryService, 1301 1301 + > tonic::server::UnaryService<super::GetAlbumRequest> 1302 1302 + for GetAlbumSvc<T> { 1118 1303 type Response = super::GetAlbumResponse; 1119 1119 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 1304 1304 + type Future = BoxFuture< 1305 1305 + tonic::Response<Self::Response>, 1306 1306 + tonic::Status, 1307 1307 + >; 1120 1308 fn call( 1121 1309 &mut self, 1122 1310 request: tonic::Request<super::GetAlbumRequest>, ··· 1153 1341 "/rockbox.v1alpha1.LibraryService/GetArtist" => { 1154 1342 #[allow(non_camel_case_types)] 1155 1343 struct GetArtistSvc<T: LibraryService>(pub Arc<T>); 1156 1156 - impl<T: LibraryService> tonic::server::UnaryService<super::GetArtistRequest> for GetArtistSvc<T> { 1344 1344 + impl< 1345 1345 + T: LibraryService, 1346 1346 + > tonic::server::UnaryService<super::GetArtistRequest> 1347 1347 + for GetArtistSvc<T> { 1157 1348 type Response = super::GetArtistResponse; 1158 1158 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 1349 1349 + type Future = BoxFuture< 1350 1350 + tonic::Response<Self::Response>, 1351 1351 + tonic::Status, 1352 1352 + >; 1159 1353 fn call( 1160 1354 &mut self, 1161 1355 request: tonic::Request<super::GetArtistRequest>, ··· 1192 1386 "/rockbox.v1alpha1.LibraryService/GetTrack" => { 1193 1387 #[allow(non_camel_case_types)] 1194 1388 struct GetTrackSvc<T: LibraryService>(pub Arc<T>); 1195 1195 - impl<T: LibraryService> tonic::server::UnaryService<super::GetTrackRequest> for GetTrackSvc<T> { 1389 1389 + impl< 1390 1390 + T: LibraryService, 1391 1391 + > tonic::server::UnaryService<super::GetTrackRequest> 1392 1392 + for GetTrackSvc<T> { 1196 1393 type Response = super::GetTrackResponse; 1197 1197 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 1394 1394 + type Future = BoxFuture< 1395 1395 + tonic::Response<Self::Response>, 1396 1396 + tonic::Status, 1397 1397 + >; 1198 1398 fn call( 1199 1399 &mut self, 1200 1400 request: tonic::Request<super::GetTrackRequest>, ··· 1231 1431 "/rockbox.v1alpha1.LibraryService/LikeTrack" => { 1232 1432 #[allow(non_camel_case_types)] 1233 1433 struct LikeTrackSvc<T: LibraryService>(pub Arc<T>); 1234 1234 - impl<T: LibraryService> tonic::server::UnaryService<super::LikeTrackRequest> for LikeTrackSvc<T> { 1434 1434 + impl< 1435 1435 + T: LibraryService, 1436 1436 + > tonic::server::UnaryService<super::LikeTrackRequest> 1437 1437 + for LikeTrackSvc<T> { 1235 1438 type Response = super::LikeTrackResponse; 1236 1236 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 1439 1439 + type Future = BoxFuture< 1440 1440 + tonic::Response<Self::Response>, 1441 1441 + tonic::Status, 1442 1442 + >; 1237 1443 fn call( 1238 1444 &mut self, 1239 1445 request: tonic::Request<super::LikeTrackRequest>, ··· 1270 1476 "/rockbox.v1alpha1.LibraryService/UnlikeTrack" => { 1271 1477 #[allow(non_camel_case_types)] 1272 1478 struct UnlikeTrackSvc<T: LibraryService>(pub Arc<T>); 1273 1273 - impl<T: LibraryService> tonic::server::UnaryService<super::UnlikeTrackRequest> 1274 1274 - for UnlikeTrackSvc<T> 1275 1275 - { 1479 1479 + impl< 1480 1480 + T: LibraryService, 1481 1481 + > tonic::server::UnaryService<super::UnlikeTrackRequest> 1482 1482 + for UnlikeTrackSvc<T> { 1276 1483 type Response = super::UnlikeTrackResponse; 1277 1277 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 1484 1484 + type Future = BoxFuture< 1485 1485 + tonic::Response<Self::Response>, 1486 1486 + tonic::Status, 1487 1487 + >; 1278 1488 fn call( 1279 1489 &mut self, 1280 1490 request: tonic::Request<super::UnlikeTrackRequest>, ··· 1311 1521 "/rockbox.v1alpha1.LibraryService/LikeAlbum" => { 1312 1522 #[allow(non_camel_case_types)] 1313 1523 struct LikeAlbumSvc<T: LibraryService>(pub Arc<T>); 1314 1314 - impl<T: LibraryService> tonic::server::UnaryService<super::LikeAlbumRequest> for LikeAlbumSvc<T> { 1524 1524 + impl< 1525 1525 + T: LibraryService, 1526 1526 + > tonic::server::UnaryService<super::LikeAlbumRequest> 1527 1527 + for LikeAlbumSvc<T> { 1315 1528 type Response = super::LikeAlbumResponse; 1316 1316 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 1529 1529 + type Future = BoxFuture< 1530 1530 + tonic::Response<Self::Response>, 1531 1531 + tonic::Status, 1532 1532 + >; 1317 1533 fn call( 1318 1534 &mut self, 1319 1535 request: tonic::Request<super::LikeAlbumRequest>, ··· 1350 1566 "/rockbox.v1alpha1.LibraryService/UnlikeAlbum" => { 1351 1567 #[allow(non_camel_case_types)] 1352 1568 struct UnlikeAlbumSvc<T: LibraryService>(pub Arc<T>); 1353 1353 - impl<T: LibraryService> tonic::server::UnaryService<super::UnlikeAlbumRequest> 1354 1354 - for UnlikeAlbumSvc<T> 1355 1355 - { 1569 1569 + impl< 1570 1570 + T: LibraryService, 1571 1571 + > tonic::server::UnaryService<super::UnlikeAlbumRequest> 1572 1572 + for UnlikeAlbumSvc<T> { 1356 1573 type Response = super::UnlikeAlbumResponse; 1357 1357 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 1574 1574 + type Future = BoxFuture< 1575 1575 + tonic::Response<Self::Response>, 1576 1576 + tonic::Status, 1577 1577 + >; 1358 1578 fn call( 1359 1579 &mut self, 1360 1580 request: tonic::Request<super::UnlikeAlbumRequest>, ··· 1391 1611 "/rockbox.v1alpha1.LibraryService/GetLikedTracks" => { 1392 1612 #[allow(non_camel_case_types)] 1393 1613 struct GetLikedTracksSvc<T: LibraryService>(pub Arc<T>); 1394 1394 - impl<T: LibraryService> 1395 1395 - tonic::server::UnaryService<super::GetLikedTracksRequest> 1396 1396 - for GetLikedTracksSvc<T> 1397 1397 - { 1614 1614 + impl< 1615 1615 + T: LibraryService, 1616 1616 + > tonic::server::UnaryService<super::GetLikedTracksRequest> 1617 1617 + for GetLikedTracksSvc<T> { 1398 1618 type Response = super::GetLikedTracksResponse; 1399 1399 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 1619 1619 + type Future = BoxFuture< 1620 1620 + tonic::Response<Self::Response>, 1621 1621 + tonic::Status, 1622 1622 + >; 1400 1623 fn call( 1401 1624 &mut self, 1402 1625 request: tonic::Request<super::GetLikedTracksRequest>, 1403 1626 ) -> Self::Future { 1404 1627 let inner = Arc::clone(&self.0); 1405 1628 let fut = async move { 1406 1406 - <T as LibraryService>::get_liked_tracks(&inner, request).await 1629 1629 + <T as LibraryService>::get_liked_tracks(&inner, request) 1630 1630 + .await 1407 1631 }; 1408 1632 Box::pin(fut) 1409 1633 } ··· 1433 1657 "/rockbox.v1alpha1.LibraryService/GetLikedAlbums" => { 1434 1658 #[allow(non_camel_case_types)] 1435 1659 struct GetLikedAlbumsSvc<T: LibraryService>(pub Arc<T>); 1436 1436 - impl<T: LibraryService> 1437 1437 - tonic::server::UnaryService<super::GetLikedAlbumsRequest> 1438 1438 - for GetLikedAlbumsSvc<T> 1439 1439 - { 1660 1660 + impl< 1661 1661 + T: LibraryService, 1662 1662 + > tonic::server::UnaryService<super::GetLikedAlbumsRequest> 1663 1663 + for GetLikedAlbumsSvc<T> { 1440 1664 type Response = super::GetLikedAlbumsResponse; 1441 1441 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 1665 1665 + type Future = BoxFuture< 1666 1666 + tonic::Response<Self::Response>, 1667 1667 + tonic::Status, 1668 1668 + >; 1442 1669 fn call( 1443 1670 &mut self, 1444 1671 request: tonic::Request<super::GetLikedAlbumsRequest>, 1445 1672 ) -> Self::Future { 1446 1673 let inner = Arc::clone(&self.0); 1447 1674 let fut = async move { 1448 1448 - <T as LibraryService>::get_liked_albums(&inner, request).await 1675 1675 + <T as LibraryService>::get_liked_albums(&inner, request) 1676 1676 + .await 1449 1677 }; 1450 1678 Box::pin(fut) 1451 1679 } ··· 1475 1703 "/rockbox.v1alpha1.LibraryService/ScanLibrary" => { 1476 1704 #[allow(non_camel_case_types)] 1477 1705 struct ScanLibrarySvc<T: LibraryService>(pub Arc<T>); 1478 1478 - impl<T: LibraryService> tonic::server::UnaryService<super::ScanLibraryRequest> 1479 1479 - for ScanLibrarySvc<T> 1480 1480 - { 1706 1706 + impl< 1707 1707 + T: LibraryService, 1708 1708 + > tonic::server::UnaryService<super::ScanLibraryRequest> 1709 1709 + for ScanLibrarySvc<T> { 1481 1710 type Response = super::ScanLibraryResponse; 1482 1482 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 1711 1711 + type Future = BoxFuture< 1712 1712 + tonic::Response<Self::Response>, 1713 1713 + tonic::Status, 1714 1714 + >; 1483 1715 fn call( 1484 1716 &mut self, 1485 1717 request: tonic::Request<super::ScanLibraryRequest>, ··· 1516 1748 "/rockbox.v1alpha1.LibraryService/Search" => { 1517 1749 #[allow(non_camel_case_types)] 1518 1750 struct SearchSvc<T: LibraryService>(pub Arc<T>); 1519 1519 - impl<T: LibraryService> tonic::server::UnaryService<super::SearchRequest> for SearchSvc<T> { 1751 1751 + impl< 1752 1752 + T: LibraryService, 1753 1753 + > tonic::server::UnaryService<super::SearchRequest> 1754 1754 + for SearchSvc<T> { 1520 1755 type Response = super::SearchResponse; 1521 1521 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 1756 1756 + type Future = BoxFuture< 1757 1757 + tonic::Response<Self::Response>, 1758 1758 + tonic::Status, 1759 1759 + >; 1522 1760 fn call( 1523 1761 &mut self, 1524 1762 request: tonic::Request<super::SearchRequest>, 1525 1763 ) -> Self::Future { 1526 1764 let inner = Arc::clone(&self.0); 1527 1527 - let fut = 1528 1528 - async move { <T as LibraryService>::search(&inner, request).await }; 1765 1765 + let fut = async move { 1766 1766 + <T as LibraryService>::search(&inner, request).await 1767 1767 + }; 1529 1768 Box::pin(fut) 1530 1769 } 1531 1770 } ··· 1551 1790 }; 1552 1791 Box::pin(fut) 1553 1792 } 1554 1554 - _ => Box::pin(async move { 1555 1555 - let mut response = http::Response::new(empty_body()); 1556 1556 - let headers = response.headers_mut(); 1557 1557 - headers.insert( 1558 1558 - tonic::Status::GRPC_STATUS, 1559 1559 - (tonic::Code::Unimplemented as i32).into(), 1560 1560 - ); 1561 1561 - headers.insert( 1562 1562 - http::header::CONTENT_TYPE, 1563 1563 - tonic::metadata::GRPC_CONTENT_TYPE, 1564 1564 - ); 1565 1565 - Ok(response) 1566 1566 - }), 1793 1793 + _ => { 1794 1794 + Box::pin(async move { 1795 1795 + let mut response = http::Response::new(empty_body()); 1796 1796 + let headers = response.headers_mut(); 1797 1797 + headers 1798 1798 + .insert( 1799 1799 + tonic::Status::GRPC_STATUS, 1800 1800 + (tonic::Code::Unimplemented as i32).into(), 1801 1801 + ); 1802 1802 + headers 1803 1803 + .insert( 1804 1804 + http::header::CONTENT_TYPE, 1805 1805 + tonic::metadata::GRPC_CONTENT_TYPE, 1806 1806 + ); 1807 1807 + Ok(response) 1808 1808 + }) 1809 1809 + } 1567 1810 } 1568 1811 } 1569 1812 } ··· 1592 1835 dead_code, 1593 1836 missing_docs, 1594 1837 clippy::wildcard_imports, 1595 1595 - clippy::let_unit_value 1838 1838 + clippy::let_unit_value, 1596 1839 )] 1597 1597 - use tonic::codegen::http::Uri; 1598 1840 use tonic::codegen::*; 1841 1841 + use tonic::codegen::http::Uri; 1599 1842 #[derive(Debug, Clone)] 1600 1843 pub struct MetadataServiceClient<T> { 1601 1844 inner: tonic::client::Grpc<T>, ··· 1639 1882 <T as tonic::client::GrpcService<tonic::body::BoxBody>>::ResponseBody, 1640 1883 >, 1641 1884 >, 1642 1642 - <T as tonic::codegen::Service<http::Request<tonic::body::BoxBody>>>::Error: 1643 1643 - Into<StdError> + std::marker::Send + std::marker::Sync, 1885 1885 + <T as tonic::codegen::Service< 1886 1886 + http::Request<tonic::body::BoxBody>, 1887 1887 + >>::Error: Into<StdError> + std::marker::Send + std::marker::Sync, 1644 1888 { 1645 1889 MetadataServiceClient::new(InterceptedService::new(inner, interceptor)) 1646 1890 } ··· 1684 1928 dead_code, 1685 1929 missing_docs, 1686 1930 clippy::wildcard_imports, 1687 1687 - clippy::let_unit_value 1931 1931 + clippy::let_unit_value, 1688 1932 )] 1689 1933 use tonic::codegen::*; 1690 1934 /// Generated trait containing gRPC methods that should be implemented for use with MetadataServiceServer. ··· 1711 1955 max_encoding_message_size: None, 1712 1956 } 1713 1957 } 1714 1714 - pub fn with_interceptor<F>(inner: T, interceptor: F) -> InterceptedService<Self, F> 1958 1958 + pub fn with_interceptor<F>( 1959 1959 + inner: T, 1960 1960 + interceptor: F, 1961 1961 + ) -> InterceptedService<Self, F> 1715 1962 where 1716 1963 F: tonic::service::Interceptor, 1717 1964 { ··· 1763 2010 } 1764 2011 fn call(&mut self, req: http::Request<B>) -> Self::Future { 1765 2012 match req.uri().path() { 1766 1766 - _ => Box::pin(async move { 1767 1767 - let mut response = http::Response::new(empty_body()); 1768 1768 - let headers = response.headers_mut(); 1769 1769 - headers.insert( 1770 1770 - tonic::Status::GRPC_STATUS, 1771 1771 - (tonic::Code::Unimplemented as i32).into(), 1772 1772 - ); 1773 1773 - headers.insert( 1774 1774 - http::header::CONTENT_TYPE, 1775 1775 - tonic::metadata::GRPC_CONTENT_TYPE, 1776 1776 - ); 1777 1777 - Ok(response) 1778 1778 - }), 2013 2013 + _ => { 2014 2014 + Box::pin(async move { 2015 2015 + let mut response = http::Response::new(empty_body()); 2016 2016 + let headers = response.headers_mut(); 2017 2017 + headers 2018 2018 + .insert( 2019 2019 + tonic::Status::GRPC_STATUS, 2020 2020 + (tonic::Code::Unimplemented as i32).into(), 2021 2021 + ); 2022 2022 + headers 2023 2023 + .insert( 2024 2024 + http::header::CONTENT_TYPE, 2025 2025 + tonic::metadata::GRPC_CONTENT_TYPE, 2026 2026 + ); 2027 2027 + Ok(response) 2028 2028 + }) 2029 2029 + } 1779 2030 } 1780 2031 } 1781 2032 } ··· 2048 2299 dead_code, 2049 2300 missing_docs, 2050 2301 clippy::wildcard_imports, 2051 2051 - clippy::let_unit_value 2302 2302 + clippy::let_unit_value, 2052 2303 )] 2053 2053 - use tonic::codegen::http::Uri; 2054 2304 use tonic::codegen::*; 2305 2305 + use tonic::codegen::http::Uri; 2055 2306 #[derive(Debug, Clone)] 2056 2307 pub struct PlaybackServiceClient<T> { 2057 2308 inner: tonic::client::Grpc<T>, ··· 2095 2346 <T as tonic::client::GrpcService<tonic::body::BoxBody>>::ResponseBody, 2096 2347 >, 2097 2348 >, 2098 2098 - <T as tonic::codegen::Service<http::Request<tonic::body::BoxBody>>>::Error: 2099 2099 - Into<StdError> + std::marker::Send + std::marker::Sync, 2349 2349 + <T as tonic::codegen::Service< 2350 2350 + http::Request<tonic::body::BoxBody>, 2351 2351 + >>::Error: Into<StdError> + std::marker::Send + std::marker::Sync, 2100 2352 { 2101 2353 PlaybackServiceClient::new(InterceptedService::new(inner, interceptor)) 2102 2354 } ··· 2135 2387 &mut self, 2136 2388 request: impl tonic::IntoRequest<super::PlayRequest>, 2137 2389 ) -> std::result::Result<tonic::Response<super::PlayResponse>, tonic::Status> { 2138 2138 - self.inner.ready().await.map_err(|e| { 2139 2139 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 2140 2140 - })?; 2390 2390 + self.inner 2391 2391 + .ready() 2392 2392 + .await 2393 2393 + .map_err(|e| { 2394 2394 + tonic::Status::unknown( 2395 2395 + format!("Service was not ready: {}", e.into()), 2396 2396 + ) 2397 2397 + })?; 2141 2398 let codec = tonic::codec::ProstCodec::default(); 2142 2142 - let path = 2143 2143 - http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.PlaybackService/Play"); 2399 2399 + let path = http::uri::PathAndQuery::from_static( 2400 2400 + "/rockbox.v1alpha1.PlaybackService/Play", 2401 2401 + ); 2144 2402 let mut req = request.into_request(); 2145 2403 req.extensions_mut() 2146 2404 .insert(GrpcMethod::new("rockbox.v1alpha1.PlaybackService", "Play")); ··· 2150 2408 &mut self, 2151 2409 request: impl tonic::IntoRequest<super::PauseRequest>, 2152 2410 ) -> std::result::Result<tonic::Response<super::PauseResponse>, tonic::Status> { 2153 2153 - self.inner.ready().await.map_err(|e| { 2154 2154 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 2155 2155 - })?; 2411 2411 + self.inner 2412 2412 + .ready() 2413 2413 + .await 2414 2414 + .map_err(|e| { 2415 2415 + tonic::Status::unknown( 2416 2416 + format!("Service was not ready: {}", e.into()), 2417 2417 + ) 2418 2418 + })?; 2156 2419 let codec = tonic::codec::ProstCodec::default(); 2157 2157 - let path = 2158 2158 - http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.PlaybackService/Pause"); 2420 2420 + let path = http::uri::PathAndQuery::from_static( 2421 2421 + "/rockbox.v1alpha1.PlaybackService/Pause", 2422 2422 + ); 2159 2423 let mut req = request.into_request(); 2160 2424 req.extensions_mut() 2161 2425 .insert(GrpcMethod::new("rockbox.v1alpha1.PlaybackService", "Pause")); ··· 2164 2428 pub async fn play_or_pause( 2165 2429 &mut self, 2166 2430 request: impl tonic::IntoRequest<super::PlayOrPauseRequest>, 2167 2167 - ) -> std::result::Result<tonic::Response<super::PlayOrPauseResponse>, tonic::Status> 2168 2168 - { 2169 2169 - self.inner.ready().await.map_err(|e| { 2170 2170 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 2171 2171 - })?; 2431 2431 + ) -> std::result::Result< 2432 2432 + tonic::Response<super::PlayOrPauseResponse>, 2433 2433 + tonic::Status, 2434 2434 + > { 2435 2435 + self.inner 2436 2436 + .ready() 2437 2437 + .await 2438 2438 + .map_err(|e| { 2439 2439 + tonic::Status::unknown( 2440 2440 + format!("Service was not ready: {}", e.into()), 2441 2441 + ) 2442 2442 + })?; 2172 2443 let codec = tonic::codec::ProstCodec::default(); 2173 2444 let path = http::uri::PathAndQuery::from_static( 2174 2445 "/rockbox.v1alpha1.PlaybackService/PlayOrPause", 2175 2446 ); 2176 2447 let mut req = request.into_request(); 2177 2177 - req.extensions_mut().insert(GrpcMethod::new( 2178 2178 - "rockbox.v1alpha1.PlaybackService", 2179 2179 - "PlayOrPause", 2180 2180 - )); 2448 2448 + req.extensions_mut() 2449 2449 + .insert( 2450 2450 + GrpcMethod::new("rockbox.v1alpha1.PlaybackService", "PlayOrPause"), 2451 2451 + ); 2181 2452 self.inner.unary(req, path, codec).await 2182 2453 } 2183 2454 pub async fn resume( 2184 2455 &mut self, 2185 2456 request: impl tonic::IntoRequest<super::ResumeRequest>, 2186 2457 ) -> std::result::Result<tonic::Response<super::ResumeResponse>, tonic::Status> { 2187 2187 - self.inner.ready().await.map_err(|e| { 2188 2188 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 2189 2189 - })?; 2458 2458 + self.inner 2459 2459 + .ready() 2460 2460 + .await 2461 2461 + .map_err(|e| { 2462 2462 + tonic::Status::unknown( 2463 2463 + format!("Service was not ready: {}", e.into()), 2464 2464 + ) 2465 2465 + })?; 2190 2466 let codec = tonic::codec::ProstCodec::default(); 2191 2191 - let path = 2192 2192 - http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.PlaybackService/Resume"); 2467 2467 + let path = http::uri::PathAndQuery::from_static( 2468 2468 + "/rockbox.v1alpha1.PlaybackService/Resume", 2469 2469 + ); 2193 2470 let mut req = request.into_request(); 2194 2194 - req.extensions_mut().insert(GrpcMethod::new( 2195 2195 - "rockbox.v1alpha1.PlaybackService", 2196 2196 - "Resume", 2197 2197 - )); 2471 2471 + req.extensions_mut() 2472 2472 + .insert(GrpcMethod::new("rockbox.v1alpha1.PlaybackService", "Resume")); 2198 2473 self.inner.unary(req, path, codec).await 2199 2474 } 2200 2475 pub async fn next( 2201 2476 &mut self, 2202 2477 request: impl tonic::IntoRequest<super::NextRequest>, 2203 2478 ) -> std::result::Result<tonic::Response<super::NextResponse>, tonic::Status> { 2204 2204 - self.inner.ready().await.map_err(|e| { 2205 2205 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 2206 2206 - })?; 2479 2479 + self.inner 2480 2480 + .ready() 2481 2481 + .await 2482 2482 + .map_err(|e| { 2483 2483 + tonic::Status::unknown( 2484 2484 + format!("Service was not ready: {}", e.into()), 2485 2485 + ) 2486 2486 + })?; 2207 2487 let codec = tonic::codec::ProstCodec::default(); 2208 2208 - let path = 2209 2209 - http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.PlaybackService/Next"); 2488 2488 + let path = http::uri::PathAndQuery::from_static( 2489 2489 + "/rockbox.v1alpha1.PlaybackService/Next", 2490 2490 + ); 2210 2491 let mut req = request.into_request(); 2211 2492 req.extensions_mut() 2212 2493 .insert(GrpcMethod::new("rockbox.v1alpha1.PlaybackService", "Next")); ··· 2215 2496 pub async fn previous( 2216 2497 &mut self, 2217 2498 request: impl tonic::IntoRequest<super::PreviousRequest>, 2218 2218 - ) -> std::result::Result<tonic::Response<super::PreviousResponse>, tonic::Status> { 2219 2219 - self.inner.ready().await.map_err(|e| { 2220 2220 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 2221 2221 - })?; 2499 2499 + ) -> std::result::Result< 2500 2500 + tonic::Response<super::PreviousResponse>, 2501 2501 + tonic::Status, 2502 2502 + > { 2503 2503 + self.inner 2504 2504 + .ready() 2505 2505 + .await 2506 2506 + .map_err(|e| { 2507 2507 + tonic::Status::unknown( 2508 2508 + format!("Service was not ready: {}", e.into()), 2509 2509 + ) 2510 2510 + })?; 2222 2511 let codec = tonic::codec::ProstCodec::default(); 2223 2223 - let path = 2224 2224 - http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.PlaybackService/Previous"); 2512 2512 + let path = http::uri::PathAndQuery::from_static( 2513 2513 + "/rockbox.v1alpha1.PlaybackService/Previous", 2514 2514 + ); 2225 2515 let mut req = request.into_request(); 2226 2226 - req.extensions_mut().insert(GrpcMethod::new( 2227 2227 - "rockbox.v1alpha1.PlaybackService", 2228 2228 - "Previous", 2229 2229 - )); 2516 2516 + req.extensions_mut() 2517 2517 + .insert(GrpcMethod::new("rockbox.v1alpha1.PlaybackService", "Previous")); 2230 2518 self.inner.unary(req, path, codec).await 2231 2519 } 2232 2520 pub async fn fast_forward_rewind( 2233 2521 &mut self, 2234 2522 request: impl tonic::IntoRequest<super::FastForwardRewindRequest>, 2235 2235 - ) -> std::result::Result<tonic::Response<super::FastForwardRewindResponse>, tonic::Status> 2236 2236 - { 2237 2237 - self.inner.ready().await.map_err(|e| { 2238 2238 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 2239 2239 - })?; 2523 2523 + ) -> std::result::Result< 2524 2524 + tonic::Response<super::FastForwardRewindResponse>, 2525 2525 + tonic::Status, 2526 2526 + > { 2527 2527 + self.inner 2528 2528 + .ready() 2529 2529 + .await 2530 2530 + .map_err(|e| { 2531 2531 + tonic::Status::unknown( 2532 2532 + format!("Service was not ready: {}", e.into()), 2533 2533 + ) 2534 2534 + })?; 2240 2535 let codec = tonic::codec::ProstCodec::default(); 2241 2536 let path = http::uri::PathAndQuery::from_static( 2242 2537 "/rockbox.v1alpha1.PlaybackService/FastForwardRewind", 2243 2538 ); 2244 2539 let mut req = request.into_request(); 2245 2245 - req.extensions_mut().insert(GrpcMethod::new( 2246 2246 - "rockbox.v1alpha1.PlaybackService", 2247 2247 - "FastForwardRewind", 2248 2248 - )); 2540 2540 + req.extensions_mut() 2541 2541 + .insert( 2542 2542 + GrpcMethod::new( 2543 2543 + "rockbox.v1alpha1.PlaybackService", 2544 2544 + "FastForwardRewind", 2545 2545 + ), 2546 2546 + ); 2249 2547 self.inner.unary(req, path, codec).await 2250 2548 } 2251 2549 pub async fn status( 2252 2550 &mut self, 2253 2551 request: impl tonic::IntoRequest<super::StatusRequest>, 2254 2552 ) -> std::result::Result<tonic::Response<super::StatusResponse>, tonic::Status> { 2255 2255 - self.inner.ready().await.map_err(|e| { 2256 2256 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 2257 2257 - })?; 2553 2553 + self.inner 2554 2554 + .ready() 2555 2555 + .await 2556 2556 + .map_err(|e| { 2557 2557 + tonic::Status::unknown( 2558 2558 + format!("Service was not ready: {}", e.into()), 2559 2559 + ) 2560 2560 + })?; 2258 2561 let codec = tonic::codec::ProstCodec::default(); 2259 2259 - let path = 2260 2260 - http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.PlaybackService/Status"); 2562 2562 + let path = http::uri::PathAndQuery::from_static( 2563 2563 + "/rockbox.v1alpha1.PlaybackService/Status", 2564 2564 + ); 2261 2565 let mut req = request.into_request(); 2262 2262 - req.extensions_mut().insert(GrpcMethod::new( 2263 2263 - "rockbox.v1alpha1.PlaybackService", 2264 2264 - "Status", 2265 2265 - )); 2566 2566 + req.extensions_mut() 2567 2567 + .insert(GrpcMethod::new("rockbox.v1alpha1.PlaybackService", "Status")); 2266 2568 self.inner.unary(req, path, codec).await 2267 2569 } 2268 2570 pub async fn current_track( 2269 2571 &mut self, 2270 2572 request: impl tonic::IntoRequest<super::CurrentTrackRequest>, 2271 2271 - ) -> std::result::Result<tonic::Response<super::CurrentTrackResponse>, tonic::Status> 2272 2272 - { 2273 2273 - self.inner.ready().await.map_err(|e| { 2274 2274 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 2275 2275 - })?; 2573 2573 + ) -> std::result::Result< 2574 2574 + tonic::Response<super::CurrentTrackResponse>, 2575 2575 + tonic::Status, 2576 2576 + > { 2577 2577 + self.inner 2578 2578 + .ready() 2579 2579 + .await 2580 2580 + .map_err(|e| { 2581 2581 + tonic::Status::unknown( 2582 2582 + format!("Service was not ready: {}", e.into()), 2583 2583 + ) 2584 2584 + })?; 2276 2585 let codec = tonic::codec::ProstCodec::default(); 2277 2586 let path = http::uri::PathAndQuery::from_static( 2278 2587 "/rockbox.v1alpha1.PlaybackService/CurrentTrack", 2279 2588 ); 2280 2589 let mut req = request.into_request(); 2281 2281 - req.extensions_mut().insert(GrpcMethod::new( 2282 2282 - "rockbox.v1alpha1.PlaybackService", 2283 2283 - "CurrentTrack", 2284 2284 - )); 2590 2590 + req.extensions_mut() 2591 2591 + .insert( 2592 2592 + GrpcMethod::new("rockbox.v1alpha1.PlaybackService", "CurrentTrack"), 2593 2593 + ); 2285 2594 self.inner.unary(req, path, codec).await 2286 2595 } 2287 2596 pub async fn next_track( 2288 2597 &mut self, 2289 2598 request: impl tonic::IntoRequest<super::NextTrackRequest>, 2290 2290 - ) -> std::result::Result<tonic::Response<super::NextTrackResponse>, tonic::Status> { 2291 2291 - self.inner.ready().await.map_err(|e| { 2292 2292 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 2293 2293 - })?; 2599 2599 + ) -> std::result::Result< 2600 2600 + tonic::Response<super::NextTrackResponse>, 2601 2601 + tonic::Status, 2602 2602 + > { 2603 2603 + self.inner 2604 2604 + .ready() 2605 2605 + .await 2606 2606 + .map_err(|e| { 2607 2607 + tonic::Status::unknown( 2608 2608 + format!("Service was not ready: {}", e.into()), 2609 2609 + ) 2610 2610 + })?; 2294 2611 let codec = tonic::codec::ProstCodec::default(); 2295 2295 - let path = 2296 2296 - http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.PlaybackService/NextTrack"); 2612 2612 + let path = http::uri::PathAndQuery::from_static( 2613 2613 + "/rockbox.v1alpha1.PlaybackService/NextTrack", 2614 2614 + ); 2297 2615 let mut req = request.into_request(); 2298 2298 - req.extensions_mut().insert(GrpcMethod::new( 2299 2299 - "rockbox.v1alpha1.PlaybackService", 2300 2300 - "NextTrack", 2301 2301 - )); 2616 2616 + req.extensions_mut() 2617 2617 + .insert( 2618 2618 + GrpcMethod::new("rockbox.v1alpha1.PlaybackService", "NextTrack"), 2619 2619 + ); 2302 2620 self.inner.unary(req, path, codec).await 2303 2621 } 2304 2622 pub async fn flush_and_reload_tracks( 2305 2623 &mut self, 2306 2624 request: impl tonic::IntoRequest<super::FlushAndReloadTracksRequest>, 2307 2307 - ) -> std::result::Result<tonic::Response<super::FlushAndReloadTracksResponse>, tonic::Status> 2308 2308 - { 2309 2309 - self.inner.ready().await.map_err(|e| { 2310 2310 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 2311 2311 - })?; 2625 2625 + ) -> std::result::Result< 2626 2626 + tonic::Response<super::FlushAndReloadTracksResponse>, 2627 2627 + tonic::Status, 2628 2628 + > { 2629 2629 + self.inner 2630 2630 + .ready() 2631 2631 + .await 2632 2632 + .map_err(|e| { 2633 2633 + tonic::Status::unknown( 2634 2634 + format!("Service was not ready: {}", e.into()), 2635 2635 + ) 2636 2636 + })?; 2312 2637 let codec = tonic::codec::ProstCodec::default(); 2313 2638 let path = http::uri::PathAndQuery::from_static( 2314 2639 "/rockbox.v1alpha1.PlaybackService/FlushAndReloadTracks", 2315 2640 ); 2316 2641 let mut req = request.into_request(); 2317 2317 - req.extensions_mut().insert(GrpcMethod::new( 2318 2318 - "rockbox.v1alpha1.PlaybackService", 2319 2319 - "FlushAndReloadTracks", 2320 2320 - )); 2642 2642 + req.extensions_mut() 2643 2643 + .insert( 2644 2644 + GrpcMethod::new( 2645 2645 + "rockbox.v1alpha1.PlaybackService", 2646 2646 + "FlushAndReloadTracks", 2647 2647 + ), 2648 2648 + ); 2321 2649 self.inner.unary(req, path, codec).await 2322 2650 } 2323 2651 pub async fn get_file_position( 2324 2652 &mut self, 2325 2653 request: impl tonic::IntoRequest<super::GetFilePositionRequest>, 2326 2326 - ) -> std::result::Result<tonic::Response<super::GetFilePositionResponse>, 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 - })?; 2654 2654 + ) -> std::result::Result< 2655 2655 + tonic::Response<super::GetFilePositionResponse>, 2656 2656 + tonic::Status, 2657 2657 + > { 2658 2658 + self.inner 2659 2659 + .ready() 2660 2660 + .await 2661 2661 + .map_err(|e| { 2662 2662 + tonic::Status::unknown( 2663 2663 + format!("Service was not ready: {}", e.into()), 2664 2664 + ) 2665 2665 + })?; 2331 2666 let codec = tonic::codec::ProstCodec::default(); 2332 2667 let path = http::uri::PathAndQuery::from_static( 2333 2668 "/rockbox.v1alpha1.PlaybackService/GetFilePosition", 2334 2669 ); 2335 2670 let mut req = request.into_request(); 2336 2336 - req.extensions_mut().insert(GrpcMethod::new( 2337 2337 - "rockbox.v1alpha1.PlaybackService", 2338 2338 - "GetFilePosition", 2339 2339 - )); 2671 2671 + req.extensions_mut() 2672 2672 + .insert( 2673 2673 + GrpcMethod::new( 2674 2674 + "rockbox.v1alpha1.PlaybackService", 2675 2675 + "GetFilePosition", 2676 2676 + ), 2677 2677 + ); 2340 2678 self.inner.unary(req, path, codec).await 2341 2679 } 2342 2680 pub async fn hard_stop( 2343 2681 &mut self, 2344 2682 request: impl tonic::IntoRequest<super::HardStopRequest>, 2345 2345 - ) -> std::result::Result<tonic::Response<super::HardStopResponse>, tonic::Status> { 2346 2346 - self.inner.ready().await.map_err(|e| { 2347 2347 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 2348 2348 - })?; 2683 2683 + ) -> std::result::Result< 2684 2684 + tonic::Response<super::HardStopResponse>, 2685 2685 + tonic::Status, 2686 2686 + > { 2687 2687 + self.inner 2688 2688 + .ready() 2689 2689 + .await 2690 2690 + .map_err(|e| { 2691 2691 + tonic::Status::unknown( 2692 2692 + format!("Service was not ready: {}", e.into()), 2693 2693 + ) 2694 2694 + })?; 2349 2695 let codec = tonic::codec::ProstCodec::default(); 2350 2350 - let path = 2351 2351 - http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.PlaybackService/HardStop"); 2696 2696 + let path = http::uri::PathAndQuery::from_static( 2697 2697 + "/rockbox.v1alpha1.PlaybackService/HardStop", 2698 2698 + ); 2352 2699 let mut req = request.into_request(); 2353 2353 - req.extensions_mut().insert(GrpcMethod::new( 2354 2354 - "rockbox.v1alpha1.PlaybackService", 2355 2355 - "HardStop", 2356 2356 - )); 2700 2700 + req.extensions_mut() 2701 2701 + .insert(GrpcMethod::new("rockbox.v1alpha1.PlaybackService", "HardStop")); 2357 2702 self.inner.unary(req, path, codec).await 2358 2703 } 2359 2704 pub async fn play_album( 2360 2705 &mut self, 2361 2706 request: impl tonic::IntoRequest<super::PlayAlbumRequest>, 2362 2362 - ) -> std::result::Result<tonic::Response<super::PlayAlbumResponse>, tonic::Status> { 2363 2363 - self.inner.ready().await.map_err(|e| { 2364 2364 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 2365 2365 - })?; 2707 2707 + ) -> std::result::Result< 2708 2708 + tonic::Response<super::PlayAlbumResponse>, 2709 2709 + tonic::Status, 2710 2710 + > { 2711 2711 + self.inner 2712 2712 + .ready() 2713 2713 + .await 2714 2714 + .map_err(|e| { 2715 2715 + tonic::Status::unknown( 2716 2716 + format!("Service was not ready: {}", e.into()), 2717 2717 + ) 2718 2718 + })?; 2366 2719 let codec = tonic::codec::ProstCodec::default(); 2367 2367 - let path = 2368 2368 - http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.PlaybackService/PlayAlbum"); 2720 2720 + let path = http::uri::PathAndQuery::from_static( 2721 2721 + "/rockbox.v1alpha1.PlaybackService/PlayAlbum", 2722 2722 + ); 2369 2723 let mut req = request.into_request(); 2370 2370 - req.extensions_mut().insert(GrpcMethod::new( 2371 2371 - "rockbox.v1alpha1.PlaybackService", 2372 2372 - "PlayAlbum", 2373 2373 - )); 2724 2724 + req.extensions_mut() 2725 2725 + .insert( 2726 2726 + GrpcMethod::new("rockbox.v1alpha1.PlaybackService", "PlayAlbum"), 2727 2727 + ); 2374 2728 self.inner.unary(req, path, codec).await 2375 2729 } 2376 2730 pub async fn play_artist_tracks( 2377 2731 &mut self, 2378 2732 request: impl tonic::IntoRequest<super::PlayArtistTracksRequest>, 2379 2379 - ) -> std::result::Result<tonic::Response<super::PlayArtistTracksResponse>, tonic::Status> 2380 2380 - { 2381 2381 - self.inner.ready().await.map_err(|e| { 2382 2382 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 2383 2383 - })?; 2733 2733 + ) -> std::result::Result< 2734 2734 + tonic::Response<super::PlayArtistTracksResponse>, 2735 2735 + tonic::Status, 2736 2736 + > { 2737 2737 + self.inner 2738 2738 + .ready() 2739 2739 + .await 2740 2740 + .map_err(|e| { 2741 2741 + tonic::Status::unknown( 2742 2742 + format!("Service was not ready: {}", e.into()), 2743 2743 + ) 2744 2744 + })?; 2384 2745 let codec = tonic::codec::ProstCodec::default(); 2385 2746 let path = http::uri::PathAndQuery::from_static( 2386 2747 "/rockbox.v1alpha1.PlaybackService/PlayArtistTracks", 2387 2748 ); 2388 2749 let mut req = request.into_request(); 2389 2389 - req.extensions_mut().insert(GrpcMethod::new( 2390 2390 - "rockbox.v1alpha1.PlaybackService", 2391 2391 - "PlayArtistTracks", 2392 2392 - )); 2750 2750 + req.extensions_mut() 2751 2751 + .insert( 2752 2752 + GrpcMethod::new( 2753 2753 + "rockbox.v1alpha1.PlaybackService", 2754 2754 + "PlayArtistTracks", 2755 2755 + ), 2756 2756 + ); 2393 2757 self.inner.unary(req, path, codec).await 2394 2758 } 2395 2759 pub async fn play_playlist( 2396 2760 &mut self, 2397 2761 request: impl tonic::IntoRequest<super::PlayPlaylistRequest>, 2398 2398 - ) -> std::result::Result<tonic::Response<super::PlayPlaylistResponse>, 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 - })?; 2762 2762 + ) -> std::result::Result< 2763 2763 + tonic::Response<super::PlayPlaylistResponse>, 2764 2764 + tonic::Status, 2765 2765 + > { 2766 2766 + self.inner 2767 2767 + .ready() 2768 2768 + .await 2769 2769 + .map_err(|e| { 2770 2770 + tonic::Status::unknown( 2771 2771 + format!("Service was not ready: {}", e.into()), 2772 2772 + ) 2773 2773 + })?; 2403 2774 let codec = tonic::codec::ProstCodec::default(); 2404 2775 let path = http::uri::PathAndQuery::from_static( 2405 2776 "/rockbox.v1alpha1.PlaybackService/PlayPlaylist", 2406 2777 ); 2407 2778 let mut req = request.into_request(); 2408 2408 - req.extensions_mut().insert(GrpcMethod::new( 2409 2409 - "rockbox.v1alpha1.PlaybackService", 2410 2410 - "PlayPlaylist", 2411 2411 - )); 2779 2779 + req.extensions_mut() 2780 2780 + .insert( 2781 2781 + GrpcMethod::new("rockbox.v1alpha1.PlaybackService", "PlayPlaylist"), 2782 2782 + ); 2412 2783 self.inner.unary(req, path, codec).await 2413 2784 } 2414 2785 pub async fn play_directory( 2415 2786 &mut self, 2416 2787 request: impl tonic::IntoRequest<super::PlayDirectoryRequest>, 2417 2417 - ) -> std::result::Result<tonic::Response<super::PlayDirectoryResponse>, 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 - })?; 2788 2788 + ) -> std::result::Result< 2789 2789 + tonic::Response<super::PlayDirectoryResponse>, 2790 2790 + tonic::Status, 2791 2791 + > { 2792 2792 + self.inner 2793 2793 + .ready() 2794 2794 + .await 2795 2795 + .map_err(|e| { 2796 2796 + tonic::Status::unknown( 2797 2797 + format!("Service was not ready: {}", e.into()), 2798 2798 + ) 2799 2799 + })?; 2422 2800 let codec = tonic::codec::ProstCodec::default(); 2423 2801 let path = http::uri::PathAndQuery::from_static( 2424 2802 "/rockbox.v1alpha1.PlaybackService/PlayDirectory", 2425 2803 ); 2426 2804 let mut req = request.into_request(); 2427 2427 - req.extensions_mut().insert(GrpcMethod::new( 2428 2428 - "rockbox.v1alpha1.PlaybackService", 2429 2429 - "PlayDirectory", 2430 2430 - )); 2805 2805 + req.extensions_mut() 2806 2806 + .insert( 2807 2807 + GrpcMethod::new("rockbox.v1alpha1.PlaybackService", "PlayDirectory"), 2808 2808 + ); 2431 2809 self.inner.unary(req, path, codec).await 2432 2810 } 2433 2811 pub async fn play_track( 2434 2812 &mut self, 2435 2813 request: impl tonic::IntoRequest<super::PlayTrackRequest>, 2436 2436 - ) -> std::result::Result<tonic::Response<super::PlayTrackResponse>, tonic::Status> { 2437 2437 - self.inner.ready().await.map_err(|e| { 2438 2438 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 2439 2439 - })?; 2814 2814 + ) -> std::result::Result< 2815 2815 + tonic::Response<super::PlayTrackResponse>, 2816 2816 + tonic::Status, 2817 2817 + > { 2818 2818 + self.inner 2819 2819 + .ready() 2820 2820 + .await 2821 2821 + .map_err(|e| { 2822 2822 + tonic::Status::unknown( 2823 2823 + format!("Service was not ready: {}", e.into()), 2824 2824 + ) 2825 2825 + })?; 2440 2826 let codec = tonic::codec::ProstCodec::default(); 2441 2441 - let path = 2442 2442 - http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.PlaybackService/PlayTrack"); 2827 2827 + let path = http::uri::PathAndQuery::from_static( 2828 2828 + "/rockbox.v1alpha1.PlaybackService/PlayTrack", 2829 2829 + ); 2443 2830 let mut req = request.into_request(); 2444 2444 - req.extensions_mut().insert(GrpcMethod::new( 2445 2445 - "rockbox.v1alpha1.PlaybackService", 2446 2446 - "PlayTrack", 2447 2447 - )); 2831 2831 + req.extensions_mut() 2832 2832 + .insert( 2833 2833 + GrpcMethod::new("rockbox.v1alpha1.PlaybackService", "PlayTrack"), 2834 2834 + ); 2448 2835 self.inner.unary(req, path, codec).await 2449 2836 } 2450 2837 pub async fn play_liked_tracks( 2451 2838 &mut self, 2452 2839 request: impl tonic::IntoRequest<super::PlayLikedTracksRequest>, 2453 2453 - ) -> std::result::Result<tonic::Response<super::PlayLikedTracksResponse>, tonic::Status> 2454 2454 - { 2455 2455 - self.inner.ready().await.map_err(|e| { 2456 2456 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 2457 2457 - })?; 2840 2840 + ) -> std::result::Result< 2841 2841 + tonic::Response<super::PlayLikedTracksResponse>, 2842 2842 + tonic::Status, 2843 2843 + > { 2844 2844 + self.inner 2845 2845 + .ready() 2846 2846 + .await 2847 2847 + .map_err(|e| { 2848 2848 + tonic::Status::unknown( 2849 2849 + format!("Service was not ready: {}", e.into()), 2850 2850 + ) 2851 2851 + })?; 2458 2852 let codec = tonic::codec::ProstCodec::default(); 2459 2853 let path = http::uri::PathAndQuery::from_static( 2460 2854 "/rockbox.v1alpha1.PlaybackService/PlayLikedTracks", 2461 2855 ); 2462 2856 let mut req = request.into_request(); 2463 2463 - req.extensions_mut().insert(GrpcMethod::new( 2464 2464 - "rockbox.v1alpha1.PlaybackService", 2465 2465 - "PlayLikedTracks", 2466 2466 - )); 2857 2857 + req.extensions_mut() 2858 2858 + .insert( 2859 2859 + GrpcMethod::new( 2860 2860 + "rockbox.v1alpha1.PlaybackService", 2861 2861 + "PlayLikedTracks", 2862 2862 + ), 2863 2863 + ); 2467 2864 self.inner.unary(req, path, codec).await 2468 2865 } 2469 2866 pub async fn play_all_tracks( 2470 2867 &mut self, 2471 2868 request: impl tonic::IntoRequest<super::PlayAllTracksRequest>, 2472 2472 - ) -> std::result::Result<tonic::Response<super::PlayAllTracksResponse>, tonic::Status> 2473 2473 - { 2474 2474 - self.inner.ready().await.map_err(|e| { 2475 2475 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 2476 2476 - })?; 2869 2869 + ) -> std::result::Result< 2870 2870 + tonic::Response<super::PlayAllTracksResponse>, 2871 2871 + tonic::Status, 2872 2872 + > { 2873 2873 + self.inner 2874 2874 + .ready() 2875 2875 + .await 2876 2876 + .map_err(|e| { 2877 2877 + tonic::Status::unknown( 2878 2878 + format!("Service was not ready: {}", e.into()), 2879 2879 + ) 2880 2880 + })?; 2477 2881 let codec = tonic::codec::ProstCodec::default(); 2478 2882 let path = http::uri::PathAndQuery::from_static( 2479 2883 "/rockbox.v1alpha1.PlaybackService/PlayAllTracks", 2480 2884 ); 2481 2885 let mut req = request.into_request(); 2482 2482 - req.extensions_mut().insert(GrpcMethod::new( 2483 2483 - "rockbox.v1alpha1.PlaybackService", 2484 2484 - "PlayAllTracks", 2485 2485 - )); 2886 2886 + req.extensions_mut() 2887 2887 + .insert( 2888 2888 + GrpcMethod::new("rockbox.v1alpha1.PlaybackService", "PlayAllTracks"), 2889 2889 + ); 2486 2890 self.inner.unary(req, path, codec).await 2487 2891 } 2488 2892 pub async fn stream_current_track( ··· 2492 2896 tonic::Response<tonic::codec::Streaming<super::CurrentTrackResponse>>, 2493 2897 tonic::Status, 2494 2898 > { 2495 2495 - self.inner.ready().await.map_err(|e| { 2496 2496 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 2497 2497 - })?; 2899 2899 + self.inner 2900 2900 + .ready() 2901 2901 + .await 2902 2902 + .map_err(|e| { 2903 2903 + tonic::Status::unknown( 2904 2904 + format!("Service was not ready: {}", e.into()), 2905 2905 + ) 2906 2906 + })?; 2498 2907 let codec = tonic::codec::ProstCodec::default(); 2499 2908 let path = http::uri::PathAndQuery::from_static( 2500 2909 "/rockbox.v1alpha1.PlaybackService/StreamCurrentTrack", 2501 2910 ); 2502 2911 let mut req = request.into_request(); 2503 2503 - req.extensions_mut().insert(GrpcMethod::new( 2504 2504 - "rockbox.v1alpha1.PlaybackService", 2505 2505 - "StreamCurrentTrack", 2506 2506 - )); 2912 2912 + req.extensions_mut() 2913 2913 + .insert( 2914 2914 + GrpcMethod::new( 2915 2915 + "rockbox.v1alpha1.PlaybackService", 2916 2916 + "StreamCurrentTrack", 2917 2917 + ), 2918 2918 + ); 2507 2919 self.inner.server_streaming(req, path, codec).await 2508 2920 } 2509 2921 pub async fn stream_status( ··· 2513 2925 tonic::Response<tonic::codec::Streaming<super::StatusResponse>>, 2514 2926 tonic::Status, 2515 2927 > { 2516 2516 - self.inner.ready().await.map_err(|e| { 2517 2517 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 2518 2518 - })?; 2928 2928 + self.inner 2929 2929 + .ready() 2930 2930 + .await 2931 2931 + .map_err(|e| { 2932 2932 + tonic::Status::unknown( 2933 2933 + format!("Service was not ready: {}", e.into()), 2934 2934 + ) 2935 2935 + })?; 2519 2936 let codec = tonic::codec::ProstCodec::default(); 2520 2937 let path = http::uri::PathAndQuery::from_static( 2521 2938 "/rockbox.v1alpha1.PlaybackService/StreamStatus", 2522 2939 ); 2523 2940 let mut req = request.into_request(); 2524 2524 - req.extensions_mut().insert(GrpcMethod::new( 2525 2525 - "rockbox.v1alpha1.PlaybackService", 2526 2526 - "StreamStatus", 2527 2527 - )); 2941 2941 + req.extensions_mut() 2942 2942 + .insert( 2943 2943 + GrpcMethod::new("rockbox.v1alpha1.PlaybackService", "StreamStatus"), 2944 2944 + ); 2528 2945 self.inner.server_streaming(req, path, codec).await 2529 2946 } 2530 2947 pub async fn stream_playlist( ··· 2534 2951 tonic::Response<tonic::codec::Streaming<super::PlaylistResponse>>, 2535 2952 tonic::Status, 2536 2953 > { 2537 2537 - self.inner.ready().await.map_err(|e| { 2538 2538 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 2539 2539 - })?; 2954 2954 + self.inner 2955 2955 + .ready() 2956 2956 + .await 2957 2957 + .map_err(|e| { 2958 2958 + tonic::Status::unknown( 2959 2959 + format!("Service was not ready: {}", e.into()), 2960 2960 + ) 2961 2961 + })?; 2540 2962 let codec = tonic::codec::ProstCodec::default(); 2541 2963 let path = http::uri::PathAndQuery::from_static( 2542 2964 "/rockbox.v1alpha1.PlaybackService/StreamPlaylist", 2543 2965 ); 2544 2966 let mut req = request.into_request(); 2545 2545 - req.extensions_mut().insert(GrpcMethod::new( 2546 2546 - "rockbox.v1alpha1.PlaybackService", 2547 2547 - "StreamPlaylist", 2548 2548 - )); 2967 2967 + req.extensions_mut() 2968 2968 + .insert( 2969 2969 + GrpcMethod::new("rockbox.v1alpha1.PlaybackService", "StreamPlaylist"), 2970 2970 + ); 2549 2971 self.inner.server_streaming(req, path, codec).await 2550 2972 } 2551 2973 } ··· 2557 2979 dead_code, 2558 2980 missing_docs, 2559 2981 clippy::wildcard_imports, 2560 2560 - clippy::let_unit_value 2982 2982 + clippy::let_unit_value, 2561 2983 )] 2562 2984 use tonic::codegen::*; 2563 2985 /// Generated trait containing gRPC methods that should be implemented for use with PlaybackServiceServer. ··· 2574 2996 async fn play_or_pause( 2575 2997 &self, 2576 2998 request: tonic::Request<super::PlayOrPauseRequest>, 2577 2577 - ) -> std::result::Result<tonic::Response<super::PlayOrPauseResponse>, tonic::Status>; 2999 2999 + ) -> std::result::Result< 3000 3000 + tonic::Response<super::PlayOrPauseResponse>, 3001 3001 + tonic::Status, 3002 3002 + >; 2578 3003 async fn resume( 2579 3004 &self, 2580 3005 request: tonic::Request<super::ResumeRequest>, ··· 2586 3011 async fn previous( 2587 3012 &self, 2588 3013 request: tonic::Request<super::PreviousRequest>, 2589 2589 - ) -> std::result::Result<tonic::Response<super::PreviousResponse>, tonic::Status>; 3014 3014 + ) -> std::result::Result< 3015 3015 + tonic::Response<super::PreviousResponse>, 3016 3016 + tonic::Status, 3017 3017 + >; 2590 3018 async fn fast_forward_rewind( 2591 3019 &self, 2592 3020 request: tonic::Request<super::FastForwardRewindRequest>, 2593 2593 - ) -> std::result::Result<tonic::Response<super::FastForwardRewindResponse>, tonic::Status>; 3021 3021 + ) -> std::result::Result< 3022 3022 + tonic::Response<super::FastForwardRewindResponse>, 3023 3023 + tonic::Status, 3024 3024 + >; 2594 3025 async fn status( 2595 3026 &self, 2596 3027 request: tonic::Request<super::StatusRequest>, ··· 2598 3029 async fn current_track( 2599 3030 &self, 2600 3031 request: tonic::Request<super::CurrentTrackRequest>, 2601 2601 - ) -> std::result::Result<tonic::Response<super::CurrentTrackResponse>, tonic::Status>; 3032 3032 + ) -> std::result::Result< 3033 3033 + tonic::Response<super::CurrentTrackResponse>, 3034 3034 + tonic::Status, 3035 3035 + >; 2602 3036 async fn next_track( 2603 3037 &self, 2604 3038 request: tonic::Request<super::NextTrackRequest>, 2605 2605 - ) -> std::result::Result<tonic::Response<super::NextTrackResponse>, tonic::Status>; 3039 3039 + ) -> std::result::Result< 3040 3040 + tonic::Response<super::NextTrackResponse>, 3041 3041 + tonic::Status, 3042 3042 + >; 2606 3043 async fn flush_and_reload_tracks( 2607 3044 &self, 2608 3045 request: tonic::Request<super::FlushAndReloadTracksRequest>, 2609 2609 - ) -> std::result::Result<tonic::Response<super::FlushAndReloadTracksResponse>, tonic::Status>; 3046 3046 + ) -> std::result::Result< 3047 3047 + tonic::Response<super::FlushAndReloadTracksResponse>, 3048 3048 + tonic::Status, 3049 3049 + >; 2610 3050 async fn get_file_position( 2611 3051 &self, 2612 3052 request: tonic::Request<super::GetFilePositionRequest>, 2613 2613 - ) -> std::result::Result<tonic::Response<super::GetFilePositionResponse>, tonic::Status>; 3053 3053 + ) -> std::result::Result< 3054 3054 + tonic::Response<super::GetFilePositionResponse>, 3055 3055 + tonic::Status, 3056 3056 + >; 2614 3057 async fn hard_stop( 2615 3058 &self, 2616 3059 request: tonic::Request<super::HardStopRequest>, 2617 2617 - ) -> std::result::Result<tonic::Response<super::HardStopResponse>, tonic::Status>; 3060 3060 + ) -> std::result::Result< 3061 3061 + tonic::Response<super::HardStopResponse>, 3062 3062 + tonic::Status, 3063 3063 + >; 2618 3064 async fn play_album( 2619 3065 &self, 2620 3066 request: tonic::Request<super::PlayAlbumRequest>, 2621 2621 - ) -> std::result::Result<tonic::Response<super::PlayAlbumResponse>, tonic::Status>; 3067 3067 + ) -> std::result::Result< 3068 3068 + tonic::Response<super::PlayAlbumResponse>, 3069 3069 + tonic::Status, 3070 3070 + >; 2622 3071 async fn play_artist_tracks( 2623 3072 &self, 2624 3073 request: tonic::Request<super::PlayArtistTracksRequest>, 2625 2625 - ) -> std::result::Result<tonic::Response<super::PlayArtistTracksResponse>, tonic::Status>; 3074 3074 + ) -> std::result::Result< 3075 3075 + tonic::Response<super::PlayArtistTracksResponse>, 3076 3076 + tonic::Status, 3077 3077 + >; 2626 3078 async fn play_playlist( 2627 3079 &self, 2628 3080 request: tonic::Request<super::PlayPlaylistRequest>, 2629 2629 - ) -> std::result::Result<tonic::Response<super::PlayPlaylistResponse>, tonic::Status>; 3081 3081 + ) -> std::result::Result< 3082 3082 + tonic::Response<super::PlayPlaylistResponse>, 3083 3083 + tonic::Status, 3084 3084 + >; 2630 3085 async fn play_directory( 2631 3086 &self, 2632 3087 request: tonic::Request<super::PlayDirectoryRequest>, 2633 2633 - ) -> std::result::Result<tonic::Response<super::PlayDirectoryResponse>, tonic::Status>; 3088 3088 + ) -> std::result::Result< 3089 3089 + tonic::Response<super::PlayDirectoryResponse>, 3090 3090 + tonic::Status, 3091 3091 + >; 2634 3092 async fn play_track( 2635 3093 &self, 2636 3094 request: tonic::Request<super::PlayTrackRequest>, 2637 2637 - ) -> std::result::Result<tonic::Response<super::PlayTrackResponse>, tonic::Status>; 3095 3095 + ) -> std::result::Result< 3096 3096 + tonic::Response<super::PlayTrackResponse>, 3097 3097 + tonic::Status, 3098 3098 + >; 2638 3099 async fn play_liked_tracks( 2639 3100 &self, 2640 3101 request: tonic::Request<super::PlayLikedTracksRequest>, 2641 2641 - ) -> std::result::Result<tonic::Response<super::PlayLikedTracksResponse>, tonic::Status>; 3102 3102 + ) -> std::result::Result< 3103 3103 + tonic::Response<super::PlayLikedTracksResponse>, 3104 3104 + tonic::Status, 3105 3105 + >; 2642 3106 async fn play_all_tracks( 2643 3107 &self, 2644 3108 request: tonic::Request<super::PlayAllTracksRequest>, 2645 2645 - ) -> std::result::Result<tonic::Response<super::PlayAllTracksResponse>, tonic::Status>; 3109 3109 + ) -> std::result::Result< 3110 3110 + tonic::Response<super::PlayAllTracksResponse>, 3111 3111 + tonic::Status, 3112 3112 + >; 2646 3113 /// Server streaming response type for the StreamCurrentTrack method. 2647 3114 type StreamCurrentTrackStream: tonic::codegen::tokio_stream::Stream< 2648 3115 Item = std::result::Result<super::CurrentTrackResponse, tonic::Status>, 2649 2649 - > + std::marker::Send 3116 3116 + > 3117 3117 + + std::marker::Send 2650 3118 + 'static; 2651 3119 async fn stream_current_track( 2652 3120 &self, 2653 3121 request: tonic::Request<super::StreamCurrentTrackRequest>, 2654 2654 - ) -> std::result::Result<tonic::Response<Self::StreamCurrentTrackStream>, tonic::Status>; 3122 3122 + ) -> std::result::Result< 3123 3123 + tonic::Response<Self::StreamCurrentTrackStream>, 3124 3124 + tonic::Status, 3125 3125 + >; 2655 3126 /// Server streaming response type for the StreamStatus method. 2656 3127 type StreamStatusStream: tonic::codegen::tokio_stream::Stream< 2657 3128 Item = std::result::Result<super::StatusResponse, tonic::Status>, 2658 2658 - > + std::marker::Send 3129 3129 + > 3130 3130 + + std::marker::Send 2659 3131 + 'static; 2660 3132 async fn stream_status( 2661 3133 &self, 2662 3134 request: tonic::Request<super::StreamStatusRequest>, 2663 2663 - ) -> std::result::Result<tonic::Response<Self::StreamStatusStream>, tonic::Status>; 3135 3135 + ) -> std::result::Result< 3136 3136 + tonic::Response<Self::StreamStatusStream>, 3137 3137 + tonic::Status, 3138 3138 + >; 2664 3139 /// Server streaming response type for the StreamPlaylist method. 2665 3140 type StreamPlaylistStream: tonic::codegen::tokio_stream::Stream< 2666 3141 Item = std::result::Result<super::PlaylistResponse, tonic::Status>, 2667 2667 - > + std::marker::Send 3142 3142 + > 3143 3143 + + std::marker::Send 2668 3144 + 'static; 2669 3145 async fn stream_playlist( 2670 3146 &self, 2671 3147 request: tonic::Request<super::StreamPlaylistRequest>, 2672 2672 - ) -> std::result::Result<tonic::Response<Self::StreamPlaylistStream>, tonic::Status>; 3148 3148 + ) -> std::result::Result< 3149 3149 + tonic::Response<Self::StreamPlaylistStream>, 3150 3150 + tonic::Status, 3151 3151 + >; 2673 3152 } 2674 3153 #[derive(Debug)] 2675 3154 pub struct PlaybackServiceServer<T> { ··· 2692 3171 max_encoding_message_size: None, 2693 3172 } 2694 3173 } 2695 2695 - pub fn with_interceptor<F>(inner: T, interceptor: F) -> InterceptedService<Self, F> 3174 3174 + pub fn with_interceptor<F>( 3175 3175 + inner: T, 3176 3176 + interceptor: F, 3177 3177 + ) -> InterceptedService<Self, F> 2696 3178 where 2697 3179 F: tonic::service::Interceptor, 2698 3180 { ··· 2747 3229 "/rockbox.v1alpha1.PlaybackService/Play" => { 2748 3230 #[allow(non_camel_case_types)] 2749 3231 struct PlaySvc<T: PlaybackService>(pub Arc<T>); 2750 2750 - impl<T: PlaybackService> tonic::server::UnaryService<super::PlayRequest> for PlaySvc<T> { 3232 3232 + impl< 3233 3233 + T: PlaybackService, 3234 3234 + > tonic::server::UnaryService<super::PlayRequest> for PlaySvc<T> { 2751 3235 type Response = super::PlayResponse; 2752 2752 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 3236 3236 + type Future = BoxFuture< 3237 3237 + tonic::Response<Self::Response>, 3238 3238 + tonic::Status, 3239 3239 + >; 2753 3240 fn call( 2754 3241 &mut self, 2755 3242 request: tonic::Request<super::PlayRequest>, 2756 3243 ) -> Self::Future { 2757 3244 let inner = Arc::clone(&self.0); 2758 2758 - let fut = 2759 2759 - async move { <T as PlaybackService>::play(&inner, request).await }; 3245 3245 + let fut = async move { 3246 3246 + <T as PlaybackService>::play(&inner, request).await 3247 3247 + }; 2760 3248 Box::pin(fut) 2761 3249 } 2762 3250 } ··· 2785 3273 "/rockbox.v1alpha1.PlaybackService/Pause" => { 2786 3274 #[allow(non_camel_case_types)] 2787 3275 struct PauseSvc<T: PlaybackService>(pub Arc<T>); 2788 2788 - impl<T: PlaybackService> tonic::server::UnaryService<super::PauseRequest> for PauseSvc<T> { 3276 3276 + impl< 3277 3277 + T: PlaybackService, 3278 3278 + > tonic::server::UnaryService<super::PauseRequest> for PauseSvc<T> { 2789 3279 type Response = super::PauseResponse; 2790 2790 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 3280 3280 + type Future = BoxFuture< 3281 3281 + tonic::Response<Self::Response>, 3282 3282 + tonic::Status, 3283 3283 + >; 2791 3284 fn call( 2792 3285 &mut self, 2793 3286 request: tonic::Request<super::PauseRequest>, 2794 3287 ) -> Self::Future { 2795 3288 let inner = Arc::clone(&self.0); 2796 2796 - let fut = 2797 2797 - async move { <T as PlaybackService>::pause(&inner, request).await }; 3289 3289 + let fut = async move { 3290 3290 + <T as PlaybackService>::pause(&inner, request).await 3291 3291 + }; 2798 3292 Box::pin(fut) 2799 3293 } 2800 3294 } ··· 2823 3317 "/rockbox.v1alpha1.PlaybackService/PlayOrPause" => { 2824 3318 #[allow(non_camel_case_types)] 2825 3319 struct PlayOrPauseSvc<T: PlaybackService>(pub Arc<T>); 2826 2826 - impl<T: PlaybackService> tonic::server::UnaryService<super::PlayOrPauseRequest> 2827 2827 - for PlayOrPauseSvc<T> 2828 2828 - { 3320 3320 + impl< 3321 3321 + T: PlaybackService, 3322 3322 + > tonic::server::UnaryService<super::PlayOrPauseRequest> 3323 3323 + for PlayOrPauseSvc<T> { 2829 3324 type Response = super::PlayOrPauseResponse; 2830 2830 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 3325 3325 + type Future = BoxFuture< 3326 3326 + tonic::Response<Self::Response>, 3327 3327 + tonic::Status, 3328 3328 + >; 2831 3329 fn call( 2832 3330 &mut self, 2833 3331 request: tonic::Request<super::PlayOrPauseRequest>, ··· 2864 3362 "/rockbox.v1alpha1.PlaybackService/Resume" => { 2865 3363 #[allow(non_camel_case_types)] 2866 3364 struct ResumeSvc<T: PlaybackService>(pub Arc<T>); 2867 2867 - impl<T: PlaybackService> tonic::server::UnaryService<super::ResumeRequest> for ResumeSvc<T> { 3365 3365 + impl< 3366 3366 + T: PlaybackService, 3367 3367 + > tonic::server::UnaryService<super::ResumeRequest> 3368 3368 + for ResumeSvc<T> { 2868 3369 type Response = super::ResumeResponse; 2869 2869 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 3370 3370 + type Future = BoxFuture< 3371 3371 + tonic::Response<Self::Response>, 3372 3372 + tonic::Status, 3373 3373 + >; 2870 3374 fn call( 2871 3375 &mut self, 2872 3376 request: tonic::Request<super::ResumeRequest>, ··· 2903 3407 "/rockbox.v1alpha1.PlaybackService/Next" => { 2904 3408 #[allow(non_camel_case_types)] 2905 3409 struct NextSvc<T: PlaybackService>(pub Arc<T>); 2906 2906 - impl<T: PlaybackService> tonic::server::UnaryService<super::NextRequest> for NextSvc<T> { 3410 3410 + impl< 3411 3411 + T: PlaybackService, 3412 3412 + > tonic::server::UnaryService<super::NextRequest> for NextSvc<T> { 2907 3413 type Response = super::NextResponse; 2908 2908 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 3414 3414 + type Future = BoxFuture< 3415 3415 + tonic::Response<Self::Response>, 3416 3416 + tonic::Status, 3417 3417 + >; 2909 3418 fn call( 2910 3419 &mut self, 2911 3420 request: tonic::Request<super::NextRequest>, 2912 3421 ) -> Self::Future { 2913 3422 let inner = Arc::clone(&self.0); 2914 2914 - let fut = 2915 2915 - async move { <T as PlaybackService>::next(&inner, request).await }; 3423 3423 + let fut = async move { 3424 3424 + <T as PlaybackService>::next(&inner, request).await 3425 3425 + }; 2916 3426 Box::pin(fut) 2917 3427 } 2918 3428 } ··· 2941 3451 "/rockbox.v1alpha1.PlaybackService/Previous" => { 2942 3452 #[allow(non_camel_case_types)] 2943 3453 struct PreviousSvc<T: PlaybackService>(pub Arc<T>); 2944 2944 - impl<T: PlaybackService> tonic::server::UnaryService<super::PreviousRequest> for PreviousSvc<T> { 3454 3454 + impl< 3455 3455 + T: PlaybackService, 3456 3456 + > tonic::server::UnaryService<super::PreviousRequest> 3457 3457 + for PreviousSvc<T> { 2945 3458 type Response = super::PreviousResponse; 2946 2946 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 3459 3459 + type Future = BoxFuture< 3460 3460 + tonic::Response<Self::Response>, 3461 3461 + tonic::Status, 3462 3462 + >; 2947 3463 fn call( 2948 3464 &mut self, 2949 3465 request: tonic::Request<super::PreviousRequest>, ··· 2980 3496 "/rockbox.v1alpha1.PlaybackService/FastForwardRewind" => { 2981 3497 #[allow(non_camel_case_types)] 2982 3498 struct FastForwardRewindSvc<T: PlaybackService>(pub Arc<T>); 2983 2983 - impl<T: PlaybackService> 2984 2984 - tonic::server::UnaryService<super::FastForwardRewindRequest> 2985 2985 - for FastForwardRewindSvc<T> 2986 2986 - { 3499 3499 + impl< 3500 3500 + T: PlaybackService, 3501 3501 + > tonic::server::UnaryService<super::FastForwardRewindRequest> 3502 3502 + for FastForwardRewindSvc<T> { 2987 3503 type Response = super::FastForwardRewindResponse; 2988 2988 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 3504 3504 + type Future = BoxFuture< 3505 3505 + tonic::Response<Self::Response>, 3506 3506 + tonic::Status, 3507 3507 + >; 2989 3508 fn call( 2990 3509 &mut self, 2991 3510 request: tonic::Request<super::FastForwardRewindRequest>, 2992 3511 ) -> Self::Future { 2993 3512 let inner = Arc::clone(&self.0); 2994 3513 let fut = async move { 2995 2995 - <T as PlaybackService>::fast_forward_rewind(&inner, request).await 3514 3514 + <T as PlaybackService>::fast_forward_rewind(&inner, request) 3515 3515 + .await 2996 3516 }; 2997 3517 Box::pin(fut) 2998 3518 } ··· 3022 3542 "/rockbox.v1alpha1.PlaybackService/Status" => { 3023 3543 #[allow(non_camel_case_types)] 3024 3544 struct StatusSvc<T: PlaybackService>(pub Arc<T>); 3025 3025 - impl<T: PlaybackService> tonic::server::UnaryService<super::StatusRequest> for StatusSvc<T> { 3545 3545 + impl< 3546 3546 + T: PlaybackService, 3547 3547 + > tonic::server::UnaryService<super::StatusRequest> 3548 3548 + for StatusSvc<T> { 3026 3549 type Response = super::StatusResponse; 3027 3027 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 3550 3550 + type Future = BoxFuture< 3551 3551 + tonic::Response<Self::Response>, 3552 3552 + tonic::Status, 3553 3553 + >; 3028 3554 fn call( 3029 3555 &mut self, 3030 3556 request: tonic::Request<super::StatusRequest>, ··· 3061 3587 "/rockbox.v1alpha1.PlaybackService/CurrentTrack" => { 3062 3588 #[allow(non_camel_case_types)] 3063 3589 struct CurrentTrackSvc<T: PlaybackService>(pub Arc<T>); 3064 3064 - impl<T: PlaybackService> tonic::server::UnaryService<super::CurrentTrackRequest> 3065 3065 - for CurrentTrackSvc<T> 3066 3066 - { 3590 3590 + impl< 3591 3591 + T: PlaybackService, 3592 3592 + > tonic::server::UnaryService<super::CurrentTrackRequest> 3593 3593 + for CurrentTrackSvc<T> { 3067 3594 type Response = super::CurrentTrackResponse; 3068 3068 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 3595 3595 + type Future = BoxFuture< 3596 3596 + tonic::Response<Self::Response>, 3597 3597 + tonic::Status, 3598 3598 + >; 3069 3599 fn call( 3070 3600 &mut self, 3071 3601 request: tonic::Request<super::CurrentTrackRequest>, ··· 3102 3632 "/rockbox.v1alpha1.PlaybackService/NextTrack" => { 3103 3633 #[allow(non_camel_case_types)] 3104 3634 struct NextTrackSvc<T: PlaybackService>(pub Arc<T>); 3105 3105 - impl<T: PlaybackService> tonic::server::UnaryService<super::NextTrackRequest> for NextTrackSvc<T> { 3635 3635 + impl< 3636 3636 + T: PlaybackService, 3637 3637 + > tonic::server::UnaryService<super::NextTrackRequest> 3638 3638 + for NextTrackSvc<T> { 3106 3639 type Response = super::NextTrackResponse; 3107 3107 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 3640 3640 + type Future = BoxFuture< 3641 3641 + tonic::Response<Self::Response>, 3642 3642 + tonic::Status, 3643 3643 + >; 3108 3644 fn call( 3109 3645 &mut self, 3110 3646 request: tonic::Request<super::NextTrackRequest>, ··· 3141 3677 "/rockbox.v1alpha1.PlaybackService/FlushAndReloadTracks" => { 3142 3678 #[allow(non_camel_case_types)] 3143 3679 struct FlushAndReloadTracksSvc<T: PlaybackService>(pub Arc<T>); 3144 3144 - impl<T: PlaybackService> 3145 3145 - tonic::server::UnaryService<super::FlushAndReloadTracksRequest> 3146 3146 - for FlushAndReloadTracksSvc<T> 3147 3147 - { 3680 3680 + impl< 3681 3681 + T: PlaybackService, 3682 3682 + > tonic::server::UnaryService<super::FlushAndReloadTracksRequest> 3683 3683 + for FlushAndReloadTracksSvc<T> { 3148 3684 type Response = super::FlushAndReloadTracksResponse; 3149 3149 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 3685 3685 + type Future = BoxFuture< 3686 3686 + tonic::Response<Self::Response>, 3687 3687 + tonic::Status, 3688 3688 + >; 3150 3689 fn call( 3151 3690 &mut self, 3152 3691 request: tonic::Request<super::FlushAndReloadTracksRequest>, 3153 3692 ) -> Self::Future { 3154 3693 let inner = Arc::clone(&self.0); 3155 3694 let fut = async move { 3156 3156 - <T as PlaybackService>::flush_and_reload_tracks(&inner, request) 3695 3695 + <T as PlaybackService>::flush_and_reload_tracks( 3696 3696 + &inner, 3697 3697 + request, 3698 3698 + ) 3157 3699 .await 3158 3700 }; 3159 3701 Box::pin(fut) ··· 3184 3726 "/rockbox.v1alpha1.PlaybackService/GetFilePosition" => { 3185 3727 #[allow(non_camel_case_types)] 3186 3728 struct GetFilePositionSvc<T: PlaybackService>(pub Arc<T>); 3187 3187 - impl<T: PlaybackService> 3188 3188 - tonic::server::UnaryService<super::GetFilePositionRequest> 3189 3189 - for GetFilePositionSvc<T> 3190 3190 - { 3729 3729 + impl< 3730 3730 + T: PlaybackService, 3731 3731 + > tonic::server::UnaryService<super::GetFilePositionRequest> 3732 3732 + for GetFilePositionSvc<T> { 3191 3733 type Response = super::GetFilePositionResponse; 3192 3192 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 3734 3734 + type Future = BoxFuture< 3735 3735 + tonic::Response<Self::Response>, 3736 3736 + tonic::Status, 3737 3737 + >; 3193 3738 fn call( 3194 3739 &mut self, 3195 3740 request: tonic::Request<super::GetFilePositionRequest>, 3196 3741 ) -> Self::Future { 3197 3742 let inner = Arc::clone(&self.0); 3198 3743 let fut = async move { 3199 3199 - <T as PlaybackService>::get_file_position(&inner, request).await 3744 3744 + <T as PlaybackService>::get_file_position(&inner, request) 3745 3745 + .await 3200 3746 }; 3201 3747 Box::pin(fut) 3202 3748 } ··· 3226 3772 "/rockbox.v1alpha1.PlaybackService/HardStop" => { 3227 3773 #[allow(non_camel_case_types)] 3228 3774 struct HardStopSvc<T: PlaybackService>(pub Arc<T>); 3229 3229 - impl<T: PlaybackService> tonic::server::UnaryService<super::HardStopRequest> for HardStopSvc<T> { 3775 3775 + impl< 3776 3776 + T: PlaybackService, 3777 3777 + > tonic::server::UnaryService<super::HardStopRequest> 3778 3778 + for HardStopSvc<T> { 3230 3779 type Response = super::HardStopResponse; 3231 3231 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 3780 3780 + type Future = BoxFuture< 3781 3781 + tonic::Response<Self::Response>, 3782 3782 + tonic::Status, 3783 3783 + >; 3232 3784 fn call( 3233 3785 &mut self, 3234 3786 request: tonic::Request<super::HardStopRequest>, ··· 3265 3817 "/rockbox.v1alpha1.PlaybackService/PlayAlbum" => { 3266 3818 #[allow(non_camel_case_types)] 3267 3819 struct PlayAlbumSvc<T: PlaybackService>(pub Arc<T>); 3268 3268 - impl<T: PlaybackService> tonic::server::UnaryService<super::PlayAlbumRequest> for PlayAlbumSvc<T> { 3820 3820 + impl< 3821 3821 + T: PlaybackService, 3822 3822 + > tonic::server::UnaryService<super::PlayAlbumRequest> 3823 3823 + for PlayAlbumSvc<T> { 3269 3824 type Response = super::PlayAlbumResponse; 3270 3270 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 3825 3825 + type Future = BoxFuture< 3826 3826 + tonic::Response<Self::Response>, 3827 3827 + tonic::Status, 3828 3828 + >; 3271 3829 fn call( 3272 3830 &mut self, 3273 3831 request: tonic::Request<super::PlayAlbumRequest>, ··· 3304 3862 "/rockbox.v1alpha1.PlaybackService/PlayArtistTracks" => { 3305 3863 #[allow(non_camel_case_types)] 3306 3864 struct PlayArtistTracksSvc<T: PlaybackService>(pub Arc<T>); 3307 3307 - impl<T: PlaybackService> 3308 3308 - tonic::server::UnaryService<super::PlayArtistTracksRequest> 3309 3309 - for PlayArtistTracksSvc<T> 3310 3310 - { 3865 3865 + impl< 3866 3866 + T: PlaybackService, 3867 3867 + > tonic::server::UnaryService<super::PlayArtistTracksRequest> 3868 3868 + for PlayArtistTracksSvc<T> { 3311 3869 type Response = super::PlayArtistTracksResponse; 3312 3312 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 3870 3870 + type Future = BoxFuture< 3871 3871 + tonic::Response<Self::Response>, 3872 3872 + tonic::Status, 3873 3873 + >; 3313 3874 fn call( 3314 3875 &mut self, 3315 3876 request: tonic::Request<super::PlayArtistTracksRequest>, 3316 3877 ) -> Self::Future { 3317 3878 let inner = Arc::clone(&self.0); 3318 3879 let fut = async move { 3319 3319 - <T as PlaybackService>::play_artist_tracks(&inner, request).await 3880 3880 + <T as PlaybackService>::play_artist_tracks(&inner, request) 3881 3881 + .await 3320 3882 }; 3321 3883 Box::pin(fut) 3322 3884 } ··· 3346 3908 "/rockbox.v1alpha1.PlaybackService/PlayPlaylist" => { 3347 3909 #[allow(non_camel_case_types)] 3348 3910 struct PlayPlaylistSvc<T: PlaybackService>(pub Arc<T>); 3349 3349 - impl<T: PlaybackService> tonic::server::UnaryService<super::PlayPlaylistRequest> 3350 3350 - for PlayPlaylistSvc<T> 3351 3351 - { 3911 3911 + impl< 3912 3912 + T: PlaybackService, 3913 3913 + > tonic::server::UnaryService<super::PlayPlaylistRequest> 3914 3914 + for PlayPlaylistSvc<T> { 3352 3915 type Response = super::PlayPlaylistResponse; 3353 3353 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 3916 3916 + type Future = BoxFuture< 3917 3917 + tonic::Response<Self::Response>, 3918 3918 + tonic::Status, 3919 3919 + >; 3354 3920 fn call( 3355 3921 &mut self, 3356 3922 request: tonic::Request<super::PlayPlaylistRequest>, ··· 3387 3953 "/rockbox.v1alpha1.PlaybackService/PlayDirectory" => { 3388 3954 #[allow(non_camel_case_types)] 3389 3955 struct PlayDirectorySvc<T: PlaybackService>(pub Arc<T>); 3390 3390 - impl<T: PlaybackService> 3391 3391 - tonic::server::UnaryService<super::PlayDirectoryRequest> 3392 3392 - for PlayDirectorySvc<T> 3393 3393 - { 3956 3956 + impl< 3957 3957 + T: PlaybackService, 3958 3958 + > tonic::server::UnaryService<super::PlayDirectoryRequest> 3959 3959 + for PlayDirectorySvc<T> { 3394 3960 type Response = super::PlayDirectoryResponse; 3395 3395 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 3961 3961 + type Future = BoxFuture< 3962 3962 + tonic::Response<Self::Response>, 3963 3963 + tonic::Status, 3964 3964 + >; 3396 3965 fn call( 3397 3966 &mut self, 3398 3967 request: tonic::Request<super::PlayDirectoryRequest>, 3399 3968 ) -> Self::Future { 3400 3969 let inner = Arc::clone(&self.0); 3401 3970 let fut = async move { 3402 3402 - <T as PlaybackService>::play_directory(&inner, request).await 3971 3971 + <T as PlaybackService>::play_directory(&inner, request) 3972 3972 + .await 3403 3973 }; 3404 3974 Box::pin(fut) 3405 3975 } ··· 3429 3999 "/rockbox.v1alpha1.PlaybackService/PlayTrack" => { 3430 4000 #[allow(non_camel_case_types)] 3431 4001 struct PlayTrackSvc<T: PlaybackService>(pub Arc<T>); 3432 3432 - impl<T: PlaybackService> tonic::server::UnaryService<super::PlayTrackRequest> for PlayTrackSvc<T> { 4002 4002 + impl< 4003 4003 + T: PlaybackService, 4004 4004 + > tonic::server::UnaryService<super::PlayTrackRequest> 4005 4005 + for PlayTrackSvc<T> { 3433 4006 type Response = super::PlayTrackResponse; 3434 3434 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 4007 4007 + type Future = BoxFuture< 4008 4008 + tonic::Response<Self::Response>, 4009 4009 + tonic::Status, 4010 4010 + >; 3435 4011 fn call( 3436 4012 &mut self, 3437 4013 request: tonic::Request<super::PlayTrackRequest>, ··· 3468 4044 "/rockbox.v1alpha1.PlaybackService/PlayLikedTracks" => { 3469 4045 #[allow(non_camel_case_types)] 3470 4046 struct PlayLikedTracksSvc<T: PlaybackService>(pub Arc<T>); 3471 3471 - impl<T: PlaybackService> 3472 3472 - tonic::server::UnaryService<super::PlayLikedTracksRequest> 3473 3473 - for PlayLikedTracksSvc<T> 3474 3474 - { 4047 4047 + impl< 4048 4048 + T: PlaybackService, 4049 4049 + > tonic::server::UnaryService<super::PlayLikedTracksRequest> 4050 4050 + for PlayLikedTracksSvc<T> { 3475 4051 type Response = super::PlayLikedTracksResponse; 3476 3476 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 4052 4052 + type Future = BoxFuture< 4053 4053 + tonic::Response<Self::Response>, 4054 4054 + tonic::Status, 4055 4055 + >; 3477 4056 fn call( 3478 4057 &mut self, 3479 4058 request: tonic::Request<super::PlayLikedTracksRequest>, 3480 4059 ) -> Self::Future { 3481 4060 let inner = Arc::clone(&self.0); 3482 4061 let fut = async move { 3483 3483 - <T as PlaybackService>::play_liked_tracks(&inner, request).await 4062 4062 + <T as PlaybackService>::play_liked_tracks(&inner, request) 4063 4063 + .await 3484 4064 }; 3485 4065 Box::pin(fut) 3486 4066 } ··· 3510 4090 "/rockbox.v1alpha1.PlaybackService/PlayAllTracks" => { 3511 4091 #[allow(non_camel_case_types)] 3512 4092 struct PlayAllTracksSvc<T: PlaybackService>(pub Arc<T>); 3513 3513 - impl<T: PlaybackService> 3514 3514 - tonic::server::UnaryService<super::PlayAllTracksRequest> 3515 3515 - for PlayAllTracksSvc<T> 3516 3516 - { 4093 4093 + impl< 4094 4094 + T: PlaybackService, 4095 4095 + > tonic::server::UnaryService<super::PlayAllTracksRequest> 4096 4096 + for PlayAllTracksSvc<T> { 3517 4097 type Response = super::PlayAllTracksResponse; 3518 3518 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 4098 4098 + type Future = BoxFuture< 4099 4099 + tonic::Response<Self::Response>, 4100 4100 + tonic::Status, 4101 4101 + >; 3519 4102 fn call( 3520 4103 &mut self, 3521 4104 request: tonic::Request<super::PlayAllTracksRequest>, 3522 4105 ) -> Self::Future { 3523 4106 let inner = Arc::clone(&self.0); 3524 4107 let fut = async move { 3525 3525 - <T as PlaybackService>::play_all_tracks(&inner, request).await 4108 4108 + <T as PlaybackService>::play_all_tracks(&inner, request) 4109 4109 + .await 3526 4110 }; 3527 4111 Box::pin(fut) 3528 4112 } ··· 3552 4136 "/rockbox.v1alpha1.PlaybackService/StreamCurrentTrack" => { 3553 4137 #[allow(non_camel_case_types)] 3554 4138 struct StreamCurrentTrackSvc<T: PlaybackService>(pub Arc<T>); 3555 3555 - impl<T: PlaybackService> 3556 3556 - tonic::server::ServerStreamingService<super::StreamCurrentTrackRequest> 3557 3557 - for StreamCurrentTrackSvc<T> 3558 3558 - { 4139 4139 + impl< 4140 4140 + T: PlaybackService, 4141 4141 + > tonic::server::ServerStreamingService< 4142 4142 + super::StreamCurrentTrackRequest, 4143 4143 + > for StreamCurrentTrackSvc<T> { 3559 4144 type Response = super::CurrentTrackResponse; 3560 4145 type ResponseStream = T::StreamCurrentTrackStream; 3561 3561 - type Future = 3562 3562 - BoxFuture<tonic::Response<Self::ResponseStream>, tonic::Status>; 4146 4146 + type Future = BoxFuture< 4147 4147 + tonic::Response<Self::ResponseStream>, 4148 4148 + tonic::Status, 4149 4149 + >; 3563 4150 fn call( 3564 4151 &mut self, 3565 4152 request: tonic::Request<super::StreamCurrentTrackRequest>, 3566 4153 ) -> Self::Future { 3567 4154 let inner = Arc::clone(&self.0); 3568 4155 let fut = async move { 3569 3569 - <T as PlaybackService>::stream_current_track(&inner, request).await 4156 4156 + <T as PlaybackService>::stream_current_track( 4157 4157 + &inner, 4158 4158 + request, 4159 4159 + ) 4160 4160 + .await 3570 4161 }; 3571 4162 Box::pin(fut) 3572 4163 } ··· 3596 4187 "/rockbox.v1alpha1.PlaybackService/StreamStatus" => { 3597 4188 #[allow(non_camel_case_types)] 3598 4189 struct StreamStatusSvc<T: PlaybackService>(pub Arc<T>); 3599 3599 - impl<T: PlaybackService> 3600 3600 - tonic::server::ServerStreamingService<super::StreamStatusRequest> 3601 3601 - for StreamStatusSvc<T> 3602 3602 - { 4190 4190 + impl< 4191 4191 + T: PlaybackService, 4192 4192 + > tonic::server::ServerStreamingService<super::StreamStatusRequest> 4193 4193 + for StreamStatusSvc<T> { 3603 4194 type Response = super::StatusResponse; 3604 4195 type ResponseStream = T::StreamStatusStream; 3605 3605 - type Future = 3606 3606 - BoxFuture<tonic::Response<Self::ResponseStream>, tonic::Status>; 4196 4196 + type Future = BoxFuture< 4197 4197 + tonic::Response<Self::ResponseStream>, 4198 4198 + tonic::Status, 4199 4199 + >; 3607 4200 fn call( 3608 4201 &mut self, 3609 4202 request: tonic::Request<super::StreamStatusRequest>, ··· 3640 4233 "/rockbox.v1alpha1.PlaybackService/StreamPlaylist" => { 3641 4234 #[allow(non_camel_case_types)] 3642 4235 struct StreamPlaylistSvc<T: PlaybackService>(pub Arc<T>); 3643 3643 - impl<T: PlaybackService> 3644 3644 - tonic::server::ServerStreamingService<super::StreamPlaylistRequest> 3645 3645 - for StreamPlaylistSvc<T> 3646 3646 - { 4236 4236 + impl< 4237 4237 + T: PlaybackService, 4238 4238 + > tonic::server::ServerStreamingService<super::StreamPlaylistRequest> 4239 4239 + for StreamPlaylistSvc<T> { 3647 4240 type Response = super::PlaylistResponse; 3648 4241 type ResponseStream = T::StreamPlaylistStream; 3649 3649 - type Future = 3650 3650 - BoxFuture<tonic::Response<Self::ResponseStream>, tonic::Status>; 4242 4242 + type Future = BoxFuture< 4243 4243 + tonic::Response<Self::ResponseStream>, 4244 4244 + tonic::Status, 4245 4245 + >; 3651 4246 fn call( 3652 4247 &mut self, 3653 4248 request: tonic::Request<super::StreamPlaylistRequest>, 3654 4249 ) -> Self::Future { 3655 4250 let inner = Arc::clone(&self.0); 3656 4251 let fut = async move { 3657 3657 - <T as PlaybackService>::stream_playlist(&inner, request).await 4252 4252 + <T as PlaybackService>::stream_playlist(&inner, request) 4253 4253 + .await 3658 4254 }; 3659 4255 Box::pin(fut) 3660 4256 } ··· 3681 4277 }; 3682 4278 Box::pin(fut) 3683 4279 } 3684 3684 - _ => Box::pin(async move { 3685 3685 - let mut response = http::Response::new(empty_body()); 3686 3686 - let headers = response.headers_mut(); 3687 3687 - headers.insert( 3688 3688 - tonic::Status::GRPC_STATUS, 3689 3689 - (tonic::Code::Unimplemented as i32).into(), 3690 3690 - ); 3691 3691 - headers.insert( 3692 3692 - http::header::CONTENT_TYPE, 3693 3693 - tonic::metadata::GRPC_CONTENT_TYPE, 3694 3694 - ); 3695 3695 - Ok(response) 3696 3696 - }), 4280 4280 + _ => { 4281 4281 + Box::pin(async move { 4282 4282 + let mut response = http::Response::new(empty_body()); 4283 4283 + let headers = response.headers_mut(); 4284 4284 + headers 4285 4285 + .insert( 4286 4286 + tonic::Status::GRPC_STATUS, 4287 4287 + (tonic::Code::Unimplemented as i32).into(), 4288 4288 + ); 4289 4289 + headers 4290 4290 + .insert( 4291 4291 + http::header::CONTENT_TYPE, 4292 4292 + tonic::metadata::GRPC_CONTENT_TYPE, 4293 4293 + ); 4294 4294 + Ok(response) 4295 4295 + }) 4296 4296 + } 3697 4297 } 3698 4298 } 3699 4299 } ··· 3900 4500 dead_code, 3901 4501 missing_docs, 3902 4502 clippy::wildcard_imports, 3903 3903 - clippy::let_unit_value 4503 4503 + clippy::let_unit_value, 3904 4504 )] 3905 3905 - use tonic::codegen::http::Uri; 3906 4505 use tonic::codegen::*; 4506 4506 + use tonic::codegen::http::Uri; 3907 4507 #[derive(Debug, Clone)] 3908 4508 pub struct PlaylistServiceClient<T> { 3909 4509 inner: tonic::client::Grpc<T>, ··· 3947 4547 <T as tonic::client::GrpcService<tonic::body::BoxBody>>::ResponseBody, 3948 4548 >, 3949 4549 >, 3950 3950 - <T as tonic::codegen::Service<http::Request<tonic::body::BoxBody>>>::Error: 3951 3951 - Into<StdError> + std::marker::Send + std::marker::Sync, 4550 4550 + <T as tonic::codegen::Service< 4551 4551 + http::Request<tonic::body::BoxBody>, 4552 4552 + >>::Error: Into<StdError> + std::marker::Send + std::marker::Sync, 3952 4553 { 3953 4554 PlaylistServiceClient::new(InterceptedService::new(inner, interceptor)) 3954 4555 } ··· 3986 4587 pub async fn get_current( 3987 4588 &mut self, 3988 4589 request: impl tonic::IntoRequest<super::GetCurrentRequest>, 3989 3989 - ) -> std::result::Result<tonic::Response<super::GetCurrentResponse>, tonic::Status> 3990 3990 - { 3991 3991 - self.inner.ready().await.map_err(|e| { 3992 3992 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 3993 3993 - })?; 4590 4590 + ) -> std::result::Result< 4591 4591 + tonic::Response<super::GetCurrentResponse>, 4592 4592 + tonic::Status, 4593 4593 + > { 4594 4594 + self.inner 4595 4595 + .ready() 4596 4596 + .await 4597 4597 + .map_err(|e| { 4598 4598 + tonic::Status::unknown( 4599 4599 + format!("Service was not ready: {}", e.into()), 4600 4600 + ) 4601 4601 + })?; 3994 4602 let codec = tonic::codec::ProstCodec::default(); 3995 4603 let path = http::uri::PathAndQuery::from_static( 3996 4604 "/rockbox.v1alpha1.PlaylistService/GetCurrent", 3997 4605 ); 3998 4606 let mut req = request.into_request(); 3999 3999 - req.extensions_mut().insert(GrpcMethod::new( 4000 4000 - "rockbox.v1alpha1.PlaylistService", 4001 4001 - "GetCurrent", 4002 4002 - )); 4607 4607 + req.extensions_mut() 4608 4608 + .insert( 4609 4609 + GrpcMethod::new("rockbox.v1alpha1.PlaylistService", "GetCurrent"), 4610 4610 + ); 4003 4611 self.inner.unary(req, path, codec).await 4004 4612 } 4005 4613 pub async fn get_resume_info( 4006 4614 &mut self, 4007 4615 request: impl tonic::IntoRequest<super::GetResumeInfoRequest>, 4008 4008 - ) -> std::result::Result<tonic::Response<super::GetResumeInfoResponse>, tonic::Status> 4009 4009 - { 4010 4010 - self.inner.ready().await.map_err(|e| { 4011 4011 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 4012 4012 - })?; 4616 4616 + ) -> std::result::Result< 4617 4617 + tonic::Response<super::GetResumeInfoResponse>, 4618 4618 + tonic::Status, 4619 4619 + > { 4620 4620 + self.inner 4621 4621 + .ready() 4622 4622 + .await 4623 4623 + .map_err(|e| { 4624 4624 + tonic::Status::unknown( 4625 4625 + format!("Service was not ready: {}", e.into()), 4626 4626 + ) 4627 4627 + })?; 4013 4628 let codec = tonic::codec::ProstCodec::default(); 4014 4629 let path = http::uri::PathAndQuery::from_static( 4015 4630 "/rockbox.v1alpha1.PlaylistService/GetResumeInfo", 4016 4631 ); 4017 4632 let mut req = request.into_request(); 4018 4018 - req.extensions_mut().insert(GrpcMethod::new( 4019 4019 - "rockbox.v1alpha1.PlaylistService", 4020 4020 - "GetResumeInfo", 4021 4021 - )); 4633 4633 + req.extensions_mut() 4634 4634 + .insert( 4635 4635 + GrpcMethod::new("rockbox.v1alpha1.PlaylistService", "GetResumeInfo"), 4636 4636 + ); 4022 4637 self.inner.unary(req, path, codec).await 4023 4638 } 4024 4639 pub async fn get_track_info( 4025 4640 &mut self, 4026 4641 request: impl tonic::IntoRequest<super::GetTrackInfoRequest>, 4027 4027 - ) -> std::result::Result<tonic::Response<super::GetTrackInfoResponse>, tonic::Status> 4028 4028 - { 4029 4029 - self.inner.ready().await.map_err(|e| { 4030 4030 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 4031 4031 - })?; 4642 4642 + ) -> std::result::Result< 4643 4643 + tonic::Response<super::GetTrackInfoResponse>, 4644 4644 + tonic::Status, 4645 4645 + > { 4646 4646 + self.inner 4647 4647 + .ready() 4648 4648 + .await 4649 4649 + .map_err(|e| { 4650 4650 + tonic::Status::unknown( 4651 4651 + format!("Service was not ready: {}", e.into()), 4652 4652 + ) 4653 4653 + })?; 4032 4654 let codec = tonic::codec::ProstCodec::default(); 4033 4655 let path = http::uri::PathAndQuery::from_static( 4034 4656 "/rockbox.v1alpha1.PlaylistService/GetTrackInfo", 4035 4657 ); 4036 4658 let mut req = request.into_request(); 4037 4037 - req.extensions_mut().insert(GrpcMethod::new( 4038 4038 - "rockbox.v1alpha1.PlaylistService", 4039 4039 - "GetTrackInfo", 4040 4040 - )); 4659 4659 + req.extensions_mut() 4660 4660 + .insert( 4661 4661 + GrpcMethod::new("rockbox.v1alpha1.PlaylistService", "GetTrackInfo"), 4662 4662 + ); 4041 4663 self.inner.unary(req, path, codec).await 4042 4664 } 4043 4665 pub async fn get_first_index( 4044 4666 &mut self, 4045 4667 request: impl tonic::IntoRequest<super::GetFirstIndexRequest>, 4046 4046 - ) -> std::result::Result<tonic::Response<super::GetFirstIndexResponse>, tonic::Status> 4047 4047 - { 4048 4048 - self.inner.ready().await.map_err(|e| { 4049 4049 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 4050 4050 - })?; 4668 4668 + ) -> std::result::Result< 4669 4669 + tonic::Response<super::GetFirstIndexResponse>, 4670 4670 + tonic::Status, 4671 4671 + > { 4672 4672 + self.inner 4673 4673 + .ready() 4674 4674 + .await 4675 4675 + .map_err(|e| { 4676 4676 + tonic::Status::unknown( 4677 4677 + format!("Service was not ready: {}", e.into()), 4678 4678 + ) 4679 4679 + })?; 4051 4680 let codec = tonic::codec::ProstCodec::default(); 4052 4681 let path = http::uri::PathAndQuery::from_static( 4053 4682 "/rockbox.v1alpha1.PlaylistService/GetFirstIndex", 4054 4683 ); 4055 4684 let mut req = request.into_request(); 4056 4056 - req.extensions_mut().insert(GrpcMethod::new( 4057 4057 - "rockbox.v1alpha1.PlaylistService", 4058 4058 - "GetFirstIndex", 4059 4059 - )); 4685 4685 + req.extensions_mut() 4686 4686 + .insert( 4687 4687 + GrpcMethod::new("rockbox.v1alpha1.PlaylistService", "GetFirstIndex"), 4688 4688 + ); 4060 4689 self.inner.unary(req, path, codec).await 4061 4690 } 4062 4691 pub async fn get_display_index( 4063 4692 &mut self, 4064 4693 request: impl tonic::IntoRequest<super::GetDisplayIndexRequest>, 4065 4065 - ) -> std::result::Result<tonic::Response<super::GetDisplayIndexResponse>, tonic::Status> 4066 4066 - { 4067 4067 - self.inner.ready().await.map_err(|e| { 4068 4068 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 4069 4069 - })?; 4694 4694 + ) -> std::result::Result< 4695 4695 + tonic::Response<super::GetDisplayIndexResponse>, 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 + })?; 4070 4706 let codec = tonic::codec::ProstCodec::default(); 4071 4707 let path = http::uri::PathAndQuery::from_static( 4072 4708 "/rockbox.v1alpha1.PlaylistService/GetDisplayIndex", 4073 4709 ); 4074 4710 let mut req = request.into_request(); 4075 4075 - req.extensions_mut().insert(GrpcMethod::new( 4076 4076 - "rockbox.v1alpha1.PlaylistService", 4077 4077 - "GetDisplayIndex", 4078 4078 - )); 4711 4711 + req.extensions_mut() 4712 4712 + .insert( 4713 4713 + GrpcMethod::new( 4714 4714 + "rockbox.v1alpha1.PlaylistService", 4715 4715 + "GetDisplayIndex", 4716 4716 + ), 4717 4717 + ); 4079 4718 self.inner.unary(req, path, codec).await 4080 4719 } 4081 4720 pub async fn amount( 4082 4721 &mut self, 4083 4722 request: impl tonic::IntoRequest<super::AmountRequest>, 4084 4723 ) -> std::result::Result<tonic::Response<super::AmountResponse>, tonic::Status> { 4085 4085 - self.inner.ready().await.map_err(|e| { 4086 4086 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 4087 4087 - })?; 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 + })?; 4088 4732 let codec = tonic::codec::ProstCodec::default(); 4089 4089 - let path = 4090 4090 - http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.PlaylistService/Amount"); 4733 4733 + let path = http::uri::PathAndQuery::from_static( 4734 4734 + "/rockbox.v1alpha1.PlaylistService/Amount", 4735 4735 + ); 4091 4736 let mut req = request.into_request(); 4092 4092 - req.extensions_mut().insert(GrpcMethod::new( 4093 4093 - "rockbox.v1alpha1.PlaylistService", 4094 4094 - "Amount", 4095 4095 - )); 4737 4737 + req.extensions_mut() 4738 4738 + .insert(GrpcMethod::new("rockbox.v1alpha1.PlaylistService", "Amount")); 4096 4739 self.inner.unary(req, path, codec).await 4097 4740 } 4098 4741 pub async fn playlist_resume( 4099 4742 &mut self, 4100 4743 request: impl tonic::IntoRequest<super::PlaylistResumeRequest>, 4101 4101 - ) -> std::result::Result<tonic::Response<super::PlaylistResumeResponse>, tonic::Status> 4102 4102 - { 4103 4103 - self.inner.ready().await.map_err(|e| { 4104 4104 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 4105 4105 - })?; 4744 4744 + ) -> std::result::Result< 4745 4745 + tonic::Response<super::PlaylistResumeResponse>, 4746 4746 + tonic::Status, 4747 4747 + > { 4748 4748 + self.inner 4749 4749 + .ready() 4750 4750 + .await 4751 4751 + .map_err(|e| { 4752 4752 + tonic::Status::unknown( 4753 4753 + format!("Service was not ready: {}", e.into()), 4754 4754 + ) 4755 4755 + })?; 4106 4756 let codec = tonic::codec::ProstCodec::default(); 4107 4757 let path = http::uri::PathAndQuery::from_static( 4108 4758 "/rockbox.v1alpha1.PlaylistService/PlaylistResume", 4109 4759 ); 4110 4760 let mut req = request.into_request(); 4111 4111 - req.extensions_mut().insert(GrpcMethod::new( 4112 4112 - "rockbox.v1alpha1.PlaylistService", 4113 4113 - "PlaylistResume", 4114 4114 - )); 4761 4761 + req.extensions_mut() 4762 4762 + .insert( 4763 4763 + GrpcMethod::new("rockbox.v1alpha1.PlaylistService", "PlaylistResume"), 4764 4764 + ); 4115 4765 self.inner.unary(req, path, codec).await 4116 4766 } 4117 4767 pub async fn resume_track( 4118 4768 &mut self, 4119 4769 request: impl tonic::IntoRequest<super::ResumeTrackRequest>, 4120 4120 - ) -> std::result::Result<tonic::Response<super::ResumeTrackResponse>, tonic::Status> 4121 4121 - { 4122 4122 - self.inner.ready().await.map_err(|e| { 4123 4123 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 4124 4124 - })?; 4770 4770 + ) -> std::result::Result< 4771 4771 + tonic::Response<super::ResumeTrackResponse>, 4772 4772 + tonic::Status, 4773 4773 + > { 4774 4774 + self.inner 4775 4775 + .ready() 4776 4776 + .await 4777 4777 + .map_err(|e| { 4778 4778 + tonic::Status::unknown( 4779 4779 + format!("Service was not ready: {}", e.into()), 4780 4780 + ) 4781 4781 + })?; 4125 4782 let codec = tonic::codec::ProstCodec::default(); 4126 4783 let path = http::uri::PathAndQuery::from_static( 4127 4784 "/rockbox.v1alpha1.PlaylistService/ResumeTrack", 4128 4785 ); 4129 4786 let mut req = request.into_request(); 4130 4130 - req.extensions_mut().insert(GrpcMethod::new( 4131 4131 - "rockbox.v1alpha1.PlaylistService", 4132 4132 - "ResumeTrack", 4133 4133 - )); 4787 4787 + req.extensions_mut() 4788 4788 + .insert( 4789 4789 + GrpcMethod::new("rockbox.v1alpha1.PlaylistService", "ResumeTrack"), 4790 4790 + ); 4134 4791 self.inner.unary(req, path, codec).await 4135 4792 } 4136 4793 pub async fn set_modified( 4137 4794 &mut self, 4138 4795 request: impl tonic::IntoRequest<super::SetModifiedRequest>, 4139 4139 - ) -> std::result::Result<tonic::Response<super::SetModifiedResponse>, tonic::Status> 4140 4140 - { 4141 4141 - self.inner.ready().await.map_err(|e| { 4142 4142 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 4143 4143 - })?; 4796 4796 + ) -> std::result::Result< 4797 4797 + tonic::Response<super::SetModifiedResponse>, 4798 4798 + tonic::Status, 4799 4799 + > { 4800 4800 + self.inner 4801 4801 + .ready() 4802 4802 + .await 4803 4803 + .map_err(|e| { 4804 4804 + tonic::Status::unknown( 4805 4805 + format!("Service was not ready: {}", e.into()), 4806 4806 + ) 4807 4807 + })?; 4144 4808 let codec = tonic::codec::ProstCodec::default(); 4145 4809 let path = http::uri::PathAndQuery::from_static( 4146 4810 "/rockbox.v1alpha1.PlaylistService/SetModified", 4147 4811 ); 4148 4812 let mut req = request.into_request(); 4149 4149 - req.extensions_mut().insert(GrpcMethod::new( 4150 4150 - "rockbox.v1alpha1.PlaylistService", 4151 4151 - "SetModified", 4152 4152 - )); 4813 4813 + req.extensions_mut() 4814 4814 + .insert( 4815 4815 + GrpcMethod::new("rockbox.v1alpha1.PlaylistService", "SetModified"), 4816 4816 + ); 4153 4817 self.inner.unary(req, path, codec).await 4154 4818 } 4155 4819 pub async fn start( 4156 4820 &mut self, 4157 4821 request: impl tonic::IntoRequest<super::StartRequest>, 4158 4822 ) -> std::result::Result<tonic::Response<super::StartResponse>, tonic::Status> { 4159 4159 - self.inner.ready().await.map_err(|e| { 4160 4160 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 4161 4161 - })?; 4823 4823 + self.inner 4824 4824 + .ready() 4825 4825 + .await 4826 4826 + .map_err(|e| { 4827 4827 + tonic::Status::unknown( 4828 4828 + format!("Service was not ready: {}", e.into()), 4829 4829 + ) 4830 4830 + })?; 4162 4831 let codec = tonic::codec::ProstCodec::default(); 4163 4163 - let path = 4164 4164 - http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.PlaylistService/Start"); 4832 4832 + let path = http::uri::PathAndQuery::from_static( 4833 4833 + "/rockbox.v1alpha1.PlaylistService/Start", 4834 4834 + ); 4165 4835 let mut req = request.into_request(); 4166 4836 req.extensions_mut() 4167 4837 .insert(GrpcMethod::new("rockbox.v1alpha1.PlaylistService", "Start")); ··· 4171 4841 &mut self, 4172 4842 request: impl tonic::IntoRequest<super::SyncRequest>, 4173 4843 ) -> std::result::Result<tonic::Response<super::SyncResponse>, tonic::Status> { 4174 4174 - self.inner.ready().await.map_err(|e| { 4175 4175 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 4176 4176 - })?; 4844 4844 + self.inner 4845 4845 + .ready() 4846 4846 + .await 4847 4847 + .map_err(|e| { 4848 4848 + tonic::Status::unknown( 4849 4849 + format!("Service was not ready: {}", e.into()), 4850 4850 + ) 4851 4851 + })?; 4177 4852 let codec = tonic::codec::ProstCodec::default(); 4178 4178 - let path = 4179 4179 - http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.PlaylistService/Sync"); 4853 4853 + let path = http::uri::PathAndQuery::from_static( 4854 4854 + "/rockbox.v1alpha1.PlaylistService/Sync", 4855 4855 + ); 4180 4856 let mut req = request.into_request(); 4181 4857 req.extensions_mut() 4182 4858 .insert(GrpcMethod::new("rockbox.v1alpha1.PlaylistService", "Sync")); ··· 4185 4861 pub async fn remove_all_tracks( 4186 4862 &mut self, 4187 4863 request: impl tonic::IntoRequest<super::RemoveAllTracksRequest>, 4188 4188 - ) -> std::result::Result<tonic::Response<super::RemoveAllTracksResponse>, tonic::Status> 4189 4189 - { 4190 4190 - self.inner.ready().await.map_err(|e| { 4191 4191 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 4192 4192 - })?; 4864 4864 + ) -> std::result::Result< 4865 4865 + tonic::Response<super::RemoveAllTracksResponse>, 4866 4866 + tonic::Status, 4867 4867 + > { 4868 4868 + self.inner 4869 4869 + .ready() 4870 4870 + .await 4871 4871 + .map_err(|e| { 4872 4872 + tonic::Status::unknown( 4873 4873 + format!("Service was not ready: {}", e.into()), 4874 4874 + ) 4875 4875 + })?; 4193 4876 let codec = tonic::codec::ProstCodec::default(); 4194 4877 let path = http::uri::PathAndQuery::from_static( 4195 4878 "/rockbox.v1alpha1.PlaylistService/RemoveAllTracks", 4196 4879 ); 4197 4880 let mut req = request.into_request(); 4198 4198 - req.extensions_mut().insert(GrpcMethod::new( 4199 4199 - "rockbox.v1alpha1.PlaylistService", 4200 4200 - "RemoveAllTracks", 4201 4201 - )); 4881 4881 + req.extensions_mut() 4882 4882 + .insert( 4883 4883 + GrpcMethod::new( 4884 4884 + "rockbox.v1alpha1.PlaylistService", 4885 4885 + "RemoveAllTracks", 4886 4886 + ), 4887 4887 + ); 4202 4888 self.inner.unary(req, path, codec).await 4203 4889 } 4204 4890 pub async fn remove_tracks( 4205 4891 &mut self, 4206 4892 request: impl tonic::IntoRequest<super::RemoveTracksRequest>, 4207 4207 - ) -> std::result::Result<tonic::Response<super::RemoveTracksResponse>, tonic::Status> 4208 4208 - { 4209 4209 - self.inner.ready().await.map_err(|e| { 4210 4210 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 4211 4211 - })?; 4893 4893 + ) -> std::result::Result< 4894 4894 + tonic::Response<super::RemoveTracksResponse>, 4895 4895 + tonic::Status, 4896 4896 + > { 4897 4897 + self.inner 4898 4898 + .ready() 4899 4899 + .await 4900 4900 + .map_err(|e| { 4901 4901 + tonic::Status::unknown( 4902 4902 + format!("Service was not ready: {}", e.into()), 4903 4903 + ) 4904 4904 + })?; 4212 4905 let codec = tonic::codec::ProstCodec::default(); 4213 4906 let path = http::uri::PathAndQuery::from_static( 4214 4907 "/rockbox.v1alpha1.PlaylistService/RemoveTracks", 4215 4908 ); 4216 4909 let mut req = request.into_request(); 4217 4217 - req.extensions_mut().insert(GrpcMethod::new( 4218 4218 - "rockbox.v1alpha1.PlaylistService", 4219 4219 - "RemoveTracks", 4220 4220 - )); 4910 4910 + req.extensions_mut() 4911 4911 + .insert( 4912 4912 + GrpcMethod::new("rockbox.v1alpha1.PlaylistService", "RemoveTracks"), 4913 4913 + ); 4221 4914 self.inner.unary(req, path, codec).await 4222 4915 } 4223 4916 pub async fn create_playlist( 4224 4917 &mut self, 4225 4918 request: impl tonic::IntoRequest<super::CreatePlaylistRequest>, 4226 4226 - ) -> std::result::Result<tonic::Response<super::CreatePlaylistResponse>, tonic::Status> 4227 4227 - { 4228 4228 - self.inner.ready().await.map_err(|e| { 4229 4229 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 4230 4230 - })?; 4919 4919 + ) -> std::result::Result< 4920 4920 + tonic::Response<super::CreatePlaylistResponse>, 4921 4921 + tonic::Status, 4922 4922 + > { 4923 4923 + self.inner 4924 4924 + .ready() 4925 4925 + .await 4926 4926 + .map_err(|e| { 4927 4927 + tonic::Status::unknown( 4928 4928 + format!("Service was not ready: {}", e.into()), 4929 4929 + ) 4930 4930 + })?; 4231 4931 let codec = tonic::codec::ProstCodec::default(); 4232 4932 let path = http::uri::PathAndQuery::from_static( 4233 4933 "/rockbox.v1alpha1.PlaylistService/CreatePlaylist", 4234 4934 ); 4235 4935 let mut req = request.into_request(); 4236 4236 - req.extensions_mut().insert(GrpcMethod::new( 4237 4237 - "rockbox.v1alpha1.PlaylistService", 4238 4238 - "CreatePlaylist", 4239 4239 - )); 4936 4936 + req.extensions_mut() 4937 4937 + .insert( 4938 4938 + GrpcMethod::new("rockbox.v1alpha1.PlaylistService", "CreatePlaylist"), 4939 4939 + ); 4240 4940 self.inner.unary(req, path, codec).await 4241 4941 } 4242 4942 pub async fn insert_tracks( 4243 4943 &mut self, 4244 4944 request: impl tonic::IntoRequest<super::InsertTracksRequest>, 4245 4245 - ) -> std::result::Result<tonic::Response<super::InsertTracksResponse>, tonic::Status> 4246 4246 - { 4247 4247 - self.inner.ready().await.map_err(|e| { 4248 4248 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 4249 4249 - })?; 4945 4945 + ) -> std::result::Result< 4946 4946 + tonic::Response<super::InsertTracksResponse>, 4947 4947 + tonic::Status, 4948 4948 + > { 4949 4949 + self.inner 4950 4950 + .ready() 4951 4951 + .await 4952 4952 + .map_err(|e| { 4953 4953 + tonic::Status::unknown( 4954 4954 + format!("Service was not ready: {}", e.into()), 4955 4955 + ) 4956 4956 + })?; 4250 4957 let codec = tonic::codec::ProstCodec::default(); 4251 4958 let path = http::uri::PathAndQuery::from_static( 4252 4959 "/rockbox.v1alpha1.PlaylistService/InsertTracks", 4253 4960 ); 4254 4961 let mut req = request.into_request(); 4255 4255 - req.extensions_mut().insert(GrpcMethod::new( 4256 4256 - "rockbox.v1alpha1.PlaylistService", 4257 4257 - "InsertTracks", 4258 4258 - )); 4962 4962 + req.extensions_mut() 4963 4963 + .insert( 4964 4964 + GrpcMethod::new("rockbox.v1alpha1.PlaylistService", "InsertTracks"), 4965 4965 + ); 4259 4966 self.inner.unary(req, path, codec).await 4260 4967 } 4261 4968 pub async fn insert_directory( 4262 4969 &mut self, 4263 4970 request: impl tonic::IntoRequest<super::InsertDirectoryRequest>, 4264 4264 - ) -> std::result::Result<tonic::Response<super::InsertDirectoryResponse>, tonic::Status> 4265 4265 - { 4266 4266 - self.inner.ready().await.map_err(|e| { 4267 4267 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 4268 4268 - })?; 4971 4971 + ) -> std::result::Result< 4972 4972 + tonic::Response<super::InsertDirectoryResponse>, 4973 4973 + tonic::Status, 4974 4974 + > { 4975 4975 + self.inner 4976 4976 + .ready() 4977 4977 + .await 4978 4978 + .map_err(|e| { 4979 4979 + tonic::Status::unknown( 4980 4980 + format!("Service was not ready: {}", e.into()), 4981 4981 + ) 4982 4982 + })?; 4269 4983 let codec = tonic::codec::ProstCodec::default(); 4270 4984 let path = http::uri::PathAndQuery::from_static( 4271 4985 "/rockbox.v1alpha1.PlaylistService/InsertDirectory", 4272 4986 ); 4273 4987 let mut req = request.into_request(); 4274 4274 - req.extensions_mut().insert(GrpcMethod::new( 4275 4275 - "rockbox.v1alpha1.PlaylistService", 4276 4276 - "InsertDirectory", 4277 4277 - )); 4988 4988 + req.extensions_mut() 4989 4989 + .insert( 4990 4990 + GrpcMethod::new( 4991 4991 + "rockbox.v1alpha1.PlaylistService", 4992 4992 + "InsertDirectory", 4993 4993 + ), 4994 4994 + ); 4278 4995 self.inner.unary(req, path, codec).await 4279 4996 } 4280 4997 pub async fn insert_playlist( 4281 4998 &mut self, 4282 4999 request: impl tonic::IntoRequest<super::InsertPlaylistRequest>, 4283 4283 - ) -> std::result::Result<tonic::Response<super::InsertPlaylistResponse>, tonic::Status> 4284 4284 - { 4285 4285 - self.inner.ready().await.map_err(|e| { 4286 4286 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 4287 4287 - })?; 5000 5000 + ) -> std::result::Result< 5001 5001 + tonic::Response<super::InsertPlaylistResponse>, 5002 5002 + tonic::Status, 5003 5003 + > { 5004 5004 + self.inner 5005 5005 + .ready() 5006 5006 + .await 5007 5007 + .map_err(|e| { 5008 5008 + tonic::Status::unknown( 5009 5009 + format!("Service was not ready: {}", e.into()), 5010 5010 + ) 5011 5011 + })?; 4288 5012 let codec = tonic::codec::ProstCodec::default(); 4289 5013 let path = http::uri::PathAndQuery::from_static( 4290 5014 "/rockbox.v1alpha1.PlaylistService/InsertPlaylist", 4291 5015 ); 4292 5016 let mut req = request.into_request(); 4293 4293 - req.extensions_mut().insert(GrpcMethod::new( 4294 4294 - "rockbox.v1alpha1.PlaylistService", 4295 4295 - "InsertPlaylist", 4296 4296 - )); 5017 5017 + req.extensions_mut() 5018 5018 + .insert( 5019 5019 + GrpcMethod::new("rockbox.v1alpha1.PlaylistService", "InsertPlaylist"), 5020 5020 + ); 4297 5021 self.inner.unary(req, path, codec).await 4298 5022 } 4299 5023 pub async fn insert_album( 4300 5024 &mut self, 4301 5025 request: impl tonic::IntoRequest<super::InsertAlbumRequest>, 4302 4302 - ) -> std::result::Result<tonic::Response<super::InsertAlbumResponse>, tonic::Status> 4303 4303 - { 4304 4304 - self.inner.ready().await.map_err(|e| { 4305 4305 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 4306 4306 - })?; 5026 5026 + ) -> std::result::Result< 5027 5027 + tonic::Response<super::InsertAlbumResponse>, 5028 5028 + tonic::Status, 5029 5029 + > { 5030 5030 + self.inner 5031 5031 + .ready() 5032 5032 + .await 5033 5033 + .map_err(|e| { 5034 5034 + tonic::Status::unknown( 5035 5035 + format!("Service was not ready: {}", e.into()), 5036 5036 + ) 5037 5037 + })?; 4307 5038 let codec = tonic::codec::ProstCodec::default(); 4308 5039 let path = http::uri::PathAndQuery::from_static( 4309 5040 "/rockbox.v1alpha1.PlaylistService/InsertAlbum", 4310 5041 ); 4311 5042 let mut req = request.into_request(); 4312 4312 - req.extensions_mut().insert(GrpcMethod::new( 4313 4313 - "rockbox.v1alpha1.PlaylistService", 4314 4314 - "InsertAlbum", 4315 4315 - )); 5043 5043 + req.extensions_mut() 5044 5044 + .insert( 5045 5045 + GrpcMethod::new("rockbox.v1alpha1.PlaylistService", "InsertAlbum"), 5046 5046 + ); 4316 5047 self.inner.unary(req, path, codec).await 4317 5048 } 4318 5049 pub async fn insert_artist_tracks( 4319 5050 &mut self, 4320 5051 request: impl tonic::IntoRequest<super::InsertArtistTracksRequest>, 4321 4321 - ) -> std::result::Result<tonic::Response<super::InsertArtistTracksResponse>, tonic::Status> 4322 4322 - { 4323 4323 - self.inner.ready().await.map_err(|e| { 4324 4324 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 4325 4325 - })?; 5052 5052 + ) -> std::result::Result< 5053 5053 + tonic::Response<super::InsertArtistTracksResponse>, 5054 5054 + tonic::Status, 5055 5055 + > { 5056 5056 + self.inner 5057 5057 + .ready() 5058 5058 + .await 5059 5059 + .map_err(|e| { 5060 5060 + tonic::Status::unknown( 5061 5061 + format!("Service was not ready: {}", e.into()), 5062 5062 + ) 5063 5063 + })?; 4326 5064 let codec = tonic::codec::ProstCodec::default(); 4327 5065 let path = http::uri::PathAndQuery::from_static( 4328 5066 "/rockbox.v1alpha1.PlaylistService/InsertArtistTracks", 4329 5067 ); 4330 5068 let mut req = request.into_request(); 4331 4331 - req.extensions_mut().insert(GrpcMethod::new( 4332 4332 - "rockbox.v1alpha1.PlaylistService", 4333 4333 - "InsertArtistTracks", 4334 4334 - )); 5069 5069 + req.extensions_mut() 5070 5070 + .insert( 5071 5071 + GrpcMethod::new( 5072 5072 + "rockbox.v1alpha1.PlaylistService", 5073 5073 + "InsertArtistTracks", 5074 5074 + ), 5075 5075 + ); 4335 5076 self.inner.unary(req, path, codec).await 4336 5077 } 4337 5078 pub async fn shuffle_playlist( 4338 5079 &mut self, 4339 5080 request: impl tonic::IntoRequest<super::ShufflePlaylistRequest>, 4340 4340 - ) -> std::result::Result<tonic::Response<super::ShufflePlaylistResponse>, tonic::Status> 4341 4341 - { 4342 4342 - self.inner.ready().await.map_err(|e| { 4343 4343 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 4344 4344 - })?; 5081 5081 + ) -> std::result::Result< 5082 5082 + tonic::Response<super::ShufflePlaylistResponse>, 5083 5083 + tonic::Status, 5084 5084 + > { 5085 5085 + self.inner 5086 5086 + .ready() 5087 5087 + .await 5088 5088 + .map_err(|e| { 5089 5089 + tonic::Status::unknown( 5090 5090 + format!("Service was not ready: {}", e.into()), 5091 5091 + ) 5092 5092 + })?; 4345 5093 let codec = tonic::codec::ProstCodec::default(); 4346 5094 let path = http::uri::PathAndQuery::from_static( 4347 5095 "/rockbox.v1alpha1.PlaylistService/ShufflePlaylist", 4348 5096 ); 4349 5097 let mut req = request.into_request(); 4350 4350 - req.extensions_mut().insert(GrpcMethod::new( 4351 4351 - "rockbox.v1alpha1.PlaylistService", 4352 4352 - "ShufflePlaylist", 4353 4353 - )); 5098 5098 + req.extensions_mut() 5099 5099 + .insert( 5100 5100 + GrpcMethod::new( 5101 5101 + "rockbox.v1alpha1.PlaylistService", 5102 5102 + "ShufflePlaylist", 5103 5103 + ), 5104 5104 + ); 4354 5105 self.inner.unary(req, path, codec).await 4355 5106 } 4356 5107 } ··· 4362 5113 dead_code, 4363 5114 missing_docs, 4364 5115 clippy::wildcard_imports, 4365 4365 - clippy::let_unit_value 5116 5116 + clippy::let_unit_value, 4366 5117 )] 4367 5118 use tonic::codegen::*; 4368 5119 /// Generated trait containing gRPC methods that should be implemented for use with PlaylistServiceServer. ··· 4371 5122 async fn get_current( 4372 5123 &self, 4373 5124 request: tonic::Request<super::GetCurrentRequest>, 4374 4374 - ) -> std::result::Result<tonic::Response<super::GetCurrentResponse>, tonic::Status>; 5125 5125 + ) -> std::result::Result< 5126 5126 + tonic::Response<super::GetCurrentResponse>, 5127 5127 + tonic::Status, 5128 5128 + >; 4375 5129 async fn get_resume_info( 4376 5130 &self, 4377 5131 request: tonic::Request<super::GetResumeInfoRequest>, 4378 4378 - ) -> std::result::Result<tonic::Response<super::GetResumeInfoResponse>, tonic::Status>; 5132 5132 + ) -> std::result::Result< 5133 5133 + tonic::Response<super::GetResumeInfoResponse>, 5134 5134 + tonic::Status, 5135 5135 + >; 4379 5136 async fn get_track_info( 4380 5137 &self, 4381 5138 request: tonic::Request<super::GetTrackInfoRequest>, 4382 4382 - ) -> std::result::Result<tonic::Response<super::GetTrackInfoResponse>, tonic::Status>; 5139 5139 + ) -> std::result::Result< 5140 5140 + tonic::Response<super::GetTrackInfoResponse>, 5141 5141 + tonic::Status, 5142 5142 + >; 4383 5143 async fn get_first_index( 4384 5144 &self, 4385 5145 request: tonic::Request<super::GetFirstIndexRequest>, 4386 4386 - ) -> std::result::Result<tonic::Response<super::GetFirstIndexResponse>, tonic::Status>; 5146 5146 + ) -> std::result::Result< 5147 5147 + tonic::Response<super::GetFirstIndexResponse>, 5148 5148 + tonic::Status, 5149 5149 + >; 4387 5150 async fn get_display_index( 4388 5151 &self, 4389 5152 request: tonic::Request<super::GetDisplayIndexRequest>, 4390 4390 - ) -> std::result::Result<tonic::Response<super::GetDisplayIndexResponse>, tonic::Status>; 5153 5153 + ) -> std::result::Result< 5154 5154 + tonic::Response<super::GetDisplayIndexResponse>, 5155 5155 + tonic::Status, 5156 5156 + >; 4391 5157 async fn amount( 4392 5158 &self, 4393 5159 request: tonic::Request<super::AmountRequest>, ··· 4395 5161 async fn playlist_resume( 4396 5162 &self, 4397 5163 request: tonic::Request<super::PlaylistResumeRequest>, 4398 4398 - ) -> std::result::Result<tonic::Response<super::PlaylistResumeResponse>, tonic::Status>; 5164 5164 + ) -> std::result::Result< 5165 5165 + tonic::Response<super::PlaylistResumeResponse>, 5166 5166 + tonic::Status, 5167 5167 + >; 4399 5168 async fn resume_track( 4400 5169 &self, 4401 5170 request: tonic::Request<super::ResumeTrackRequest>, 4402 4402 - ) -> std::result::Result<tonic::Response<super::ResumeTrackResponse>, tonic::Status>; 5171 5171 + ) -> std::result::Result< 5172 5172 + tonic::Response<super::ResumeTrackResponse>, 5173 5173 + tonic::Status, 5174 5174 + >; 4403 5175 async fn set_modified( 4404 5176 &self, 4405 5177 request: tonic::Request<super::SetModifiedRequest>, 4406 4406 - ) -> std::result::Result<tonic::Response<super::SetModifiedResponse>, tonic::Status>; 5178 5178 + ) -> std::result::Result< 5179 5179 + tonic::Response<super::SetModifiedResponse>, 5180 5180 + tonic::Status, 5181 5181 + >; 4407 5182 async fn start( 4408 5183 &self, 4409 5184 request: tonic::Request<super::StartRequest>, ··· 4415 5190 async fn remove_all_tracks( 4416 5191 &self, 4417 5192 request: tonic::Request<super::RemoveAllTracksRequest>, 4418 4418 - ) -> std::result::Result<tonic::Response<super::RemoveAllTracksResponse>, tonic::Status>; 5193 5193 + ) -> std::result::Result< 5194 5194 + tonic::Response<super::RemoveAllTracksResponse>, 5195 5195 + tonic::Status, 5196 5196 + >; 4419 5197 async fn remove_tracks( 4420 5198 &self, 4421 5199 request: tonic::Request<super::RemoveTracksRequest>, 4422 4422 - ) -> std::result::Result<tonic::Response<super::RemoveTracksResponse>, tonic::Status>; 5200 5200 + ) -> std::result::Result< 5201 5201 + tonic::Response<super::RemoveTracksResponse>, 5202 5202 + tonic::Status, 5203 5203 + >; 4423 5204 async fn create_playlist( 4424 5205 &self, 4425 5206 request: tonic::Request<super::CreatePlaylistRequest>, 4426 4426 - ) -> std::result::Result<tonic::Response<super::CreatePlaylistResponse>, tonic::Status>; 5207 5207 + ) -> std::result::Result< 5208 5208 + tonic::Response<super::CreatePlaylistResponse>, 5209 5209 + tonic::Status, 5210 5210 + >; 4427 5211 async fn insert_tracks( 4428 5212 &self, 4429 5213 request: tonic::Request<super::InsertTracksRequest>, 4430 4430 - ) -> std::result::Result<tonic::Response<super::InsertTracksResponse>, tonic::Status>; 5214 5214 + ) -> std::result::Result< 5215 5215 + tonic::Response<super::InsertTracksResponse>, 5216 5216 + tonic::Status, 5217 5217 + >; 4431 5218 async fn insert_directory( 4432 5219 &self, 4433 5220 request: tonic::Request<super::InsertDirectoryRequest>, 4434 4434 - ) -> std::result::Result<tonic::Response<super::InsertDirectoryResponse>, tonic::Status>; 5221 5221 + ) -> std::result::Result< 5222 5222 + tonic::Response<super::InsertDirectoryResponse>, 5223 5223 + tonic::Status, 5224 5224 + >; 4435 5225 async fn insert_playlist( 4436 5226 &self, 4437 5227 request: tonic::Request<super::InsertPlaylistRequest>, 4438 4438 - ) -> std::result::Result<tonic::Response<super::InsertPlaylistResponse>, tonic::Status>; 5228 5228 + ) -> std::result::Result< 5229 5229 + tonic::Response<super::InsertPlaylistResponse>, 5230 5230 + tonic::Status, 5231 5231 + >; 4439 5232 async fn insert_album( 4440 5233 &self, 4441 5234 request: tonic::Request<super::InsertAlbumRequest>, 4442 4442 - ) -> std::result::Result<tonic::Response<super::InsertAlbumResponse>, tonic::Status>; 5235 5235 + ) -> std::result::Result< 5236 5236 + tonic::Response<super::InsertAlbumResponse>, 5237 5237 + tonic::Status, 5238 5238 + >; 4443 5239 async fn insert_artist_tracks( 4444 5240 &self, 4445 5241 request: tonic::Request<super::InsertArtistTracksRequest>, 4446 4446 - ) -> std::result::Result<tonic::Response<super::InsertArtistTracksResponse>, tonic::Status>; 5242 5242 + ) -> std::result::Result< 5243 5243 + tonic::Response<super::InsertArtistTracksResponse>, 5244 5244 + tonic::Status, 5245 5245 + >; 4447 5246 async fn shuffle_playlist( 4448 5247 &self, 4449 5248 request: tonic::Request<super::ShufflePlaylistRequest>, 4450 4450 - ) -> std::result::Result<tonic::Response<super::ShufflePlaylistResponse>, tonic::Status>; 5249 5249 + ) -> std::result::Result< 5250 5250 + tonic::Response<super::ShufflePlaylistResponse>, 5251 5251 + tonic::Status, 5252 5252 + >; 4451 5253 } 4452 5254 #[derive(Debug)] 4453 5255 pub struct PlaylistServiceServer<T> { ··· 4470 5272 max_encoding_message_size: None, 4471 5273 } 4472 5274 } 4473 4473 - pub fn with_interceptor<F>(inner: T, interceptor: F) -> InterceptedService<Self, F> 5275 5275 + pub fn with_interceptor<F>( 5276 5276 + inner: T, 5277 5277 + interceptor: F, 5278 5278 + ) -> InterceptedService<Self, F> 4474 5279 where 4475 5280 F: tonic::service::Interceptor, 4476 5281 { ··· 4525 5330 "/rockbox.v1alpha1.PlaylistService/GetCurrent" => { 4526 5331 #[allow(non_camel_case_types)] 4527 5332 struct GetCurrentSvc<T: PlaylistService>(pub Arc<T>); 4528 4528 - impl<T: PlaylistService> tonic::server::UnaryService<super::GetCurrentRequest> 4529 4529 - for GetCurrentSvc<T> 4530 4530 - { 5333 5333 + impl< 5334 5334 + T: PlaylistService, 5335 5335 + > tonic::server::UnaryService<super::GetCurrentRequest> 5336 5336 + for GetCurrentSvc<T> { 4531 5337 type Response = super::GetCurrentResponse; 4532 4532 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 5338 5338 + type Future = BoxFuture< 5339 5339 + tonic::Response<Self::Response>, 5340 5340 + tonic::Status, 5341 5341 + >; 4533 5342 fn call( 4534 5343 &mut self, 4535 5344 request: tonic::Request<super::GetCurrentRequest>, ··· 4566 5375 "/rockbox.v1alpha1.PlaylistService/GetResumeInfo" => { 4567 5376 #[allow(non_camel_case_types)] 4568 5377 struct GetResumeInfoSvc<T: PlaylistService>(pub Arc<T>); 4569 4569 - impl<T: PlaylistService> 4570 4570 - tonic::server::UnaryService<super::GetResumeInfoRequest> 4571 4571 - for GetResumeInfoSvc<T> 4572 4572 - { 5378 5378 + impl< 5379 5379 + T: PlaylistService, 5380 5380 + > tonic::server::UnaryService<super::GetResumeInfoRequest> 5381 5381 + for GetResumeInfoSvc<T> { 4573 5382 type Response = super::GetResumeInfoResponse; 4574 4574 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 5383 5383 + type Future = BoxFuture< 5384 5384 + tonic::Response<Self::Response>, 5385 5385 + tonic::Status, 5386 5386 + >; 4575 5387 fn call( 4576 5388 &mut self, 4577 5389 request: tonic::Request<super::GetResumeInfoRequest>, 4578 5390 ) -> Self::Future { 4579 5391 let inner = Arc::clone(&self.0); 4580 5392 let fut = async move { 4581 4581 - <T as PlaylistService>::get_resume_info(&inner, request).await 5393 5393 + <T as PlaylistService>::get_resume_info(&inner, request) 5394 5394 + .await 4582 5395 }; 4583 5396 Box::pin(fut) 4584 5397 } ··· 4608 5421 "/rockbox.v1alpha1.PlaylistService/GetTrackInfo" => { 4609 5422 #[allow(non_camel_case_types)] 4610 5423 struct GetTrackInfoSvc<T: PlaylistService>(pub Arc<T>); 4611 4611 - impl<T: PlaylistService> tonic::server::UnaryService<super::GetTrackInfoRequest> 4612 4612 - for GetTrackInfoSvc<T> 4613 4613 - { 5424 5424 + impl< 5425 5425 + T: PlaylistService, 5426 5426 + > tonic::server::UnaryService<super::GetTrackInfoRequest> 5427 5427 + for GetTrackInfoSvc<T> { 4614 5428 type Response = super::GetTrackInfoResponse; 4615 4615 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 5429 5429 + type Future = BoxFuture< 5430 5430 + tonic::Response<Self::Response>, 5431 5431 + tonic::Status, 5432 5432 + >; 4616 5433 fn call( 4617 5434 &mut self, 4618 5435 request: tonic::Request<super::GetTrackInfoRequest>, 4619 5436 ) -> Self::Future { 4620 5437 let inner = Arc::clone(&self.0); 4621 5438 let fut = async move { 4622 4622 - <T as PlaylistService>::get_track_info(&inner, request).await 5439 5439 + <T as PlaylistService>::get_track_info(&inner, request) 5440 5440 + .await 4623 5441 }; 4624 5442 Box::pin(fut) 4625 5443 } ··· 4649 5467 "/rockbox.v1alpha1.PlaylistService/GetFirstIndex" => { 4650 5468 #[allow(non_camel_case_types)] 4651 5469 struct GetFirstIndexSvc<T: PlaylistService>(pub Arc<T>); 4652 4652 - impl<T: PlaylistService> 4653 4653 - tonic::server::UnaryService<super::GetFirstIndexRequest> 4654 4654 - for GetFirstIndexSvc<T> 4655 4655 - { 5470 5470 + impl< 5471 5471 + T: PlaylistService, 5472 5472 + > tonic::server::UnaryService<super::GetFirstIndexRequest> 5473 5473 + for GetFirstIndexSvc<T> { 4656 5474 type Response = super::GetFirstIndexResponse; 4657 4657 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 5475 5475 + type Future = BoxFuture< 5476 5476 + tonic::Response<Self::Response>, 5477 5477 + tonic::Status, 5478 5478 + >; 4658 5479 fn call( 4659 5480 &mut self, 4660 5481 request: tonic::Request<super::GetFirstIndexRequest>, 4661 5482 ) -> Self::Future { 4662 5483 let inner = Arc::clone(&self.0); 4663 5484 let fut = async move { 4664 4664 - <T as PlaylistService>::get_first_index(&inner, request).await 5485 5485 + <T as PlaylistService>::get_first_index(&inner, request) 5486 5486 + .await 4665 5487 }; 4666 5488 Box::pin(fut) 4667 5489 } ··· 4691 5513 "/rockbox.v1alpha1.PlaylistService/GetDisplayIndex" => { 4692 5514 #[allow(non_camel_case_types)] 4693 5515 struct GetDisplayIndexSvc<T: PlaylistService>(pub Arc<T>); 4694 4694 - impl<T: PlaylistService> 4695 4695 - tonic::server::UnaryService<super::GetDisplayIndexRequest> 4696 4696 - for GetDisplayIndexSvc<T> 4697 4697 - { 5516 5516 + impl< 5517 5517 + T: PlaylistService, 5518 5518 + > tonic::server::UnaryService<super::GetDisplayIndexRequest> 5519 5519 + for GetDisplayIndexSvc<T> { 4698 5520 type Response = super::GetDisplayIndexResponse; 4699 4699 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 5521 5521 + type Future = BoxFuture< 5522 5522 + tonic::Response<Self::Response>, 5523 5523 + tonic::Status, 5524 5524 + >; 4700 5525 fn call( 4701 5526 &mut self, 4702 5527 request: tonic::Request<super::GetDisplayIndexRequest>, 4703 5528 ) -> Self::Future { 4704 5529 let inner = Arc::clone(&self.0); 4705 5530 let fut = async move { 4706 4706 - <T as PlaylistService>::get_display_index(&inner, request).await 5531 5531 + <T as PlaylistService>::get_display_index(&inner, request) 5532 5532 + .await 4707 5533 }; 4708 5534 Box::pin(fut) 4709 5535 } ··· 4733 5559 "/rockbox.v1alpha1.PlaylistService/Amount" => { 4734 5560 #[allow(non_camel_case_types)] 4735 5561 struct AmountSvc<T: PlaylistService>(pub Arc<T>); 4736 4736 - impl<T: PlaylistService> tonic::server::UnaryService<super::AmountRequest> for AmountSvc<T> { 5562 5562 + impl< 5563 5563 + T: PlaylistService, 5564 5564 + > tonic::server::UnaryService<super::AmountRequest> 5565 5565 + for AmountSvc<T> { 4737 5566 type Response = super::AmountResponse; 4738 4738 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 5567 5567 + type Future = BoxFuture< 5568 5568 + tonic::Response<Self::Response>, 5569 5569 + tonic::Status, 5570 5570 + >; 4739 5571 fn call( 4740 5572 &mut self, 4741 5573 request: tonic::Request<super::AmountRequest>, ··· 4772 5604 "/rockbox.v1alpha1.PlaylistService/PlaylistResume" => { 4773 5605 #[allow(non_camel_case_types)] 4774 5606 struct PlaylistResumeSvc<T: PlaylistService>(pub Arc<T>); 4775 4775 - impl<T: PlaylistService> 4776 4776 - tonic::server::UnaryService<super::PlaylistResumeRequest> 4777 4777 - for PlaylistResumeSvc<T> 4778 4778 - { 5607 5607 + impl< 5608 5608 + T: PlaylistService, 5609 5609 + > tonic::server::UnaryService<super::PlaylistResumeRequest> 5610 5610 + for PlaylistResumeSvc<T> { 4779 5611 type Response = super::PlaylistResumeResponse; 4780 4780 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 5612 5612 + type Future = BoxFuture< 5613 5613 + tonic::Response<Self::Response>, 5614 5614 + tonic::Status, 5615 5615 + >; 4781 5616 fn call( 4782 5617 &mut self, 4783 5618 request: tonic::Request<super::PlaylistResumeRequest>, 4784 5619 ) -> Self::Future { 4785 5620 let inner = Arc::clone(&self.0); 4786 5621 let fut = async move { 4787 4787 - <T as PlaylistService>::playlist_resume(&inner, request).await 5622 5622 + <T as PlaylistService>::playlist_resume(&inner, request) 5623 5623 + .await 4788 5624 }; 4789 5625 Box::pin(fut) 4790 5626 } ··· 4814 5650 "/rockbox.v1alpha1.PlaylistService/ResumeTrack" => { 4815 5651 #[allow(non_camel_case_types)] 4816 5652 struct ResumeTrackSvc<T: PlaylistService>(pub Arc<T>); 4817 4817 - impl<T: PlaylistService> tonic::server::UnaryService<super::ResumeTrackRequest> 4818 4818 - for ResumeTrackSvc<T> 4819 4819 - { 5653 5653 + impl< 5654 5654 + T: PlaylistService, 5655 5655 + > tonic::server::UnaryService<super::ResumeTrackRequest> 5656 5656 + for ResumeTrackSvc<T> { 4820 5657 type Response = super::ResumeTrackResponse; 4821 4821 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 5658 5658 + type Future = BoxFuture< 5659 5659 + tonic::Response<Self::Response>, 5660 5660 + tonic::Status, 5661 5661 + >; 4822 5662 fn call( 4823 5663 &mut self, 4824 5664 request: tonic::Request<super::ResumeTrackRequest>, ··· 4855 5695 "/rockbox.v1alpha1.PlaylistService/SetModified" => { 4856 5696 #[allow(non_camel_case_types)] 4857 5697 struct SetModifiedSvc<T: PlaylistService>(pub Arc<T>); 4858 4858 - impl<T: PlaylistService> tonic::server::UnaryService<super::SetModifiedRequest> 4859 4859 - for SetModifiedSvc<T> 4860 4860 - { 5698 5698 + impl< 5699 5699 + T: PlaylistService, 5700 5700 + > tonic::server::UnaryService<super::SetModifiedRequest> 5701 5701 + for SetModifiedSvc<T> { 4861 5702 type Response = super::SetModifiedResponse; 4862 4862 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 5703 5703 + type Future = BoxFuture< 5704 5704 + tonic::Response<Self::Response>, 5705 5705 + tonic::Status, 5706 5706 + >; 4863 5707 fn call( 4864 5708 &mut self, 4865 5709 request: tonic::Request<super::SetModifiedRequest>, ··· 4896 5740 "/rockbox.v1alpha1.PlaylistService/Start" => { 4897 5741 #[allow(non_camel_case_types)] 4898 5742 struct StartSvc<T: PlaylistService>(pub Arc<T>); 4899 4899 - impl<T: PlaylistService> tonic::server::UnaryService<super::StartRequest> for StartSvc<T> { 5743 5743 + impl< 5744 5744 + T: PlaylistService, 5745 5745 + > tonic::server::UnaryService<super::StartRequest> for StartSvc<T> { 4900 5746 type Response = super::StartResponse; 4901 4901 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 5747 5747 + type Future = BoxFuture< 5748 5748 + tonic::Response<Self::Response>, 5749 5749 + tonic::Status, 5750 5750 + >; 4902 5751 fn call( 4903 5752 &mut self, 4904 5753 request: tonic::Request<super::StartRequest>, 4905 5754 ) -> Self::Future { 4906 5755 let inner = Arc::clone(&self.0); 4907 4907 - let fut = 4908 4908 - async move { <T as PlaylistService>::start(&inner, request).await }; 5756 5756 + let fut = async move { 5757 5757 + <T as PlaylistService>::start(&inner, request).await 5758 5758 + }; 4909 5759 Box::pin(fut) 4910 5760 } 4911 5761 } ··· 4934 5784 "/rockbox.v1alpha1.PlaylistService/Sync" => { 4935 5785 #[allow(non_camel_case_types)] 4936 5786 struct SyncSvc<T: PlaylistService>(pub Arc<T>); 4937 4937 - impl<T: PlaylistService> tonic::server::UnaryService<super::SyncRequest> for SyncSvc<T> { 5787 5787 + impl< 5788 5788 + T: PlaylistService, 5789 5789 + > tonic::server::UnaryService<super::SyncRequest> for SyncSvc<T> { 4938 5790 type Response = super::SyncResponse; 4939 4939 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 5791 5791 + type Future = BoxFuture< 5792 5792 + tonic::Response<Self::Response>, 5793 5793 + tonic::Status, 5794 5794 + >; 4940 5795 fn call( 4941 5796 &mut self, 4942 5797 request: tonic::Request<super::SyncRequest>, 4943 5798 ) -> Self::Future { 4944 5799 let inner = Arc::clone(&self.0); 4945 4945 - let fut = 4946 4946 - async move { <T as PlaylistService>::sync(&inner, request).await }; 5800 5800 + let fut = async move { 5801 5801 + <T as PlaylistService>::sync(&inner, request).await 5802 5802 + }; 4947 5803 Box::pin(fut) 4948 5804 } 4949 5805 } ··· 4972 5828 "/rockbox.v1alpha1.PlaylistService/RemoveAllTracks" => { 4973 5829 #[allow(non_camel_case_types)] 4974 5830 struct RemoveAllTracksSvc<T: PlaylistService>(pub Arc<T>); 4975 4975 - impl<T: PlaylistService> 4976 4976 - tonic::server::UnaryService<super::RemoveAllTracksRequest> 4977 4977 - for RemoveAllTracksSvc<T> 4978 4978 - { 5831 5831 + impl< 5832 5832 + T: PlaylistService, 5833 5833 + > tonic::server::UnaryService<super::RemoveAllTracksRequest> 5834 5834 + for RemoveAllTracksSvc<T> { 4979 5835 type Response = super::RemoveAllTracksResponse; 4980 4980 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 5836 5836 + type Future = BoxFuture< 5837 5837 + tonic::Response<Self::Response>, 5838 5838 + tonic::Status, 5839 5839 + >; 4981 5840 fn call( 4982 5841 &mut self, 4983 5842 request: tonic::Request<super::RemoveAllTracksRequest>, 4984 5843 ) -> Self::Future { 4985 5844 let inner = Arc::clone(&self.0); 4986 5845 let fut = async move { 4987 4987 - <T as PlaylistService>::remove_all_tracks(&inner, request).await 5846 5846 + <T as PlaylistService>::remove_all_tracks(&inner, request) 5847 5847 + .await 4988 5848 }; 4989 5849 Box::pin(fut) 4990 5850 } ··· 5014 5874 "/rockbox.v1alpha1.PlaylistService/RemoveTracks" => { 5015 5875 #[allow(non_camel_case_types)] 5016 5876 struct RemoveTracksSvc<T: PlaylistService>(pub Arc<T>); 5017 5017 - impl<T: PlaylistService> tonic::server::UnaryService<super::RemoveTracksRequest> 5018 5018 - for RemoveTracksSvc<T> 5019 5019 - { 5877 5877 + impl< 5878 5878 + T: PlaylistService, 5879 5879 + > tonic::server::UnaryService<super::RemoveTracksRequest> 5880 5880 + for RemoveTracksSvc<T> { 5020 5881 type Response = super::RemoveTracksResponse; 5021 5021 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 5882 5882 + type Future = BoxFuture< 5883 5883 + tonic::Response<Self::Response>, 5884 5884 + tonic::Status, 5885 5885 + >; 5022 5886 fn call( 5023 5887 &mut self, 5024 5888 request: tonic::Request<super::RemoveTracksRequest>, ··· 5055 5919 "/rockbox.v1alpha1.PlaylistService/CreatePlaylist" => { 5056 5920 #[allow(non_camel_case_types)] 5057 5921 struct CreatePlaylistSvc<T: PlaylistService>(pub Arc<T>); 5058 5058 - impl<T: PlaylistService> 5059 5059 - tonic::server::UnaryService<super::CreatePlaylistRequest> 5060 5060 - for CreatePlaylistSvc<T> 5061 5061 - { 5922 5922 + impl< 5923 5923 + T: PlaylistService, 5924 5924 + > tonic::server::UnaryService<super::CreatePlaylistRequest> 5925 5925 + for CreatePlaylistSvc<T> { 5062 5926 type Response = super::CreatePlaylistResponse; 5063 5063 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 5927 5927 + type Future = BoxFuture< 5928 5928 + tonic::Response<Self::Response>, 5929 5929 + tonic::Status, 5930 5930 + >; 5064 5931 fn call( 5065 5932 &mut self, 5066 5933 request: tonic::Request<super::CreatePlaylistRequest>, 5067 5934 ) -> Self::Future { 5068 5935 let inner = Arc::clone(&self.0); 5069 5936 let fut = async move { 5070 5070 - <T as PlaylistService>::create_playlist(&inner, request).await 5937 5937 + <T as PlaylistService>::create_playlist(&inner, request) 5938 5938 + .await 5071 5939 }; 5072 5940 Box::pin(fut) 5073 5941 } ··· 5097 5965 "/rockbox.v1alpha1.PlaylistService/InsertTracks" => { 5098 5966 #[allow(non_camel_case_types)] 5099 5967 struct InsertTracksSvc<T: PlaylistService>(pub Arc<T>); 5100 5100 - impl<T: PlaylistService> tonic::server::UnaryService<super::InsertTracksRequest> 5101 5101 - for InsertTracksSvc<T> 5102 5102 - { 5968 5968 + impl< 5969 5969 + T: PlaylistService, 5970 5970 + > tonic::server::UnaryService<super::InsertTracksRequest> 5971 5971 + for InsertTracksSvc<T> { 5103 5972 type Response = super::InsertTracksResponse; 5104 5104 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 5973 5973 + type Future = BoxFuture< 5974 5974 + tonic::Response<Self::Response>, 5975 5975 + tonic::Status, 5976 5976 + >; 5105 5977 fn call( 5106 5978 &mut self, 5107 5979 request: tonic::Request<super::InsertTracksRequest>, ··· 5138 6010 "/rockbox.v1alpha1.PlaylistService/InsertDirectory" => { 5139 6011 #[allow(non_camel_case_types)] 5140 6012 struct InsertDirectorySvc<T: PlaylistService>(pub Arc<T>); 5141 5141 - impl<T: PlaylistService> 5142 5142 - tonic::server::UnaryService<super::InsertDirectoryRequest> 5143 5143 - for InsertDirectorySvc<T> 5144 5144 - { 6013 6013 + impl< 6014 6014 + T: PlaylistService, 6015 6015 + > tonic::server::UnaryService<super::InsertDirectoryRequest> 6016 6016 + for InsertDirectorySvc<T> { 5145 6017 type Response = super::InsertDirectoryResponse; 5146 5146 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 6018 6018 + type Future = BoxFuture< 6019 6019 + tonic::Response<Self::Response>, 6020 6020 + tonic::Status, 6021 6021 + >; 5147 6022 fn call( 5148 6023 &mut self, 5149 6024 request: tonic::Request<super::InsertDirectoryRequest>, 5150 6025 ) -> Self::Future { 5151 6026 let inner = Arc::clone(&self.0); 5152 6027 let fut = async move { 5153 5153 - <T as PlaylistService>::insert_directory(&inner, request).await 6028 6028 + <T as PlaylistService>::insert_directory(&inner, request) 6029 6029 + .await 5154 6030 }; 5155 6031 Box::pin(fut) 5156 6032 } ··· 5180 6056 "/rockbox.v1alpha1.PlaylistService/InsertPlaylist" => { 5181 6057 #[allow(non_camel_case_types)] 5182 6058 struct InsertPlaylistSvc<T: PlaylistService>(pub Arc<T>); 5183 5183 - impl<T: PlaylistService> 5184 5184 - tonic::server::UnaryService<super::InsertPlaylistRequest> 5185 5185 - for InsertPlaylistSvc<T> 5186 5186 - { 6059 6059 + impl< 6060 6060 + T: PlaylistService, 6061 6061 + > tonic::server::UnaryService<super::InsertPlaylistRequest> 6062 6062 + for InsertPlaylistSvc<T> { 5187 6063 type Response = super::InsertPlaylistResponse; 5188 5188 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 6064 6064 + type Future = BoxFuture< 6065 6065 + tonic::Response<Self::Response>, 6066 6066 + tonic::Status, 6067 6067 + >; 5189 6068 fn call( 5190 6069 &mut self, 5191 6070 request: tonic::Request<super::InsertPlaylistRequest>, 5192 6071 ) -> Self::Future { 5193 6072 let inner = Arc::clone(&self.0); 5194 6073 let fut = async move { 5195 5195 - <T as PlaylistService>::insert_playlist(&inner, request).await 6074 6074 + <T as PlaylistService>::insert_playlist(&inner, request) 6075 6075 + .await 5196 6076 }; 5197 6077 Box::pin(fut) 5198 6078 } ··· 5222 6102 "/rockbox.v1alpha1.PlaylistService/InsertAlbum" => { 5223 6103 #[allow(non_camel_case_types)] 5224 6104 struct InsertAlbumSvc<T: PlaylistService>(pub Arc<T>); 5225 5225 - impl<T: PlaylistService> tonic::server::UnaryService<super::InsertAlbumRequest> 5226 5226 - for InsertAlbumSvc<T> 5227 5227 - { 6105 6105 + impl< 6106 6106 + T: PlaylistService, 6107 6107 + > tonic::server::UnaryService<super::InsertAlbumRequest> 6108 6108 + for InsertAlbumSvc<T> { 5228 6109 type Response = super::InsertAlbumResponse; 5229 5229 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 6110 6110 + type Future = BoxFuture< 6111 6111 + tonic::Response<Self::Response>, 6112 6112 + tonic::Status, 6113 6113 + >; 5230 6114 fn call( 5231 6115 &mut self, 5232 6116 request: tonic::Request<super::InsertAlbumRequest>, ··· 5263 6147 "/rockbox.v1alpha1.PlaylistService/InsertArtistTracks" => { 5264 6148 #[allow(non_camel_case_types)] 5265 6149 struct InsertArtistTracksSvc<T: PlaylistService>(pub Arc<T>); 5266 5266 - impl<T: PlaylistService> 5267 5267 - tonic::server::UnaryService<super::InsertArtistTracksRequest> 5268 5268 - for InsertArtistTracksSvc<T> 5269 5269 - { 6150 6150 + impl< 6151 6151 + T: PlaylistService, 6152 6152 + > tonic::server::UnaryService<super::InsertArtistTracksRequest> 6153 6153 + for InsertArtistTracksSvc<T> { 5270 6154 type Response = super::InsertArtistTracksResponse; 5271 5271 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 6155 6155 + type Future = BoxFuture< 6156 6156 + tonic::Response<Self::Response>, 6157 6157 + tonic::Status, 6158 6158 + >; 5272 6159 fn call( 5273 6160 &mut self, 5274 6161 request: tonic::Request<super::InsertArtistTracksRequest>, 5275 6162 ) -> Self::Future { 5276 6163 let inner = Arc::clone(&self.0); 5277 6164 let fut = async move { 5278 5278 - <T as PlaylistService>::insert_artist_tracks(&inner, request).await 6165 6165 + <T as PlaylistService>::insert_artist_tracks( 6166 6166 + &inner, 6167 6167 + request, 6168 6168 + ) 6169 6169 + .await 5279 6170 }; 5280 6171 Box::pin(fut) 5281 6172 } ··· 5305 6196 "/rockbox.v1alpha1.PlaylistService/ShufflePlaylist" => { 5306 6197 #[allow(non_camel_case_types)] 5307 6198 struct ShufflePlaylistSvc<T: PlaylistService>(pub Arc<T>); 5308 5308 - impl<T: PlaylistService> 5309 5309 - tonic::server::UnaryService<super::ShufflePlaylistRequest> 5310 5310 - for ShufflePlaylistSvc<T> 5311 5311 - { 6199 6199 + impl< 6200 6200 + T: PlaylistService, 6201 6201 + > tonic::server::UnaryService<super::ShufflePlaylistRequest> 6202 6202 + for ShufflePlaylistSvc<T> { 5312 6203 type Response = super::ShufflePlaylistResponse; 5313 5313 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 6204 6204 + type Future = BoxFuture< 6205 6205 + tonic::Response<Self::Response>, 6206 6206 + tonic::Status, 6207 6207 + >; 5314 6208 fn call( 5315 6209 &mut self, 5316 6210 request: tonic::Request<super::ShufflePlaylistRequest>, 5317 6211 ) -> Self::Future { 5318 6212 let inner = Arc::clone(&self.0); 5319 6213 let fut = async move { 5320 5320 - <T as PlaylistService>::shuffle_playlist(&inner, request).await 6214 6214 + <T as PlaylistService>::shuffle_playlist(&inner, request) 6215 6215 + .await 5321 6216 }; 5322 6217 Box::pin(fut) 5323 6218 } ··· 5344 6239 }; 5345 6240 Box::pin(fut) 5346 6241 } 5347 5347 - _ => Box::pin(async move { 5348 5348 - let mut response = http::Response::new(empty_body()); 5349 5349 - let headers = response.headers_mut(); 5350 5350 - headers.insert( 5351 5351 - tonic::Status::GRPC_STATUS, 5352 5352 - (tonic::Code::Unimplemented as i32).into(), 5353 5353 - ); 5354 5354 - headers.insert( 5355 5355 - http::header::CONTENT_TYPE, 5356 5356 - tonic::metadata::GRPC_CONTENT_TYPE, 5357 5357 - ); 5358 5358 - Ok(response) 5359 5359 - }), 6242 6242 + _ => { 6243 6243 + Box::pin(async move { 6244 6244 + let mut response = http::Response::new(empty_body()); 6245 6245 + let headers = response.headers_mut(); 6246 6246 + headers 6247 6247 + .insert( 6248 6248 + tonic::Status::GRPC_STATUS, 6249 6249 + (tonic::Code::Unimplemented as i32).into(), 6250 6250 + ); 6251 6251 + headers 6252 6252 + .insert( 6253 6253 + http::header::CONTENT_TYPE, 6254 6254 + tonic::metadata::GRPC_CONTENT_TYPE, 6255 6255 + ); 6256 6256 + Ok(response) 6257 6257 + }) 6258 6258 + } 5360 6259 } 5361 6260 } 5362 6261 } ··· 5864 6763 dead_code, 5865 6764 missing_docs, 5866 6765 clippy::wildcard_imports, 5867 5867 - clippy::let_unit_value 6766 6766 + clippy::let_unit_value, 5868 6767 )] 5869 5869 - use tonic::codegen::http::Uri; 5870 6768 use tonic::codegen::*; 6769 6769 + use tonic::codegen::http::Uri; 5871 6770 #[derive(Debug, Clone)] 5872 6771 pub struct SettingsServiceClient<T> { 5873 6772 inner: tonic::client::Grpc<T>, ··· 5911 6810 <T as tonic::client::GrpcService<tonic::body::BoxBody>>::ResponseBody, 5912 6811 >, 5913 6812 >, 5914 5914 - <T as tonic::codegen::Service<http::Request<tonic::body::BoxBody>>>::Error: 5915 5915 - Into<StdError> + std::marker::Send + std::marker::Sync, 6813 6813 + <T as tonic::codegen::Service< 6814 6814 + http::Request<tonic::body::BoxBody>, 6815 6815 + >>::Error: Into<StdError> + std::marker::Send + std::marker::Sync, 5916 6816 { 5917 6817 SettingsServiceClient::new(InterceptedService::new(inner, interceptor)) 5918 6818 } ··· 5950 6850 pub async fn get_settings_list( 5951 6851 &mut self, 5952 6852 request: impl tonic::IntoRequest<super::GetSettingsListRequest>, 5953 5953 - ) -> std::result::Result<tonic::Response<super::GetSettingsListResponse>, tonic::Status> 5954 5954 - { 5955 5955 - self.inner.ready().await.map_err(|e| { 5956 5956 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 5957 5957 - })?; 6853 6853 + ) -> std::result::Result< 6854 6854 + tonic::Response<super::GetSettingsListResponse>, 6855 6855 + tonic::Status, 6856 6856 + > { 6857 6857 + self.inner 6858 6858 + .ready() 6859 6859 + .await 6860 6860 + .map_err(|e| { 6861 6861 + tonic::Status::unknown( 6862 6862 + format!("Service was not ready: {}", e.into()), 6863 6863 + ) 6864 6864 + })?; 5958 6865 let codec = tonic::codec::ProstCodec::default(); 5959 6866 let path = http::uri::PathAndQuery::from_static( 5960 6867 "/rockbox.v1alpha1.SettingsService/GetSettingsList", 5961 6868 ); 5962 6869 let mut req = request.into_request(); 5963 5963 - req.extensions_mut().insert(GrpcMethod::new( 5964 5964 - "rockbox.v1alpha1.SettingsService", 5965 5965 - "GetSettingsList", 5966 5966 - )); 6870 6870 + req.extensions_mut() 6871 6871 + .insert( 6872 6872 + GrpcMethod::new( 6873 6873 + "rockbox.v1alpha1.SettingsService", 6874 6874 + "GetSettingsList", 6875 6875 + ), 6876 6876 + ); 5967 6877 self.inner.unary(req, path, codec).await 5968 6878 } 5969 6879 pub async fn get_global_settings( 5970 6880 &mut self, 5971 6881 request: impl tonic::IntoRequest<super::GetGlobalSettingsRequest>, 5972 5972 - ) -> std::result::Result<tonic::Response<super::GetGlobalSettingsResponse>, tonic::Status> 5973 5973 - { 5974 5974 - self.inner.ready().await.map_err(|e| { 5975 5975 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 5976 5976 - })?; 6882 6882 + ) -> std::result::Result< 6883 6883 + tonic::Response<super::GetGlobalSettingsResponse>, 6884 6884 + tonic::Status, 6885 6885 + > { 6886 6886 + self.inner 6887 6887 + .ready() 6888 6888 + .await 6889 6889 + .map_err(|e| { 6890 6890 + tonic::Status::unknown( 6891 6891 + format!("Service was not ready: {}", e.into()), 6892 6892 + ) 6893 6893 + })?; 5977 6894 let codec = tonic::codec::ProstCodec::default(); 5978 6895 let path = http::uri::PathAndQuery::from_static( 5979 6896 "/rockbox.v1alpha1.SettingsService/GetGlobalSettings", 5980 6897 ); 5981 6898 let mut req = request.into_request(); 5982 5982 - req.extensions_mut().insert(GrpcMethod::new( 5983 5983 - "rockbox.v1alpha1.SettingsService", 5984 5984 - "GetGlobalSettings", 5985 5985 - )); 6899 6899 + req.extensions_mut() 6900 6900 + .insert( 6901 6901 + GrpcMethod::new( 6902 6902 + "rockbox.v1alpha1.SettingsService", 6903 6903 + "GetGlobalSettings", 6904 6904 + ), 6905 6905 + ); 5986 6906 self.inner.unary(req, path, codec).await 5987 6907 } 5988 6908 pub async fn save_settings( 5989 6909 &mut self, 5990 6910 request: impl tonic::IntoRequest<super::SaveSettingsRequest>, 5991 5991 - ) -> std::result::Result<tonic::Response<super::SaveSettingsResponse>, tonic::Status> 5992 5992 - { 5993 5993 - self.inner.ready().await.map_err(|e| { 5994 5994 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 5995 5995 - })?; 6911 6911 + ) -> std::result::Result< 6912 6912 + tonic::Response<super::SaveSettingsResponse>, 6913 6913 + tonic::Status, 6914 6914 + > { 6915 6915 + self.inner 6916 6916 + .ready() 6917 6917 + .await 6918 6918 + .map_err(|e| { 6919 6919 + tonic::Status::unknown( 6920 6920 + format!("Service was not ready: {}", e.into()), 6921 6921 + ) 6922 6922 + })?; 5996 6923 let codec = tonic::codec::ProstCodec::default(); 5997 6924 let path = http::uri::PathAndQuery::from_static( 5998 6925 "/rockbox.v1alpha1.SettingsService/SaveSettings", 5999 6926 ); 6000 6927 let mut req = request.into_request(); 6001 6001 - req.extensions_mut().insert(GrpcMethod::new( 6002 6002 - "rockbox.v1alpha1.SettingsService", 6003 6003 - "SaveSettings", 6004 6004 - )); 6928 6928 + req.extensions_mut() 6929 6929 + .insert( 6930 6930 + GrpcMethod::new("rockbox.v1alpha1.SettingsService", "SaveSettings"), 6931 6931 + ); 6005 6932 self.inner.unary(req, path, codec).await 6006 6933 } 6007 6934 } ··· 6013 6940 dead_code, 6014 6941 missing_docs, 6015 6942 clippy::wildcard_imports, 6016 6016 - clippy::let_unit_value 6943 6943 + clippy::let_unit_value, 6017 6944 )] 6018 6945 use tonic::codegen::*; 6019 6946 /// Generated trait containing gRPC methods that should be implemented for use with SettingsServiceServer. ··· 6022 6949 async fn get_settings_list( 6023 6950 &self, 6024 6951 request: tonic::Request<super::GetSettingsListRequest>, 6025 6025 - ) -> std::result::Result<tonic::Response<super::GetSettingsListResponse>, tonic::Status>; 6952 6952 + ) -> std::result::Result< 6953 6953 + tonic::Response<super::GetSettingsListResponse>, 6954 6954 + tonic::Status, 6955 6955 + >; 6026 6956 async fn get_global_settings( 6027 6957 &self, 6028 6958 request: tonic::Request<super::GetGlobalSettingsRequest>, 6029 6029 - ) -> std::result::Result<tonic::Response<super::GetGlobalSettingsResponse>, tonic::Status>; 6959 6959 + ) -> std::result::Result< 6960 6960 + tonic::Response<super::GetGlobalSettingsResponse>, 6961 6961 + tonic::Status, 6962 6962 + >; 6030 6963 async fn save_settings( 6031 6964 &self, 6032 6965 request: tonic::Request<super::SaveSettingsRequest>, 6033 6033 - ) -> std::result::Result<tonic::Response<super::SaveSettingsResponse>, tonic::Status>; 6966 6966 + ) -> std::result::Result< 6967 6967 + tonic::Response<super::SaveSettingsResponse>, 6968 6968 + tonic::Status, 6969 6969 + >; 6034 6970 } 6035 6971 #[derive(Debug)] 6036 6972 pub struct SettingsServiceServer<T> { ··· 6053 6989 max_encoding_message_size: None, 6054 6990 } 6055 6991 } 6056 6056 - pub fn with_interceptor<F>(inner: T, interceptor: F) -> InterceptedService<Self, F> 6992 6992 + pub fn with_interceptor<F>( 6993 6993 + inner: T, 6994 6994 + interceptor: F, 6995 6995 + ) -> InterceptedService<Self, F> 6057 6996 where 6058 6997 F: tonic::service::Interceptor, 6059 6998 { ··· 6108 7047 "/rockbox.v1alpha1.SettingsService/GetSettingsList" => { 6109 7048 #[allow(non_camel_case_types)] 6110 7049 struct GetSettingsListSvc<T: SettingsService>(pub Arc<T>); 6111 6111 - impl<T: SettingsService> 6112 6112 - tonic::server::UnaryService<super::GetSettingsListRequest> 6113 6113 - for GetSettingsListSvc<T> 6114 6114 - { 7050 7050 + impl< 7051 7051 + T: SettingsService, 7052 7052 + > tonic::server::UnaryService<super::GetSettingsListRequest> 7053 7053 + for GetSettingsListSvc<T> { 6115 7054 type Response = super::GetSettingsListResponse; 6116 6116 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 7055 7055 + type Future = BoxFuture< 7056 7056 + tonic::Response<Self::Response>, 7057 7057 + tonic::Status, 7058 7058 + >; 6117 7059 fn call( 6118 7060 &mut self, 6119 7061 request: tonic::Request<super::GetSettingsListRequest>, 6120 7062 ) -> Self::Future { 6121 7063 let inner = Arc::clone(&self.0); 6122 7064 let fut = async move { 6123 6123 - <T as SettingsService>::get_settings_list(&inner, request).await 7065 7065 + <T as SettingsService>::get_settings_list(&inner, request) 7066 7066 + .await 6124 7067 }; 6125 7068 Box::pin(fut) 6126 7069 } ··· 6150 7093 "/rockbox.v1alpha1.SettingsService/GetGlobalSettings" => { 6151 7094 #[allow(non_camel_case_types)] 6152 7095 struct GetGlobalSettingsSvc<T: SettingsService>(pub Arc<T>); 6153 6153 - impl<T: SettingsService> 6154 6154 - tonic::server::UnaryService<super::GetGlobalSettingsRequest> 6155 6155 - for GetGlobalSettingsSvc<T> 6156 6156 - { 7096 7096 + impl< 7097 7097 + T: SettingsService, 7098 7098 + > tonic::server::UnaryService<super::GetGlobalSettingsRequest> 7099 7099 + for GetGlobalSettingsSvc<T> { 6157 7100 type Response = super::GetGlobalSettingsResponse; 6158 6158 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 7101 7101 + type Future = BoxFuture< 7102 7102 + tonic::Response<Self::Response>, 7103 7103 + tonic::Status, 7104 7104 + >; 6159 7105 fn call( 6160 7106 &mut self, 6161 7107 request: tonic::Request<super::GetGlobalSettingsRequest>, 6162 7108 ) -> Self::Future { 6163 7109 let inner = Arc::clone(&self.0); 6164 7110 let fut = async move { 6165 6165 - <T as SettingsService>::get_global_settings(&inner, request).await 7111 7111 + <T as SettingsService>::get_global_settings(&inner, request) 7112 7112 + .await 6166 7113 }; 6167 7114 Box::pin(fut) 6168 7115 } ··· 6192 7139 "/rockbox.v1alpha1.SettingsService/SaveSettings" => { 6193 7140 #[allow(non_camel_case_types)] 6194 7141 struct SaveSettingsSvc<T: SettingsService>(pub Arc<T>); 6195 6195 - impl<T: SettingsService> tonic::server::UnaryService<super::SaveSettingsRequest> 6196 6196 - for SaveSettingsSvc<T> 6197 6197 - { 7142 7142 + impl< 7143 7143 + T: SettingsService, 7144 7144 + > tonic::server::UnaryService<super::SaveSettingsRequest> 7145 7145 + for SaveSettingsSvc<T> { 6198 7146 type Response = super::SaveSettingsResponse; 6199 6199 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 7147 7147 + type Future = BoxFuture< 7148 7148 + tonic::Response<Self::Response>, 7149 7149 + tonic::Status, 7150 7150 + >; 6200 7151 fn call( 6201 7152 &mut self, 6202 7153 request: tonic::Request<super::SaveSettingsRequest>, ··· 6230 7181 }; 6231 7182 Box::pin(fut) 6232 7183 } 6233 6233 - _ => Box::pin(async move { 6234 6234 - let mut response = http::Response::new(empty_body()); 6235 6235 - let headers = response.headers_mut(); 6236 6236 - headers.insert( 6237 6237 - tonic::Status::GRPC_STATUS, 6238 6238 - (tonic::Code::Unimplemented as i32).into(), 6239 6239 - ); 6240 6240 - headers.insert( 6241 6241 - http::header::CONTENT_TYPE, 6242 6242 - tonic::metadata::GRPC_CONTENT_TYPE, 6243 6243 - ); 6244 6244 - Ok(response) 6245 6245 - }), 7184 7184 + _ => { 7185 7185 + Box::pin(async move { 7186 7186 + let mut response = http::Response::new(empty_body()); 7187 7187 + let headers = response.headers_mut(); 7188 7188 + headers 7189 7189 + .insert( 7190 7190 + tonic::Status::GRPC_STATUS, 7191 7191 + (tonic::Code::Unimplemented as i32).into(), 7192 7192 + ); 7193 7193 + headers 7194 7194 + .insert( 7195 7195 + http::header::CONTENT_TYPE, 7196 7196 + tonic::metadata::GRPC_CONTENT_TYPE, 7197 7197 + ); 7198 7198 + Ok(response) 7199 7199 + }) 7200 7200 + } 6246 7201 } 6247 7202 } 6248 7203 } ··· 6400 7355 dead_code, 6401 7356 missing_docs, 6402 7357 clippy::wildcard_imports, 6403 6403 - clippy::let_unit_value 7358 7358 + clippy::let_unit_value, 6404 7359 )] 6405 6405 - use tonic::codegen::http::Uri; 6406 7360 use tonic::codegen::*; 7361 7361 + use tonic::codegen::http::Uri; 6407 7362 #[derive(Debug, Clone)] 6408 7363 pub struct SoundServiceClient<T> { 6409 7364 inner: tonic::client::Grpc<T>, ··· 6447 7402 <T as tonic::client::GrpcService<tonic::body::BoxBody>>::ResponseBody, 6448 7403 >, 6449 7404 >, 6450 6450 - <T as tonic::codegen::Service<http::Request<tonic::body::BoxBody>>>::Error: 6451 6451 - Into<StdError> + std::marker::Send + std::marker::Sync, 7405 7405 + <T as tonic::codegen::Service< 7406 7406 + http::Request<tonic::body::BoxBody>, 7407 7407 + >>::Error: Into<StdError> + std::marker::Send + std::marker::Sync, 6452 7408 { 6453 7409 SoundServiceClient::new(InterceptedService::new(inner, interceptor)) 6454 7410 } ··· 6486 7442 pub async fn adjust_volume( 6487 7443 &mut self, 6488 7444 request: impl tonic::IntoRequest<super::AdjustVolumeRequest>, 6489 6489 - ) -> std::result::Result<tonic::Response<super::AdjustVolumeResponse>, tonic::Status> 6490 6490 - { 6491 6491 - self.inner.ready().await.map_err(|e| { 6492 6492 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 6493 6493 - })?; 7445 7445 + ) -> std::result::Result< 7446 7446 + tonic::Response<super::AdjustVolumeResponse>, 7447 7447 + tonic::Status, 7448 7448 + > { 7449 7449 + self.inner 7450 7450 + .ready() 7451 7451 + .await 7452 7452 + .map_err(|e| { 7453 7453 + tonic::Status::unknown( 7454 7454 + format!("Service was not ready: {}", e.into()), 7455 7455 + ) 7456 7456 + })?; 6494 7457 let codec = tonic::codec::ProstCodec::default(); 6495 6495 - let path = 6496 6496 - http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.SoundService/AdjustVolume"); 7458 7458 + let path = http::uri::PathAndQuery::from_static( 7459 7459 + "/rockbox.v1alpha1.SoundService/AdjustVolume", 7460 7460 + ); 6497 7461 let mut req = request.into_request(); 6498 6498 - req.extensions_mut().insert(GrpcMethod::new( 6499 6499 - "rockbox.v1alpha1.SoundService", 6500 6500 - "AdjustVolume", 6501 6501 - )); 7462 7462 + req.extensions_mut() 7463 7463 + .insert( 7464 7464 + GrpcMethod::new("rockbox.v1alpha1.SoundService", "AdjustVolume"), 7465 7465 + ); 6502 7466 self.inner.unary(req, path, codec).await 6503 7467 } 6504 7468 pub async fn sound_set( 6505 7469 &mut self, 6506 7470 request: impl tonic::IntoRequest<super::SoundSetRequest>, 6507 6507 - ) -> std::result::Result<tonic::Response<super::SoundSetResponse>, tonic::Status> { 6508 6508 - self.inner.ready().await.map_err(|e| { 6509 6509 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 6510 6510 - })?; 7471 7471 + ) -> std::result::Result< 7472 7472 + tonic::Response<super::SoundSetResponse>, 7473 7473 + tonic::Status, 7474 7474 + > { 7475 7475 + self.inner 7476 7476 + .ready() 7477 7477 + .await 7478 7478 + .map_err(|e| { 7479 7479 + tonic::Status::unknown( 7480 7480 + format!("Service was not ready: {}", e.into()), 7481 7481 + ) 7482 7482 + })?; 6511 7483 let codec = tonic::codec::ProstCodec::default(); 6512 6512 - let path = 6513 6513 - http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.SoundService/SoundSet"); 7484 7484 + let path = http::uri::PathAndQuery::from_static( 7485 7485 + "/rockbox.v1alpha1.SoundService/SoundSet", 7486 7486 + ); 6514 7487 let mut req = request.into_request(); 6515 7488 req.extensions_mut() 6516 7489 .insert(GrpcMethod::new("rockbox.v1alpha1.SoundService", "SoundSet")); ··· 6519 7492 pub async fn sound_current( 6520 7493 &mut self, 6521 7494 request: impl tonic::IntoRequest<super::SoundCurrentRequest>, 6522 6522 - ) -> std::result::Result<tonic::Response<super::SoundCurrentResponse>, tonic::Status> 6523 6523 - { 6524 6524 - self.inner.ready().await.map_err(|e| { 6525 6525 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 6526 6526 - })?; 7495 7495 + ) -> std::result::Result< 7496 7496 + tonic::Response<super::SoundCurrentResponse>, 7497 7497 + tonic::Status, 7498 7498 + > { 7499 7499 + self.inner 7500 7500 + .ready() 7501 7501 + .await 7502 7502 + .map_err(|e| { 7503 7503 + tonic::Status::unknown( 7504 7504 + format!("Service was not ready: {}", e.into()), 7505 7505 + ) 7506 7506 + })?; 6527 7507 let codec = tonic::codec::ProstCodec::default(); 6528 6528 - let path = 6529 6529 - http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.SoundService/SoundCurrent"); 7508 7508 + let path = http::uri::PathAndQuery::from_static( 7509 7509 + "/rockbox.v1alpha1.SoundService/SoundCurrent", 7510 7510 + ); 6530 7511 let mut req = request.into_request(); 6531 6531 - req.extensions_mut().insert(GrpcMethod::new( 6532 6532 - "rockbox.v1alpha1.SoundService", 6533 6533 - "SoundCurrent", 6534 6534 - )); 7512 7512 + req.extensions_mut() 7513 7513 + .insert( 7514 7514 + GrpcMethod::new("rockbox.v1alpha1.SoundService", "SoundCurrent"), 7515 7515 + ); 6535 7516 self.inner.unary(req, path, codec).await 6536 7517 } 6537 7518 pub async fn sound_default( 6538 7519 &mut self, 6539 7520 request: impl tonic::IntoRequest<super::SoundDefaultRequest>, 6540 6540 - ) -> std::result::Result<tonic::Response<super::SoundDefaultResponse>, tonic::Status> 6541 6541 - { 6542 6542 - self.inner.ready().await.map_err(|e| { 6543 6543 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 6544 6544 - })?; 7521 7521 + ) -> std::result::Result< 7522 7522 + tonic::Response<super::SoundDefaultResponse>, 7523 7523 + tonic::Status, 7524 7524 + > { 7525 7525 + self.inner 7526 7526 + .ready() 7527 7527 + .await 7528 7528 + .map_err(|e| { 7529 7529 + tonic::Status::unknown( 7530 7530 + format!("Service was not ready: {}", e.into()), 7531 7531 + ) 7532 7532 + })?; 6545 7533 let codec = tonic::codec::ProstCodec::default(); 6546 6546 - let path = 6547 6547 - http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.SoundService/SoundDefault"); 7534 7534 + let path = http::uri::PathAndQuery::from_static( 7535 7535 + "/rockbox.v1alpha1.SoundService/SoundDefault", 7536 7536 + ); 6548 7537 let mut req = request.into_request(); 6549 6549 - req.extensions_mut().insert(GrpcMethod::new( 6550 6550 - "rockbox.v1alpha1.SoundService", 6551 6551 - "SoundDefault", 6552 6552 - )); 7538 7538 + req.extensions_mut() 7539 7539 + .insert( 7540 7540 + GrpcMethod::new("rockbox.v1alpha1.SoundService", "SoundDefault"), 7541 7541 + ); 6553 7542 self.inner.unary(req, path, codec).await 6554 7543 } 6555 7544 pub async fn sound_min( 6556 7545 &mut self, 6557 7546 request: impl tonic::IntoRequest<super::SoundMinRequest>, 6558 6558 - ) -> std::result::Result<tonic::Response<super::SoundMinResponse>, tonic::Status> { 6559 6559 - self.inner.ready().await.map_err(|e| { 6560 6560 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 6561 6561 - })?; 7547 7547 + ) -> std::result::Result< 7548 7548 + tonic::Response<super::SoundMinResponse>, 7549 7549 + tonic::Status, 7550 7550 + > { 7551 7551 + self.inner 7552 7552 + .ready() 7553 7553 + .await 7554 7554 + .map_err(|e| { 7555 7555 + tonic::Status::unknown( 7556 7556 + format!("Service was not ready: {}", e.into()), 7557 7557 + ) 7558 7558 + })?; 6562 7559 let codec = tonic::codec::ProstCodec::default(); 6563 6563 - let path = 6564 6564 - http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.SoundService/SoundMin"); 7560 7560 + let path = http::uri::PathAndQuery::from_static( 7561 7561 + "/rockbox.v1alpha1.SoundService/SoundMin", 7562 7562 + ); 6565 7563 let mut req = request.into_request(); 6566 7564 req.extensions_mut() 6567 7565 .insert(GrpcMethod::new("rockbox.v1alpha1.SoundService", "SoundMin")); ··· 6570 7568 pub async fn sound_max( 6571 7569 &mut self, 6572 7570 request: impl tonic::IntoRequest<super::SoundMaxRequest>, 6573 6573 - ) -> std::result::Result<tonic::Response<super::SoundMaxResponse>, tonic::Status> { 6574 6574 - self.inner.ready().await.map_err(|e| { 6575 6575 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 6576 6576 - })?; 7571 7571 + ) -> std::result::Result< 7572 7572 + tonic::Response<super::SoundMaxResponse>, 7573 7573 + tonic::Status, 7574 7574 + > { 7575 7575 + self.inner 7576 7576 + .ready() 7577 7577 + .await 7578 7578 + .map_err(|e| { 7579 7579 + tonic::Status::unknown( 7580 7580 + format!("Service was not ready: {}", e.into()), 7581 7581 + ) 7582 7582 + })?; 6577 7583 let codec = tonic::codec::ProstCodec::default(); 6578 6578 - let path = 6579 6579 - http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.SoundService/SoundMax"); 7584 7584 + let path = http::uri::PathAndQuery::from_static( 7585 7585 + "/rockbox.v1alpha1.SoundService/SoundMax", 7586 7586 + ); 6580 7587 let mut req = request.into_request(); 6581 7588 req.extensions_mut() 6582 7589 .insert(GrpcMethod::new("rockbox.v1alpha1.SoundService", "SoundMax")); ··· 6585 7592 pub async fn sound_unit( 6586 7593 &mut self, 6587 7594 request: impl tonic::IntoRequest<super::SoundUnitRequest>, 6588 6588 - ) -> std::result::Result<tonic::Response<super::SoundUnitResponse>, tonic::Status> { 6589 6589 - self.inner.ready().await.map_err(|e| { 6590 6590 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 6591 6591 - })?; 7595 7595 + ) -> std::result::Result< 7596 7596 + tonic::Response<super::SoundUnitResponse>, 7597 7597 + tonic::Status, 7598 7598 + > { 7599 7599 + self.inner 7600 7600 + .ready() 7601 7601 + .await 7602 7602 + .map_err(|e| { 7603 7603 + tonic::Status::unknown( 7604 7604 + format!("Service was not ready: {}", e.into()), 7605 7605 + ) 7606 7606 + })?; 6592 7607 let codec = tonic::codec::ProstCodec::default(); 6593 6593 - let path = 6594 6594 - http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.SoundService/SoundUnit"); 7608 7608 + let path = http::uri::PathAndQuery::from_static( 7609 7609 + "/rockbox.v1alpha1.SoundService/SoundUnit", 7610 7610 + ); 6595 7611 let mut req = request.into_request(); 6596 6596 - req.extensions_mut().insert(GrpcMethod::new( 6597 6597 - "rockbox.v1alpha1.SoundService", 6598 6598 - "SoundUnit", 6599 6599 - )); 7612 7612 + req.extensions_mut() 7613 7613 + .insert(GrpcMethod::new("rockbox.v1alpha1.SoundService", "SoundUnit")); 6600 7614 self.inner.unary(req, path, codec).await 6601 7615 } 6602 7616 pub async fn sound_val2_phys( 6603 7617 &mut self, 6604 7618 request: impl tonic::IntoRequest<super::SoundVal2PhysRequest>, 6605 6605 - ) -> std::result::Result<tonic::Response<super::SoundVal2PhysResponse>, tonic::Status> 6606 6606 - { 6607 6607 - self.inner.ready().await.map_err(|e| { 6608 6608 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 6609 6609 - })?; 7619 7619 + ) -> std::result::Result< 7620 7620 + tonic::Response<super::SoundVal2PhysResponse>, 7621 7621 + tonic::Status, 7622 7622 + > { 7623 7623 + self.inner 7624 7624 + .ready() 7625 7625 + .await 7626 7626 + .map_err(|e| { 7627 7627 + tonic::Status::unknown( 7628 7628 + format!("Service was not ready: {}", e.into()), 7629 7629 + ) 7630 7630 + })?; 6610 7631 let codec = tonic::codec::ProstCodec::default(); 6611 7632 let path = http::uri::PathAndQuery::from_static( 6612 7633 "/rockbox.v1alpha1.SoundService/SoundVal2Phys", 6613 7634 ); 6614 7635 let mut req = request.into_request(); 6615 6615 - req.extensions_mut().insert(GrpcMethod::new( 6616 6616 - "rockbox.v1alpha1.SoundService", 6617 6617 - "SoundVal2Phys", 6618 6618 - )); 7636 7636 + req.extensions_mut() 7637 7637 + .insert( 7638 7638 + GrpcMethod::new("rockbox.v1alpha1.SoundService", "SoundVal2Phys"), 7639 7639 + ); 6619 7640 self.inner.unary(req, path, codec).await 6620 7641 } 6621 7642 pub async fn get_pitch( 6622 7643 &mut self, 6623 7644 request: impl tonic::IntoRequest<super::GetPitchRequest>, 6624 6624 - ) -> std::result::Result<tonic::Response<super::GetPitchResponse>, tonic::Status> { 6625 6625 - self.inner.ready().await.map_err(|e| { 6626 6626 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 6627 6627 - })?; 7645 7645 + ) -> std::result::Result< 7646 7646 + tonic::Response<super::GetPitchResponse>, 7647 7647 + tonic::Status, 7648 7648 + > { 7649 7649 + self.inner 7650 7650 + .ready() 7651 7651 + .await 7652 7652 + .map_err(|e| { 7653 7653 + tonic::Status::unknown( 7654 7654 + format!("Service was not ready: {}", e.into()), 7655 7655 + ) 7656 7656 + })?; 6628 7657 let codec = tonic::codec::ProstCodec::default(); 6629 6629 - let path = 6630 6630 - http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.SoundService/GetPitch"); 7658 7658 + let path = http::uri::PathAndQuery::from_static( 7659 7659 + "/rockbox.v1alpha1.SoundService/GetPitch", 7660 7660 + ); 6631 7661 let mut req = request.into_request(); 6632 7662 req.extensions_mut() 6633 7663 .insert(GrpcMethod::new("rockbox.v1alpha1.SoundService", "GetPitch")); ··· 6636 7666 pub async fn set_pitch( 6637 7667 &mut self, 6638 7668 request: impl tonic::IntoRequest<super::SetPitchRequest>, 6639 6639 - ) -> std::result::Result<tonic::Response<super::SetPitchResponse>, tonic::Status> { 6640 6640 - self.inner.ready().await.map_err(|e| { 6641 6641 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 6642 6642 - })?; 7669 7669 + ) -> std::result::Result< 7670 7670 + tonic::Response<super::SetPitchResponse>, 7671 7671 + tonic::Status, 7672 7672 + > { 7673 7673 + self.inner 7674 7674 + .ready() 7675 7675 + .await 7676 7676 + .map_err(|e| { 7677 7677 + tonic::Status::unknown( 7678 7678 + format!("Service was not ready: {}", e.into()), 7679 7679 + ) 7680 7680 + })?; 6643 7681 let codec = tonic::codec::ProstCodec::default(); 6644 6644 - let path = 6645 6645 - http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.SoundService/SetPitch"); 7682 7682 + let path = http::uri::PathAndQuery::from_static( 7683 7683 + "/rockbox.v1alpha1.SoundService/SetPitch", 7684 7684 + ); 6646 7685 let mut req = request.into_request(); 6647 7686 req.extensions_mut() 6648 7687 .insert(GrpcMethod::new("rockbox.v1alpha1.SoundService", "SetPitch")); ··· 6651 7690 pub async fn beep_play( 6652 7691 &mut self, 6653 7692 request: impl tonic::IntoRequest<super::BeepPlayRequest>, 6654 6654 - ) -> std::result::Result<tonic::Response<super::BeepPlayResponse>, tonic::Status> { 6655 6655 - self.inner.ready().await.map_err(|e| { 6656 6656 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 6657 6657 - })?; 7693 7693 + ) -> std::result::Result< 7694 7694 + tonic::Response<super::BeepPlayResponse>, 7695 7695 + tonic::Status, 7696 7696 + > { 7697 7697 + self.inner 7698 7698 + .ready() 7699 7699 + .await 7700 7700 + .map_err(|e| { 7701 7701 + tonic::Status::unknown( 7702 7702 + format!("Service was not ready: {}", e.into()), 7703 7703 + ) 7704 7704 + })?; 6658 7705 let codec = tonic::codec::ProstCodec::default(); 6659 6659 - let path = 6660 6660 - http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.SoundService/BeepPlay"); 7706 7706 + let path = http::uri::PathAndQuery::from_static( 7707 7707 + "/rockbox.v1alpha1.SoundService/BeepPlay", 7708 7708 + ); 6661 7709 let mut req = request.into_request(); 6662 7710 req.extensions_mut() 6663 7711 .insert(GrpcMethod::new("rockbox.v1alpha1.SoundService", "BeepPlay")); ··· 6666 7714 pub async fn pcmbuf_fade( 6667 7715 &mut self, 6668 7716 request: impl tonic::IntoRequest<super::PcmbufFadeRequest>, 6669 6669 - ) -> std::result::Result<tonic::Response<super::PcmbufFadeResponse>, tonic::Status> 6670 6670 - { 6671 6671 - self.inner.ready().await.map_err(|e| { 6672 6672 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 6673 6673 - })?; 7717 7717 + ) -> std::result::Result< 7718 7718 + tonic::Response<super::PcmbufFadeResponse>, 7719 7719 + tonic::Status, 7720 7720 + > { 7721 7721 + self.inner 7722 7722 + .ready() 7723 7723 + .await 7724 7724 + .map_err(|e| { 7725 7725 + tonic::Status::unknown( 7726 7726 + format!("Service was not ready: {}", e.into()), 7727 7727 + ) 7728 7728 + })?; 6674 7729 let codec = tonic::codec::ProstCodec::default(); 6675 6675 - let path = 6676 6676 - http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.SoundService/PcmbufFade"); 7730 7730 + let path = http::uri::PathAndQuery::from_static( 7731 7731 + "/rockbox.v1alpha1.SoundService/PcmbufFade", 7732 7732 + ); 6677 7733 let mut req = request.into_request(); 6678 6678 - req.extensions_mut().insert(GrpcMethod::new( 6679 6679 - "rockbox.v1alpha1.SoundService", 6680 6680 - "PcmbufFade", 6681 6681 - )); 7734 7734 + req.extensions_mut() 7735 7735 + .insert(GrpcMethod::new("rockbox.v1alpha1.SoundService", "PcmbufFade")); 6682 7736 self.inner.unary(req, path, codec).await 6683 7737 } 6684 7738 pub async fn pcmbuf_set_low_latency( 6685 7739 &mut self, 6686 7740 request: impl tonic::IntoRequest<super::PcmbufSetLowLatencyRequest>, 6687 6687 - ) -> std::result::Result<tonic::Response<super::PcmbufSetLowLatencyResponse>, tonic::Status> 6688 6688 - { 6689 6689 - self.inner.ready().await.map_err(|e| { 6690 6690 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 6691 6691 - })?; 7741 7741 + ) -> std::result::Result< 7742 7742 + tonic::Response<super::PcmbufSetLowLatencyResponse>, 7743 7743 + tonic::Status, 7744 7744 + > { 7745 7745 + self.inner 7746 7746 + .ready() 7747 7747 + .await 7748 7748 + .map_err(|e| { 7749 7749 + tonic::Status::unknown( 7750 7750 + format!("Service was not ready: {}", e.into()), 7751 7751 + ) 7752 7752 + })?; 6692 7753 let codec = tonic::codec::ProstCodec::default(); 6693 7754 let path = http::uri::PathAndQuery::from_static( 6694 7755 "/rockbox.v1alpha1.SoundService/PcmbufSetLowLatency", 6695 7756 ); 6696 7757 let mut req = request.into_request(); 6697 6697 - req.extensions_mut().insert(GrpcMethod::new( 6698 6698 - "rockbox.v1alpha1.SoundService", 6699 6699 - "PcmbufSetLowLatency", 6700 6700 - )); 7758 7758 + req.extensions_mut() 7759 7759 + .insert( 7760 7760 + GrpcMethod::new( 7761 7761 + "rockbox.v1alpha1.SoundService", 7762 7762 + "PcmbufSetLowLatency", 7763 7763 + ), 7764 7764 + ); 6701 7765 self.inner.unary(req, path, codec).await 6702 7766 } 6703 7767 pub async fn system_sound_play( 6704 7768 &mut self, 6705 7769 request: impl tonic::IntoRequest<super::SystemSoundPlayRequest>, 6706 6706 - ) -> std::result::Result<tonic::Response<super::SystemSoundPlayResponse>, tonic::Status> 6707 6707 - { 6708 6708 - self.inner.ready().await.map_err(|e| { 6709 6709 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 6710 6710 - })?; 7770 7770 + ) -> std::result::Result< 7771 7771 + tonic::Response<super::SystemSoundPlayResponse>, 7772 7772 + tonic::Status, 7773 7773 + > { 7774 7774 + self.inner 7775 7775 + .ready() 7776 7776 + .await 7777 7777 + .map_err(|e| { 7778 7778 + tonic::Status::unknown( 7779 7779 + format!("Service was not ready: {}", e.into()), 7780 7780 + ) 7781 7781 + })?; 6711 7782 let codec = tonic::codec::ProstCodec::default(); 6712 7783 let path = http::uri::PathAndQuery::from_static( 6713 7784 "/rockbox.v1alpha1.SoundService/SystemSoundPlay", 6714 7785 ); 6715 7786 let mut req = request.into_request(); 6716 6716 - req.extensions_mut().insert(GrpcMethod::new( 6717 6717 - "rockbox.v1alpha1.SoundService", 6718 6718 - "SystemSoundPlay", 6719 6719 - )); 7787 7787 + req.extensions_mut() 7788 7788 + .insert( 7789 7789 + GrpcMethod::new("rockbox.v1alpha1.SoundService", "SystemSoundPlay"), 7790 7790 + ); 6720 7791 self.inner.unary(req, path, codec).await 6721 7792 } 6722 7793 pub async fn keyclick_click( 6723 7794 &mut self, 6724 7795 request: impl tonic::IntoRequest<super::KeyclickClickRequest>, 6725 6725 - ) -> std::result::Result<tonic::Response<super::KeyclickClickResponse>, tonic::Status> 6726 6726 - { 6727 6727 - self.inner.ready().await.map_err(|e| { 6728 6728 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 6729 6729 - })?; 7796 7796 + ) -> std::result::Result< 7797 7797 + tonic::Response<super::KeyclickClickResponse>, 7798 7798 + tonic::Status, 7799 7799 + > { 7800 7800 + self.inner 7801 7801 + .ready() 7802 7802 + .await 7803 7803 + .map_err(|e| { 7804 7804 + tonic::Status::unknown( 7805 7805 + format!("Service was not ready: {}", e.into()), 7806 7806 + ) 7807 7807 + })?; 6730 7808 let codec = tonic::codec::ProstCodec::default(); 6731 7809 let path = http::uri::PathAndQuery::from_static( 6732 7810 "/rockbox.v1alpha1.SoundService/KeyclickClick", 6733 7811 ); 6734 7812 let mut req = request.into_request(); 6735 6735 - req.extensions_mut().insert(GrpcMethod::new( 6736 6736 - "rockbox.v1alpha1.SoundService", 6737 6737 - "KeyclickClick", 6738 6738 - )); 7813 7813 + req.extensions_mut() 7814 7814 + .insert( 7815 7815 + GrpcMethod::new("rockbox.v1alpha1.SoundService", "KeyclickClick"), 7816 7816 + ); 6739 7817 self.inner.unary(req, path, codec).await 6740 7818 } 6741 7819 } ··· 6747 7825 dead_code, 6748 7826 missing_docs, 6749 7827 clippy::wildcard_imports, 6750 6750 - clippy::let_unit_value 7828 7828 + clippy::let_unit_value, 6751 7829 )] 6752 7830 use tonic::codegen::*; 6753 7831 /// Generated trait containing gRPC methods that should be implemented for use with SoundServiceServer. ··· 6756 7834 async fn adjust_volume( 6757 7835 &self, 6758 7836 request: tonic::Request<super::AdjustVolumeRequest>, 6759 6759 - ) -> std::result::Result<tonic::Response<super::AdjustVolumeResponse>, tonic::Status>; 7837 7837 + ) -> std::result::Result< 7838 7838 + tonic::Response<super::AdjustVolumeResponse>, 7839 7839 + tonic::Status, 7840 7840 + >; 6760 7841 async fn sound_set( 6761 7842 &self, 6762 7843 request: tonic::Request<super::SoundSetRequest>, 6763 6763 - ) -> std::result::Result<tonic::Response<super::SoundSetResponse>, tonic::Status>; 7844 7844 + ) -> std::result::Result< 7845 7845 + tonic::Response<super::SoundSetResponse>, 7846 7846 + tonic::Status, 7847 7847 + >; 6764 7848 async fn sound_current( 6765 7849 &self, 6766 7850 request: tonic::Request<super::SoundCurrentRequest>, 6767 6767 - ) -> std::result::Result<tonic::Response<super::SoundCurrentResponse>, tonic::Status>; 7851 7851 + ) -> std::result::Result< 7852 7852 + tonic::Response<super::SoundCurrentResponse>, 7853 7853 + tonic::Status, 7854 7854 + >; 6768 7855 async fn sound_default( 6769 7856 &self, 6770 7857 request: tonic::Request<super::SoundDefaultRequest>, 6771 6771 - ) -> std::result::Result<tonic::Response<super::SoundDefaultResponse>, tonic::Status>; 7858 7858 + ) -> std::result::Result< 7859 7859 + tonic::Response<super::SoundDefaultResponse>, 7860 7860 + tonic::Status, 7861 7861 + >; 6772 7862 async fn sound_min( 6773 7863 &self, 6774 7864 request: tonic::Request<super::SoundMinRequest>, 6775 6775 - ) -> std::result::Result<tonic::Response<super::SoundMinResponse>, tonic::Status>; 7865 7865 + ) -> std::result::Result< 7866 7866 + tonic::Response<super::SoundMinResponse>, 7867 7867 + tonic::Status, 7868 7868 + >; 6776 7869 async fn sound_max( 6777 7870 &self, 6778 7871 request: tonic::Request<super::SoundMaxRequest>, 6779 6779 - ) -> std::result::Result<tonic::Response<super::SoundMaxResponse>, tonic::Status>; 7872 7872 + ) -> std::result::Result< 7873 7873 + tonic::Response<super::SoundMaxResponse>, 7874 7874 + tonic::Status, 7875 7875 + >; 6780 7876 async fn sound_unit( 6781 7877 &self, 6782 7878 request: tonic::Request<super::SoundUnitRequest>, 6783 6783 - ) -> std::result::Result<tonic::Response<super::SoundUnitResponse>, tonic::Status>; 7879 7879 + ) -> std::result::Result< 7880 7880 + tonic::Response<super::SoundUnitResponse>, 7881 7881 + tonic::Status, 7882 7882 + >; 6784 7883 async fn sound_val2_phys( 6785 7884 &self, 6786 7885 request: tonic::Request<super::SoundVal2PhysRequest>, 6787 6787 - ) -> std::result::Result<tonic::Response<super::SoundVal2PhysResponse>, tonic::Status>; 7886 7886 + ) -> std::result::Result< 7887 7887 + tonic::Response<super::SoundVal2PhysResponse>, 7888 7888 + tonic::Status, 7889 7889 + >; 6788 7890 async fn get_pitch( 6789 7891 &self, 6790 7892 request: tonic::Request<super::GetPitchRequest>, 6791 6791 - ) -> std::result::Result<tonic::Response<super::GetPitchResponse>, tonic::Status>; 7893 7893 + ) -> std::result::Result< 7894 7894 + tonic::Response<super::GetPitchResponse>, 7895 7895 + tonic::Status, 7896 7896 + >; 6792 7897 async fn set_pitch( 6793 7898 &self, 6794 7899 request: tonic::Request<super::SetPitchRequest>, 6795 6795 - ) -> std::result::Result<tonic::Response<super::SetPitchResponse>, tonic::Status>; 7900 7900 + ) -> std::result::Result< 7901 7901 + tonic::Response<super::SetPitchResponse>, 7902 7902 + tonic::Status, 7903 7903 + >; 6796 7904 async fn beep_play( 6797 7905 &self, 6798 7906 request: tonic::Request<super::BeepPlayRequest>, 6799 6799 - ) -> std::result::Result<tonic::Response<super::BeepPlayResponse>, tonic::Status>; 7907 7907 + ) -> std::result::Result< 7908 7908 + tonic::Response<super::BeepPlayResponse>, 7909 7909 + tonic::Status, 7910 7910 + >; 6800 7911 async fn pcmbuf_fade( 6801 7912 &self, 6802 7913 request: tonic::Request<super::PcmbufFadeRequest>, 6803 6803 - ) -> std::result::Result<tonic::Response<super::PcmbufFadeResponse>, tonic::Status>; 7914 7914 + ) -> std::result::Result< 7915 7915 + tonic::Response<super::PcmbufFadeResponse>, 7916 7916 + tonic::Status, 7917 7917 + >; 6804 7918 async fn pcmbuf_set_low_latency( 6805 7919 &self, 6806 7920 request: tonic::Request<super::PcmbufSetLowLatencyRequest>, 6807 6807 - ) -> std::result::Result<tonic::Response<super::PcmbufSetLowLatencyResponse>, tonic::Status>; 7921 7921 + ) -> std::result::Result< 7922 7922 + tonic::Response<super::PcmbufSetLowLatencyResponse>, 7923 7923 + tonic::Status, 7924 7924 + >; 6808 7925 async fn system_sound_play( 6809 7926 &self, 6810 7927 request: tonic::Request<super::SystemSoundPlayRequest>, 6811 6811 - ) -> std::result::Result<tonic::Response<super::SystemSoundPlayResponse>, tonic::Status>; 7928 7928 + ) -> std::result::Result< 7929 7929 + tonic::Response<super::SystemSoundPlayResponse>, 7930 7930 + tonic::Status, 7931 7931 + >; 6812 7932 async fn keyclick_click( 6813 7933 &self, 6814 7934 request: tonic::Request<super::KeyclickClickRequest>, 6815 6815 - ) -> std::result::Result<tonic::Response<super::KeyclickClickResponse>, tonic::Status>; 7935 7935 + ) -> std::result::Result< 7936 7936 + tonic::Response<super::KeyclickClickResponse>, 7937 7937 + tonic::Status, 7938 7938 + >; 6816 7939 } 6817 7940 #[derive(Debug)] 6818 7941 pub struct SoundServiceServer<T> { ··· 6835 7958 max_encoding_message_size: None, 6836 7959 } 6837 7960 } 6838 6838 - pub fn with_interceptor<F>(inner: T, interceptor: F) -> InterceptedService<Self, F> 7961 7961 + pub fn with_interceptor<F>( 7962 7962 + inner: T, 7963 7963 + interceptor: F, 7964 7964 + ) -> InterceptedService<Self, F> 6839 7965 where 6840 7966 F: tonic::service::Interceptor, 6841 7967 { ··· 6890 8016 "/rockbox.v1alpha1.SoundService/AdjustVolume" => { 6891 8017 #[allow(non_camel_case_types)] 6892 8018 struct AdjustVolumeSvc<T: SoundService>(pub Arc<T>); 6893 6893 - impl<T: SoundService> tonic::server::UnaryService<super::AdjustVolumeRequest> 6894 6894 - for AdjustVolumeSvc<T> 6895 6895 - { 8019 8019 + impl< 8020 8020 + T: SoundService, 8021 8021 + > tonic::server::UnaryService<super::AdjustVolumeRequest> 8022 8022 + for AdjustVolumeSvc<T> { 6896 8023 type Response = super::AdjustVolumeResponse; 6897 6897 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 8024 8024 + type Future = BoxFuture< 8025 8025 + tonic::Response<Self::Response>, 8026 8026 + tonic::Status, 8027 8027 + >; 6898 8028 fn call( 6899 8029 &mut self, 6900 8030 request: tonic::Request<super::AdjustVolumeRequest>, ··· 6931 8061 "/rockbox.v1alpha1.SoundService/SoundSet" => { 6932 8062 #[allow(non_camel_case_types)] 6933 8063 struct SoundSetSvc<T: SoundService>(pub Arc<T>); 6934 6934 - impl<T: SoundService> tonic::server::UnaryService<super::SoundSetRequest> for SoundSetSvc<T> { 8064 8064 + impl< 8065 8065 + T: SoundService, 8066 8066 + > tonic::server::UnaryService<super::SoundSetRequest> 8067 8067 + for SoundSetSvc<T> { 6935 8068 type Response = super::SoundSetResponse; 6936 6936 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 8069 8069 + type Future = BoxFuture< 8070 8070 + tonic::Response<Self::Response>, 8071 8071 + tonic::Status, 8072 8072 + >; 6937 8073 fn call( 6938 8074 &mut self, 6939 8075 request: tonic::Request<super::SoundSetRequest>, ··· 6970 8106 "/rockbox.v1alpha1.SoundService/SoundCurrent" => { 6971 8107 #[allow(non_camel_case_types)] 6972 8108 struct SoundCurrentSvc<T: SoundService>(pub Arc<T>); 6973 6973 - impl<T: SoundService> tonic::server::UnaryService<super::SoundCurrentRequest> 6974 6974 - for SoundCurrentSvc<T> 6975 6975 - { 8109 8109 + impl< 8110 8110 + T: SoundService, 8111 8111 + > tonic::server::UnaryService<super::SoundCurrentRequest> 8112 8112 + for SoundCurrentSvc<T> { 6976 8113 type Response = super::SoundCurrentResponse; 6977 6977 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 8114 8114 + type Future = BoxFuture< 8115 8115 + tonic::Response<Self::Response>, 8116 8116 + tonic::Status, 8117 8117 + >; 6978 8118 fn call( 6979 8119 &mut self, 6980 8120 request: tonic::Request<super::SoundCurrentRequest>, ··· 7011 8151 "/rockbox.v1alpha1.SoundService/SoundDefault" => { 7012 8152 #[allow(non_camel_case_types)] 7013 8153 struct SoundDefaultSvc<T: SoundService>(pub Arc<T>); 7014 7014 - impl<T: SoundService> tonic::server::UnaryService<super::SoundDefaultRequest> 7015 7015 - for SoundDefaultSvc<T> 7016 7016 - { 8154 8154 + impl< 8155 8155 + T: SoundService, 8156 8156 + > tonic::server::UnaryService<super::SoundDefaultRequest> 8157 8157 + for SoundDefaultSvc<T> { 7017 8158 type Response = super::SoundDefaultResponse; 7018 7018 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 8159 8159 + type Future = BoxFuture< 8160 8160 + tonic::Response<Self::Response>, 8161 8161 + tonic::Status, 8162 8162 + >; 7019 8163 fn call( 7020 8164 &mut self, 7021 8165 request: tonic::Request<super::SoundDefaultRequest>, ··· 7052 8196 "/rockbox.v1alpha1.SoundService/SoundMin" => { 7053 8197 #[allow(non_camel_case_types)] 7054 8198 struct SoundMinSvc<T: SoundService>(pub Arc<T>); 7055 7055 - impl<T: SoundService> tonic::server::UnaryService<super::SoundMinRequest> for SoundMinSvc<T> { 8199 8199 + impl< 8200 8200 + T: SoundService, 8201 8201 + > tonic::server::UnaryService<super::SoundMinRequest> 8202 8202 + for SoundMinSvc<T> { 7056 8203 type Response = super::SoundMinResponse; 7057 7057 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 8204 8204 + type Future = BoxFuture< 8205 8205 + tonic::Response<Self::Response>, 8206 8206 + tonic::Status, 8207 8207 + >; 7058 8208 fn call( 7059 8209 &mut self, 7060 8210 request: tonic::Request<super::SoundMinRequest>, ··· 7091 8241 "/rockbox.v1alpha1.SoundService/SoundMax" => { 7092 8242 #[allow(non_camel_case_types)] 7093 8243 struct SoundMaxSvc<T: SoundService>(pub Arc<T>); 7094 7094 - impl<T: SoundService> tonic::server::UnaryService<super::SoundMaxRequest> for SoundMaxSvc<T> { 8244 8244 + impl< 8245 8245 + T: SoundService, 8246 8246 + > tonic::server::UnaryService<super::SoundMaxRequest> 8247 8247 + for SoundMaxSvc<T> { 7095 8248 type Response = super::SoundMaxResponse; 7096 7096 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 8249 8249 + type Future = BoxFuture< 8250 8250 + tonic::Response<Self::Response>, 8251 8251 + tonic::Status, 8252 8252 + >; 7097 8253 fn call( 7098 8254 &mut self, 7099 8255 request: tonic::Request<super::SoundMaxRequest>, ··· 7130 8286 "/rockbox.v1alpha1.SoundService/SoundUnit" => { 7131 8287 #[allow(non_camel_case_types)] 7132 8288 struct SoundUnitSvc<T: SoundService>(pub Arc<T>); 7133 7133 - impl<T: SoundService> tonic::server::UnaryService<super::SoundUnitRequest> for SoundUnitSvc<T> { 8289 8289 + impl< 8290 8290 + T: SoundService, 8291 8291 + > tonic::server::UnaryService<super::SoundUnitRequest> 8292 8292 + for SoundUnitSvc<T> { 7134 8293 type Response = super::SoundUnitResponse; 7135 7135 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 8294 8294 + type Future = BoxFuture< 8295 8295 + tonic::Response<Self::Response>, 8296 8296 + tonic::Status, 8297 8297 + >; 7136 8298 fn call( 7137 8299 &mut self, 7138 8300 request: tonic::Request<super::SoundUnitRequest>, ··· 7169 8331 "/rockbox.v1alpha1.SoundService/SoundVal2Phys" => { 7170 8332 #[allow(non_camel_case_types)] 7171 8333 struct SoundVal2PhysSvc<T: SoundService>(pub Arc<T>); 7172 7172 - impl<T: SoundService> tonic::server::UnaryService<super::SoundVal2PhysRequest> 7173 7173 - for SoundVal2PhysSvc<T> 7174 7174 - { 8334 8334 + impl< 8335 8335 + T: SoundService, 8336 8336 + > tonic::server::UnaryService<super::SoundVal2PhysRequest> 8337 8337 + for SoundVal2PhysSvc<T> { 7175 8338 type Response = super::SoundVal2PhysResponse; 7176 7176 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 8339 8339 + type Future = BoxFuture< 8340 8340 + tonic::Response<Self::Response>, 8341 8341 + tonic::Status, 8342 8342 + >; 7177 8343 fn call( 7178 8344 &mut self, 7179 8345 request: tonic::Request<super::SoundVal2PhysRequest>, ··· 7210 8376 "/rockbox.v1alpha1.SoundService/GetPitch" => { 7211 8377 #[allow(non_camel_case_types)] 7212 8378 struct GetPitchSvc<T: SoundService>(pub Arc<T>); 7213 7213 - impl<T: SoundService> tonic::server::UnaryService<super::GetPitchRequest> for GetPitchSvc<T> { 8379 8379 + impl< 8380 8380 + T: SoundService, 8381 8381 + > tonic::server::UnaryService<super::GetPitchRequest> 8382 8382 + for GetPitchSvc<T> { 7214 8383 type Response = super::GetPitchResponse; 7215 7215 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 8384 8384 + type Future = BoxFuture< 8385 8385 + tonic::Response<Self::Response>, 8386 8386 + tonic::Status, 8387 8387 + >; 7216 8388 fn call( 7217 8389 &mut self, 7218 8390 request: tonic::Request<super::GetPitchRequest>, ··· 7249 8421 "/rockbox.v1alpha1.SoundService/SetPitch" => { 7250 8422 #[allow(non_camel_case_types)] 7251 8423 struct SetPitchSvc<T: SoundService>(pub Arc<T>); 7252 7252 - impl<T: SoundService> tonic::server::UnaryService<super::SetPitchRequest> for SetPitchSvc<T> { 8424 8424 + impl< 8425 8425 + T: SoundService, 8426 8426 + > tonic::server::UnaryService<super::SetPitchRequest> 8427 8427 + for SetPitchSvc<T> { 7253 8428 type Response = super::SetPitchResponse; 7254 7254 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 8429 8429 + type Future = BoxFuture< 8430 8430 + tonic::Response<Self::Response>, 8431 8431 + tonic::Status, 8432 8432 + >; 7255 8433 fn call( 7256 8434 &mut self, 7257 8435 request: tonic::Request<super::SetPitchRequest>, ··· 7288 8466 "/rockbox.v1alpha1.SoundService/BeepPlay" => { 7289 8467 #[allow(non_camel_case_types)] 7290 8468 struct BeepPlaySvc<T: SoundService>(pub Arc<T>); 7291 7291 - impl<T: SoundService> tonic::server::UnaryService<super::BeepPlayRequest> for BeepPlaySvc<T> { 8469 8469 + impl< 8470 8470 + T: SoundService, 8471 8471 + > tonic::server::UnaryService<super::BeepPlayRequest> 8472 8472 + for BeepPlaySvc<T> { 7292 8473 type Response = super::BeepPlayResponse; 7293 7293 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 8474 8474 + type Future = BoxFuture< 8475 8475 + tonic::Response<Self::Response>, 8476 8476 + tonic::Status, 8477 8477 + >; 7294 8478 fn call( 7295 8479 &mut self, 7296 8480 request: tonic::Request<super::BeepPlayRequest>, ··· 7327 8511 "/rockbox.v1alpha1.SoundService/PcmbufFade" => { 7328 8512 #[allow(non_camel_case_types)] 7329 8513 struct PcmbufFadeSvc<T: SoundService>(pub Arc<T>); 7330 7330 - impl<T: SoundService> tonic::server::UnaryService<super::PcmbufFadeRequest> for PcmbufFadeSvc<T> { 8514 8514 + impl< 8515 8515 + T: SoundService, 8516 8516 + > tonic::server::UnaryService<super::PcmbufFadeRequest> 8517 8517 + for PcmbufFadeSvc<T> { 7331 8518 type Response = super::PcmbufFadeResponse; 7332 7332 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 8519 8519 + type Future = BoxFuture< 8520 8520 + tonic::Response<Self::Response>, 8521 8521 + tonic::Status, 8522 8522 + >; 7333 8523 fn call( 7334 8524 &mut self, 7335 8525 request: tonic::Request<super::PcmbufFadeRequest>, ··· 7366 8556 "/rockbox.v1alpha1.SoundService/PcmbufSetLowLatency" => { 7367 8557 #[allow(non_camel_case_types)] 7368 8558 struct PcmbufSetLowLatencySvc<T: SoundService>(pub Arc<T>); 7369 7369 - impl<T: SoundService> 7370 7370 - tonic::server::UnaryService<super::PcmbufSetLowLatencyRequest> 7371 7371 - for PcmbufSetLowLatencySvc<T> 7372 7372 - { 8559 8559 + impl< 8560 8560 + T: SoundService, 8561 8561 + > tonic::server::UnaryService<super::PcmbufSetLowLatencyRequest> 8562 8562 + for PcmbufSetLowLatencySvc<T> { 7373 8563 type Response = super::PcmbufSetLowLatencyResponse; 7374 7374 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 8564 8564 + type Future = BoxFuture< 8565 8565 + tonic::Response<Self::Response>, 8566 8566 + tonic::Status, 8567 8567 + >; 7375 8568 fn call( 7376 8569 &mut self, 7377 8570 request: tonic::Request<super::PcmbufSetLowLatencyRequest>, 7378 8571 ) -> Self::Future { 7379 8572 let inner = Arc::clone(&self.0); 7380 8573 let fut = async move { 7381 7381 - <T as SoundService>::pcmbuf_set_low_latency(&inner, request).await 8574 8574 + <T as SoundService>::pcmbuf_set_low_latency(&inner, request) 8575 8575 + .await 7382 8576 }; 7383 8577 Box::pin(fut) 7384 8578 } ··· 7408 8602 "/rockbox.v1alpha1.SoundService/SystemSoundPlay" => { 7409 8603 #[allow(non_camel_case_types)] 7410 8604 struct SystemSoundPlaySvc<T: SoundService>(pub Arc<T>); 7411 7411 - impl<T: SoundService> tonic::server::UnaryService<super::SystemSoundPlayRequest> 7412 7412 - for SystemSoundPlaySvc<T> 7413 7413 - { 8605 8605 + impl< 8606 8606 + T: SoundService, 8607 8607 + > tonic::server::UnaryService<super::SystemSoundPlayRequest> 8608 8608 + for SystemSoundPlaySvc<T> { 7414 8609 type Response = super::SystemSoundPlayResponse; 7415 7415 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 8610 8610 + type Future = BoxFuture< 8611 8611 + tonic::Response<Self::Response>, 8612 8612 + tonic::Status, 8613 8613 + >; 7416 8614 fn call( 7417 8615 &mut self, 7418 8616 request: tonic::Request<super::SystemSoundPlayRequest>, 7419 8617 ) -> Self::Future { 7420 8618 let inner = Arc::clone(&self.0); 7421 8619 let fut = async move { 7422 7422 - <T as SoundService>::system_sound_play(&inner, request).await 8620 8620 + <T as SoundService>::system_sound_play(&inner, request) 8621 8621 + .await 7423 8622 }; 7424 8623 Box::pin(fut) 7425 8624 } ··· 7449 8648 "/rockbox.v1alpha1.SoundService/KeyclickClick" => { 7450 8649 #[allow(non_camel_case_types)] 7451 8650 struct KeyclickClickSvc<T: SoundService>(pub Arc<T>); 7452 7452 - impl<T: SoundService> tonic::server::UnaryService<super::KeyclickClickRequest> 7453 7453 - for KeyclickClickSvc<T> 7454 7454 - { 8651 8651 + impl< 8652 8652 + T: SoundService, 8653 8653 + > tonic::server::UnaryService<super::KeyclickClickRequest> 8654 8654 + for KeyclickClickSvc<T> { 7455 8655 type Response = super::KeyclickClickResponse; 7456 7456 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 8656 8656 + type Future = BoxFuture< 8657 8657 + tonic::Response<Self::Response>, 8658 8658 + tonic::Status, 8659 8659 + >; 7457 8660 fn call( 7458 8661 &mut self, 7459 8662 request: tonic::Request<super::KeyclickClickRequest>, ··· 7487 8690 }; 7488 8691 Box::pin(fut) 7489 8692 } 7490 7490 - _ => Box::pin(async move { 7491 7491 - let mut response = http::Response::new(empty_body()); 7492 7492 - let headers = response.headers_mut(); 7493 7493 - headers.insert( 7494 7494 - tonic::Status::GRPC_STATUS, 7495 7495 - (tonic::Code::Unimplemented as i32).into(), 7496 7496 - ); 7497 7497 - headers.insert( 7498 7498 - http::header::CONTENT_TYPE, 7499 7499 - tonic::metadata::GRPC_CONTENT_TYPE, 7500 7500 - ); 7501 7501 - Ok(response) 7502 7502 - }), 8693 8693 + _ => { 8694 8694 + Box::pin(async move { 8695 8695 + let mut response = http::Response::new(empty_body()); 8696 8696 + let headers = response.headers_mut(); 8697 8697 + headers 8698 8698 + .insert( 8699 8699 + tonic::Status::GRPC_STATUS, 8700 8700 + (tonic::Code::Unimplemented as i32).into(), 8701 8701 + ); 8702 8702 + headers 8703 8703 + .insert( 8704 8704 + http::header::CONTENT_TYPE, 8705 8705 + tonic::metadata::GRPC_CONTENT_TYPE, 8706 8706 + ); 8707 8707 + Ok(response) 8708 8708 + }) 8709 8709 + } 7503 8710 } 7504 8711 } 7505 8712 } ··· 7560 8767 dead_code, 7561 8768 missing_docs, 7562 8769 clippy::wildcard_imports, 7563 7563 - clippy::let_unit_value 8770 8770 + clippy::let_unit_value, 7564 8771 )] 7565 7565 - use tonic::codegen::http::Uri; 7566 8772 use tonic::codegen::*; 8773 8773 + use tonic::codegen::http::Uri; 7567 8774 #[derive(Debug, Clone)] 7568 8775 pub struct SystemServiceClient<T> { 7569 8776 inner: tonic::client::Grpc<T>, ··· 7607 8814 <T as tonic::client::GrpcService<tonic::body::BoxBody>>::ResponseBody, 7608 8815 >, 7609 8816 >, 7610 7610 - <T as tonic::codegen::Service<http::Request<tonic::body::BoxBody>>>::Error: 7611 7611 - Into<StdError> + std::marker::Send + std::marker::Sync, 8817 8817 + <T as tonic::codegen::Service< 8818 8818 + http::Request<tonic::body::BoxBody>, 8819 8819 + >>::Error: Into<StdError> + std::marker::Send + std::marker::Sync, 7612 8820 { 7613 8821 SystemServiceClient::new(InterceptedService::new(inner, interceptor)) 7614 8822 } ··· 7646 8854 pub async fn get_rockbox_version( 7647 8855 &mut self, 7648 8856 request: impl tonic::IntoRequest<super::GetRockboxVersionRequest>, 7649 7649 - ) -> std::result::Result<tonic::Response<super::GetRockboxVersionResponse>, tonic::Status> 7650 7650 - { 7651 7651 - self.inner.ready().await.map_err(|e| { 7652 7652 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 7653 7653 - })?; 8857 8857 + ) -> std::result::Result< 8858 8858 + tonic::Response<super::GetRockboxVersionResponse>, 8859 8859 + tonic::Status, 8860 8860 + > { 8861 8861 + self.inner 8862 8862 + .ready() 8863 8863 + .await 8864 8864 + .map_err(|e| { 8865 8865 + tonic::Status::unknown( 8866 8866 + format!("Service was not ready: {}", e.into()), 8867 8867 + ) 8868 8868 + })?; 7654 8869 let codec = tonic::codec::ProstCodec::default(); 7655 8870 let path = http::uri::PathAndQuery::from_static( 7656 8871 "/rockbox.v1alpha1.SystemService/GetRockboxVersion", 7657 8872 ); 7658 8873 let mut req = request.into_request(); 7659 7659 - req.extensions_mut().insert(GrpcMethod::new( 7660 7660 - "rockbox.v1alpha1.SystemService", 7661 7661 - "GetRockboxVersion", 7662 7662 - )); 8874 8874 + req.extensions_mut() 8875 8875 + .insert( 8876 8876 + GrpcMethod::new( 8877 8877 + "rockbox.v1alpha1.SystemService", 8878 8878 + "GetRockboxVersion", 8879 8879 + ), 8880 8880 + ); 7663 8881 self.inner.unary(req, path, codec).await 7664 8882 } 7665 8883 pub async fn get_global_status( 7666 8884 &mut self, 7667 8885 request: impl tonic::IntoRequest<super::GetGlobalStatusRequest>, 7668 7668 - ) -> std::result::Result<tonic::Response<super::GetGlobalStatusResponse>, tonic::Status> 7669 7669 - { 7670 7670 - self.inner.ready().await.map_err(|e| { 7671 7671 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 7672 7672 - })?; 8886 8886 + ) -> std::result::Result< 8887 8887 + tonic::Response<super::GetGlobalStatusResponse>, 8888 8888 + tonic::Status, 8889 8889 + > { 8890 8890 + self.inner 8891 8891 + .ready() 8892 8892 + .await 8893 8893 + .map_err(|e| { 8894 8894 + tonic::Status::unknown( 8895 8895 + format!("Service was not ready: {}", e.into()), 8896 8896 + ) 8897 8897 + })?; 7673 8898 let codec = tonic::codec::ProstCodec::default(); 7674 8899 let path = http::uri::PathAndQuery::from_static( 7675 8900 "/rockbox.v1alpha1.SystemService/GetGlobalStatus", 7676 8901 ); 7677 8902 let mut req = request.into_request(); 7678 7678 - req.extensions_mut().insert(GrpcMethod::new( 7679 7679 - "rockbox.v1alpha1.SystemService", 7680 7680 - "GetGlobalStatus", 7681 7681 - )); 8903 8903 + req.extensions_mut() 8904 8904 + .insert( 8905 8905 + GrpcMethod::new("rockbox.v1alpha1.SystemService", "GetGlobalStatus"), 8906 8906 + ); 7682 8907 self.inner.unary(req, path, codec).await 7683 8908 } 7684 8909 } ··· 7690 8915 dead_code, 7691 8916 missing_docs, 7692 8917 clippy::wildcard_imports, 7693 7693 - clippy::let_unit_value 8918 8918 + clippy::let_unit_value, 7694 8919 )] 7695 8920 use tonic::codegen::*; 7696 8921 /// Generated trait containing gRPC methods that should be implemented for use with SystemServiceServer. ··· 7699 8924 async fn get_rockbox_version( 7700 8925 &self, 7701 8926 request: tonic::Request<super::GetRockboxVersionRequest>, 7702 7702 - ) -> std::result::Result<tonic::Response<super::GetRockboxVersionResponse>, tonic::Status>; 8927 8927 + ) -> std::result::Result< 8928 8928 + tonic::Response<super::GetRockboxVersionResponse>, 8929 8929 + tonic::Status, 8930 8930 + >; 7703 8931 async fn get_global_status( 7704 8932 &self, 7705 8933 request: tonic::Request<super::GetGlobalStatusRequest>, 7706 7706 - ) -> std::result::Result<tonic::Response<super::GetGlobalStatusResponse>, tonic::Status>; 8934 8934 + ) -> std::result::Result< 8935 8935 + tonic::Response<super::GetGlobalStatusResponse>, 8936 8936 + tonic::Status, 8937 8937 + >; 7707 8938 } 7708 8939 #[derive(Debug)] 7709 8940 pub struct SystemServiceServer<T> { ··· 7726 8957 max_encoding_message_size: None, 7727 8958 } 7728 8959 } 7729 7729 - pub fn with_interceptor<F>(inner: T, interceptor: F) -> InterceptedService<Self, F> 8960 8960 + pub fn with_interceptor<F>( 8961 8961 + inner: T, 8962 8962 + interceptor: F, 8963 8963 + ) -> InterceptedService<Self, F> 7730 8964 where 7731 8965 F: tonic::service::Interceptor, 7732 8966 { ··· 7781 9015 "/rockbox.v1alpha1.SystemService/GetRockboxVersion" => { 7782 9016 #[allow(non_camel_case_types)] 7783 9017 struct GetRockboxVersionSvc<T: SystemService>(pub Arc<T>); 7784 7784 - impl<T: SystemService> 7785 7785 - tonic::server::UnaryService<super::GetRockboxVersionRequest> 7786 7786 - for GetRockboxVersionSvc<T> 7787 7787 - { 9018 9018 + impl< 9019 9019 + T: SystemService, 9020 9020 + > tonic::server::UnaryService<super::GetRockboxVersionRequest> 9021 9021 + for GetRockboxVersionSvc<T> { 7788 9022 type Response = super::GetRockboxVersionResponse; 7789 7789 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 9023 9023 + type Future = BoxFuture< 9024 9024 + tonic::Response<Self::Response>, 9025 9025 + tonic::Status, 9026 9026 + >; 7790 9027 fn call( 7791 9028 &mut self, 7792 9029 request: tonic::Request<super::GetRockboxVersionRequest>, 7793 9030 ) -> Self::Future { 7794 9031 let inner = Arc::clone(&self.0); 7795 9032 let fut = async move { 7796 7796 - <T as SystemService>::get_rockbox_version(&inner, request).await 9033 9033 + <T as SystemService>::get_rockbox_version(&inner, request) 9034 9034 + .await 7797 9035 }; 7798 9036 Box::pin(fut) 7799 9037 } ··· 7823 9061 "/rockbox.v1alpha1.SystemService/GetGlobalStatus" => { 7824 9062 #[allow(non_camel_case_types)] 7825 9063 struct GetGlobalStatusSvc<T: SystemService>(pub Arc<T>); 7826 7826 - impl<T: SystemService> 7827 7827 - tonic::server::UnaryService<super::GetGlobalStatusRequest> 7828 7828 - for GetGlobalStatusSvc<T> 7829 7829 - { 9064 9064 + impl< 9065 9065 + T: SystemService, 9066 9066 + > tonic::server::UnaryService<super::GetGlobalStatusRequest> 9067 9067 + for GetGlobalStatusSvc<T> { 7830 9068 type Response = super::GetGlobalStatusResponse; 7831 7831 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 9069 9069 + type Future = BoxFuture< 9070 9070 + tonic::Response<Self::Response>, 9071 9071 + tonic::Status, 9072 9072 + >; 7832 9073 fn call( 7833 9074 &mut self, 7834 9075 request: tonic::Request<super::GetGlobalStatusRequest>, 7835 9076 ) -> Self::Future { 7836 9077 let inner = Arc::clone(&self.0); 7837 9078 let fut = async move { 7838 7838 - <T as SystemService>::get_global_status(&inner, request).await 9079 9079 + <T as SystemService>::get_global_status(&inner, request) 9080 9080 + .await 7839 9081 }; 7840 9082 Box::pin(fut) 7841 9083 } ··· 7862 9104 }; 7863 9105 Box::pin(fut) 7864 9106 } 7865 7865 - _ => Box::pin(async move { 7866 7866 - let mut response = http::Response::new(empty_body()); 7867 7867 - let headers = response.headers_mut(); 7868 7868 - headers.insert( 7869 7869 - tonic::Status::GRPC_STATUS, 7870 7870 - (tonic::Code::Unimplemented as i32).into(), 7871 7871 - ); 7872 7872 - headers.insert( 7873 7873 - http::header::CONTENT_TYPE, 7874 7874 - tonic::metadata::GRPC_CONTENT_TYPE, 7875 7875 - ); 7876 7876 - Ok(response) 7877 7877 - }), 9107 9107 + _ => { 9108 9108 + Box::pin(async move { 9109 9109 + let mut response = http::Response::new(empty_body()); 9110 9110 + let headers = response.headers_mut(); 9111 9111 + headers 9112 9112 + .insert( 9113 9113 + tonic::Status::GRPC_STATUS, 9114 9114 + (tonic::Code::Unimplemented as i32).into(), 9115 9115 + ); 9116 9116 + headers 9117 9117 + .insert( 9118 9118 + http::header::CONTENT_TYPE, 9119 9119 + tonic::metadata::GRPC_CONTENT_TYPE, 9120 9120 + ); 9121 9121 + Ok(response) 9122 9122 + }) 9123 9123 + } 7878 9124 } 7879 9125 } 7880 9126 }

+6 -1

crates/cli/src/lib.rs

reviewed

··· 15 15 #[macro_export] 16 16 macro_rules! cast_ptr { 17 17 ($ptr:expr) => {{ 18 18 - #[cfg(target_arch = "aarch64")] 18 18 + #[cfg(all(target_arch = "aarch64", target_os = "macos"))] 19 19 + { 20 20 + $ptr as *const i8 21 21 + } 22 22 + 23 23 + #[cfg(all(target_arch = "aarch64", target_os = "linux"))] 19 24 { 20 25 $ptr as *const u8 21 26 }

+6 -1

crates/sys/src/lib.rs

reviewed

··· 34 34 #[macro_export] 35 35 macro_rules! cast_ptr { 36 36 ($ptr:expr) => {{ 37 37 - #[cfg(target_arch = "aarch64")] 37 37 + #[cfg(all(target_arch = "aarch64", target_os = "macos"))] 38 38 + { 39 39 + $ptr as *const i8 40 40 + } 41 41 + 42 42 + #[cfg(all(target_arch = "aarch64", target_os = "linux"))] 38 43 { 39 44 $ptr as *const u8 40 45 }

webui/rockbox/bun.lockb

reviewed

This is a binary file and will not be displayed.

+1 -1

webui/rockbox/tsconfig.app.tsbuildinfo

reviewed

··· 1 1 - {"root":["./src/App.tsx","./src/Theme.ts","./src/constants.ts","./src/emotion.d.ts","./src/main.tsx","./src/mocks.ts","./src/vite-env.d.ts","./src/Components/Album/Album.stories.tsx","./src/Components/Album/Album.test.tsx","./src/Components/Album/Album.tsx","./src/Components/Album/AlbumWithData.tsx","./src/Components/Album/index.tsx","./src/Components/Album/styles.tsx","./src/Components/Album/ContextMenu/ChildMenu.tsx","./src/Components/Album/ContextMenu/ContextMenu.stories.tsx","./src/Components/Album/ContextMenu/ContextMenu.test.tsx","./src/Components/Album/ContextMenu/ContextMenu.tsx","./src/Components/Album/ContextMenu/ContextMenuWithData.tsx","./src/Components/Album/ContextMenu/index.tsx","./src/Components/Album/ContextMenu/styles.tsx","./src/Components/AlbumDetails/AlbumDetails.stories.tsx","./src/Components/AlbumDetails/AlbumDetails.test.tsx","./src/Components/AlbumDetails/AlbumDetails.tsx","./src/Components/AlbumDetails/AlbumDetailsWithData.tsx","./src/Components/AlbumDetails/index.tsx","./src/Components/AlbumDetails/mocks.tsx","./src/Components/AlbumDetails/styles.tsx","./src/Components/Albums/Albums.stories.tsx","./src/Components/Albums/Albums.test.tsx","./src/Components/Albums/Albums.tsx","./src/Components/Albums/AlbumsWithData.tsx","./src/Components/Albums/index.tsx","./src/Components/Albums/mocks.tsx","./src/Components/Albums/styles.tsx","./src/Components/ArtistDetails/ArtistDetails.stories.tsx","./src/Components/ArtistDetails/ArtistDetails.test.tsx","./src/Components/ArtistDetails/ArtistDetails.tsx","./src/Components/ArtistDetails/ArtistDetailsWithData.tsx","./src/Components/ArtistDetails/index.tsx","./src/Components/ArtistDetails/mocks.tsx","./src/Components/ArtistDetails/styles.tsx","./src/Components/Artists/Artists.stories.tsx","./src/Components/Artists/Artists.test.tsx","./src/Components/Artists/Artists.tsx","./src/Components/Artists/ArtistsWithData.tsx","./src/Components/Artists/index.tsx","./src/Components/Artists/mocks.tsx","./src/Components/Artists/styles.tsx","./src/Components/Button/Button.test.tsx","./src/Components/Button/Button.tsx","./src/Components/Button/index.tsx","./src/Components/ContextMenu/ChildMenu.tsx","./src/Components/ContextMenu/ContextMenu.stories.tsx","./src/Components/ContextMenu/ContextMenu.test.tsx","./src/Components/ContextMenu/ContextMenu.tsx","./src/Components/ContextMenu/ContextMenuWithData.tsx","./src/Components/ContextMenu/index.tsx","./src/Components/ContextMenu/styles.tsx","./src/Components/ControlBar/ControlBar.stories.tsx","./src/Components/ControlBar/ControlBar.test.tsx","./src/Components/ControlBar/ControlBar.tsx","./src/Components/ControlBar/ControlBarState.tsx","./src/Components/ControlBar/ControlBarWithData.tsx","./src/Components/ControlBar/index.tsx","./src/Components/ControlBar/styles.tsx","./src/Components/ControlBar/CurrentTrack/CurrentTrack.tsx","./src/Components/ControlBar/CurrentTrack/index.tsx","./src/Components/ControlBar/CurrentTrack/styles.ts","./src/Components/ControlBar/DeviceList/DeviceList.tsx","./src/Components/ControlBar/DeviceList/DeviceListWithData.tsx","./src/Components/ControlBar/DeviceList/DeviceState.tsx","./src/Components/ControlBar/DeviceList/index.tsx","./src/Components/ControlBar/DeviceList/styles.ts","./src/Components/ControlBar/PlayQueue/PlayQueue.stories.tsx","./src/Components/ControlBar/PlayQueue/PlayQueue.test.tsx","./src/Components/ControlBar/PlayQueue/PlayQueue.tsx","./src/Components/ControlBar/PlayQueue/PlayQueueWithData.tsx","./src/Components/ControlBar/PlayQueue/index.tsx","./src/Components/ControlBar/PlayQueue/mocks.tsx","./src/Components/ControlBar/PlayQueue/styles.tsx","./src/Components/ControlBar/RightMenu/RightMenu.tsx","./src/Components/ControlBar/RightMenu/index.tsx","./src/Components/ControlBar/RightMenu/styles.tsx","./src/Components/ControlBar/RightMenu/Volume/Volume.stories.tsx","./src/Components/ControlBar/RightMenu/Volume/Volume.test.tsx","./src/Components/ControlBar/RightMenu/Volume/Volume.tsx","./src/Components/ControlBar/RightMenu/Volume/VolumeWithData.tsx","./src/Components/ControlBar/RightMenu/Volume/index.tsx","./src/Components/ControlBar/RightMenu/Volume/styles.tsx","./src/Components/Extensions/Extensions.stories.tsx","./src/Components/Extensions/Extensions.tsx","./src/Components/Extensions/index.tsx","./src/Components/Files/Files.stories.tsx","./src/Components/Files/Files.test.tsx","./src/Components/Files/Files.tsx","./src/Components/Files/FilesWithData.tsx","./src/Components/Files/index.tsx","./src/Components/Files/mocks.tsx","./src/Components/Files/styles.tsx","./src/Components/Files/ContextMenu/ChildMenu.tsx","./src/Components/Files/ContextMenu/ContextMenu.stories.tsx","./src/Components/Files/ContextMenu/ContextMenu.test.tsx","./src/Components/Files/ContextMenu/ContextMenu.tsx","./src/Components/Files/ContextMenu/ContextMenuWithData.tsx","./src/Components/Files/ContextMenu/index.tsx","./src/Components/Files/ContextMenu/styles.tsx","./src/Components/Filter/Filter.test.tsx","./src/Components/Filter/Filter.tsx","./src/Components/Filter/FilterState.tsx","./src/Components/Filter/FilterWithData.tsx","./src/Components/Filter/index.tsx","./src/Components/Folder/Folder.stories.tsx","./src/Components/Folder/Folder.tsx","./src/Components/Folder/index.tsx","./src/Components/Icons/Add.tsx","./src/Components/Icons/AlbumCover.tsx","./src/Components/Icons/ArrowBack.tsx","./src/Components/Icons/Artist.tsx","./src/Components/Icons/Heart.tsx","./src/Components/Icons/HeartOutline.tsx","./src/Components/Icons/Next.tsx","./src/Components/Icons/Pause.tsx","./src/Components/Icons/Play.tsx","./src/Components/Icons/Previous.tsx","./src/Components/Icons/Repeat.tsx","./src/Components/Icons/Search.tsx","./src/Components/Icons/Shuffle.tsx","./src/Components/Icons/Speaker.tsx","./src/Components/Icons/Track.tsx","./src/Components/Likes/Likes.tsx","./src/Components/Likes/LikesState.ts","./src/Components/Likes/LikesWithData.tsx","./src/Components/Likes/index.tsx","./src/Components/Likes/styles.tsx","./src/Components/MainView/MainView.tsx","./src/Components/MainView/MainViewWithData.tsx","./src/Components/MainView/index.tsx","./src/Components/MainView/styles.tsx","./src/Components/PlaylistDetails/PlaylistDetails.stories.tsx","./src/Components/PlaylistDetails/PlaylistDetails.tsx","./src/Components/PlaylistDetails/index.tsx","./src/Components/Playlists/Playlists.stories.tsx","./src/Components/Playlists/Playlists.tsx","./src/Components/Playlists/index.tsx","./src/Components/Settings/Settings.tsx","./src/Components/Settings/SettingsState.ts","./src/Components/Settings/SettingsWithData.tsx","./src/Components/Settings/index.tsx","./src/Components/Settings/styles.tsx","./src/Components/Settings/Library/Library.tsx","./src/Components/Settings/Library/LibraryWithData.tsx","./src/Components/Settings/Library/index.tsx","./src/Components/Settings/Library/styles.tsx","./src/Components/Settings/Playback/Playback.tsx","./src/Components/Settings/Playback/PlaybackWithData.tsx","./src/Components/Settings/Playback/consts.ts","./src/Components/Settings/Playback/index.tsx","./src/Components/Settings/Playback/styles.tsx","./src/Components/Settings/Sound/Sound.tsx","./src/Components/Settings/Sound/SoundWithData.tsx","./src/Components/Settings/Sound/index.tsx","./src/Components/Settings/Sound/styles.tsx","./src/Components/Settings/Sound/Equalizer/Equalizer.tsx","./src/Components/Settings/Sound/Equalizer/EqualizerWithData.tsx","./src/Components/Settings/Sound/Equalizer/index.tsx","./src/Components/Settings/Sound/Equalizer/styles.tsx","./src/Components/Sidebar/Sidebar.test.tsx","./src/Components/Sidebar/Sidebar.tsx","./src/Components/Sidebar/SidebarWithData.tsx","./src/Components/Sidebar/Stidebar.stories.tsx","./src/Components/Sidebar/index.tsx","./src/Components/Sidebar/styles.tsx","./src/Components/Switch/Switch.tsx","./src/Components/Switch/index.tsx","./src/Components/Table/Table.tsx","./src/Components/Table/index.tsx","./src/Components/Tracks/Tracks.stories.tsx","./src/Components/Tracks/Tracks.test.tsx","./src/Components/Tracks/Tracks.tsx","./src/Components/Tracks/TracksWithData.tsx","./src/Components/Tracks/index.tsx","./src/Components/Tracks/mocks.tsx","./src/Components/Tracks/styles.tsx","./src/Components/VirtualizedTable/VirtualizedTable.tsx","./src/Components/VirtualizedTable/index.tsx","./src/Containers/AlbumDetails/AlbumDetailsPage.tsx","./src/Containers/AlbumDetails/index.tsx","./src/Containers/Albums/AlbumsPage.tsx","./src/Containers/Albums/index.tsx","./src/Containers/ArtistDetails/ArtistDetailsPage.tsx","./src/Containers/ArtistDetails/index.tsx","./src/Containers/Artists/ArtistsPage.tsx","./src/Containers/Artists/index.tsx","./src/Containers/Extensions/ExtensionsPage.tsx","./src/Containers/Extensions/index.tsx","./src/Containers/Files/FilesPage.tsx","./src/Containers/Files/index.tsx","./src/Containers/Likes/LikesPage.tsx","./src/Containers/Likes/index.tsx","./src/Containers/Playlists/PlaylistsPage.tsx","./src/Containers/Playlists/index.tsx","./src/Containers/Settings/SettingsPage.tsx","./src/Containers/Settings/index.tsx","./src/Containers/Tracks/TracksPage.tsx","./src/Containers/Tracks/index.tsx","./src/GraphQL/Browse/Query.ts","./src/GraphQL/Device/Mutation.ts","./src/GraphQL/Device/Query.ts","./src/GraphQL/Library/Mutation.ts","./src/GraphQL/Library/Query.ts","./src/GraphQL/Playback/Mutation.ts","./src/GraphQL/Playback/Query.ts","./src/GraphQL/Playback/Subscription.ts","./src/GraphQL/Playlist/Mutation.ts","./src/GraphQL/Playlist/Query.ts","./src/GraphQL/Playlist/Subscription.ts","./src/GraphQL/Settings/Mutation.ts","./src/GraphQL/Settings/Query.ts","./src/GraphQL/Sound/Mutation.tsx","./src/GraphQL/System/Query.ts","./src/Hooks/GraphQL.tsx","./src/Hooks/useFormat.tsx","./src/Hooks/usePlayQueue.tsx","./src/Hooks/useResumePlaylist.tsx","./src/Hooks/useSettings.tsx","./src/Providers/GraphQLProvider.tsx","./src/Providers/ThemeProvider.tsx","./src/Providers/index.tsx","./src/Types/file.ts","./src/Types/playlist.ts","./src/Types/track.ts","./src/stories/Button.stories.ts","./src/stories/Button.tsx","./src/stories/Header.stories.ts","./src/stories/Header.tsx","./src/stories/Page.stories.ts","./src/stories/Page.tsx"],"version":"5.6.3"} 1 1 + {"root":["./src/app.tsx","./src/theme.ts","./src/constants.ts","./src/emotion.d.ts","./src/main.tsx","./src/mocks.ts","./src/vite-env.d.ts","./src/components/album/album.stories.tsx","./src/components/album/album.test.tsx","./src/components/album/album.tsx","./src/components/album/albumwithdata.tsx","./src/components/album/index.tsx","./src/components/album/styles.tsx","./src/components/album/contextmenu/childmenu.tsx","./src/components/album/contextmenu/contextmenu.stories.tsx","./src/components/album/contextmenu/contextmenu.test.tsx","./src/components/album/contextmenu/contextmenu.tsx","./src/components/album/contextmenu/contextmenuwithdata.tsx","./src/components/album/contextmenu/index.tsx","./src/components/album/contextmenu/styles.tsx","./src/components/albumdetails/albumdetails.stories.tsx","./src/components/albumdetails/albumdetails.test.tsx","./src/components/albumdetails/albumdetails.tsx","./src/components/albumdetails/albumdetailswithdata.tsx","./src/components/albumdetails/index.tsx","./src/components/albumdetails/mocks.tsx","./src/components/albumdetails/styles.tsx","./src/components/albums/albums.stories.tsx","./src/components/albums/albums.test.tsx","./src/components/albums/albums.tsx","./src/components/albums/albumswithdata.tsx","./src/components/albums/index.tsx","./src/components/albums/mocks.tsx","./src/components/albums/styles.tsx","./src/components/artistdetails/artistdetails.stories.tsx","./src/components/artistdetails/artistdetails.test.tsx","./src/components/artistdetails/artistdetails.tsx","./src/components/artistdetails/artistdetailswithdata.tsx","./src/components/artistdetails/index.tsx","./src/components/artistdetails/mocks.tsx","./src/components/artistdetails/styles.tsx","./src/components/artists/artists.stories.tsx","./src/components/artists/artists.test.tsx","./src/components/artists/artists.tsx","./src/components/artists/artistswithdata.tsx","./src/components/artists/index.tsx","./src/components/artists/mocks.tsx","./src/components/artists/styles.tsx","./src/components/button/button.test.tsx","./src/components/button/button.tsx","./src/components/button/index.tsx","./src/components/contextmenu/childmenu.tsx","./src/components/contextmenu/contextmenu.stories.tsx","./src/components/contextmenu/contextmenu.test.tsx","./src/components/contextmenu/contextmenu.tsx","./src/components/contextmenu/contextmenuwithdata.tsx","./src/components/contextmenu/index.tsx","./src/components/contextmenu/styles.tsx","./src/components/controlbar/controlbar.stories.tsx","./src/components/controlbar/controlbar.test.tsx","./src/components/controlbar/controlbar.tsx","./src/components/controlbar/controlbarstate.tsx","./src/components/controlbar/controlbarwithdata.tsx","./src/components/controlbar/index.tsx","./src/components/controlbar/styles.tsx","./src/components/controlbar/currenttrack/currenttrack.tsx","./src/components/controlbar/currenttrack/index.tsx","./src/components/controlbar/currenttrack/styles.ts","./src/components/controlbar/devicelist/devicelist.tsx","./src/components/controlbar/devicelist/devicelistwithdata.tsx","./src/components/controlbar/devicelist/devicestate.tsx","./src/components/controlbar/devicelist/index.tsx","./src/components/controlbar/devicelist/styles.ts","./src/components/controlbar/playqueue/playqueue.stories.tsx","./src/components/controlbar/playqueue/playqueue.test.tsx","./src/components/controlbar/playqueue/playqueue.tsx","./src/components/controlbar/playqueue/playqueuewithdata.tsx","./src/components/controlbar/playqueue/index.tsx","./src/components/controlbar/playqueue/mocks.tsx","./src/components/controlbar/playqueue/styles.tsx","./src/components/controlbar/rightmenu/rightmenu.tsx","./src/components/controlbar/rightmenu/index.tsx","./src/components/controlbar/rightmenu/styles.tsx","./src/components/controlbar/rightmenu/volume/volume.stories.tsx","./src/components/controlbar/rightmenu/volume/volume.test.tsx","./src/components/controlbar/rightmenu/volume/volume.tsx","./src/components/controlbar/rightmenu/volume/volumewithdata.tsx","./src/components/controlbar/rightmenu/volume/index.tsx","./src/components/controlbar/rightmenu/volume/styles.tsx","./src/components/extensions/extensions.stories.tsx","./src/components/extensions/extensions.tsx","./src/components/extensions/index.tsx","./src/components/files/files.stories.tsx","./src/components/files/files.test.tsx","./src/components/files/files.tsx","./src/components/files/fileswithdata.tsx","./src/components/files/index.tsx","./src/components/files/mocks.tsx","./src/components/files/styles.tsx","./src/components/files/contextmenu/childmenu.tsx","./src/components/files/contextmenu/contextmenu.stories.tsx","./src/components/files/contextmenu/contextmenu.test.tsx","./src/components/files/contextmenu/contextmenu.tsx","./src/components/files/contextmenu/contextmenuwithdata.tsx","./src/components/files/contextmenu/index.tsx","./src/components/files/contextmenu/styles.tsx","./src/components/filter/filter.test.tsx","./src/components/filter/filter.tsx","./src/components/filter/filterstate.tsx","./src/components/filter/filterwithdata.tsx","./src/components/filter/index.tsx","./src/components/folder/folder.stories.tsx","./src/components/folder/folder.tsx","./src/components/folder/index.tsx","./src/components/icons/add.tsx","./src/components/icons/albumcover.tsx","./src/components/icons/arrowback.tsx","./src/components/icons/artist.tsx","./src/components/icons/heart.tsx","./src/components/icons/heartoutline.tsx","./src/components/icons/next.tsx","./src/components/icons/pause.tsx","./src/components/icons/play.tsx","./src/components/icons/previous.tsx","./src/components/icons/repeat.tsx","./src/components/icons/search.tsx","./src/components/icons/shuffle.tsx","./src/components/icons/speaker.tsx","./src/components/icons/track.tsx","./src/components/likes/likes.tsx","./src/components/likes/likesstate.ts","./src/components/likes/likeswithdata.tsx","./src/components/likes/index.tsx","./src/components/likes/styles.tsx","./src/components/mainview/mainview.tsx","./src/components/mainview/mainviewwithdata.tsx","./src/components/mainview/index.tsx","./src/components/mainview/styles.tsx","./src/components/playlistdetails/playlistdetails.stories.tsx","./src/components/playlistdetails/playlistdetails.tsx","./src/components/playlistdetails/index.tsx","./src/components/playlists/playlists.stories.tsx","./src/components/playlists/playlists.tsx","./src/components/playlists/index.tsx","./src/components/settings/settings.tsx","./src/components/settings/settingsstate.ts","./src/components/settings/settingswithdata.tsx","./src/components/settings/index.tsx","./src/components/settings/styles.tsx","./src/components/settings/library/library.tsx","./src/components/settings/library/librarywithdata.tsx","./src/components/settings/library/index.tsx","./src/components/settings/library/styles.tsx","./src/components/settings/playback/playback.tsx","./src/components/settings/playback/playbackwithdata.tsx","./src/components/settings/playback/consts.ts","./src/components/settings/playback/index.tsx","./src/components/settings/playback/styles.tsx","./src/components/settings/sound/sound.tsx","./src/components/settings/sound/soundwithdata.tsx","./src/components/settings/sound/index.tsx","./src/components/settings/sound/styles.tsx","./src/components/settings/sound/equalizer/equalizer.tsx","./src/components/settings/sound/equalizer/equalizerwithdata.tsx","./src/components/settings/sound/equalizer/index.tsx","./src/components/settings/sound/equalizer/styles.tsx","./src/components/sidebar/sidebar.test.tsx","./src/components/sidebar/sidebar.tsx","./src/components/sidebar/sidebarwithdata.tsx","./src/components/sidebar/stidebar.stories.tsx","./src/components/sidebar/index.tsx","./src/components/sidebar/styles.tsx","./src/components/switch/switch.tsx","./src/components/switch/index.tsx","./src/components/table/table.tsx","./src/components/table/index.tsx","./src/components/tracks/tracks.stories.tsx","./src/components/tracks/tracks.test.tsx","./src/components/tracks/tracks.tsx","./src/components/tracks/trackswithdata.tsx","./src/components/tracks/index.tsx","./src/components/tracks/mocks.tsx","./src/components/tracks/styles.tsx","./src/components/virtualizedtable/virtualizedtable.tsx","./src/components/virtualizedtable/index.tsx","./src/containers/albumdetails/albumdetailspage.tsx","./src/containers/albumdetails/index.tsx","./src/containers/albums/albumspage.tsx","./src/containers/albums/index.tsx","./src/containers/artistdetails/artistdetailspage.tsx","./src/containers/artistdetails/index.tsx","./src/containers/artists/artistspage.tsx","./src/containers/artists/index.tsx","./src/containers/extensions/extensionspage.tsx","./src/containers/extensions/index.tsx","./src/containers/files/filespage.tsx","./src/containers/files/index.tsx","./src/containers/likes/likespage.tsx","./src/containers/likes/index.tsx","./src/containers/playlists/playlistspage.tsx","./src/containers/playlists/index.tsx","./src/containers/settings/settingspage.tsx","./src/containers/settings/index.tsx","./src/containers/tracks/trackspage.tsx","./src/containers/tracks/index.tsx","./src/graphql/browse/query.ts","./src/graphql/device/mutation.ts","./src/graphql/device/query.ts","./src/graphql/library/mutation.ts","./src/graphql/library/query.ts","./src/graphql/playback/mutation.ts","./src/graphql/playback/query.ts","./src/graphql/playback/subscription.ts","./src/graphql/playlist/mutation.ts","./src/graphql/playlist/query.ts","./src/graphql/playlist/subscription.ts","./src/graphql/settings/mutation.ts","./src/graphql/settings/query.ts","./src/graphql/sound/mutation.tsx","./src/graphql/system/query.ts","./src/hooks/graphql.tsx","./src/hooks/useformat.tsx","./src/hooks/useplayqueue.tsx","./src/hooks/useresumeplaylist.tsx","./src/hooks/usesettings.tsx","./src/providers/graphqlprovider.tsx","./src/providers/themeprovider.tsx","./src/providers/index.tsx","./src/types/file.ts","./src/types/playlist.ts","./src/types/track.ts","./src/stories/button.stories.ts","./src/stories/button.tsx","./src/stories/header.stories.ts","./src/stories/header.tsx","./src/stories/page.stories.ts","./src/stories/page.tsx"],"version":"5.6.2"}

+1 -1

webui/rockbox/tsconfig.node.tsbuildinfo

reviewed

··· 1 1 - {"root":["./vite.config.ts"],"version":"5.6.3"} 1 1 + {"root":["./vite.config.ts"],"version":"5.6.2"}