Make audio stop/pause non-blocking · tsiry-sandratraina.com/rockbox-zig@e0eac04

+20 -9

apps/playback.c

··· 3629 3629 audio_stop_playback(); 3630 3630 if (ev->data != 0) 3631 3631 queue_clear(&audio_queue); 3632 + /* data=2: audio_hard_stop() posted asynchronously; free the 3633 + * audio buffer here instead of in the (non-Rockbox) caller. */ 3634 + if (ev->data >= 2 && audiobuf_handle > 0) 3635 + audiobuf_handle = core_free(audiobuf_handle); 3632 3636 return; /* no more playback */ 3633 3637 3634 3638 case Q_AUDIO_PAUSE: ··· 4014 4018 /* Stop playback if playing */ 4015 4019 void audio_stop(void) 4016 4020 { 4017 - LOGFQUEUE("audio >| audio Q_AUDIO_STOP"); 4018 - audio_queue_send(Q_AUDIO_STOP, 0); 4021 + LOGFQUEUE("audio > audio Q_AUDIO_STOP"); 4022 + /* Non-blocking post: safe to call from any OS thread. */ 4023 + audio_queue_post(Q_AUDIO_STOP, 0); 4019 4024 } 4020 4025 4021 4026 /* Pause playback if playing */ 4022 4027 void audio_pause(void) 4023 4028 { 4024 - LOGFQUEUE("audio >| audio Q_AUDIO_PAUSE"); 4025 - audio_queue_send(Q_AUDIO_PAUSE, true); 4029 + LOGFQUEUE("audio > audio Q_AUDIO_PAUSE"); 4030 + /* Non-blocking post: safe to call from any OS thread. */ 4031 + audio_queue_post(Q_AUDIO_PAUSE, true); 4026 4032 } 4027 4033 4028 4034 /* This sends a stop message and the audio thread will dump all its 4029 - subsequent messages */ 4035 + subsequent messages. data=2 tells the audio thread to free 4036 + audiobuf_handle itself so the caller need not synchronise. */ 4030 4037 void audio_hard_stop(void) 4031 4038 { 4032 - /* Stop playback */ 4033 - LOGFQUEUE("audio >| audio Q_AUDIO_STOP: 1"); 4034 - audio_queue_send(Q_AUDIO_STOP, 1); 4039 + LOGFQUEUE("audio > audio Q_AUDIO_STOP: 2 (hard)"); 4040 + /* Non-blocking post: safe to call from any OS thread. 4041 + * Use data=2 so the audio thread knows to clear the queue AND free 4042 + * the audio buffer (see Q_AUDIO_STOP handler). The legacy 4043 + * buflib-callback path uses data=1 and does NOT want the handler to 4044 + * free the buffer, so we use a distinct value here. */ 4045 + audio_queue_post(Q_AUDIO_STOP, 2); 4035 4046 #ifdef PLAYBACK_VOICE 4036 4047 voice_stop(); 4037 4048 #endif 4038 - audiobuf_handle = core_free(audiobuf_handle); 4049 + /* audiobuf_handle freed by the audio thread (data=2 path). */ 4039 4050 } 4040 4051 4041 4052 /* Resume playback if paused */

+24 -18

crates/server/src/handlers/playlists.rs

··· 179 179 for i in 0..amount { 180 180 let info = rb::playlist::get_track_info(i); 181 181 // Skip get_metadata for HTTP files — it opens a live connection. 182 - let entry = if info.filename.starts_with("http://") 183 - || info.filename.starts_with("https://") 184 - { 185 - let mut e = rb::types::mp3_entry::Mp3Entry::default(); 186 - e.path = info.filename; 187 - e 188 - } else { 189 - rb::metadata::get_metadata(-1, &info.filename) 190 - }; 182 + let entry = 183 + if info.filename.starts_with("http://") || info.filename.starts_with("https://") { 184 + let mut e = rb::types::mp3_entry::Mp3Entry::default(); 185 + e.path = info.filename; 186 + e 187 + } else { 188 + rb::metadata::get_metadata(-1, &info.filename) 189 + }; 191 190 entries.push(entry); 192 191 } 193 192 entries ··· 416 415 .map(|i| { 417 416 let info = rb::playlist::get_track_info(i); 418 417 let filename = info.filename.clone(); 419 - let entry = 420 - if filename.starts_with("http://") || filename.starts_with("https://") { 421 - let mut e = rockbox_sys::types::mp3_entry::Mp3Entry::default(); 422 - e.path = filename.clone(); 423 - e 424 - } else { 425 - rb::metadata::get_metadata(-1, &filename) 426 - }; 418 + let entry = if filename.starts_with("http://") || filename.starts_with("https://") { 419 + let mut e = rockbox_sys::types::mp3_entry::Mp3Entry::default(); 420 + e.path = filename.clone(); 421 + e 422 + } else { 423 + rb::metadata::get_metadata(-1, &filename) 424 + }; 427 425 (entry, filename) 428 426 }) 429 427 .collect(); ··· 442 440 .await 443 441 .map_err(ErrorInternalServerError)?; 444 442 445 - let (result_base, max_playlist_size, index, first_index, last_insert_pos, seed, last_shuffled_start) = playlist_meta; 443 + let ( 444 + result_base, 445 + max_playlist_size, 446 + index, 447 + first_index, 448 + last_insert_pos, 449 + seed, 450 + last_shuffled_start, 451 + ) = playlist_meta; 446 452 let amount = raw_entries.len() as i32; 447 453 448 454 let mut entries = Vec::with_capacity(raw_entries.len());

+1255 -2532

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

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

Configure Feed

Configure Feed