Rockbox open source high quality audio player as a Music Player Daemon
mpris
rockbox
mpd
libadwaita
audio
rust
zig
deno
run cargo fmt
+2450
-4948
+1240
-2506
cli/src/api/rockbox.v1alpha1.rs
+1240
-2506
cli/src/api/rockbox.v1alpha1.rs
···
43
43
dead_code,
44
44
missing_docs,
45
45
clippy::wildcard_imports,
46
-
clippy::let_unit_value,
46
+
clippy::let_unit_value
47
47
)]
48
-
use tonic::codegen::*;
49
48
use tonic::codegen::http::Uri;
49
+
use tonic::codegen::*;
50
50
#[derive(Debug, Clone)]
51
51
pub struct BrowseServiceClient<T> {
52
52
inner: tonic::client::Grpc<T>,
···
90
90
<T as tonic::client::GrpcService<tonic::body::BoxBody>>::ResponseBody,
91
91
>,
92
92
>,
93
-
<T as tonic::codegen::Service<
94
-
http::Request<tonic::body::BoxBody>,
95
-
>>::Error: Into<StdError> + std::marker::Send + std::marker::Sync,
93
+
<T as tonic::codegen::Service<http::Request<tonic::body::BoxBody>>>::Error:
94
+
Into<StdError> + std::marker::Send + std::marker::Sync,
96
95
{
97
96
BrowseServiceClient::new(InterceptedService::new(inner, interceptor))
98
97
}
···
130
129
pub async fn tree_get_entries(
131
130
&mut self,
132
131
request: impl tonic::IntoRequest<super::TreeGetEntriesRequest>,
133
-
) -> std::result::Result<
134
-
tonic::Response<super::TreeGetEntriesResponse>,
135
-
tonic::Status,
136
-
> {
137
-
self.inner
138
-
.ready()
139
-
.await
140
-
.map_err(|e| {
141
-
tonic::Status::unknown(
142
-
format!("Service was not ready: {}", e.into()),
143
-
)
144
-
})?;
132
+
) -> std::result::Result<tonic::Response<super::TreeGetEntriesResponse>, tonic::Status>
133
+
{
134
+
self.inner.ready().await.map_err(|e| {
135
+
tonic::Status::unknown(format!("Service was not ready: {}", e.into()))
136
+
})?;
145
137
let codec = tonic::codec::ProstCodec::default();
146
138
let path = http::uri::PathAndQuery::from_static(
147
139
"/rockbox.v1alpha1.BrowseService/TreeGetEntries",
148
140
);
149
141
let mut req = request.into_request();
150
-
req.extensions_mut()
151
-
.insert(
152
-
GrpcMethod::new("rockbox.v1alpha1.BrowseService", "TreeGetEntries"),
153
-
);
142
+
req.extensions_mut().insert(GrpcMethod::new(
143
+
"rockbox.v1alpha1.BrowseService",
144
+
"TreeGetEntries",
145
+
));
154
146
self.inner.unary(req, path, codec).await
155
147
}
156
148
}
···
162
154
dead_code,
163
155
missing_docs,
164
156
clippy::wildcard_imports,
165
-
clippy::let_unit_value,
157
+
clippy::let_unit_value
166
158
)]
167
159
use tonic::codegen::*;
168
160
/// Generated trait containing gRPC methods that should be implemented for use with BrowseServiceServer.
···
171
163
async fn tree_get_entries(
172
164
&self,
173
165
request: tonic::Request<super::TreeGetEntriesRequest>,
174
-
) -> std::result::Result<
175
-
tonic::Response<super::TreeGetEntriesResponse>,
176
-
tonic::Status,
177
-
>;
166
+
) -> std::result::Result<tonic::Response<super::TreeGetEntriesResponse>, tonic::Status>;
178
167
}
179
168
#[derive(Debug)]
180
169
pub struct BrowseServiceServer<T> {
···
197
186
max_encoding_message_size: None,
198
187
}
199
188
}
200
-
pub fn with_interceptor<F>(
201
-
inner: T,
202
-
interceptor: F,
203
-
) -> InterceptedService<Self, F>
189
+
pub fn with_interceptor<F>(inner: T, interceptor: F) -> InterceptedService<Self, F>
204
190
where
205
191
F: tonic::service::Interceptor,
206
192
{
···
255
241
"/rockbox.v1alpha1.BrowseService/TreeGetEntries" => {
256
242
#[allow(non_camel_case_types)]
257
243
struct TreeGetEntriesSvc<T: BrowseService>(pub Arc<T>);
258
-
impl<
259
-
T: BrowseService,
260
-
> tonic::server::UnaryService<super::TreeGetEntriesRequest>
261
-
for TreeGetEntriesSvc<T> {
244
+
impl<T: BrowseService> tonic::server::UnaryService<super::TreeGetEntriesRequest>
245
+
for TreeGetEntriesSvc<T>
246
+
{
262
247
type Response = super::TreeGetEntriesResponse;
263
-
type Future = BoxFuture<
264
-
tonic::Response<Self::Response>,
265
-
tonic::Status,
266
-
>;
248
+
type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
267
249
fn call(
268
250
&mut self,
269
251
request: tonic::Request<super::TreeGetEntriesRequest>,
270
252
) -> Self::Future {
271
253
let inner = Arc::clone(&self.0);
272
254
let fut = async move {
273
-
<T as BrowseService>::tree_get_entries(&inner, request)
274
-
.await
255
+
<T as BrowseService>::tree_get_entries(&inner, request).await
275
256
};
276
257
Box::pin(fut)
277
258
}
···
298
279
};
299
280
Box::pin(fut)
300
281
}
301
-
_ => {
302
-
Box::pin(async move {
303
-
let mut response = http::Response::new(empty_body());
304
-
let headers = response.headers_mut();
305
-
headers
306
-
.insert(
307
-
tonic::Status::GRPC_STATUS,
308
-
(tonic::Code::Unimplemented as i32).into(),
309
-
);
310
-
headers
311
-
.insert(
312
-
http::header::CONTENT_TYPE,
313
-
tonic::metadata::GRPC_CONTENT_TYPE,
314
-
);
315
-
Ok(response)
316
-
})
317
-
}
282
+
_ => Box::pin(async move {
283
+
let mut response = http::Response::new(empty_body());
284
+
let headers = response.headers_mut();
285
+
headers.insert(
286
+
tonic::Status::GRPC_STATUS,
287
+
(tonic::Code::Unimplemented as i32).into(),
288
+
);
289
+
headers.insert(
290
+
http::header::CONTENT_TYPE,
291
+
tonic::metadata::GRPC_CONTENT_TYPE,
292
+
);
293
+
Ok(response)
294
+
}),
318
295
}
319
296
}
320
297
}
···
550
527
dead_code,
551
528
missing_docs,
552
529
clippy::wildcard_imports,
553
-
clippy::let_unit_value,
530
+
clippy::let_unit_value
554
531
)]
555
-
use tonic::codegen::*;
556
532
use tonic::codegen::http::Uri;
533
+
use tonic::codegen::*;
557
534
#[derive(Debug, Clone)]
558
535
pub struct LibraryServiceClient<T> {
559
536
inner: tonic::client::Grpc<T>,
···
597
574
<T as tonic::client::GrpcService<tonic::body::BoxBody>>::ResponseBody,
598
575
>,
599
576
>,
600
-
<T as tonic::codegen::Service<
601
-
http::Request<tonic::body::BoxBody>,
602
-
>>::Error: Into<StdError> + std::marker::Send + std::marker::Sync,
577
+
<T as tonic::codegen::Service<http::Request<tonic::body::BoxBody>>>::Error:
578
+
Into<StdError> + std::marker::Send + std::marker::Sync,
603
579
{
604
580
LibraryServiceClient::new(InterceptedService::new(inner, interceptor))
605
581
}
···
637
613
pub async fn get_albums(
638
614
&mut self,
639
615
request: impl tonic::IntoRequest<super::GetAlbumsRequest>,
640
-
) -> std::result::Result<
641
-
tonic::Response<super::GetAlbumsResponse>,
642
-
tonic::Status,
643
-
> {
644
-
self.inner
645
-
.ready()
646
-
.await
647
-
.map_err(|e| {
648
-
tonic::Status::unknown(
649
-
format!("Service was not ready: {}", e.into()),
650
-
)
651
-
})?;
616
+
) -> std::result::Result<tonic::Response<super::GetAlbumsResponse>, tonic::Status> {
617
+
self.inner.ready().await.map_err(|e| {
618
+
tonic::Status::unknown(format!("Service was not ready: {}", e.into()))
619
+
})?;
652
620
let codec = tonic::codec::ProstCodec::default();
653
-
let path = http::uri::PathAndQuery::from_static(
654
-
"/rockbox.v1alpha1.LibraryService/GetAlbums",
655
-
);
621
+
let path =
622
+
http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.LibraryService/GetAlbums");
656
623
let mut req = request.into_request();
657
-
req.extensions_mut()
658
-
.insert(GrpcMethod::new("rockbox.v1alpha1.LibraryService", "GetAlbums"));
624
+
req.extensions_mut().insert(GrpcMethod::new(
625
+
"rockbox.v1alpha1.LibraryService",
626
+
"GetAlbums",
627
+
));
659
628
self.inner.unary(req, path, codec).await
660
629
}
661
630
pub async fn get_artists(
662
631
&mut self,
663
632
request: impl tonic::IntoRequest<super::GetArtistsRequest>,
664
-
) -> std::result::Result<
665
-
tonic::Response<super::GetArtistsResponse>,
666
-
tonic::Status,
667
-
> {
668
-
self.inner
669
-
.ready()
670
-
.await
671
-
.map_err(|e| {
672
-
tonic::Status::unknown(
673
-
format!("Service was not ready: {}", e.into()),
674
-
)
675
-
})?;
633
+
) -> std::result::Result<tonic::Response<super::GetArtistsResponse>, tonic::Status>
634
+
{
635
+
self.inner.ready().await.map_err(|e| {
636
+
tonic::Status::unknown(format!("Service was not ready: {}", e.into()))
637
+
})?;
676
638
let codec = tonic::codec::ProstCodec::default();
677
-
let path = http::uri::PathAndQuery::from_static(
678
-
"/rockbox.v1alpha1.LibraryService/GetArtists",
679
-
);
639
+
let path =
640
+
http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.LibraryService/GetArtists");
680
641
let mut req = request.into_request();
681
-
req.extensions_mut()
682
-
.insert(
683
-
GrpcMethod::new("rockbox.v1alpha1.LibraryService", "GetArtists"),
684
-
);
642
+
req.extensions_mut().insert(GrpcMethod::new(
643
+
"rockbox.v1alpha1.LibraryService",
644
+
"GetArtists",
645
+
));
685
646
self.inner.unary(req, path, codec).await
686
647
}
687
648
pub async fn get_tracks(
688
649
&mut self,
689
650
request: impl tonic::IntoRequest<super::GetTracksRequest>,
690
-
) -> std::result::Result<
691
-
tonic::Response<super::GetTracksResponse>,
692
-
tonic::Status,
693
-
> {
694
-
self.inner
695
-
.ready()
696
-
.await
697
-
.map_err(|e| {
698
-
tonic::Status::unknown(
699
-
format!("Service was not ready: {}", e.into()),
700
-
)
701
-
})?;
651
+
) -> std::result::Result<tonic::Response<super::GetTracksResponse>, tonic::Status> {
652
+
self.inner.ready().await.map_err(|e| {
653
+
tonic::Status::unknown(format!("Service was not ready: {}", e.into()))
654
+
})?;
702
655
let codec = tonic::codec::ProstCodec::default();
703
-
let path = http::uri::PathAndQuery::from_static(
704
-
"/rockbox.v1alpha1.LibraryService/GetTracks",
705
-
);
656
+
let path =
657
+
http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.LibraryService/GetTracks");
706
658
let mut req = request.into_request();
707
-
req.extensions_mut()
708
-
.insert(GrpcMethod::new("rockbox.v1alpha1.LibraryService", "GetTracks"));
659
+
req.extensions_mut().insert(GrpcMethod::new(
660
+
"rockbox.v1alpha1.LibraryService",
661
+
"GetTracks",
662
+
));
709
663
self.inner.unary(req, path, codec).await
710
664
}
711
665
pub async fn get_album(
712
666
&mut self,
713
667
request: impl tonic::IntoRequest<super::GetAlbumRequest>,
714
-
) -> std::result::Result<
715
-
tonic::Response<super::GetAlbumResponse>,
716
-
tonic::Status,
717
-
> {
718
-
self.inner
719
-
.ready()
720
-
.await
721
-
.map_err(|e| {
722
-
tonic::Status::unknown(
723
-
format!("Service was not ready: {}", e.into()),
724
-
)
725
-
})?;
668
+
) -> std::result::Result<tonic::Response<super::GetAlbumResponse>, tonic::Status> {
669
+
self.inner.ready().await.map_err(|e| {
670
+
tonic::Status::unknown(format!("Service was not ready: {}", e.into()))
671
+
})?;
726
672
let codec = tonic::codec::ProstCodec::default();
727
-
let path = http::uri::PathAndQuery::from_static(
728
-
"/rockbox.v1alpha1.LibraryService/GetAlbum",
729
-
);
673
+
let path =
674
+
http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.LibraryService/GetAlbum");
730
675
let mut req = request.into_request();
731
-
req.extensions_mut()
732
-
.insert(GrpcMethod::new("rockbox.v1alpha1.LibraryService", "GetAlbum"));
676
+
req.extensions_mut().insert(GrpcMethod::new(
677
+
"rockbox.v1alpha1.LibraryService",
678
+
"GetAlbum",
679
+
));
733
680
self.inner.unary(req, path, codec).await
734
681
}
735
682
pub async fn get_artist(
736
683
&mut self,
737
684
request: impl tonic::IntoRequest<super::GetArtistRequest>,
738
-
) -> std::result::Result<
739
-
tonic::Response<super::GetArtistResponse>,
740
-
tonic::Status,
741
-
> {
742
-
self.inner
743
-
.ready()
744
-
.await
745
-
.map_err(|e| {
746
-
tonic::Status::unknown(
747
-
format!("Service was not ready: {}", e.into()),
748
-
)
749
-
})?;
685
+
) -> std::result::Result<tonic::Response<super::GetArtistResponse>, tonic::Status> {
686
+
self.inner.ready().await.map_err(|e| {
687
+
tonic::Status::unknown(format!("Service was not ready: {}", e.into()))
688
+
})?;
750
689
let codec = tonic::codec::ProstCodec::default();
751
-
let path = http::uri::PathAndQuery::from_static(
752
-
"/rockbox.v1alpha1.LibraryService/GetArtist",
753
-
);
690
+
let path =
691
+
http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.LibraryService/GetArtist");
754
692
let mut req = request.into_request();
755
-
req.extensions_mut()
756
-
.insert(GrpcMethod::new("rockbox.v1alpha1.LibraryService", "GetArtist"));
693
+
req.extensions_mut().insert(GrpcMethod::new(
694
+
"rockbox.v1alpha1.LibraryService",
695
+
"GetArtist",
696
+
));
757
697
self.inner.unary(req, path, codec).await
758
698
}
759
699
pub async fn get_track(
760
700
&mut self,
761
701
request: impl tonic::IntoRequest<super::GetTrackRequest>,
762
-
) -> std::result::Result<
763
-
tonic::Response<super::GetTrackResponse>,
764
-
tonic::Status,
765
-
> {
766
-
self.inner
767
-
.ready()
768
-
.await
769
-
.map_err(|e| {
770
-
tonic::Status::unknown(
771
-
format!("Service was not ready: {}", e.into()),
772
-
)
773
-
})?;
702
+
) -> std::result::Result<tonic::Response<super::GetTrackResponse>, tonic::Status> {
703
+
self.inner.ready().await.map_err(|e| {
704
+
tonic::Status::unknown(format!("Service was not ready: {}", e.into()))
705
+
})?;
774
706
let codec = tonic::codec::ProstCodec::default();
775
-
let path = http::uri::PathAndQuery::from_static(
776
-
"/rockbox.v1alpha1.LibraryService/GetTrack",
777
-
);
707
+
let path =
708
+
http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.LibraryService/GetTrack");
778
709
let mut req = request.into_request();
779
-
req.extensions_mut()
780
-
.insert(GrpcMethod::new("rockbox.v1alpha1.LibraryService", "GetTrack"));
710
+
req.extensions_mut().insert(GrpcMethod::new(
711
+
"rockbox.v1alpha1.LibraryService",
712
+
"GetTrack",
713
+
));
781
714
self.inner.unary(req, path, codec).await
782
715
}
783
716
pub async fn like_track(
784
717
&mut self,
785
718
request: impl tonic::IntoRequest<super::LikeTrackRequest>,
786
-
) -> std::result::Result<
787
-
tonic::Response<super::LikeTrackResponse>,
788
-
tonic::Status,
789
-
> {
790
-
self.inner
791
-
.ready()
792
-
.await
793
-
.map_err(|e| {
794
-
tonic::Status::unknown(
795
-
format!("Service was not ready: {}", e.into()),
796
-
)
797
-
})?;
719
+
) -> std::result::Result<tonic::Response<super::LikeTrackResponse>, tonic::Status> {
720
+
self.inner.ready().await.map_err(|e| {
721
+
tonic::Status::unknown(format!("Service was not ready: {}", e.into()))
722
+
})?;
798
723
let codec = tonic::codec::ProstCodec::default();
799
-
let path = http::uri::PathAndQuery::from_static(
800
-
"/rockbox.v1alpha1.LibraryService/LikeTrack",
801
-
);
724
+
let path =
725
+
http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.LibraryService/LikeTrack");
802
726
let mut req = request.into_request();
803
-
req.extensions_mut()
804
-
.insert(GrpcMethod::new("rockbox.v1alpha1.LibraryService", "LikeTrack"));
727
+
req.extensions_mut().insert(GrpcMethod::new(
728
+
"rockbox.v1alpha1.LibraryService",
729
+
"LikeTrack",
730
+
));
805
731
self.inner.unary(req, path, codec).await
806
732
}
807
733
pub async fn unlike_track(
808
734
&mut self,
809
735
request: impl tonic::IntoRequest<super::UnlikeTrackRequest>,
810
-
) -> std::result::Result<
811
-
tonic::Response<super::UnlikeTrackResponse>,
812
-
tonic::Status,
813
-
> {
814
-
self.inner
815
-
.ready()
816
-
.await
817
-
.map_err(|e| {
818
-
tonic::Status::unknown(
819
-
format!("Service was not ready: {}", e.into()),
820
-
)
821
-
})?;
736
+
) -> std::result::Result<tonic::Response<super::UnlikeTrackResponse>, tonic::Status>
737
+
{
738
+
self.inner.ready().await.map_err(|e| {
739
+
tonic::Status::unknown(format!("Service was not ready: {}", e.into()))
740
+
})?;
822
741
let codec = tonic::codec::ProstCodec::default();
823
742
let path = http::uri::PathAndQuery::from_static(
824
743
"/rockbox.v1alpha1.LibraryService/UnlikeTrack",
825
744
);
826
745
let mut req = request.into_request();
827
-
req.extensions_mut()
828
-
.insert(
829
-
GrpcMethod::new("rockbox.v1alpha1.LibraryService", "UnlikeTrack"),
830
-
);
746
+
req.extensions_mut().insert(GrpcMethod::new(
747
+
"rockbox.v1alpha1.LibraryService",
748
+
"UnlikeTrack",
749
+
));
831
750
self.inner.unary(req, path, codec).await
832
751
}
833
752
pub async fn like_album(
834
753
&mut self,
835
754
request: impl tonic::IntoRequest<super::LikeAlbumRequest>,
836
-
) -> std::result::Result<
837
-
tonic::Response<super::LikeAlbumResponse>,
838
-
tonic::Status,
839
-
> {
840
-
self.inner
841
-
.ready()
842
-
.await
843
-
.map_err(|e| {
844
-
tonic::Status::unknown(
845
-
format!("Service was not ready: {}", e.into()),
846
-
)
847
-
})?;
755
+
) -> std::result::Result<tonic::Response<super::LikeAlbumResponse>, tonic::Status> {
756
+
self.inner.ready().await.map_err(|e| {
757
+
tonic::Status::unknown(format!("Service was not ready: {}", e.into()))
758
+
})?;
848
759
let codec = tonic::codec::ProstCodec::default();
849
-
let path = http::uri::PathAndQuery::from_static(
850
-
"/rockbox.v1alpha1.LibraryService/LikeAlbum",
851
-
);
760
+
let path =
761
+
http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.LibraryService/LikeAlbum");
852
762
let mut req = request.into_request();
853
-
req.extensions_mut()
854
-
.insert(GrpcMethod::new("rockbox.v1alpha1.LibraryService", "LikeAlbum"));
763
+
req.extensions_mut().insert(GrpcMethod::new(
764
+
"rockbox.v1alpha1.LibraryService",
765
+
"LikeAlbum",
766
+
));
855
767
self.inner.unary(req, path, codec).await
856
768
}
857
769
pub async fn unlike_album(
858
770
&mut self,
859
771
request: impl tonic::IntoRequest<super::UnlikeAlbumRequest>,
860
-
) -> std::result::Result<
861
-
tonic::Response<super::UnlikeAlbumResponse>,
862
-
tonic::Status,
863
-
> {
864
-
self.inner
865
-
.ready()
866
-
.await
867
-
.map_err(|e| {
868
-
tonic::Status::unknown(
869
-
format!("Service was not ready: {}", e.into()),
870
-
)
871
-
})?;
772
+
) -> std::result::Result<tonic::Response<super::UnlikeAlbumResponse>, tonic::Status>
773
+
{
774
+
self.inner.ready().await.map_err(|e| {
775
+
tonic::Status::unknown(format!("Service was not ready: {}", e.into()))
776
+
})?;
872
777
let codec = tonic::codec::ProstCodec::default();
873
778
let path = http::uri::PathAndQuery::from_static(
874
779
"/rockbox.v1alpha1.LibraryService/UnlikeAlbum",
875
780
);
876
781
let mut req = request.into_request();
877
-
req.extensions_mut()
878
-
.insert(
879
-
GrpcMethod::new("rockbox.v1alpha1.LibraryService", "UnlikeAlbum"),
880
-
);
782
+
req.extensions_mut().insert(GrpcMethod::new(
783
+
"rockbox.v1alpha1.LibraryService",
784
+
"UnlikeAlbum",
785
+
));
881
786
self.inner.unary(req, path, codec).await
882
787
}
883
788
pub async fn get_liked_tracks(
884
789
&mut self,
885
790
request: impl tonic::IntoRequest<super::GetLikedTracksRequest>,
886
-
) -> std::result::Result<
887
-
tonic::Response<super::GetLikedTracksResponse>,
888
-
tonic::Status,
889
-
> {
890
-
self.inner
891
-
.ready()
892
-
.await
893
-
.map_err(|e| {
894
-
tonic::Status::unknown(
895
-
format!("Service was not ready: {}", e.into()),
896
-
)
897
-
})?;
791
+
) -> std::result::Result<tonic::Response<super::GetLikedTracksResponse>, tonic::Status>
792
+
{
793
+
self.inner.ready().await.map_err(|e| {
794
+
tonic::Status::unknown(format!("Service was not ready: {}", e.into()))
795
+
})?;
898
796
let codec = tonic::codec::ProstCodec::default();
899
797
let path = http::uri::PathAndQuery::from_static(
900
798
"/rockbox.v1alpha1.LibraryService/GetLikedTracks",
901
799
);
902
800
let mut req = request.into_request();
903
-
req.extensions_mut()
904
-
.insert(
905
-
GrpcMethod::new("rockbox.v1alpha1.LibraryService", "GetLikedTracks"),
906
-
);
801
+
req.extensions_mut().insert(GrpcMethod::new(
802
+
"rockbox.v1alpha1.LibraryService",
803
+
"GetLikedTracks",
804
+
));
907
805
self.inner.unary(req, path, codec).await
908
806
}
909
807
pub async fn get_liked_albums(
910
808
&mut self,
911
809
request: impl tonic::IntoRequest<super::GetLikedAlbumsRequest>,
912
-
) -> std::result::Result<
913
-
tonic::Response<super::GetLikedAlbumsResponse>,
914
-
tonic::Status,
915
-
> {
916
-
self.inner
917
-
.ready()
918
-
.await
919
-
.map_err(|e| {
920
-
tonic::Status::unknown(
921
-
format!("Service was not ready: {}", e.into()),
922
-
)
923
-
})?;
810
+
) -> std::result::Result<tonic::Response<super::GetLikedAlbumsResponse>, tonic::Status>
811
+
{
812
+
self.inner.ready().await.map_err(|e| {
813
+
tonic::Status::unknown(format!("Service was not ready: {}", e.into()))
814
+
})?;
924
815
let codec = tonic::codec::ProstCodec::default();
925
816
let path = http::uri::PathAndQuery::from_static(
926
817
"/rockbox.v1alpha1.LibraryService/GetLikedAlbums",
927
818
);
928
819
let mut req = request.into_request();
929
-
req.extensions_mut()
930
-
.insert(
931
-
GrpcMethod::new("rockbox.v1alpha1.LibraryService", "GetLikedAlbums"),
932
-
);
820
+
req.extensions_mut().insert(GrpcMethod::new(
821
+
"rockbox.v1alpha1.LibraryService",
822
+
"GetLikedAlbums",
823
+
));
933
824
self.inner.unary(req, path, codec).await
934
825
}
935
826
pub async fn scan_library(
936
827
&mut self,
937
828
request: impl tonic::IntoRequest<super::ScanLibraryRequest>,
938
-
) -> std::result::Result<
939
-
tonic::Response<super::ScanLibraryResponse>,
940
-
tonic::Status,
941
-
> {
942
-
self.inner
943
-
.ready()
944
-
.await
945
-
.map_err(|e| {
946
-
tonic::Status::unknown(
947
-
format!("Service was not ready: {}", e.into()),
948
-
)
949
-
})?;
829
+
) -> std::result::Result<tonic::Response<super::ScanLibraryResponse>, tonic::Status>
830
+
{
831
+
self.inner.ready().await.map_err(|e| {
832
+
tonic::Status::unknown(format!("Service was not ready: {}", e.into()))
833
+
})?;
950
834
let codec = tonic::codec::ProstCodec::default();
951
835
let path = http::uri::PathAndQuery::from_static(
952
836
"/rockbox.v1alpha1.LibraryService/ScanLibrary",
953
837
);
954
838
let mut req = request.into_request();
955
-
req.extensions_mut()
956
-
.insert(
957
-
GrpcMethod::new("rockbox.v1alpha1.LibraryService", "ScanLibrary"),
958
-
);
839
+
req.extensions_mut().insert(GrpcMethod::new(
840
+
"rockbox.v1alpha1.LibraryService",
841
+
"ScanLibrary",
842
+
));
959
843
self.inner.unary(req, path, codec).await
960
844
}
961
845
pub async fn search(
962
846
&mut self,
963
847
request: impl tonic::IntoRequest<super::SearchRequest>,
964
848
) -> std::result::Result<tonic::Response<super::SearchResponse>, tonic::Status> {
965
-
self.inner
966
-
.ready()
967
-
.await
968
-
.map_err(|e| {
969
-
tonic::Status::unknown(
970
-
format!("Service was not ready: {}", e.into()),
971
-
)
972
-
})?;
849
+
self.inner.ready().await.map_err(|e| {
850
+
tonic::Status::unknown(format!("Service was not ready: {}", e.into()))
851
+
})?;
973
852
let codec = tonic::codec::ProstCodec::default();
974
-
let path = http::uri::PathAndQuery::from_static(
975
-
"/rockbox.v1alpha1.LibraryService/Search",
976
-
);
853
+
let path =
854
+
http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.LibraryService/Search");
977
855
let mut req = request.into_request();
978
856
req.extensions_mut()
979
857
.insert(GrpcMethod::new("rockbox.v1alpha1.LibraryService", "Search"));
···
988
866
dead_code,
989
867
missing_docs,
990
868
clippy::wildcard_imports,
991
-
clippy::let_unit_value,
869
+
clippy::let_unit_value
992
870
)]
993
871
use tonic::codegen::*;
994
872
/// Generated trait containing gRPC methods that should be implemented for use with LibraryServiceServer.
···
997
875
async fn get_albums(
998
876
&self,
999
877
request: tonic::Request<super::GetAlbumsRequest>,
1000
-
) -> std::result::Result<
1001
-
tonic::Response<super::GetAlbumsResponse>,
1002
-
tonic::Status,
1003
-
>;
878
+
) -> std::result::Result<tonic::Response<super::GetAlbumsResponse>, tonic::Status>;
1004
879
async fn get_artists(
1005
880
&self,
1006
881
request: tonic::Request<super::GetArtistsRequest>,
1007
-
) -> std::result::Result<
1008
-
tonic::Response<super::GetArtistsResponse>,
1009
-
tonic::Status,
1010
-
>;
882
+
) -> std::result::Result<tonic::Response<super::GetArtistsResponse>, tonic::Status>;
1011
883
async fn get_tracks(
1012
884
&self,
1013
885
request: tonic::Request<super::GetTracksRequest>,
1014
-
) -> std::result::Result<
1015
-
tonic::Response<super::GetTracksResponse>,
1016
-
tonic::Status,
1017
-
>;
886
+
) -> std::result::Result<tonic::Response<super::GetTracksResponse>, tonic::Status>;
1018
887
async fn get_album(
1019
888
&self,
1020
889
request: tonic::Request<super::GetAlbumRequest>,
1021
-
) -> std::result::Result<
1022
-
tonic::Response<super::GetAlbumResponse>,
1023
-
tonic::Status,
1024
-
>;
890
+
) -> std::result::Result<tonic::Response<super::GetAlbumResponse>, tonic::Status>;
1025
891
async fn get_artist(
1026
892
&self,
1027
893
request: tonic::Request<super::GetArtistRequest>,
1028
-
) -> std::result::Result<
1029
-
tonic::Response<super::GetArtistResponse>,
1030
-
tonic::Status,
1031
-
>;
894
+
) -> std::result::Result<tonic::Response<super::GetArtistResponse>, tonic::Status>;
1032
895
async fn get_track(
1033
896
&self,
1034
897
request: tonic::Request<super::GetTrackRequest>,
1035
-
) -> std::result::Result<
1036
-
tonic::Response<super::GetTrackResponse>,
1037
-
tonic::Status,
1038
-
>;
898
+
) -> std::result::Result<tonic::Response<super::GetTrackResponse>, tonic::Status>;
1039
899
async fn like_track(
1040
900
&self,
1041
901
request: tonic::Request<super::LikeTrackRequest>,
1042
-
) -> std::result::Result<
1043
-
tonic::Response<super::LikeTrackResponse>,
1044
-
tonic::Status,
1045
-
>;
902
+
) -> std::result::Result<tonic::Response<super::LikeTrackResponse>, tonic::Status>;
1046
903
async fn unlike_track(
1047
904
&self,
1048
905
request: tonic::Request<super::UnlikeTrackRequest>,
1049
-
) -> std::result::Result<
1050
-
tonic::Response<super::UnlikeTrackResponse>,
1051
-
tonic::Status,
1052
-
>;
906
+
) -> std::result::Result<tonic::Response<super::UnlikeTrackResponse>, tonic::Status>;
1053
907
async fn like_album(
1054
908
&self,
1055
909
request: tonic::Request<super::LikeAlbumRequest>,
1056
-
) -> std::result::Result<
1057
-
tonic::Response<super::LikeAlbumResponse>,
1058
-
tonic::Status,
1059
-
>;
910
+
) -> std::result::Result<tonic::Response<super::LikeAlbumResponse>, tonic::Status>;
1060
911
async fn unlike_album(
1061
912
&self,
1062
913
request: tonic::Request<super::UnlikeAlbumRequest>,
1063
-
) -> std::result::Result<
1064
-
tonic::Response<super::UnlikeAlbumResponse>,
1065
-
tonic::Status,
1066
-
>;
914
+
) -> std::result::Result<tonic::Response<super::UnlikeAlbumResponse>, tonic::Status>;
1067
915
async fn get_liked_tracks(
1068
916
&self,
1069
917
request: tonic::Request<super::GetLikedTracksRequest>,
1070
-
) -> std::result::Result<
1071
-
tonic::Response<super::GetLikedTracksResponse>,
1072
-
tonic::Status,
1073
-
>;
918
+
) -> std::result::Result<tonic::Response<super::GetLikedTracksResponse>, tonic::Status>;
1074
919
async fn get_liked_albums(
1075
920
&self,
1076
921
request: tonic::Request<super::GetLikedAlbumsRequest>,
1077
-
) -> std::result::Result<
1078
-
tonic::Response<super::GetLikedAlbumsResponse>,
1079
-
tonic::Status,
1080
-
>;
922
+
) -> std::result::Result<tonic::Response<super::GetLikedAlbumsResponse>, tonic::Status>;
1081
923
async fn scan_library(
1082
924
&self,
1083
925
request: tonic::Request<super::ScanLibraryRequest>,
1084
-
) -> std::result::Result<
1085
-
tonic::Response<super::ScanLibraryResponse>,
1086
-
tonic::Status,
1087
-
>;
926
+
) -> std::result::Result<tonic::Response<super::ScanLibraryResponse>, tonic::Status>;
1088
927
async fn search(
1089
928
&self,
1090
929
request: tonic::Request<super::SearchRequest>,
···
1111
950
max_encoding_message_size: None,
1112
951
}
1113
952
}
1114
-
pub fn with_interceptor<F>(
1115
-
inner: T,
1116
-
interceptor: F,
1117
-
) -> InterceptedService<Self, F>
953
+
pub fn with_interceptor<F>(inner: T, interceptor: F) -> InterceptedService<Self, F>
1118
954
where
1119
955
F: tonic::service::Interceptor,
1120
956
{
···
1169
1005
"/rockbox.v1alpha1.LibraryService/GetAlbums" => {
1170
1006
#[allow(non_camel_case_types)]
1171
1007
struct GetAlbumsSvc<T: LibraryService>(pub Arc<T>);
1172
-
impl<
1173
-
T: LibraryService,
1174
-
> tonic::server::UnaryService<super::GetAlbumsRequest>
1175
-
for GetAlbumsSvc<T> {
1008
+
impl<T: LibraryService> tonic::server::UnaryService<super::GetAlbumsRequest> for GetAlbumsSvc<T> {
1176
1009
type Response = super::GetAlbumsResponse;
1177
-
type Future = BoxFuture<
1178
-
tonic::Response<Self::Response>,
1179
-
tonic::Status,
1180
-
>;
1010
+
type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
1181
1011
fn call(
1182
1012
&mut self,
1183
1013
request: tonic::Request<super::GetAlbumsRequest>,
···
1214
1044
"/rockbox.v1alpha1.LibraryService/GetArtists" => {
1215
1045
#[allow(non_camel_case_types)]
1216
1046
struct GetArtistsSvc<T: LibraryService>(pub Arc<T>);
1217
-
impl<
1218
-
T: LibraryService,
1219
-
> tonic::server::UnaryService<super::GetArtistsRequest>
1220
-
for GetArtistsSvc<T> {
1047
+
impl<T: LibraryService> tonic::server::UnaryService<super::GetArtistsRequest> for GetArtistsSvc<T> {
1221
1048
type Response = super::GetArtistsResponse;
1222
-
type Future = BoxFuture<
1223
-
tonic::Response<Self::Response>,
1224
-
tonic::Status,
1225
-
>;
1049
+
type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
1226
1050
fn call(
1227
1051
&mut self,
1228
1052
request: tonic::Request<super::GetArtistsRequest>,
···
1259
1083
"/rockbox.v1alpha1.LibraryService/GetTracks" => {
1260
1084
#[allow(non_camel_case_types)]
1261
1085
struct GetTracksSvc<T: LibraryService>(pub Arc<T>);
1262
-
impl<
1263
-
T: LibraryService,
1264
-
> tonic::server::UnaryService<super::GetTracksRequest>
1265
-
for GetTracksSvc<T> {
1086
+
impl<T: LibraryService> tonic::server::UnaryService<super::GetTracksRequest> for GetTracksSvc<T> {
1266
1087
type Response = super::GetTracksResponse;
1267
-
type Future = BoxFuture<
1268
-
tonic::Response<Self::Response>,
1269
-
tonic::Status,
1270
-
>;
1088
+
type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
1271
1089
fn call(
1272
1090
&mut self,
1273
1091
request: tonic::Request<super::GetTracksRequest>,
···
1304
1122
"/rockbox.v1alpha1.LibraryService/GetAlbum" => {
1305
1123
#[allow(non_camel_case_types)]
1306
1124
struct GetAlbumSvc<T: LibraryService>(pub Arc<T>);
1307
-
impl<
1308
-
T: LibraryService,
1309
-
> tonic::server::UnaryService<super::GetAlbumRequest>
1310
-
for GetAlbumSvc<T> {
1125
+
impl<T: LibraryService> tonic::server::UnaryService<super::GetAlbumRequest> for GetAlbumSvc<T> {
1311
1126
type Response = super::GetAlbumResponse;
1312
-
type Future = BoxFuture<
1313
-
tonic::Response<Self::Response>,
1314
-
tonic::Status,
1315
-
>;
1127
+
type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
1316
1128
fn call(
1317
1129
&mut self,
1318
1130
request: tonic::Request<super::GetAlbumRequest>,
···
1349
1161
"/rockbox.v1alpha1.LibraryService/GetArtist" => {
1350
1162
#[allow(non_camel_case_types)]
1351
1163
struct GetArtistSvc<T: LibraryService>(pub Arc<T>);
1352
-
impl<
1353
-
T: LibraryService,
1354
-
> tonic::server::UnaryService<super::GetArtistRequest>
1355
-
for GetArtistSvc<T> {
1164
+
impl<T: LibraryService> tonic::server::UnaryService<super::GetArtistRequest> for GetArtistSvc<T> {
1356
1165
type Response = super::GetArtistResponse;
1357
-
type Future = BoxFuture<
1358
-
tonic::Response<Self::Response>,
1359
-
tonic::Status,
1360
-
>;
1166
+
type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
1361
1167
fn call(
1362
1168
&mut self,
1363
1169
request: tonic::Request<super::GetArtistRequest>,
···
1394
1200
"/rockbox.v1alpha1.LibraryService/GetTrack" => {
1395
1201
#[allow(non_camel_case_types)]
1396
1202
struct GetTrackSvc<T: LibraryService>(pub Arc<T>);
1397
-
impl<
1398
-
T: LibraryService,
1399
-
> tonic::server::UnaryService<super::GetTrackRequest>
1400
-
for GetTrackSvc<T> {
1203
+
impl<T: LibraryService> tonic::server::UnaryService<super::GetTrackRequest> for GetTrackSvc<T> {
1401
1204
type Response = super::GetTrackResponse;
1402
-
type Future = BoxFuture<
1403
-
tonic::Response<Self::Response>,
1404
-
tonic::Status,
1405
-
>;
1205
+
type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
1406
1206
fn call(
1407
1207
&mut self,
1408
1208
request: tonic::Request<super::GetTrackRequest>,
···
1439
1239
"/rockbox.v1alpha1.LibraryService/LikeTrack" => {
1440
1240
#[allow(non_camel_case_types)]
1441
1241
struct LikeTrackSvc<T: LibraryService>(pub Arc<T>);
1442
-
impl<
1443
-
T: LibraryService,
1444
-
> tonic::server::UnaryService<super::LikeTrackRequest>
1445
-
for LikeTrackSvc<T> {
1242
+
impl<T: LibraryService> tonic::server::UnaryService<super::LikeTrackRequest> for LikeTrackSvc<T> {
1446
1243
type Response = super::LikeTrackResponse;
1447
-
type Future = BoxFuture<
1448
-
tonic::Response<Self::Response>,
1449
-
tonic::Status,
1450
-
>;
1244
+
type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
1451
1245
fn call(
1452
1246
&mut self,
1453
1247
request: tonic::Request<super::LikeTrackRequest>,
···
1484
1278
"/rockbox.v1alpha1.LibraryService/UnlikeTrack" => {
1485
1279
#[allow(non_camel_case_types)]
1486
1280
struct UnlikeTrackSvc<T: LibraryService>(pub Arc<T>);
1487
-
impl<
1488
-
T: LibraryService,
1489
-
> tonic::server::UnaryService<super::UnlikeTrackRequest>
1490
-
for UnlikeTrackSvc<T> {
1281
+
impl<T: LibraryService> tonic::server::UnaryService<super::UnlikeTrackRequest>
1282
+
for UnlikeTrackSvc<T>
1283
+
{
1491
1284
type Response = super::UnlikeTrackResponse;
1492
-
type Future = BoxFuture<
1493
-
tonic::Response<Self::Response>,
1494
-
tonic::Status,
1495
-
>;
1285
+
type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
1496
1286
fn call(
1497
1287
&mut self,
1498
1288
request: tonic::Request<super::UnlikeTrackRequest>,
···
1529
1319
"/rockbox.v1alpha1.LibraryService/LikeAlbum" => {
1530
1320
#[allow(non_camel_case_types)]
1531
1321
struct LikeAlbumSvc<T: LibraryService>(pub Arc<T>);
1532
-
impl<
1533
-
T: LibraryService,
1534
-
> tonic::server::UnaryService<super::LikeAlbumRequest>
1535
-
for LikeAlbumSvc<T> {
1322
+
impl<T: LibraryService> tonic::server::UnaryService<super::LikeAlbumRequest> for LikeAlbumSvc<T> {
1536
1323
type Response = super::LikeAlbumResponse;
1537
-
type Future = BoxFuture<
1538
-
tonic::Response<Self::Response>,
1539
-
tonic::Status,
1540
-
>;
1324
+
type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
1541
1325
fn call(
1542
1326
&mut self,
1543
1327
request: tonic::Request<super::LikeAlbumRequest>,
···
1574
1358
"/rockbox.v1alpha1.LibraryService/UnlikeAlbum" => {
1575
1359
#[allow(non_camel_case_types)]
1576
1360
struct UnlikeAlbumSvc<T: LibraryService>(pub Arc<T>);
1577
-
impl<
1578
-
T: LibraryService,
1579
-
> tonic::server::UnaryService<super::UnlikeAlbumRequest>
1580
-
for UnlikeAlbumSvc<T> {
1361
+
impl<T: LibraryService> tonic::server::UnaryService<super::UnlikeAlbumRequest>
1362
+
for UnlikeAlbumSvc<T>
1363
+
{
1581
1364
type Response = super::UnlikeAlbumResponse;
1582
-
type Future = BoxFuture<
1583
-
tonic::Response<Self::Response>,
1584
-
tonic::Status,
1585
-
>;
1365
+
type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
1586
1366
fn call(
1587
1367
&mut self,
1588
1368
request: tonic::Request<super::UnlikeAlbumRequest>,
···
1619
1399
"/rockbox.v1alpha1.LibraryService/GetLikedTracks" => {
1620
1400
#[allow(non_camel_case_types)]
1621
1401
struct GetLikedTracksSvc<T: LibraryService>(pub Arc<T>);
1622
-
impl<
1623
-
T: LibraryService,
1624
-
> tonic::server::UnaryService<super::GetLikedTracksRequest>
1625
-
for GetLikedTracksSvc<T> {
1402
+
impl<T: LibraryService>
1403
+
tonic::server::UnaryService<super::GetLikedTracksRequest>
1404
+
for GetLikedTracksSvc<T>
1405
+
{
1626
1406
type Response = super::GetLikedTracksResponse;
1627
-
type Future = BoxFuture<
1628
-
tonic::Response<Self::Response>,
1629
-
tonic::Status,
1630
-
>;
1407
+
type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
1631
1408
fn call(
1632
1409
&mut self,
1633
1410
request: tonic::Request<super::GetLikedTracksRequest>,
1634
1411
) -> Self::Future {
1635
1412
let inner = Arc::clone(&self.0);
1636
1413
let fut = async move {
1637
-
<T as LibraryService>::get_liked_tracks(&inner, request)
1638
-
.await
1414
+
<T as LibraryService>::get_liked_tracks(&inner, request).await
1639
1415
};
1640
1416
Box::pin(fut)
1641
1417
}
···
1665
1441
"/rockbox.v1alpha1.LibraryService/GetLikedAlbums" => {
1666
1442
#[allow(non_camel_case_types)]
1667
1443
struct GetLikedAlbumsSvc<T: LibraryService>(pub Arc<T>);
1668
-
impl<
1669
-
T: LibraryService,
1670
-
> tonic::server::UnaryService<super::GetLikedAlbumsRequest>
1671
-
for GetLikedAlbumsSvc<T> {
1444
+
impl<T: LibraryService>
1445
+
tonic::server::UnaryService<super::GetLikedAlbumsRequest>
1446
+
for GetLikedAlbumsSvc<T>
1447
+
{
1672
1448
type Response = super::GetLikedAlbumsResponse;
1673
-
type Future = BoxFuture<
1674
-
tonic::Response<Self::Response>,
1675
-
tonic::Status,
1676
-
>;
1449
+
type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
1677
1450
fn call(
1678
1451
&mut self,
1679
1452
request: tonic::Request<super::GetLikedAlbumsRequest>,
1680
1453
) -> Self::Future {
1681
1454
let inner = Arc::clone(&self.0);
1682
1455
let fut = async move {
1683
-
<T as LibraryService>::get_liked_albums(&inner, request)
1684
-
.await
1456
+
<T as LibraryService>::get_liked_albums(&inner, request).await
1685
1457
};
1686
1458
Box::pin(fut)
1687
1459
}
···
1711
1483
"/rockbox.v1alpha1.LibraryService/ScanLibrary" => {
1712
1484
#[allow(non_camel_case_types)]
1713
1485
struct ScanLibrarySvc<T: LibraryService>(pub Arc<T>);
1714
-
impl<
1715
-
T: LibraryService,
1716
-
> tonic::server::UnaryService<super::ScanLibraryRequest>
1717
-
for ScanLibrarySvc<T> {
1486
+
impl<T: LibraryService> tonic::server::UnaryService<super::ScanLibraryRequest>
1487
+
for ScanLibrarySvc<T>
1488
+
{
1718
1489
type Response = super::ScanLibraryResponse;
1719
-
type Future = BoxFuture<
1720
-
tonic::Response<Self::Response>,
1721
-
tonic::Status,
1722
-
>;
1490
+
type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
1723
1491
fn call(
1724
1492
&mut self,
1725
1493
request: tonic::Request<super::ScanLibraryRequest>,
···
1756
1524
"/rockbox.v1alpha1.LibraryService/Search" => {
1757
1525
#[allow(non_camel_case_types)]
1758
1526
struct SearchSvc<T: LibraryService>(pub Arc<T>);
1759
-
impl<
1760
-
T: LibraryService,
1761
-
> tonic::server::UnaryService<super::SearchRequest>
1762
-
for SearchSvc<T> {
1527
+
impl<T: LibraryService> tonic::server::UnaryService<super::SearchRequest> for SearchSvc<T> {
1763
1528
type Response = super::SearchResponse;
1764
-
type Future = BoxFuture<
1765
-
tonic::Response<Self::Response>,
1766
-
tonic::Status,
1767
-
>;
1529
+
type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
1768
1530
fn call(
1769
1531
&mut self,
1770
1532
request: tonic::Request<super::SearchRequest>,
1771
1533
) -> Self::Future {
1772
1534
let inner = Arc::clone(&self.0);
1773
-
let fut = async move {
1774
-
<T as LibraryService>::search(&inner, request).await
1775
-
};
1535
+
let fut =
1536
+
async move { <T as LibraryService>::search(&inner, request).await };
1776
1537
Box::pin(fut)
1777
1538
}
1778
1539
}
···
1798
1559
};
1799
1560
Box::pin(fut)
1800
1561
}
1801
-
_ => {
1802
-
Box::pin(async move {
1803
-
let mut response = http::Response::new(empty_body());
1804
-
let headers = response.headers_mut();
1805
-
headers
1806
-
.insert(
1807
-
tonic::Status::GRPC_STATUS,
1808
-
(tonic::Code::Unimplemented as i32).into(),
1809
-
);
1810
-
headers
1811
-
.insert(
1812
-
http::header::CONTENT_TYPE,
1813
-
tonic::metadata::GRPC_CONTENT_TYPE,
1814
-
);
1815
-
Ok(response)
1816
-
})
1817
-
}
1562
+
_ => Box::pin(async move {
1563
+
let mut response = http::Response::new(empty_body());
1564
+
let headers = response.headers_mut();
1565
+
headers.insert(
1566
+
tonic::Status::GRPC_STATUS,
1567
+
(tonic::Code::Unimplemented as i32).into(),
1568
+
);
1569
+
headers.insert(
1570
+
http::header::CONTENT_TYPE,
1571
+
tonic::metadata::GRPC_CONTENT_TYPE,
1572
+
);
1573
+
Ok(response)
1574
+
}),
1818
1575
}
1819
1576
}
1820
1577
}
···
1843
1600
dead_code,
1844
1601
missing_docs,
1845
1602
clippy::wildcard_imports,
1846
-
clippy::let_unit_value,
1603
+
clippy::let_unit_value
1847
1604
)]
1848
-
use tonic::codegen::*;
1849
1605
use tonic::codegen::http::Uri;
1606
+
use tonic::codegen::*;
1850
1607
#[derive(Debug, Clone)]
1851
1608
pub struct MetadataServiceClient<T> {
1852
1609
inner: tonic::client::Grpc<T>,
···
1890
1647
<T as tonic::client::GrpcService<tonic::body::BoxBody>>::ResponseBody,
1891
1648
>,
1892
1649
>,
1893
-
<T as tonic::codegen::Service<
1894
-
http::Request<tonic::body::BoxBody>,
1895
-
>>::Error: Into<StdError> + std::marker::Send + std::marker::Sync,
1650
+
<T as tonic::codegen::Service<http::Request<tonic::body::BoxBody>>>::Error:
1651
+
Into<StdError> + std::marker::Send + std::marker::Sync,
1896
1652
{
1897
1653
MetadataServiceClient::new(InterceptedService::new(inner, interceptor))
1898
1654
}
···
1936
1692
dead_code,
1937
1693
missing_docs,
1938
1694
clippy::wildcard_imports,
1939
-
clippy::let_unit_value,
1695
+
clippy::let_unit_value
1940
1696
)]
1941
1697
use tonic::codegen::*;
1942
1698
/// Generated trait containing gRPC methods that should be implemented for use with MetadataServiceServer.
···
1963
1719
max_encoding_message_size: None,
1964
1720
}
1965
1721
}
1966
-
pub fn with_interceptor<F>(
1967
-
inner: T,
1968
-
interceptor: F,
1969
-
) -> InterceptedService<Self, F>
1722
+
pub fn with_interceptor<F>(inner: T, interceptor: F) -> InterceptedService<Self, F>
1970
1723
where
1971
1724
F: tonic::service::Interceptor,
1972
1725
{
···
2018
1771
}
2019
1772
fn call(&mut self, req: http::Request<B>) -> Self::Future {
2020
1773
match req.uri().path() {
2021
-
_ => {
2022
-
Box::pin(async move {
2023
-
let mut response = http::Response::new(empty_body());
2024
-
let headers = response.headers_mut();
2025
-
headers
2026
-
.insert(
2027
-
tonic::Status::GRPC_STATUS,
2028
-
(tonic::Code::Unimplemented as i32).into(),
2029
-
);
2030
-
headers
2031
-
.insert(
2032
-
http::header::CONTENT_TYPE,
2033
-
tonic::metadata::GRPC_CONTENT_TYPE,
2034
-
);
2035
-
Ok(response)
2036
-
})
2037
-
}
1774
+
_ => Box::pin(async move {
1775
+
let mut response = http::Response::new(empty_body());
1776
+
let headers = response.headers_mut();
1777
+
headers.insert(
1778
+
tonic::Status::GRPC_STATUS,
1779
+
(tonic::Code::Unimplemented as i32).into(),
1780
+
);
1781
+
headers.insert(
1782
+
http::header::CONTENT_TYPE,
1783
+
tonic::metadata::GRPC_CONTENT_TYPE,
1784
+
);
1785
+
Ok(response)
1786
+
}),
2038
1787
}
2039
1788
}
2040
1789
}
···
2318
2067
dead_code,
2319
2068
missing_docs,
2320
2069
clippy::wildcard_imports,
2321
-
clippy::let_unit_value,
2070
+
clippy::let_unit_value
2322
2071
)]
2323
-
use tonic::codegen::*;
2324
2072
use tonic::codegen::http::Uri;
2073
+
use tonic::codegen::*;
2325
2074
#[derive(Debug, Clone)]
2326
2075
pub struct PlaybackServiceClient<T> {
2327
2076
inner: tonic::client::Grpc<T>,
···
2365
2114
<T as tonic::client::GrpcService<tonic::body::BoxBody>>::ResponseBody,
2366
2115
>,
2367
2116
>,
2368
-
<T as tonic::codegen::Service<
2369
-
http::Request<tonic::body::BoxBody>,
2370
-
>>::Error: Into<StdError> + std::marker::Send + std::marker::Sync,
2117
+
<T as tonic::codegen::Service<http::Request<tonic::body::BoxBody>>>::Error:
2118
+
Into<StdError> + std::marker::Send + std::marker::Sync,
2371
2119
{
2372
2120
PlaybackServiceClient::new(InterceptedService::new(inner, interceptor))
2373
2121
}
···
2406
2154
&mut self,
2407
2155
request: impl tonic::IntoRequest<super::PlayRequest>,
2408
2156
) -> std::result::Result<tonic::Response<super::PlayResponse>, tonic::Status> {
2409
-
self.inner
2410
-
.ready()
2411
-
.await
2412
-
.map_err(|e| {
2413
-
tonic::Status::unknown(
2414
-
format!("Service was not ready: {}", e.into()),
2415
-
)
2416
-
})?;
2157
+
self.inner.ready().await.map_err(|e| {
2158
+
tonic::Status::unknown(format!("Service was not ready: {}", e.into()))
2159
+
})?;
2417
2160
let codec = tonic::codec::ProstCodec::default();
2418
-
let path = http::uri::PathAndQuery::from_static(
2419
-
"/rockbox.v1alpha1.PlaybackService/Play",
2420
-
);
2161
+
let path =
2162
+
http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.PlaybackService/Play");
2421
2163
let mut req = request.into_request();
2422
2164
req.extensions_mut()
2423
2165
.insert(GrpcMethod::new("rockbox.v1alpha1.PlaybackService", "Play"));
···
2427
2169
&mut self,
2428
2170
request: impl tonic::IntoRequest<super::PauseRequest>,
2429
2171
) -> std::result::Result<tonic::Response<super::PauseResponse>, tonic::Status> {
2430
-
self.inner
2431
-
.ready()
2432
-
.await
2433
-
.map_err(|e| {
2434
-
tonic::Status::unknown(
2435
-
format!("Service was not ready: {}", e.into()),
2436
-
)
2437
-
})?;
2172
+
self.inner.ready().await.map_err(|e| {
2173
+
tonic::Status::unknown(format!("Service was not ready: {}", e.into()))
2174
+
})?;
2438
2175
let codec = tonic::codec::ProstCodec::default();
2439
-
let path = http::uri::PathAndQuery::from_static(
2440
-
"/rockbox.v1alpha1.PlaybackService/Pause",
2441
-
);
2176
+
let path =
2177
+
http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.PlaybackService/Pause");
2442
2178
let mut req = request.into_request();
2443
2179
req.extensions_mut()
2444
2180
.insert(GrpcMethod::new("rockbox.v1alpha1.PlaybackService", "Pause"));
···
2447
2183
pub async fn play_or_pause(
2448
2184
&mut self,
2449
2185
request: impl tonic::IntoRequest<super::PlayOrPauseRequest>,
2450
-
) -> std::result::Result<
2451
-
tonic::Response<super::PlayOrPauseResponse>,
2452
-
tonic::Status,
2453
-
> {
2454
-
self.inner
2455
-
.ready()
2456
-
.await
2457
-
.map_err(|e| {
2458
-
tonic::Status::unknown(
2459
-
format!("Service was not ready: {}", e.into()),
2460
-
)
2461
-
})?;
2186
+
) -> std::result::Result<tonic::Response<super::PlayOrPauseResponse>, tonic::Status>
2187
+
{
2188
+
self.inner.ready().await.map_err(|e| {
2189
+
tonic::Status::unknown(format!("Service was not ready: {}", e.into()))
2190
+
})?;
2462
2191
let codec = tonic::codec::ProstCodec::default();
2463
2192
let path = http::uri::PathAndQuery::from_static(
2464
2193
"/rockbox.v1alpha1.PlaybackService/PlayOrPause",
2465
2194
);
2466
2195
let mut req = request.into_request();
2467
-
req.extensions_mut()
2468
-
.insert(
2469
-
GrpcMethod::new("rockbox.v1alpha1.PlaybackService", "PlayOrPause"),
2470
-
);
2196
+
req.extensions_mut().insert(GrpcMethod::new(
2197
+
"rockbox.v1alpha1.PlaybackService",
2198
+
"PlayOrPause",
2199
+
));
2471
2200
self.inner.unary(req, path, codec).await
2472
2201
}
2473
2202
pub async fn resume(
2474
2203
&mut self,
2475
2204
request: impl tonic::IntoRequest<super::ResumeRequest>,
2476
2205
) -> std::result::Result<tonic::Response<super::ResumeResponse>, tonic::Status> {
2477
-
self.inner
2478
-
.ready()
2479
-
.await
2480
-
.map_err(|e| {
2481
-
tonic::Status::unknown(
2482
-
format!("Service was not ready: {}", e.into()),
2483
-
)
2484
-
})?;
2206
+
self.inner.ready().await.map_err(|e| {
2207
+
tonic::Status::unknown(format!("Service was not ready: {}", e.into()))
2208
+
})?;
2485
2209
let codec = tonic::codec::ProstCodec::default();
2486
-
let path = http::uri::PathAndQuery::from_static(
2487
-
"/rockbox.v1alpha1.PlaybackService/Resume",
2488
-
);
2210
+
let path =
2211
+
http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.PlaybackService/Resume");
2489
2212
let mut req = request.into_request();
2490
-
req.extensions_mut()
2491
-
.insert(GrpcMethod::new("rockbox.v1alpha1.PlaybackService", "Resume"));
2213
+
req.extensions_mut().insert(GrpcMethod::new(
2214
+
"rockbox.v1alpha1.PlaybackService",
2215
+
"Resume",
2216
+
));
2492
2217
self.inner.unary(req, path, codec).await
2493
2218
}
2494
2219
pub async fn next(
2495
2220
&mut self,
2496
2221
request: impl tonic::IntoRequest<super::NextRequest>,
2497
2222
) -> std::result::Result<tonic::Response<super::NextResponse>, tonic::Status> {
2498
-
self.inner
2499
-
.ready()
2500
-
.await
2501
-
.map_err(|e| {
2502
-
tonic::Status::unknown(
2503
-
format!("Service was not ready: {}", e.into()),
2504
-
)
2505
-
})?;
2223
+
self.inner.ready().await.map_err(|e| {
2224
+
tonic::Status::unknown(format!("Service was not ready: {}", e.into()))
2225
+
})?;
2506
2226
let codec = tonic::codec::ProstCodec::default();
2507
-
let path = http::uri::PathAndQuery::from_static(
2508
-
"/rockbox.v1alpha1.PlaybackService/Next",
2509
-
);
2227
+
let path =
2228
+
http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.PlaybackService/Next");
2510
2229
let mut req = request.into_request();
2511
2230
req.extensions_mut()
2512
2231
.insert(GrpcMethod::new("rockbox.v1alpha1.PlaybackService", "Next"));
···
2515
2234
pub async fn previous(
2516
2235
&mut self,
2517
2236
request: impl tonic::IntoRequest<super::PreviousRequest>,
2518
-
) -> std::result::Result<
2519
-
tonic::Response<super::PreviousResponse>,
2520
-
tonic::Status,
2521
-
> {
2522
-
self.inner
2523
-
.ready()
2524
-
.await
2525
-
.map_err(|e| {
2526
-
tonic::Status::unknown(
2527
-
format!("Service was not ready: {}", e.into()),
2528
-
)
2529
-
})?;
2237
+
) -> std::result::Result<tonic::Response<super::PreviousResponse>, tonic::Status> {
2238
+
self.inner.ready().await.map_err(|e| {
2239
+
tonic::Status::unknown(format!("Service was not ready: {}", e.into()))
2240
+
})?;
2530
2241
let codec = tonic::codec::ProstCodec::default();
2531
-
let path = http::uri::PathAndQuery::from_static(
2532
-
"/rockbox.v1alpha1.PlaybackService/Previous",
2533
-
);
2242
+
let path =
2243
+
http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.PlaybackService/Previous");
2534
2244
let mut req = request.into_request();
2535
-
req.extensions_mut()
2536
-
.insert(GrpcMethod::new("rockbox.v1alpha1.PlaybackService", "Previous"));
2245
+
req.extensions_mut().insert(GrpcMethod::new(
2246
+
"rockbox.v1alpha1.PlaybackService",
2247
+
"Previous",
2248
+
));
2537
2249
self.inner.unary(req, path, codec).await
2538
2250
}
2539
2251
pub async fn fast_forward_rewind(
2540
2252
&mut self,
2541
2253
request: impl tonic::IntoRequest<super::FastForwardRewindRequest>,
2542
-
) -> std::result::Result<
2543
-
tonic::Response<super::FastForwardRewindResponse>,
2544
-
tonic::Status,
2545
-
> {
2546
-
self.inner
2547
-
.ready()
2548
-
.await
2549
-
.map_err(|e| {
2550
-
tonic::Status::unknown(
2551
-
format!("Service was not ready: {}", e.into()),
2552
-
)
2553
-
})?;
2254
+
) -> std::result::Result<tonic::Response<super::FastForwardRewindResponse>, tonic::Status>
2255
+
{
2256
+
self.inner.ready().await.map_err(|e| {
2257
+
tonic::Status::unknown(format!("Service was not ready: {}", e.into()))
2258
+
})?;
2554
2259
let codec = tonic::codec::ProstCodec::default();
2555
2260
let path = http::uri::PathAndQuery::from_static(
2556
2261
"/rockbox.v1alpha1.PlaybackService/FastForwardRewind",
2557
2262
);
2558
2263
let mut req = request.into_request();
2559
-
req.extensions_mut()
2560
-
.insert(
2561
-
GrpcMethod::new(
2562
-
"rockbox.v1alpha1.PlaybackService",
2563
-
"FastForwardRewind",
2564
-
),
2565
-
);
2264
+
req.extensions_mut().insert(GrpcMethod::new(
2265
+
"rockbox.v1alpha1.PlaybackService",
2266
+
"FastForwardRewind",
2267
+
));
2566
2268
self.inner.unary(req, path, codec).await
2567
2269
}
2568
2270
pub async fn status(
2569
2271
&mut self,
2570
2272
request: impl tonic::IntoRequest<super::StatusRequest>,
2571
2273
) -> std::result::Result<tonic::Response<super::StatusResponse>, tonic::Status> {
2572
-
self.inner
2573
-
.ready()
2574
-
.await
2575
-
.map_err(|e| {
2576
-
tonic::Status::unknown(
2577
-
format!("Service was not ready: {}", e.into()),
2578
-
)
2579
-
})?;
2274
+
self.inner.ready().await.map_err(|e| {
2275
+
tonic::Status::unknown(format!("Service was not ready: {}", e.into()))
2276
+
})?;
2580
2277
let codec = tonic::codec::ProstCodec::default();
2581
-
let path = http::uri::PathAndQuery::from_static(
2582
-
"/rockbox.v1alpha1.PlaybackService/Status",
2583
-
);
2278
+
let path =
2279
+
http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.PlaybackService/Status");
2584
2280
let mut req = request.into_request();
2585
-
req.extensions_mut()
2586
-
.insert(GrpcMethod::new("rockbox.v1alpha1.PlaybackService", "Status"));
2281
+
req.extensions_mut().insert(GrpcMethod::new(
2282
+
"rockbox.v1alpha1.PlaybackService",
2283
+
"Status",
2284
+
));
2587
2285
self.inner.unary(req, path, codec).await
2588
2286
}
2589
2287
pub async fn current_track(
2590
2288
&mut self,
2591
2289
request: impl tonic::IntoRequest<super::CurrentTrackRequest>,
2592
-
) -> std::result::Result<
2593
-
tonic::Response<super::CurrentTrackResponse>,
2594
-
tonic::Status,
2595
-
> {
2596
-
self.inner
2597
-
.ready()
2598
-
.await
2599
-
.map_err(|e| {
2600
-
tonic::Status::unknown(
2601
-
format!("Service was not ready: {}", e.into()),
2602
-
)
2603
-
})?;
2290
+
) -> std::result::Result<tonic::Response<super::CurrentTrackResponse>, tonic::Status>
2291
+
{
2292
+
self.inner.ready().await.map_err(|e| {
2293
+
tonic::Status::unknown(format!("Service was not ready: {}", e.into()))
2294
+
})?;
2604
2295
let codec = tonic::codec::ProstCodec::default();
2605
2296
let path = http::uri::PathAndQuery::from_static(
2606
2297
"/rockbox.v1alpha1.PlaybackService/CurrentTrack",
2607
2298
);
2608
2299
let mut req = request.into_request();
2609
-
req.extensions_mut()
2610
-
.insert(
2611
-
GrpcMethod::new("rockbox.v1alpha1.PlaybackService", "CurrentTrack"),
2612
-
);
2300
+
req.extensions_mut().insert(GrpcMethod::new(
2301
+
"rockbox.v1alpha1.PlaybackService",
2302
+
"CurrentTrack",
2303
+
));
2613
2304
self.inner.unary(req, path, codec).await
2614
2305
}
2615
2306
pub async fn next_track(
2616
2307
&mut self,
2617
2308
request: impl tonic::IntoRequest<super::NextTrackRequest>,
2618
-
) -> std::result::Result<
2619
-
tonic::Response<super::NextTrackResponse>,
2620
-
tonic::Status,
2621
-
> {
2622
-
self.inner
2623
-
.ready()
2624
-
.await
2625
-
.map_err(|e| {
2626
-
tonic::Status::unknown(
2627
-
format!("Service was not ready: {}", e.into()),
2628
-
)
2629
-
})?;
2309
+
) -> std::result::Result<tonic::Response<super::NextTrackResponse>, tonic::Status> {
2310
+
self.inner.ready().await.map_err(|e| {
2311
+
tonic::Status::unknown(format!("Service was not ready: {}", e.into()))
2312
+
})?;
2630
2313
let codec = tonic::codec::ProstCodec::default();
2631
-
let path = http::uri::PathAndQuery::from_static(
2632
-
"/rockbox.v1alpha1.PlaybackService/NextTrack",
2633
-
);
2314
+
let path =
2315
+
http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.PlaybackService/NextTrack");
2634
2316
let mut req = request.into_request();
2635
-
req.extensions_mut()
2636
-
.insert(
2637
-
GrpcMethod::new("rockbox.v1alpha1.PlaybackService", "NextTrack"),
2638
-
);
2317
+
req.extensions_mut().insert(GrpcMethod::new(
2318
+
"rockbox.v1alpha1.PlaybackService",
2319
+
"NextTrack",
2320
+
));
2639
2321
self.inner.unary(req, path, codec).await
2640
2322
}
2641
2323
pub async fn flush_and_reload_tracks(
2642
2324
&mut self,
2643
2325
request: impl tonic::IntoRequest<super::FlushAndReloadTracksRequest>,
2644
-
) -> std::result::Result<
2645
-
tonic::Response<super::FlushAndReloadTracksResponse>,
2646
-
tonic::Status,
2647
-
> {
2648
-
self.inner
2649
-
.ready()
2650
-
.await
2651
-
.map_err(|e| {
2652
-
tonic::Status::unknown(
2653
-
format!("Service was not ready: {}", e.into()),
2654
-
)
2655
-
})?;
2326
+
) -> std::result::Result<tonic::Response<super::FlushAndReloadTracksResponse>, tonic::Status>
2327
+
{
2328
+
self.inner.ready().await.map_err(|e| {
2329
+
tonic::Status::unknown(format!("Service was not ready: {}", e.into()))
2330
+
})?;
2656
2331
let codec = tonic::codec::ProstCodec::default();
2657
2332
let path = http::uri::PathAndQuery::from_static(
2658
2333
"/rockbox.v1alpha1.PlaybackService/FlushAndReloadTracks",
2659
2334
);
2660
2335
let mut req = request.into_request();
2661
-
req.extensions_mut()
2662
-
.insert(
2663
-
GrpcMethod::new(
2664
-
"rockbox.v1alpha1.PlaybackService",
2665
-
"FlushAndReloadTracks",
2666
-
),
2667
-
);
2336
+
req.extensions_mut().insert(GrpcMethod::new(
2337
+
"rockbox.v1alpha1.PlaybackService",
2338
+
"FlushAndReloadTracks",
2339
+
));
2668
2340
self.inner.unary(req, path, codec).await
2669
2341
}
2670
2342
pub async fn get_file_position(
2671
2343
&mut self,
2672
2344
request: impl tonic::IntoRequest<super::GetFilePositionRequest>,
2673
-
) -> std::result::Result<
2674
-
tonic::Response<super::GetFilePositionResponse>,
2675
-
tonic::Status,
2676
-
> {
2677
-
self.inner
2678
-
.ready()
2679
-
.await
2680
-
.map_err(|e| {
2681
-
tonic::Status::unknown(
2682
-
format!("Service was not ready: {}", e.into()),
2683
-
)
2684
-
})?;
2345
+
) -> std::result::Result<tonic::Response<super::GetFilePositionResponse>, tonic::Status>
2346
+
{
2347
+
self.inner.ready().await.map_err(|e| {
2348
+
tonic::Status::unknown(format!("Service was not ready: {}", e.into()))
2349
+
})?;
2685
2350
let codec = tonic::codec::ProstCodec::default();
2686
2351
let path = http::uri::PathAndQuery::from_static(
2687
2352
"/rockbox.v1alpha1.PlaybackService/GetFilePosition",
2688
2353
);
2689
2354
let mut req = request.into_request();
2690
-
req.extensions_mut()
2691
-
.insert(
2692
-
GrpcMethod::new(
2693
-
"rockbox.v1alpha1.PlaybackService",
2694
-
"GetFilePosition",
2695
-
),
2696
-
);
2355
+
req.extensions_mut().insert(GrpcMethod::new(
2356
+
"rockbox.v1alpha1.PlaybackService",
2357
+
"GetFilePosition",
2358
+
));
2697
2359
self.inner.unary(req, path, codec).await
2698
2360
}
2699
2361
pub async fn hard_stop(
2700
2362
&mut self,
2701
2363
request: impl tonic::IntoRequest<super::HardStopRequest>,
2702
-
) -> std::result::Result<
2703
-
tonic::Response<super::HardStopResponse>,
2704
-
tonic::Status,
2705
-
> {
2706
-
self.inner
2707
-
.ready()
2708
-
.await
2709
-
.map_err(|e| {
2710
-
tonic::Status::unknown(
2711
-
format!("Service was not ready: {}", e.into()),
2712
-
)
2713
-
})?;
2364
+
) -> std::result::Result<tonic::Response<super::HardStopResponse>, tonic::Status> {
2365
+
self.inner.ready().await.map_err(|e| {
2366
+
tonic::Status::unknown(format!("Service was not ready: {}", e.into()))
2367
+
})?;
2714
2368
let codec = tonic::codec::ProstCodec::default();
2715
-
let path = http::uri::PathAndQuery::from_static(
2716
-
"/rockbox.v1alpha1.PlaybackService/HardStop",
2717
-
);
2369
+
let path =
2370
+
http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.PlaybackService/HardStop");
2718
2371
let mut req = request.into_request();
2719
-
req.extensions_mut()
2720
-
.insert(GrpcMethod::new("rockbox.v1alpha1.PlaybackService", "HardStop"));
2372
+
req.extensions_mut().insert(GrpcMethod::new(
2373
+
"rockbox.v1alpha1.PlaybackService",
2374
+
"HardStop",
2375
+
));
2721
2376
self.inner.unary(req, path, codec).await
2722
2377
}
2723
2378
pub async fn play_album(
2724
2379
&mut self,
2725
2380
request: impl tonic::IntoRequest<super::PlayAlbumRequest>,
2726
-
) -> std::result::Result<
2727
-
tonic::Response<super::PlayAlbumResponse>,
2728
-
tonic::Status,
2729
-
> {
2730
-
self.inner
2731
-
.ready()
2732
-
.await
2733
-
.map_err(|e| {
2734
-
tonic::Status::unknown(
2735
-
format!("Service was not ready: {}", e.into()),
2736
-
)
2737
-
})?;
2381
+
) -> std::result::Result<tonic::Response<super::PlayAlbumResponse>, tonic::Status> {
2382
+
self.inner.ready().await.map_err(|e| {
2383
+
tonic::Status::unknown(format!("Service was not ready: {}", e.into()))
2384
+
})?;
2738
2385
let codec = tonic::codec::ProstCodec::default();
2739
-
let path = http::uri::PathAndQuery::from_static(
2740
-
"/rockbox.v1alpha1.PlaybackService/PlayAlbum",
2741
-
);
2386
+
let path =
2387
+
http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.PlaybackService/PlayAlbum");
2742
2388
let mut req = request.into_request();
2743
-
req.extensions_mut()
2744
-
.insert(
2745
-
GrpcMethod::new("rockbox.v1alpha1.PlaybackService", "PlayAlbum"),
2746
-
);
2389
+
req.extensions_mut().insert(GrpcMethod::new(
2390
+
"rockbox.v1alpha1.PlaybackService",
2391
+
"PlayAlbum",
2392
+
));
2747
2393
self.inner.unary(req, path, codec).await
2748
2394
}
2749
2395
pub async fn play_artist_tracks(
2750
2396
&mut self,
2751
2397
request: impl tonic::IntoRequest<super::PlayArtistTracksRequest>,
2752
-
) -> std::result::Result<
2753
-
tonic::Response<super::PlayArtistTracksResponse>,
2754
-
tonic::Status,
2755
-
> {
2756
-
self.inner
2757
-
.ready()
2758
-
.await
2759
-
.map_err(|e| {
2760
-
tonic::Status::unknown(
2761
-
format!("Service was not ready: {}", e.into()),
2762
-
)
2763
-
})?;
2398
+
) -> std::result::Result<tonic::Response<super::PlayArtistTracksResponse>, tonic::Status>
2399
+
{
2400
+
self.inner.ready().await.map_err(|e| {
2401
+
tonic::Status::unknown(format!("Service was not ready: {}", e.into()))
2402
+
})?;
2764
2403
let codec = tonic::codec::ProstCodec::default();
2765
2404
let path = http::uri::PathAndQuery::from_static(
2766
2405
"/rockbox.v1alpha1.PlaybackService/PlayArtistTracks",
2767
2406
);
2768
2407
let mut req = request.into_request();
2769
-
req.extensions_mut()
2770
-
.insert(
2771
-
GrpcMethod::new(
2772
-
"rockbox.v1alpha1.PlaybackService",
2773
-
"PlayArtistTracks",
2774
-
),
2775
-
);
2408
+
req.extensions_mut().insert(GrpcMethod::new(
2409
+
"rockbox.v1alpha1.PlaybackService",
2410
+
"PlayArtistTracks",
2411
+
));
2776
2412
self.inner.unary(req, path, codec).await
2777
2413
}
2778
2414
pub async fn play_playlist(
2779
2415
&mut self,
2780
2416
request: impl tonic::IntoRequest<super::PlayPlaylistRequest>,
2781
-
) -> std::result::Result<
2782
-
tonic::Response<super::PlayPlaylistResponse>,
2783
-
tonic::Status,
2784
-
> {
2785
-
self.inner
2786
-
.ready()
2787
-
.await
2788
-
.map_err(|e| {
2789
-
tonic::Status::unknown(
2790
-
format!("Service was not ready: {}", e.into()),
2791
-
)
2792
-
})?;
2417
+
) -> std::result::Result<tonic::Response<super::PlayPlaylistResponse>, tonic::Status>
2418
+
{
2419
+
self.inner.ready().await.map_err(|e| {
2420
+
tonic::Status::unknown(format!("Service was not ready: {}", e.into()))
2421
+
})?;
2793
2422
let codec = tonic::codec::ProstCodec::default();
2794
2423
let path = http::uri::PathAndQuery::from_static(
2795
2424
"/rockbox.v1alpha1.PlaybackService/PlayPlaylist",
2796
2425
);
2797
2426
let mut req = request.into_request();
2798
-
req.extensions_mut()
2799
-
.insert(
2800
-
GrpcMethod::new("rockbox.v1alpha1.PlaybackService", "PlayPlaylist"),
2801
-
);
2427
+
req.extensions_mut().insert(GrpcMethod::new(
2428
+
"rockbox.v1alpha1.PlaybackService",
2429
+
"PlayPlaylist",
2430
+
));
2802
2431
self.inner.unary(req, path, codec).await
2803
2432
}
2804
2433
pub async fn play_directory(
2805
2434
&mut self,
2806
2435
request: impl tonic::IntoRequest<super::PlayDirectoryRequest>,
2807
-
) -> std::result::Result<
2808
-
tonic::Response<super::PlayDirectoryResponse>,
2809
-
tonic::Status,
2810
-
> {
2811
-
self.inner
2812
-
.ready()
2813
-
.await
2814
-
.map_err(|e| {
2815
-
tonic::Status::unknown(
2816
-
format!("Service was not ready: {}", e.into()),
2817
-
)
2818
-
})?;
2436
+
) -> std::result::Result<tonic::Response<super::PlayDirectoryResponse>, tonic::Status>
2437
+
{
2438
+
self.inner.ready().await.map_err(|e| {
2439
+
tonic::Status::unknown(format!("Service was not ready: {}", e.into()))
2440
+
})?;
2819
2441
let codec = tonic::codec::ProstCodec::default();
2820
2442
let path = http::uri::PathAndQuery::from_static(
2821
2443
"/rockbox.v1alpha1.PlaybackService/PlayDirectory",
2822
2444
);
2823
2445
let mut req = request.into_request();
2824
-
req.extensions_mut()
2825
-
.insert(
2826
-
GrpcMethod::new("rockbox.v1alpha1.PlaybackService", "PlayDirectory"),
2827
-
);
2446
+
req.extensions_mut().insert(GrpcMethod::new(
2447
+
"rockbox.v1alpha1.PlaybackService",
2448
+
"PlayDirectory",
2449
+
));
2828
2450
self.inner.unary(req, path, codec).await
2829
2451
}
2830
2452
pub async fn play_music_directory(
2831
2453
&mut self,
2832
2454
request: impl tonic::IntoRequest<super::PlayMusicDirectoryRequest>,
2833
-
) -> std::result::Result<
2834
-
tonic::Response<super::PlayMusicDirectoryResponse>,
2835
-
tonic::Status,
2836
-
> {
2837
-
self.inner
2838
-
.ready()
2839
-
.await
2840
-
.map_err(|e| {
2841
-
tonic::Status::unknown(
2842
-
format!("Service was not ready: {}", e.into()),
2843
-
)
2844
-
})?;
2455
+
) -> std::result::Result<tonic::Response<super::PlayMusicDirectoryResponse>, tonic::Status>
2456
+
{
2457
+
self.inner.ready().await.map_err(|e| {
2458
+
tonic::Status::unknown(format!("Service was not ready: {}", e.into()))
2459
+
})?;
2845
2460
let codec = tonic::codec::ProstCodec::default();
2846
2461
let path = http::uri::PathAndQuery::from_static(
2847
2462
"/rockbox.v1alpha1.PlaybackService/PlayMusicDirectory",
2848
2463
);
2849
2464
let mut req = request.into_request();
2850
-
req.extensions_mut()
2851
-
.insert(
2852
-
GrpcMethod::new(
2853
-
"rockbox.v1alpha1.PlaybackService",
2854
-
"PlayMusicDirectory",
2855
-
),
2856
-
);
2465
+
req.extensions_mut().insert(GrpcMethod::new(
2466
+
"rockbox.v1alpha1.PlaybackService",
2467
+
"PlayMusicDirectory",
2468
+
));
2857
2469
self.inner.unary(req, path, codec).await
2858
2470
}
2859
2471
pub async fn play_track(
2860
2472
&mut self,
2861
2473
request: impl tonic::IntoRequest<super::PlayTrackRequest>,
2862
-
) -> std::result::Result<
2863
-
tonic::Response<super::PlayTrackResponse>,
2864
-
tonic::Status,
2865
-
> {
2866
-
self.inner
2867
-
.ready()
2868
-
.await
2869
-
.map_err(|e| {
2870
-
tonic::Status::unknown(
2871
-
format!("Service was not ready: {}", e.into()),
2872
-
)
2873
-
})?;
2474
+
) -> std::result::Result<tonic::Response<super::PlayTrackResponse>, tonic::Status> {
2475
+
self.inner.ready().await.map_err(|e| {
2476
+
tonic::Status::unknown(format!("Service was not ready: {}", e.into()))
2477
+
})?;
2874
2478
let codec = tonic::codec::ProstCodec::default();
2875
-
let path = http::uri::PathAndQuery::from_static(
2876
-
"/rockbox.v1alpha1.PlaybackService/PlayTrack",
2877
-
);
2479
+
let path =
2480
+
http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.PlaybackService/PlayTrack");
2878
2481
let mut req = request.into_request();
2879
-
req.extensions_mut()
2880
-
.insert(
2881
-
GrpcMethod::new("rockbox.v1alpha1.PlaybackService", "PlayTrack"),
2882
-
);
2482
+
req.extensions_mut().insert(GrpcMethod::new(
2483
+
"rockbox.v1alpha1.PlaybackService",
2484
+
"PlayTrack",
2485
+
));
2883
2486
self.inner.unary(req, path, codec).await
2884
2487
}
2885
2488
pub async fn play_liked_tracks(
2886
2489
&mut self,
2887
2490
request: impl tonic::IntoRequest<super::PlayLikedTracksRequest>,
2888
-
) -> std::result::Result<
2889
-
tonic::Response<super::PlayLikedTracksResponse>,
2890
-
tonic::Status,
2891
-
> {
2892
-
self.inner
2893
-
.ready()
2894
-
.await
2895
-
.map_err(|e| {
2896
-
tonic::Status::unknown(
2897
-
format!("Service was not ready: {}", e.into()),
2898
-
)
2899
-
})?;
2491
+
) -> std::result::Result<tonic::Response<super::PlayLikedTracksResponse>, tonic::Status>
2492
+
{
2493
+
self.inner.ready().await.map_err(|e| {
2494
+
tonic::Status::unknown(format!("Service was not ready: {}", e.into()))
2495
+
})?;
2900
2496
let codec = tonic::codec::ProstCodec::default();
2901
2497
let path = http::uri::PathAndQuery::from_static(
2902
2498
"/rockbox.v1alpha1.PlaybackService/PlayLikedTracks",
2903
2499
);
2904
2500
let mut req = request.into_request();
2905
-
req.extensions_mut()
2906
-
.insert(
2907
-
GrpcMethod::new(
2908
-
"rockbox.v1alpha1.PlaybackService",
2909
-
"PlayLikedTracks",
2910
-
),
2911
-
);
2501
+
req.extensions_mut().insert(GrpcMethod::new(
2502
+
"rockbox.v1alpha1.PlaybackService",
2503
+
"PlayLikedTracks",
2504
+
));
2912
2505
self.inner.unary(req, path, codec).await
2913
2506
}
2914
2507
pub async fn play_all_tracks(
2915
2508
&mut self,
2916
2509
request: impl tonic::IntoRequest<super::PlayAllTracksRequest>,
2917
-
) -> std::result::Result<
2918
-
tonic::Response<super::PlayAllTracksResponse>,
2919
-
tonic::Status,
2920
-
> {
2921
-
self.inner
2922
-
.ready()
2923
-
.await
2924
-
.map_err(|e| {
2925
-
tonic::Status::unknown(
2926
-
format!("Service was not ready: {}", e.into()),
2927
-
)
2928
-
})?;
2510
+
) -> std::result::Result<tonic::Response<super::PlayAllTracksResponse>, tonic::Status>
2511
+
{
2512
+
self.inner.ready().await.map_err(|e| {
2513
+
tonic::Status::unknown(format!("Service was not ready: {}", e.into()))
2514
+
})?;
2929
2515
let codec = tonic::codec::ProstCodec::default();
2930
2516
let path = http::uri::PathAndQuery::from_static(
2931
2517
"/rockbox.v1alpha1.PlaybackService/PlayAllTracks",
2932
2518
);
2933
2519
let mut req = request.into_request();
2934
-
req.extensions_mut()
2935
-
.insert(
2936
-
GrpcMethod::new("rockbox.v1alpha1.PlaybackService", "PlayAllTracks"),
2937
-
);
2520
+
req.extensions_mut().insert(GrpcMethod::new(
2521
+
"rockbox.v1alpha1.PlaybackService",
2522
+
"PlayAllTracks",
2523
+
));
2938
2524
self.inner.unary(req, path, codec).await
2939
2525
}
2940
2526
pub async fn stream_current_track(
···
2944
2530
tonic::Response<tonic::codec::Streaming<super::CurrentTrackResponse>>,
2945
2531
tonic::Status,
2946
2532
> {
2947
-
self.inner
2948
-
.ready()
2949
-
.await
2950
-
.map_err(|e| {
2951
-
tonic::Status::unknown(
2952
-
format!("Service was not ready: {}", e.into()),
2953
-
)
2954
-
})?;
2533
+
self.inner.ready().await.map_err(|e| {
2534
+
tonic::Status::unknown(format!("Service was not ready: {}", e.into()))
2535
+
})?;
2955
2536
let codec = tonic::codec::ProstCodec::default();
2956
2537
let path = http::uri::PathAndQuery::from_static(
2957
2538
"/rockbox.v1alpha1.PlaybackService/StreamCurrentTrack",
2958
2539
);
2959
2540
let mut req = request.into_request();
2960
-
req.extensions_mut()
2961
-
.insert(
2962
-
GrpcMethod::new(
2963
-
"rockbox.v1alpha1.PlaybackService",
2964
-
"StreamCurrentTrack",
2965
-
),
2966
-
);
2541
+
req.extensions_mut().insert(GrpcMethod::new(
2542
+
"rockbox.v1alpha1.PlaybackService",
2543
+
"StreamCurrentTrack",
2544
+
));
2967
2545
self.inner.server_streaming(req, path, codec).await
2968
2546
}
2969
2547
pub async fn stream_status(
···
2973
2551
tonic::Response<tonic::codec::Streaming<super::StatusResponse>>,
2974
2552
tonic::Status,
2975
2553
> {
2976
-
self.inner
2977
-
.ready()
2978
-
.await
2979
-
.map_err(|e| {
2980
-
tonic::Status::unknown(
2981
-
format!("Service was not ready: {}", e.into()),
2982
-
)
2983
-
})?;
2554
+
self.inner.ready().await.map_err(|e| {
2555
+
tonic::Status::unknown(format!("Service was not ready: {}", e.into()))
2556
+
})?;
2984
2557
let codec = tonic::codec::ProstCodec::default();
2985
2558
let path = http::uri::PathAndQuery::from_static(
2986
2559
"/rockbox.v1alpha1.PlaybackService/StreamStatus",
2987
2560
);
2988
2561
let mut req = request.into_request();
2989
-
req.extensions_mut()
2990
-
.insert(
2991
-
GrpcMethod::new("rockbox.v1alpha1.PlaybackService", "StreamStatus"),
2992
-
);
2562
+
req.extensions_mut().insert(GrpcMethod::new(
2563
+
"rockbox.v1alpha1.PlaybackService",
2564
+
"StreamStatus",
2565
+
));
2993
2566
self.inner.server_streaming(req, path, codec).await
2994
2567
}
2995
2568
pub async fn stream_playlist(
···
2999
2572
tonic::Response<tonic::codec::Streaming<super::PlaylistResponse>>,
3000
2573
tonic::Status,
3001
2574
> {
3002
-
self.inner
3003
-
.ready()
3004
-
.await
3005
-
.map_err(|e| {
3006
-
tonic::Status::unknown(
3007
-
format!("Service was not ready: {}", e.into()),
3008
-
)
3009
-
})?;
2575
+
self.inner.ready().await.map_err(|e| {
2576
+
tonic::Status::unknown(format!("Service was not ready: {}", e.into()))
2577
+
})?;
3010
2578
let codec = tonic::codec::ProstCodec::default();
3011
2579
let path = http::uri::PathAndQuery::from_static(
3012
2580
"/rockbox.v1alpha1.PlaybackService/StreamPlaylist",
3013
2581
);
3014
2582
let mut req = request.into_request();
3015
-
req.extensions_mut()
3016
-
.insert(
3017
-
GrpcMethod::new("rockbox.v1alpha1.PlaybackService", "StreamPlaylist"),
3018
-
);
2583
+
req.extensions_mut().insert(GrpcMethod::new(
2584
+
"rockbox.v1alpha1.PlaybackService",
2585
+
"StreamPlaylist",
2586
+
));
3019
2587
self.inner.server_streaming(req, path, codec).await
3020
2588
}
3021
2589
}
···
3027
2595
dead_code,
3028
2596
missing_docs,
3029
2597
clippy::wildcard_imports,
3030
-
clippy::let_unit_value,
2598
+
clippy::let_unit_value
3031
2599
)]
3032
2600
use tonic::codegen::*;
3033
2601
/// Generated trait containing gRPC methods that should be implemented for use with PlaybackServiceServer.
···
3044
2612
async fn play_or_pause(
3045
2613
&self,
3046
2614
request: tonic::Request<super::PlayOrPauseRequest>,
3047
-
) -> std::result::Result<
3048
-
tonic::Response<super::PlayOrPauseResponse>,
3049
-
tonic::Status,
3050
-
>;
2615
+
) -> std::result::Result<tonic::Response<super::PlayOrPauseResponse>, tonic::Status>;
3051
2616
async fn resume(
3052
2617
&self,
3053
2618
request: tonic::Request<super::ResumeRequest>,
···
3059
2624
async fn previous(
3060
2625
&self,
3061
2626
request: tonic::Request<super::PreviousRequest>,
3062
-
) -> std::result::Result<
3063
-
tonic::Response<super::PreviousResponse>,
3064
-
tonic::Status,
3065
-
>;
2627
+
) -> std::result::Result<tonic::Response<super::PreviousResponse>, tonic::Status>;
3066
2628
async fn fast_forward_rewind(
3067
2629
&self,
3068
2630
request: tonic::Request<super::FastForwardRewindRequest>,
3069
-
) -> std::result::Result<
3070
-
tonic::Response<super::FastForwardRewindResponse>,
3071
-
tonic::Status,
3072
-
>;
2631
+
) -> std::result::Result<tonic::Response<super::FastForwardRewindResponse>, tonic::Status>;
3073
2632
async fn status(
3074
2633
&self,
3075
2634
request: tonic::Request<super::StatusRequest>,
···
3077
2636
async fn current_track(
3078
2637
&self,
3079
2638
request: tonic::Request<super::CurrentTrackRequest>,
3080
-
) -> std::result::Result<
3081
-
tonic::Response<super::CurrentTrackResponse>,
3082
-
tonic::Status,
3083
-
>;
2639
+
) -> std::result::Result<tonic::Response<super::CurrentTrackResponse>, tonic::Status>;
3084
2640
async fn next_track(
3085
2641
&self,
3086
2642
request: tonic::Request<super::NextTrackRequest>,
3087
-
) -> std::result::Result<
3088
-
tonic::Response<super::NextTrackResponse>,
3089
-
tonic::Status,
3090
-
>;
2643
+
) -> std::result::Result<tonic::Response<super::NextTrackResponse>, tonic::Status>;
3091
2644
async fn flush_and_reload_tracks(
3092
2645
&self,
3093
2646
request: tonic::Request<super::FlushAndReloadTracksRequest>,
3094
-
) -> std::result::Result<
3095
-
tonic::Response<super::FlushAndReloadTracksResponse>,
3096
-
tonic::Status,
3097
-
>;
2647
+
) -> std::result::Result<tonic::Response<super::FlushAndReloadTracksResponse>, tonic::Status>;
3098
2648
async fn get_file_position(
3099
2649
&self,
3100
2650
request: tonic::Request<super::GetFilePositionRequest>,
3101
-
) -> std::result::Result<
3102
-
tonic::Response<super::GetFilePositionResponse>,
3103
-
tonic::Status,
3104
-
>;
2651
+
) -> std::result::Result<tonic::Response<super::GetFilePositionResponse>, tonic::Status>;
3105
2652
async fn hard_stop(
3106
2653
&self,
3107
2654
request: tonic::Request<super::HardStopRequest>,
3108
-
) -> std::result::Result<
3109
-
tonic::Response<super::HardStopResponse>,
3110
-
tonic::Status,
3111
-
>;
2655
+
) -> std::result::Result<tonic::Response<super::HardStopResponse>, tonic::Status>;
3112
2656
async fn play_album(
3113
2657
&self,
3114
2658
request: tonic::Request<super::PlayAlbumRequest>,
3115
-
) -> std::result::Result<
3116
-
tonic::Response<super::PlayAlbumResponse>,
3117
-
tonic::Status,
3118
-
>;
2659
+
) -> std::result::Result<tonic::Response<super::PlayAlbumResponse>, tonic::Status>;
3119
2660
async fn play_artist_tracks(
3120
2661
&self,
3121
2662
request: tonic::Request<super::PlayArtistTracksRequest>,
3122
-
) -> std::result::Result<
3123
-
tonic::Response<super::PlayArtistTracksResponse>,
3124
-
tonic::Status,
3125
-
>;
2663
+
) -> std::result::Result<tonic::Response<super::PlayArtistTracksResponse>, tonic::Status>;
3126
2664
async fn play_playlist(
3127
2665
&self,
3128
2666
request: tonic::Request<super::PlayPlaylistRequest>,
3129
-
) -> std::result::Result<
3130
-
tonic::Response<super::PlayPlaylistResponse>,
3131
-
tonic::Status,
3132
-
>;
2667
+
) -> std::result::Result<tonic::Response<super::PlayPlaylistResponse>, tonic::Status>;
3133
2668
async fn play_directory(
3134
2669
&self,
3135
2670
request: tonic::Request<super::PlayDirectoryRequest>,
3136
-
) -> std::result::Result<
3137
-
tonic::Response<super::PlayDirectoryResponse>,
3138
-
tonic::Status,
3139
-
>;
2671
+
) -> std::result::Result<tonic::Response<super::PlayDirectoryResponse>, tonic::Status>;
3140
2672
async fn play_music_directory(
3141
2673
&self,
3142
2674
request: tonic::Request<super::PlayMusicDirectoryRequest>,
3143
-
) -> std::result::Result<
3144
-
tonic::Response<super::PlayMusicDirectoryResponse>,
3145
-
tonic::Status,
3146
-
>;
2675
+
) -> std::result::Result<tonic::Response<super::PlayMusicDirectoryResponse>, tonic::Status>;
3147
2676
async fn play_track(
3148
2677
&self,
3149
2678
request: tonic::Request<super::PlayTrackRequest>,
3150
-
) -> std::result::Result<
3151
-
tonic::Response<super::PlayTrackResponse>,
3152
-
tonic::Status,
3153
-
>;
2679
+
) -> std::result::Result<tonic::Response<super::PlayTrackResponse>, tonic::Status>;
3154
2680
async fn play_liked_tracks(
3155
2681
&self,
3156
2682
request: tonic::Request<super::PlayLikedTracksRequest>,
3157
-
) -> std::result::Result<
3158
-
tonic::Response<super::PlayLikedTracksResponse>,
3159
-
tonic::Status,
3160
-
>;
2683
+
) -> std::result::Result<tonic::Response<super::PlayLikedTracksResponse>, tonic::Status>;
3161
2684
async fn play_all_tracks(
3162
2685
&self,
3163
2686
request: tonic::Request<super::PlayAllTracksRequest>,
3164
-
) -> std::result::Result<
3165
-
tonic::Response<super::PlayAllTracksResponse>,
3166
-
tonic::Status,
3167
-
>;
2687
+
) -> std::result::Result<tonic::Response<super::PlayAllTracksResponse>, tonic::Status>;
3168
2688
/// Server streaming response type for the StreamCurrentTrack method.
3169
2689
type StreamCurrentTrackStream: tonic::codegen::tokio_stream::Stream<
3170
2690
Item = std::result::Result<super::CurrentTrackResponse, tonic::Status>,
3171
-
>
3172
-
+ std::marker::Send
2691
+
> + std::marker::Send
3173
2692
+ 'static;
3174
2693
async fn stream_current_track(
3175
2694
&self,
3176
2695
request: tonic::Request<super::StreamCurrentTrackRequest>,
3177
-
) -> std::result::Result<
3178
-
tonic::Response<Self::StreamCurrentTrackStream>,
3179
-
tonic::Status,
3180
-
>;
2696
+
) -> std::result::Result<tonic::Response<Self::StreamCurrentTrackStream>, tonic::Status>;
3181
2697
/// Server streaming response type for the StreamStatus method.
3182
2698
type StreamStatusStream: tonic::codegen::tokio_stream::Stream<
3183
2699
Item = std::result::Result<super::StatusResponse, tonic::Status>,
3184
-
>
3185
-
+ std::marker::Send
2700
+
> + std::marker::Send
3186
2701
+ 'static;
3187
2702
async fn stream_status(
3188
2703
&self,
3189
2704
request: tonic::Request<super::StreamStatusRequest>,
3190
-
) -> std::result::Result<
3191
-
tonic::Response<Self::StreamStatusStream>,
3192
-
tonic::Status,
3193
-
>;
2705
+
) -> std::result::Result<tonic::Response<Self::StreamStatusStream>, tonic::Status>;
3194
2706
/// Server streaming response type for the StreamPlaylist method.
3195
2707
type StreamPlaylistStream: tonic::codegen::tokio_stream::Stream<
3196
2708
Item = std::result::Result<super::PlaylistResponse, tonic::Status>,
3197
-
>
3198
-
+ std::marker::Send
2709
+
> + std::marker::Send
3199
2710
+ 'static;
3200
2711
async fn stream_playlist(
3201
2712
&self,
3202
2713
request: tonic::Request<super::StreamPlaylistRequest>,
3203
-
) -> std::result::Result<
3204
-
tonic::Response<Self::StreamPlaylistStream>,
3205
-
tonic::Status,
3206
-
>;
2714
+
) -> std::result::Result<tonic::Response<Self::StreamPlaylistStream>, tonic::Status>;
3207
2715
}
3208
2716
#[derive(Debug)]
3209
2717
pub struct PlaybackServiceServer<T> {
···
3226
2734
max_encoding_message_size: None,
3227
2735
}
3228
2736
}
3229
-
pub fn with_interceptor<F>(
3230
-
inner: T,
3231
-
interceptor: F,
3232
-
) -> InterceptedService<Self, F>
2737
+
pub fn with_interceptor<F>(inner: T, interceptor: F) -> InterceptedService<Self, F>
3233
2738
where
3234
2739
F: tonic::service::Interceptor,
3235
2740
{
···
3284
2789
"/rockbox.v1alpha1.PlaybackService/Play" => {
3285
2790
#[allow(non_camel_case_types)]
3286
2791
struct PlaySvc<T: PlaybackService>(pub Arc<T>);
3287
-
impl<
3288
-
T: PlaybackService,
3289
-
> tonic::server::UnaryService<super::PlayRequest> for PlaySvc<T> {
2792
+
impl<T: PlaybackService> tonic::server::UnaryService<super::PlayRequest> for PlaySvc<T> {
3290
2793
type Response = super::PlayResponse;
3291
-
type Future = BoxFuture<
3292
-
tonic::Response<Self::Response>,
3293
-
tonic::Status,
3294
-
>;
2794
+
type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
3295
2795
fn call(
3296
2796
&mut self,
3297
2797
request: tonic::Request<super::PlayRequest>,
3298
2798
) -> Self::Future {
3299
2799
let inner = Arc::clone(&self.0);
3300
-
let fut = async move {
3301
-
<T as PlaybackService>::play(&inner, request).await
3302
-
};
2800
+
let fut =
2801
+
async move { <T as PlaybackService>::play(&inner, request).await };
3303
2802
Box::pin(fut)
3304
2803
}
3305
2804
}
···
3328
2827
"/rockbox.v1alpha1.PlaybackService/Pause" => {
3329
2828
#[allow(non_camel_case_types)]
3330
2829
struct PauseSvc<T: PlaybackService>(pub Arc<T>);
3331
-
impl<
3332
-
T: PlaybackService,
3333
-
> tonic::server::UnaryService<super::PauseRequest> for PauseSvc<T> {
2830
+
impl<T: PlaybackService> tonic::server::UnaryService<super::PauseRequest> for PauseSvc<T> {
3334
2831
type Response = super::PauseResponse;
3335
-
type Future = BoxFuture<
3336
-
tonic::Response<Self::Response>,
3337
-
tonic::Status,
3338
-
>;
2832
+
type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
3339
2833
fn call(
3340
2834
&mut self,
3341
2835
request: tonic::Request<super::PauseRequest>,
3342
2836
) -> Self::Future {
3343
2837
let inner = Arc::clone(&self.0);
3344
-
let fut = async move {
3345
-
<T as PlaybackService>::pause(&inner, request).await
3346
-
};
2838
+
let fut =
2839
+
async move { <T as PlaybackService>::pause(&inner, request).await };
3347
2840
Box::pin(fut)
3348
2841
}
3349
2842
}
···
3372
2865
"/rockbox.v1alpha1.PlaybackService/PlayOrPause" => {
3373
2866
#[allow(non_camel_case_types)]
3374
2867
struct PlayOrPauseSvc<T: PlaybackService>(pub Arc<T>);
3375
-
impl<
3376
-
T: PlaybackService,
3377
-
> tonic::server::UnaryService<super::PlayOrPauseRequest>
3378
-
for PlayOrPauseSvc<T> {
2868
+
impl<T: PlaybackService> tonic::server::UnaryService<super::PlayOrPauseRequest>
2869
+
for PlayOrPauseSvc<T>
2870
+
{
3379
2871
type Response = super::PlayOrPauseResponse;
3380
-
type Future = BoxFuture<
3381
-
tonic::Response<Self::Response>,
3382
-
tonic::Status,
3383
-
>;
2872
+
type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
3384
2873
fn call(
3385
2874
&mut self,
3386
2875
request: tonic::Request<super::PlayOrPauseRequest>,
···
3417
2906
"/rockbox.v1alpha1.PlaybackService/Resume" => {
3418
2907
#[allow(non_camel_case_types)]
3419
2908
struct ResumeSvc<T: PlaybackService>(pub Arc<T>);
3420
-
impl<
3421
-
T: PlaybackService,
3422
-
> tonic::server::UnaryService<super::ResumeRequest>
3423
-
for ResumeSvc<T> {
2909
+
impl<T: PlaybackService> tonic::server::UnaryService<super::ResumeRequest> for ResumeSvc<T> {
3424
2910
type Response = super::ResumeResponse;
3425
-
type Future = BoxFuture<
3426
-
tonic::Response<Self::Response>,
3427
-
tonic::Status,
3428
-
>;
2911
+
type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
3429
2912
fn call(
3430
2913
&mut self,
3431
2914
request: tonic::Request<super::ResumeRequest>,
···
3462
2945
"/rockbox.v1alpha1.PlaybackService/Next" => {
3463
2946
#[allow(non_camel_case_types)]
3464
2947
struct NextSvc<T: PlaybackService>(pub Arc<T>);
3465
-
impl<
3466
-
T: PlaybackService,
3467
-
> tonic::server::UnaryService<super::NextRequest> for NextSvc<T> {
2948
+
impl<T: PlaybackService> tonic::server::UnaryService<super::NextRequest> for NextSvc<T> {
3468
2949
type Response = super::NextResponse;
3469
-
type Future = BoxFuture<
3470
-
tonic::Response<Self::Response>,
3471
-
tonic::Status,
3472
-
>;
2950
+
type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
3473
2951
fn call(
3474
2952
&mut self,
3475
2953
request: tonic::Request<super::NextRequest>,
3476
2954
) -> Self::Future {
3477
2955
let inner = Arc::clone(&self.0);
3478
-
let fut = async move {
3479
-
<T as PlaybackService>::next(&inner, request).await
3480
-
};
2956
+
let fut =
2957
+
async move { <T as PlaybackService>::next(&inner, request).await };
3481
2958
Box::pin(fut)
3482
2959
}
3483
2960
}
···
3506
2983
"/rockbox.v1alpha1.PlaybackService/Previous" => {
3507
2984
#[allow(non_camel_case_types)]
3508
2985
struct PreviousSvc<T: PlaybackService>(pub Arc<T>);
3509
-
impl<
3510
-
T: PlaybackService,
3511
-
> tonic::server::UnaryService<super::PreviousRequest>
3512
-
for PreviousSvc<T> {
2986
+
impl<T: PlaybackService> tonic::server::UnaryService<super::PreviousRequest> for PreviousSvc<T> {
3513
2987
type Response = super::PreviousResponse;
3514
-
type Future = BoxFuture<
3515
-
tonic::Response<Self::Response>,
3516
-
tonic::Status,
3517
-
>;
2988
+
type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
3518
2989
fn call(
3519
2990
&mut self,
3520
2991
request: tonic::Request<super::PreviousRequest>,
···
3551
3022
"/rockbox.v1alpha1.PlaybackService/FastForwardRewind" => {
3552
3023
#[allow(non_camel_case_types)]
3553
3024
struct FastForwardRewindSvc<T: PlaybackService>(pub Arc<T>);
3554
-
impl<
3555
-
T: PlaybackService,
3556
-
> tonic::server::UnaryService<super::FastForwardRewindRequest>
3557
-
for FastForwardRewindSvc<T> {
3025
+
impl<T: PlaybackService>
3026
+
tonic::server::UnaryService<super::FastForwardRewindRequest>
3027
+
for FastForwardRewindSvc<T>
3028
+
{
3558
3029
type Response = super::FastForwardRewindResponse;
3559
-
type Future = BoxFuture<
3560
-
tonic::Response<Self::Response>,
3561
-
tonic::Status,
3562
-
>;
3030
+
type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
3563
3031
fn call(
3564
3032
&mut self,
3565
3033
request: tonic::Request<super::FastForwardRewindRequest>,
3566
3034
) -> Self::Future {
3567
3035
let inner = Arc::clone(&self.0);
3568
3036
let fut = async move {
3569
-
<T as PlaybackService>::fast_forward_rewind(&inner, request)
3570
-
.await
3037
+
<T as PlaybackService>::fast_forward_rewind(&inner, request).await
3571
3038
};
3572
3039
Box::pin(fut)
3573
3040
}
···
3597
3064
"/rockbox.v1alpha1.PlaybackService/Status" => {
3598
3065
#[allow(non_camel_case_types)]
3599
3066
struct StatusSvc<T: PlaybackService>(pub Arc<T>);
3600
-
impl<
3601
-
T: PlaybackService,
3602
-
> tonic::server::UnaryService<super::StatusRequest>
3603
-
for StatusSvc<T> {
3067
+
impl<T: PlaybackService> tonic::server::UnaryService<super::StatusRequest> for StatusSvc<T> {
3604
3068
type Response = super::StatusResponse;
3605
-
type Future = BoxFuture<
3606
-
tonic::Response<Self::Response>,
3607
-
tonic::Status,
3608
-
>;
3069
+
type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
3609
3070
fn call(
3610
3071
&mut self,
3611
3072
request: tonic::Request<super::StatusRequest>,
···
3642
3103
"/rockbox.v1alpha1.PlaybackService/CurrentTrack" => {
3643
3104
#[allow(non_camel_case_types)]
3644
3105
struct CurrentTrackSvc<T: PlaybackService>(pub Arc<T>);
3645
-
impl<
3646
-
T: PlaybackService,
3647
-
> tonic::server::UnaryService<super::CurrentTrackRequest>
3648
-
for CurrentTrackSvc<T> {
3106
+
impl<T: PlaybackService> tonic::server::UnaryService<super::CurrentTrackRequest>
3107
+
for CurrentTrackSvc<T>
3108
+
{
3649
3109
type Response = super::CurrentTrackResponse;
3650
-
type Future = BoxFuture<
3651
-
tonic::Response<Self::Response>,
3652
-
tonic::Status,
3653
-
>;
3110
+
type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
3654
3111
fn call(
3655
3112
&mut self,
3656
3113
request: tonic::Request<super::CurrentTrackRequest>,
···
3687
3144
"/rockbox.v1alpha1.PlaybackService/NextTrack" => {
3688
3145
#[allow(non_camel_case_types)]
3689
3146
struct NextTrackSvc<T: PlaybackService>(pub Arc<T>);
3690
-
impl<
3691
-
T: PlaybackService,
3692
-
> tonic::server::UnaryService<super::NextTrackRequest>
3693
-
for NextTrackSvc<T> {
3147
+
impl<T: PlaybackService> tonic::server::UnaryService<super::NextTrackRequest> for NextTrackSvc<T> {
3694
3148
type Response = super::NextTrackResponse;
3695
-
type Future = BoxFuture<
3696
-
tonic::Response<Self::Response>,
3697
-
tonic::Status,
3698
-
>;
3149
+
type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
3699
3150
fn call(
3700
3151
&mut self,
3701
3152
request: tonic::Request<super::NextTrackRequest>,
···
3732
3183
"/rockbox.v1alpha1.PlaybackService/FlushAndReloadTracks" => {
3733
3184
#[allow(non_camel_case_types)]
3734
3185
struct FlushAndReloadTracksSvc<T: PlaybackService>(pub Arc<T>);
3735
-
impl<
3736
-
T: PlaybackService,
3737
-
> tonic::server::UnaryService<super::FlushAndReloadTracksRequest>
3738
-
for FlushAndReloadTracksSvc<T> {
3186
+
impl<T: PlaybackService>
3187
+
tonic::server::UnaryService<super::FlushAndReloadTracksRequest>
3188
+
for FlushAndReloadTracksSvc<T>
3189
+
{
3739
3190
type Response = super::FlushAndReloadTracksResponse;
3740
-
type Future = BoxFuture<
3741
-
tonic::Response<Self::Response>,
3742
-
tonic::Status,
3743
-
>;
3191
+
type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
3744
3192
fn call(
3745
3193
&mut self,
3746
3194
request: tonic::Request<super::FlushAndReloadTracksRequest>,
3747
3195
) -> Self::Future {
3748
3196
let inner = Arc::clone(&self.0);
3749
3197
let fut = async move {
3750
-
<T as PlaybackService>::flush_and_reload_tracks(
3751
-
&inner,
3752
-
request,
3753
-
)
3198
+
<T as PlaybackService>::flush_and_reload_tracks(&inner, request)
3754
3199
.await
3755
3200
};
3756
3201
Box::pin(fut)
···
3781
3226
"/rockbox.v1alpha1.PlaybackService/GetFilePosition" => {
3782
3227
#[allow(non_camel_case_types)]
3783
3228
struct GetFilePositionSvc<T: PlaybackService>(pub Arc<T>);
3784
-
impl<
3785
-
T: PlaybackService,
3786
-
> tonic::server::UnaryService<super::GetFilePositionRequest>
3787
-
for GetFilePositionSvc<T> {
3229
+
impl<T: PlaybackService>
3230
+
tonic::server::UnaryService<super::GetFilePositionRequest>
3231
+
for GetFilePositionSvc<T>
3232
+
{
3788
3233
type Response = super::GetFilePositionResponse;
3789
-
type Future = BoxFuture<
3790
-
tonic::Response<Self::Response>,
3791
-
tonic::Status,
3792
-
>;
3234
+
type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
3793
3235
fn call(
3794
3236
&mut self,
3795
3237
request: tonic::Request<super::GetFilePositionRequest>,
3796
3238
) -> Self::Future {
3797
3239
let inner = Arc::clone(&self.0);
3798
3240
let fut = async move {
3799
-
<T as PlaybackService>::get_file_position(&inner, request)
3800
-
.await
3241
+
<T as PlaybackService>::get_file_position(&inner, request).await
3801
3242
};
3802
3243
Box::pin(fut)
3803
3244
}
···
3827
3268
"/rockbox.v1alpha1.PlaybackService/HardStop" => {
3828
3269
#[allow(non_camel_case_types)]
3829
3270
struct HardStopSvc<T: PlaybackService>(pub Arc<T>);
3830
-
impl<
3831
-
T: PlaybackService,
3832
-
> tonic::server::UnaryService<super::HardStopRequest>
3833
-
for HardStopSvc<T> {
3271
+
impl<T: PlaybackService> tonic::server::UnaryService<super::HardStopRequest> for HardStopSvc<T> {
3834
3272
type Response = super::HardStopResponse;
3835
-
type Future = BoxFuture<
3836
-
tonic::Response<Self::Response>,
3837
-
tonic::Status,
3838
-
>;
3273
+
type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
3839
3274
fn call(
3840
3275
&mut self,
3841
3276
request: tonic::Request<super::HardStopRequest>,
···
3872
3307
"/rockbox.v1alpha1.PlaybackService/PlayAlbum" => {
3873
3308
#[allow(non_camel_case_types)]
3874
3309
struct PlayAlbumSvc<T: PlaybackService>(pub Arc<T>);
3875
-
impl<
3876
-
T: PlaybackService,
3877
-
> tonic::server::UnaryService<super::PlayAlbumRequest>
3878
-
for PlayAlbumSvc<T> {
3310
+
impl<T: PlaybackService> tonic::server::UnaryService<super::PlayAlbumRequest> for PlayAlbumSvc<T> {
3879
3311
type Response = super::PlayAlbumResponse;
3880
-
type Future = BoxFuture<
3881
-
tonic::Response<Self::Response>,
3882
-
tonic::Status,
3883
-
>;
3312
+
type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
3884
3313
fn call(
3885
3314
&mut self,
3886
3315
request: tonic::Request<super::PlayAlbumRequest>,
···
3917
3346
"/rockbox.v1alpha1.PlaybackService/PlayArtistTracks" => {
3918
3347
#[allow(non_camel_case_types)]
3919
3348
struct PlayArtistTracksSvc<T: PlaybackService>(pub Arc<T>);
3920
-
impl<
3921
-
T: PlaybackService,
3922
-
> tonic::server::UnaryService<super::PlayArtistTracksRequest>
3923
-
for PlayArtistTracksSvc<T> {
3349
+
impl<T: PlaybackService>
3350
+
tonic::server::UnaryService<super::PlayArtistTracksRequest>
3351
+
for PlayArtistTracksSvc<T>
3352
+
{
3924
3353
type Response = super::PlayArtistTracksResponse;
3925
-
type Future = BoxFuture<
3926
-
tonic::Response<Self::Response>,
3927
-
tonic::Status,
3928
-
>;
3354
+
type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
3929
3355
fn call(
3930
3356
&mut self,
3931
3357
request: tonic::Request<super::PlayArtistTracksRequest>,
3932
3358
) -> Self::Future {
3933
3359
let inner = Arc::clone(&self.0);
3934
3360
let fut = async move {
3935
-
<T as PlaybackService>::play_artist_tracks(&inner, request)
3936
-
.await
3361
+
<T as PlaybackService>::play_artist_tracks(&inner, request).await
3937
3362
};
3938
3363
Box::pin(fut)
3939
3364
}
···
3963
3388
"/rockbox.v1alpha1.PlaybackService/PlayPlaylist" => {
3964
3389
#[allow(non_camel_case_types)]
3965
3390
struct PlayPlaylistSvc<T: PlaybackService>(pub Arc<T>);
3966
-
impl<
3967
-
T: PlaybackService,
3968
-
> tonic::server::UnaryService<super::PlayPlaylistRequest>
3969
-
for PlayPlaylistSvc<T> {
3391
+
impl<T: PlaybackService> tonic::server::UnaryService<super::PlayPlaylistRequest>
3392
+
for PlayPlaylistSvc<T>
3393
+
{
3970
3394
type Response = super::PlayPlaylistResponse;
3971
-
type Future = BoxFuture<
3972
-
tonic::Response<Self::Response>,
3973
-
tonic::Status,
3974
-
>;
3395
+
type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
3975
3396
fn call(
3976
3397
&mut self,
3977
3398
request: tonic::Request<super::PlayPlaylistRequest>,
···
4008
3429
"/rockbox.v1alpha1.PlaybackService/PlayDirectory" => {
4009
3430
#[allow(non_camel_case_types)]
4010
3431
struct PlayDirectorySvc<T: PlaybackService>(pub Arc<T>);
4011
-
impl<
4012
-
T: PlaybackService,
4013
-
> tonic::server::UnaryService<super::PlayDirectoryRequest>
4014
-
for PlayDirectorySvc<T> {
3432
+
impl<T: PlaybackService>
3433
+
tonic::server::UnaryService<super::PlayDirectoryRequest>
3434
+
for PlayDirectorySvc<T>
3435
+
{
4015
3436
type Response = super::PlayDirectoryResponse;
4016
-
type Future = BoxFuture<
4017
-
tonic::Response<Self::Response>,
4018
-
tonic::Status,
4019
-
>;
3437
+
type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
4020
3438
fn call(
4021
3439
&mut self,
4022
3440
request: tonic::Request<super::PlayDirectoryRequest>,
4023
3441
) -> Self::Future {
4024
3442
let inner = Arc::clone(&self.0);
4025
3443
let fut = async move {
4026
-
<T as PlaybackService>::play_directory(&inner, request)
4027
-
.await
3444
+
<T as PlaybackService>::play_directory(&inner, request).await
4028
3445
};
4029
3446
Box::pin(fut)
4030
3447
}
···
4054
3471
"/rockbox.v1alpha1.PlaybackService/PlayMusicDirectory" => {
4055
3472
#[allow(non_camel_case_types)]
4056
3473
struct PlayMusicDirectorySvc<T: PlaybackService>(pub Arc<T>);
4057
-
impl<
4058
-
T: PlaybackService,
4059
-
> tonic::server::UnaryService<super::PlayMusicDirectoryRequest>
4060
-
for PlayMusicDirectorySvc<T> {
3474
+
impl<T: PlaybackService>
3475
+
tonic::server::UnaryService<super::PlayMusicDirectoryRequest>
3476
+
for PlayMusicDirectorySvc<T>
3477
+
{
4061
3478
type Response = super::PlayMusicDirectoryResponse;
4062
-
type Future = BoxFuture<
4063
-
tonic::Response<Self::Response>,
4064
-
tonic::Status,
4065
-
>;
3479
+
type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
4066
3480
fn call(
4067
3481
&mut self,
4068
3482
request: tonic::Request<super::PlayMusicDirectoryRequest>,
4069
3483
) -> Self::Future {
4070
3484
let inner = Arc::clone(&self.0);
4071
3485
let fut = async move {
4072
-
<T as PlaybackService>::play_music_directory(
4073
-
&inner,
4074
-
request,
4075
-
)
4076
-
.await
3486
+
<T as PlaybackService>::play_music_directory(&inner, request).await
4077
3487
};
4078
3488
Box::pin(fut)
4079
3489
}
···
4103
3513
"/rockbox.v1alpha1.PlaybackService/PlayTrack" => {
4104
3514
#[allow(non_camel_case_types)]
4105
3515
struct PlayTrackSvc<T: PlaybackService>(pub Arc<T>);
4106
-
impl<
4107
-
T: PlaybackService,
4108
-
> tonic::server::UnaryService<super::PlayTrackRequest>
4109
-
for PlayTrackSvc<T> {
3516
+
impl<T: PlaybackService> tonic::server::UnaryService<super::PlayTrackRequest> for PlayTrackSvc<T> {
4110
3517
type Response = super::PlayTrackResponse;
4111
-
type Future = BoxFuture<
4112
-
tonic::Response<Self::Response>,
4113
-
tonic::Status,
4114
-
>;
3518
+
type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
4115
3519
fn call(
4116
3520
&mut self,
4117
3521
request: tonic::Request<super::PlayTrackRequest>,
···
4148
3552
"/rockbox.v1alpha1.PlaybackService/PlayLikedTracks" => {
4149
3553
#[allow(non_camel_case_types)]
4150
3554
struct PlayLikedTracksSvc<T: PlaybackService>(pub Arc<T>);
4151
-
impl<
4152
-
T: PlaybackService,
4153
-
> tonic::server::UnaryService<super::PlayLikedTracksRequest>
4154
-
for PlayLikedTracksSvc<T> {
3555
+
impl<T: PlaybackService>
3556
+
tonic::server::UnaryService<super::PlayLikedTracksRequest>
3557
+
for PlayLikedTracksSvc<T>
3558
+
{
4155
3559
type Response = super::PlayLikedTracksResponse;
4156
-
type Future = BoxFuture<
4157
-
tonic::Response<Self::Response>,
4158
-
tonic::Status,
4159
-
>;
3560
+
type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
4160
3561
fn call(
4161
3562
&mut self,
4162
3563
request: tonic::Request<super::PlayLikedTracksRequest>,
4163
3564
) -> Self::Future {
4164
3565
let inner = Arc::clone(&self.0);
4165
3566
let fut = async move {
4166
-
<T as PlaybackService>::play_liked_tracks(&inner, request)
4167
-
.await
3567
+
<T as PlaybackService>::play_liked_tracks(&inner, request).await
4168
3568
};
4169
3569
Box::pin(fut)
4170
3570
}
···
4194
3594
"/rockbox.v1alpha1.PlaybackService/PlayAllTracks" => {
4195
3595
#[allow(non_camel_case_types)]
4196
3596
struct PlayAllTracksSvc<T: PlaybackService>(pub Arc<T>);
4197
-
impl<
4198
-
T: PlaybackService,
4199
-
> tonic::server::UnaryService<super::PlayAllTracksRequest>
4200
-
for PlayAllTracksSvc<T> {
3597
+
impl<T: PlaybackService>
3598
+
tonic::server::UnaryService<super::PlayAllTracksRequest>
3599
+
for PlayAllTracksSvc<T>
3600
+
{
4201
3601
type Response = super::PlayAllTracksResponse;
4202
-
type Future = BoxFuture<
4203
-
tonic::Response<Self::Response>,
4204
-
tonic::Status,
4205
-
>;
3602
+
type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
4206
3603
fn call(
4207
3604
&mut self,
4208
3605
request: tonic::Request<super::PlayAllTracksRequest>,
4209
3606
) -> Self::Future {
4210
3607
let inner = Arc::clone(&self.0);
4211
3608
let fut = async move {
4212
-
<T as PlaybackService>::play_all_tracks(&inner, request)
4213
-
.await
3609
+
<T as PlaybackService>::play_all_tracks(&inner, request).await
4214
3610
};
4215
3611
Box::pin(fut)
4216
3612
}
···
4240
3636
"/rockbox.v1alpha1.PlaybackService/StreamCurrentTrack" => {
4241
3637
#[allow(non_camel_case_types)]
4242
3638
struct StreamCurrentTrackSvc<T: PlaybackService>(pub Arc<T>);
4243
-
impl<
4244
-
T: PlaybackService,
4245
-
> tonic::server::ServerStreamingService<
4246
-
super::StreamCurrentTrackRequest,
4247
-
> for StreamCurrentTrackSvc<T> {
3639
+
impl<T: PlaybackService>
3640
+
tonic::server::ServerStreamingService<super::StreamCurrentTrackRequest>
3641
+
for StreamCurrentTrackSvc<T>
3642
+
{
4248
3643
type Response = super::CurrentTrackResponse;
4249
3644
type ResponseStream = T::StreamCurrentTrackStream;
4250
-
type Future = BoxFuture<
4251
-
tonic::Response<Self::ResponseStream>,
4252
-
tonic::Status,
4253
-
>;
3645
+
type Future =
3646
+
BoxFuture<tonic::Response<Self::ResponseStream>, tonic::Status>;
4254
3647
fn call(
4255
3648
&mut self,
4256
3649
request: tonic::Request<super::StreamCurrentTrackRequest>,
4257
3650
) -> Self::Future {
4258
3651
let inner = Arc::clone(&self.0);
4259
3652
let fut = async move {
4260
-
<T as PlaybackService>::stream_current_track(
4261
-
&inner,
4262
-
request,
4263
-
)
4264
-
.await
3653
+
<T as PlaybackService>::stream_current_track(&inner, request).await
4265
3654
};
4266
3655
Box::pin(fut)
4267
3656
}
···
4291
3680
"/rockbox.v1alpha1.PlaybackService/StreamStatus" => {
4292
3681
#[allow(non_camel_case_types)]
4293
3682
struct StreamStatusSvc<T: PlaybackService>(pub Arc<T>);
4294
-
impl<
4295
-
T: PlaybackService,
4296
-
> tonic::server::ServerStreamingService<super::StreamStatusRequest>
4297
-
for StreamStatusSvc<T> {
3683
+
impl<T: PlaybackService>
3684
+
tonic::server::ServerStreamingService<super::StreamStatusRequest>
3685
+
for StreamStatusSvc<T>
3686
+
{
4298
3687
type Response = super::StatusResponse;
4299
3688
type ResponseStream = T::StreamStatusStream;
4300
-
type Future = BoxFuture<
4301
-
tonic::Response<Self::ResponseStream>,
4302
-
tonic::Status,
4303
-
>;
3689
+
type Future =
3690
+
BoxFuture<tonic::Response<Self::ResponseStream>, tonic::Status>;
4304
3691
fn call(
4305
3692
&mut self,
4306
3693
request: tonic::Request<super::StreamStatusRequest>,
···
4337
3724
"/rockbox.v1alpha1.PlaybackService/StreamPlaylist" => {
4338
3725
#[allow(non_camel_case_types)]
4339
3726
struct StreamPlaylistSvc<T: PlaybackService>(pub Arc<T>);
4340
-
impl<
4341
-
T: PlaybackService,
4342
-
> tonic::server::ServerStreamingService<super::StreamPlaylistRequest>
4343
-
for StreamPlaylistSvc<T> {
3727
+
impl<T: PlaybackService>
3728
+
tonic::server::ServerStreamingService<super::StreamPlaylistRequest>
3729
+
for StreamPlaylistSvc<T>
3730
+
{
4344
3731
type Response = super::PlaylistResponse;
4345
3732
type ResponseStream = T::StreamPlaylistStream;
4346
-
type Future = BoxFuture<
4347
-
tonic::Response<Self::ResponseStream>,
4348
-
tonic::Status,
4349
-
>;
3733
+
type Future =
3734
+
BoxFuture<tonic::Response<Self::ResponseStream>, tonic::Status>;
4350
3735
fn call(
4351
3736
&mut self,
4352
3737
request: tonic::Request<super::StreamPlaylistRequest>,
4353
3738
) -> Self::Future {
4354
3739
let inner = Arc::clone(&self.0);
4355
3740
let fut = async move {
4356
-
<T as PlaybackService>::stream_playlist(&inner, request)
4357
-
.await
3741
+
<T as PlaybackService>::stream_playlist(&inner, request).await
4358
3742
};
4359
3743
Box::pin(fut)
4360
3744
}
···
4381
3765
};
4382
3766
Box::pin(fut)
4383
3767
}
4384
-
_ => {
4385
-
Box::pin(async move {
4386
-
let mut response = http::Response::new(empty_body());
4387
-
let headers = response.headers_mut();
4388
-
headers
4389
-
.insert(
4390
-
tonic::Status::GRPC_STATUS,
4391
-
(tonic::Code::Unimplemented as i32).into(),
4392
-
);
4393
-
headers
4394
-
.insert(
4395
-
http::header::CONTENT_TYPE,
4396
-
tonic::metadata::GRPC_CONTENT_TYPE,
4397
-
);
4398
-
Ok(response)
4399
-
})
4400
-
}
3768
+
_ => Box::pin(async move {
3769
+
let mut response = http::Response::new(empty_body());
3770
+
let headers = response.headers_mut();
3771
+
headers.insert(
3772
+
tonic::Status::GRPC_STATUS,
3773
+
(tonic::Code::Unimplemented as i32).into(),
3774
+
);
3775
+
headers.insert(
3776
+
http::header::CONTENT_TYPE,
3777
+
tonic::metadata::GRPC_CONTENT_TYPE,
3778
+
);
3779
+
Ok(response)
3780
+
}),
4401
3781
}
4402
3782
}
4403
3783
}
···
4604
3984
dead_code,
4605
3985
missing_docs,
4606
3986
clippy::wildcard_imports,
4607
-
clippy::let_unit_value,
3987
+
clippy::let_unit_value
4608
3988
)]
4609
-
use tonic::codegen::*;
4610
3989
use tonic::codegen::http::Uri;
3990
+
use tonic::codegen::*;
4611
3991
#[derive(Debug, Clone)]
4612
3992
pub struct PlaylistServiceClient<T> {
4613
3993
inner: tonic::client::Grpc<T>,
···
4651
4031
<T as tonic::client::GrpcService<tonic::body::BoxBody>>::ResponseBody,
4652
4032
>,
4653
4033
>,
4654
-
<T as tonic::codegen::Service<
4655
-
http::Request<tonic::body::BoxBody>,
4656
-
>>::Error: Into<StdError> + std::marker::Send + std::marker::Sync,
4034
+
<T as tonic::codegen::Service<http::Request<tonic::body::BoxBody>>>::Error:
4035
+
Into<StdError> + std::marker::Send + std::marker::Sync,
4657
4036
{
4658
4037
PlaylistServiceClient::new(InterceptedService::new(inner, interceptor))
4659
4038
}
···
4691
4070
pub async fn get_current(
4692
4071
&mut self,
4693
4072
request: impl tonic::IntoRequest<super::GetCurrentRequest>,
4694
-
) -> std::result::Result<
4695
-
tonic::Response<super::GetCurrentResponse>,
4696
-
tonic::Status,
4697
-
> {
4698
-
self.inner
4699
-
.ready()
4700
-
.await
4701
-
.map_err(|e| {
4702
-
tonic::Status::unknown(
4703
-
format!("Service was not ready: {}", e.into()),
4704
-
)
4705
-
})?;
4073
+
) -> std::result::Result<tonic::Response<super::GetCurrentResponse>, tonic::Status>
4074
+
{
4075
+
self.inner.ready().await.map_err(|e| {
4076
+
tonic::Status::unknown(format!("Service was not ready: {}", e.into()))
4077
+
})?;
4706
4078
let codec = tonic::codec::ProstCodec::default();
4707
4079
let path = http::uri::PathAndQuery::from_static(
4708
4080
"/rockbox.v1alpha1.PlaylistService/GetCurrent",
4709
4081
);
4710
4082
let mut req = request.into_request();
4711
-
req.extensions_mut()
4712
-
.insert(
4713
-
GrpcMethod::new("rockbox.v1alpha1.PlaylistService", "GetCurrent"),
4714
-
);
4083
+
req.extensions_mut().insert(GrpcMethod::new(
4084
+
"rockbox.v1alpha1.PlaylistService",
4085
+
"GetCurrent",
4086
+
));
4715
4087
self.inner.unary(req, path, codec).await
4716
4088
}
4717
4089
pub async fn get_resume_info(
4718
4090
&mut self,
4719
4091
request: impl tonic::IntoRequest<super::GetResumeInfoRequest>,
4720
-
) -> std::result::Result<
4721
-
tonic::Response<super::GetResumeInfoResponse>,
4722
-
tonic::Status,
4723
-
> {
4724
-
self.inner
4725
-
.ready()
4726
-
.await
4727
-
.map_err(|e| {
4728
-
tonic::Status::unknown(
4729
-
format!("Service was not ready: {}", e.into()),
4730
-
)
4731
-
})?;
4092
+
) -> std::result::Result<tonic::Response<super::GetResumeInfoResponse>, tonic::Status>
4093
+
{
4094
+
self.inner.ready().await.map_err(|e| {
4095
+
tonic::Status::unknown(format!("Service was not ready: {}", e.into()))
4096
+
})?;
4732
4097
let codec = tonic::codec::ProstCodec::default();
4733
4098
let path = http::uri::PathAndQuery::from_static(
4734
4099
"/rockbox.v1alpha1.PlaylistService/GetResumeInfo",
4735
4100
);
4736
4101
let mut req = request.into_request();
4737
-
req.extensions_mut()
4738
-
.insert(
4739
-
GrpcMethod::new("rockbox.v1alpha1.PlaylistService", "GetResumeInfo"),
4740
-
);
4102
+
req.extensions_mut().insert(GrpcMethod::new(
4103
+
"rockbox.v1alpha1.PlaylistService",
4104
+
"GetResumeInfo",
4105
+
));
4741
4106
self.inner.unary(req, path, codec).await
4742
4107
}
4743
4108
pub async fn get_track_info(
4744
4109
&mut self,
4745
4110
request: impl tonic::IntoRequest<super::GetTrackInfoRequest>,
4746
-
) -> std::result::Result<
4747
-
tonic::Response<super::GetTrackInfoResponse>,
4748
-
tonic::Status,
4749
-
> {
4750
-
self.inner
4751
-
.ready()
4752
-
.await
4753
-
.map_err(|e| {
4754
-
tonic::Status::unknown(
4755
-
format!("Service was not ready: {}", e.into()),
4756
-
)
4757
-
})?;
4111
+
) -> std::result::Result<tonic::Response<super::GetTrackInfoResponse>, tonic::Status>
4112
+
{
4113
+
self.inner.ready().await.map_err(|e| {
4114
+
tonic::Status::unknown(format!("Service was not ready: {}", e.into()))
4115
+
})?;
4758
4116
let codec = tonic::codec::ProstCodec::default();
4759
4117
let path = http::uri::PathAndQuery::from_static(
4760
4118
"/rockbox.v1alpha1.PlaylistService/GetTrackInfo",
4761
4119
);
4762
4120
let mut req = request.into_request();
4763
-
req.extensions_mut()
4764
-
.insert(
4765
-
GrpcMethod::new("rockbox.v1alpha1.PlaylistService", "GetTrackInfo"),
4766
-
);
4121
+
req.extensions_mut().insert(GrpcMethod::new(
4122
+
"rockbox.v1alpha1.PlaylistService",
4123
+
"GetTrackInfo",
4124
+
));
4767
4125
self.inner.unary(req, path, codec).await
4768
4126
}
4769
4127
pub async fn get_first_index(
4770
4128
&mut self,
4771
4129
request: impl tonic::IntoRequest<super::GetFirstIndexRequest>,
4772
-
) -> std::result::Result<
4773
-
tonic::Response<super::GetFirstIndexResponse>,
4774
-
tonic::Status,
4775
-
> {
4776
-
self.inner
4777
-
.ready()
4778
-
.await
4779
-
.map_err(|e| {
4780
-
tonic::Status::unknown(
4781
-
format!("Service was not ready: {}", e.into()),
4782
-
)
4783
-
})?;
4130
+
) -> std::result::Result<tonic::Response<super::GetFirstIndexResponse>, tonic::Status>
4131
+
{
4132
+
self.inner.ready().await.map_err(|e| {
4133
+
tonic::Status::unknown(format!("Service was not ready: {}", e.into()))
4134
+
})?;
4784
4135
let codec = tonic::codec::ProstCodec::default();
4785
4136
let path = http::uri::PathAndQuery::from_static(
4786
4137
"/rockbox.v1alpha1.PlaylistService/GetFirstIndex",
4787
4138
);
4788
4139
let mut req = request.into_request();
4789
-
req.extensions_mut()
4790
-
.insert(
4791
-
GrpcMethod::new("rockbox.v1alpha1.PlaylistService", "GetFirstIndex"),
4792
-
);
4140
+
req.extensions_mut().insert(GrpcMethod::new(
4141
+
"rockbox.v1alpha1.PlaylistService",
4142
+
"GetFirstIndex",
4143
+
));
4793
4144
self.inner.unary(req, path, codec).await
4794
4145
}
4795
4146
pub async fn get_display_index(
4796
4147
&mut self,
4797
4148
request: impl tonic::IntoRequest<super::GetDisplayIndexRequest>,
4798
-
) -> std::result::Result<
4799
-
tonic::Response<super::GetDisplayIndexResponse>,
4800
-
tonic::Status,
4801
-
> {
4802
-
self.inner
4803
-
.ready()
4804
-
.await
4805
-
.map_err(|e| {
4806
-
tonic::Status::unknown(
4807
-
format!("Service was not ready: {}", e.into()),
4808
-
)
4809
-
})?;
4149
+
) -> std::result::Result<tonic::Response<super::GetDisplayIndexResponse>, tonic::Status>
4150
+
{
4151
+
self.inner.ready().await.map_err(|e| {
4152
+
tonic::Status::unknown(format!("Service was not ready: {}", e.into()))
4153
+
})?;
4810
4154
let codec = tonic::codec::ProstCodec::default();
4811
4155
let path = http::uri::PathAndQuery::from_static(
4812
4156
"/rockbox.v1alpha1.PlaylistService/GetDisplayIndex",
4813
4157
);
4814
4158
let mut req = request.into_request();
4815
-
req.extensions_mut()
4816
-
.insert(
4817
-
GrpcMethod::new(
4818
-
"rockbox.v1alpha1.PlaylistService",
4819
-
"GetDisplayIndex",
4820
-
),
4821
-
);
4159
+
req.extensions_mut().insert(GrpcMethod::new(
4160
+
"rockbox.v1alpha1.PlaylistService",
4161
+
"GetDisplayIndex",
4162
+
));
4822
4163
self.inner.unary(req, path, codec).await
4823
4164
}
4824
4165
pub async fn amount(
4825
4166
&mut self,
4826
4167
request: impl tonic::IntoRequest<super::AmountRequest>,
4827
4168
) -> std::result::Result<tonic::Response<super::AmountResponse>, tonic::Status> {
4828
-
self.inner
4829
-
.ready()
4830
-
.await
4831
-
.map_err(|e| {
4832
-
tonic::Status::unknown(
4833
-
format!("Service was not ready: {}", e.into()),
4834
-
)
4835
-
})?;
4169
+
self.inner.ready().await.map_err(|e| {
4170
+
tonic::Status::unknown(format!("Service was not ready: {}", e.into()))
4171
+
})?;
4836
4172
let codec = tonic::codec::ProstCodec::default();
4837
-
let path = http::uri::PathAndQuery::from_static(
4838
-
"/rockbox.v1alpha1.PlaylistService/Amount",
4839
-
);
4173
+
let path =
4174
+
http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.PlaylistService/Amount");
4840
4175
let mut req = request.into_request();
4841
-
req.extensions_mut()
4842
-
.insert(GrpcMethod::new("rockbox.v1alpha1.PlaylistService", "Amount"));
4176
+
req.extensions_mut().insert(GrpcMethod::new(
4177
+
"rockbox.v1alpha1.PlaylistService",
4178
+
"Amount",
4179
+
));
4843
4180
self.inner.unary(req, path, codec).await
4844
4181
}
4845
4182
pub async fn playlist_resume(
4846
4183
&mut self,
4847
4184
request: impl tonic::IntoRequest<super::PlaylistResumeRequest>,
4848
-
) -> std::result::Result<
4849
-
tonic::Response<super::PlaylistResumeResponse>,
4850
-
tonic::Status,
4851
-
> {
4852
-
self.inner
4853
-
.ready()
4854
-
.await
4855
-
.map_err(|e| {
4856
-
tonic::Status::unknown(
4857
-
format!("Service was not ready: {}", e.into()),
4858
-
)
4859
-
})?;
4185
+
) -> std::result::Result<tonic::Response<super::PlaylistResumeResponse>, tonic::Status>
4186
+
{
4187
+
self.inner.ready().await.map_err(|e| {
4188
+
tonic::Status::unknown(format!("Service was not ready: {}", e.into()))
4189
+
})?;
4860
4190
let codec = tonic::codec::ProstCodec::default();
4861
4191
let path = http::uri::PathAndQuery::from_static(
4862
4192
"/rockbox.v1alpha1.PlaylistService/PlaylistResume",
4863
4193
);
4864
4194
let mut req = request.into_request();
4865
-
req.extensions_mut()
4866
-
.insert(
4867
-
GrpcMethod::new("rockbox.v1alpha1.PlaylistService", "PlaylistResume"),
4868
-
);
4195
+
req.extensions_mut().insert(GrpcMethod::new(
4196
+
"rockbox.v1alpha1.PlaylistService",
4197
+
"PlaylistResume",
4198
+
));
4869
4199
self.inner.unary(req, path, codec).await
4870
4200
}
4871
4201
pub async fn resume_track(
4872
4202
&mut self,
4873
4203
request: impl tonic::IntoRequest<super::ResumeTrackRequest>,
4874
-
) -> std::result::Result<
4875
-
tonic::Response<super::ResumeTrackResponse>,
4876
-
tonic::Status,
4877
-
> {
4878
-
self.inner
4879
-
.ready()
4880
-
.await
4881
-
.map_err(|e| {
4882
-
tonic::Status::unknown(
4883
-
format!("Service was not ready: {}", e.into()),
4884
-
)
4885
-
})?;
4204
+
) -> std::result::Result<tonic::Response<super::ResumeTrackResponse>, tonic::Status>
4205
+
{
4206
+
self.inner.ready().await.map_err(|e| {
4207
+
tonic::Status::unknown(format!("Service was not ready: {}", e.into()))
4208
+
})?;
4886
4209
let codec = tonic::codec::ProstCodec::default();
4887
4210
let path = http::uri::PathAndQuery::from_static(
4888
4211
"/rockbox.v1alpha1.PlaylistService/ResumeTrack",
4889
4212
);
4890
4213
let mut req = request.into_request();
4891
-
req.extensions_mut()
4892
-
.insert(
4893
-
GrpcMethod::new("rockbox.v1alpha1.PlaylistService", "ResumeTrack"),
4894
-
);
4214
+
req.extensions_mut().insert(GrpcMethod::new(
4215
+
"rockbox.v1alpha1.PlaylistService",
4216
+
"ResumeTrack",
4217
+
));
4895
4218
self.inner.unary(req, path, codec).await
4896
4219
}
4897
4220
pub async fn set_modified(
4898
4221
&mut self,
4899
4222
request: impl tonic::IntoRequest<super::SetModifiedRequest>,
4900
-
) -> std::result::Result<
4901
-
tonic::Response<super::SetModifiedResponse>,
4902
-
tonic::Status,
4903
-
> {
4904
-
self.inner
4905
-
.ready()
4906
-
.await
4907
-
.map_err(|e| {
4908
-
tonic::Status::unknown(
4909
-
format!("Service was not ready: {}", e.into()),
4910
-
)
4911
-
})?;
4223
+
) -> std::result::Result<tonic::Response<super::SetModifiedResponse>, tonic::Status>
4224
+
{
4225
+
self.inner.ready().await.map_err(|e| {
4226
+
tonic::Status::unknown(format!("Service was not ready: {}", e.into()))
4227
+
})?;
4912
4228
let codec = tonic::codec::ProstCodec::default();
4913
4229
let path = http::uri::PathAndQuery::from_static(
4914
4230
"/rockbox.v1alpha1.PlaylistService/SetModified",
4915
4231
);
4916
4232
let mut req = request.into_request();
4917
-
req.extensions_mut()
4918
-
.insert(
4919
-
GrpcMethod::new("rockbox.v1alpha1.PlaylistService", "SetModified"),
4920
-
);
4233
+
req.extensions_mut().insert(GrpcMethod::new(
4234
+
"rockbox.v1alpha1.PlaylistService",
4235
+
"SetModified",
4236
+
));
4921
4237
self.inner.unary(req, path, codec).await
4922
4238
}
4923
4239
pub async fn start(
4924
4240
&mut self,
4925
4241
request: impl tonic::IntoRequest<super::StartRequest>,
4926
4242
) -> std::result::Result<tonic::Response<super::StartResponse>, tonic::Status> {
4927
-
self.inner
4928
-
.ready()
4929
-
.await
4930
-
.map_err(|e| {
4931
-
tonic::Status::unknown(
4932
-
format!("Service was not ready: {}", e.into()),
4933
-
)
4934
-
})?;
4243
+
self.inner.ready().await.map_err(|e| {
4244
+
tonic::Status::unknown(format!("Service was not ready: {}", e.into()))
4245
+
})?;
4935
4246
let codec = tonic::codec::ProstCodec::default();
4936
-
let path = http::uri::PathAndQuery::from_static(
4937
-
"/rockbox.v1alpha1.PlaylistService/Start",
4938
-
);
4247
+
let path =
4248
+
http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.PlaylistService/Start");
4939
4249
let mut req = request.into_request();
4940
4250
req.extensions_mut()
4941
4251
.insert(GrpcMethod::new("rockbox.v1alpha1.PlaylistService", "Start"));
···
4945
4255
&mut self,
4946
4256
request: impl tonic::IntoRequest<super::SyncRequest>,
4947
4257
) -> std::result::Result<tonic::Response<super::SyncResponse>, tonic::Status> {
4948
-
self.inner
4949
-
.ready()
4950
-
.await
4951
-
.map_err(|e| {
4952
-
tonic::Status::unknown(
4953
-
format!("Service was not ready: {}", e.into()),
4954
-
)
4955
-
})?;
4258
+
self.inner.ready().await.map_err(|e| {
4259
+
tonic::Status::unknown(format!("Service was not ready: {}", e.into()))
4260
+
})?;
4956
4261
let codec = tonic::codec::ProstCodec::default();
4957
-
let path = http::uri::PathAndQuery::from_static(
4958
-
"/rockbox.v1alpha1.PlaylistService/Sync",
4959
-
);
4262
+
let path =
4263
+
http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.PlaylistService/Sync");
4960
4264
let mut req = request.into_request();
4961
4265
req.extensions_mut()
4962
4266
.insert(GrpcMethod::new("rockbox.v1alpha1.PlaylistService", "Sync"));
···
4965
4269
pub async fn remove_all_tracks(
4966
4270
&mut self,
4967
4271
request: impl tonic::IntoRequest<super::RemoveAllTracksRequest>,
4968
-
) -> std::result::Result<
4969
-
tonic::Response<super::RemoveAllTracksResponse>,
4970
-
tonic::Status,
4971
-
> {
4972
-
self.inner
4973
-
.ready()
4974
-
.await
4975
-
.map_err(|e| {
4976
-
tonic::Status::unknown(
4977
-
format!("Service was not ready: {}", e.into()),
4978
-
)
4979
-
})?;
4272
+
) -> std::result::Result<tonic::Response<super::RemoveAllTracksResponse>, tonic::Status>
4273
+
{
4274
+
self.inner.ready().await.map_err(|e| {
4275
+
tonic::Status::unknown(format!("Service was not ready: {}", e.into()))
4276
+
})?;
4980
4277
let codec = tonic::codec::ProstCodec::default();
4981
4278
let path = http::uri::PathAndQuery::from_static(
4982
4279
"/rockbox.v1alpha1.PlaylistService/RemoveAllTracks",
4983
4280
);
4984
4281
let mut req = request.into_request();
4985
-
req.extensions_mut()
4986
-
.insert(
4987
-
GrpcMethod::new(
4988
-
"rockbox.v1alpha1.PlaylistService",
4989
-
"RemoveAllTracks",
4990
-
),
4991
-
);
4282
+
req.extensions_mut().insert(GrpcMethod::new(
4283
+
"rockbox.v1alpha1.PlaylistService",
4284
+
"RemoveAllTracks",
4285
+
));
4992
4286
self.inner.unary(req, path, codec).await
4993
4287
}
4994
4288
pub async fn remove_tracks(
4995
4289
&mut self,
4996
4290
request: impl tonic::IntoRequest<super::RemoveTracksRequest>,
4997
-
) -> std::result::Result<
4998
-
tonic::Response<super::RemoveTracksResponse>,
4999
-
tonic::Status,
5000
-
> {
5001
-
self.inner
5002
-
.ready()
5003
-
.await
5004
-
.map_err(|e| {
5005
-
tonic::Status::unknown(
5006
-
format!("Service was not ready: {}", e.into()),
5007
-
)
5008
-
})?;
4291
+
) -> std::result::Result<tonic::Response<super::RemoveTracksResponse>, tonic::Status>
4292
+
{
4293
+
self.inner.ready().await.map_err(|e| {
4294
+
tonic::Status::unknown(format!("Service was not ready: {}", e.into()))
4295
+
})?;
5009
4296
let codec = tonic::codec::ProstCodec::default();
5010
4297
let path = http::uri::PathAndQuery::from_static(
5011
4298
"/rockbox.v1alpha1.PlaylistService/RemoveTracks",
5012
4299
);
5013
4300
let mut req = request.into_request();
5014
-
req.extensions_mut()
5015
-
.insert(
5016
-
GrpcMethod::new("rockbox.v1alpha1.PlaylistService", "RemoveTracks"),
5017
-
);
4301
+
req.extensions_mut().insert(GrpcMethod::new(
4302
+
"rockbox.v1alpha1.PlaylistService",
4303
+
"RemoveTracks",
4304
+
));
5018
4305
self.inner.unary(req, path, codec).await
5019
4306
}
5020
4307
pub async fn create_playlist(
5021
4308
&mut self,
5022
4309
request: impl tonic::IntoRequest<super::CreatePlaylistRequest>,
5023
-
) -> std::result::Result<
5024
-
tonic::Response<super::CreatePlaylistResponse>,
5025
-
tonic::Status,
5026
-
> {
5027
-
self.inner
5028
-
.ready()
5029
-
.await
5030
-
.map_err(|e| {
5031
-
tonic::Status::unknown(
5032
-
format!("Service was not ready: {}", e.into()),
5033
-
)
5034
-
})?;
4310
+
) -> std::result::Result<tonic::Response<super::CreatePlaylistResponse>, tonic::Status>
4311
+
{
4312
+
self.inner.ready().await.map_err(|e| {
4313
+
tonic::Status::unknown(format!("Service was not ready: {}", e.into()))
4314
+
})?;
5035
4315
let codec = tonic::codec::ProstCodec::default();
5036
4316
let path = http::uri::PathAndQuery::from_static(
5037
4317
"/rockbox.v1alpha1.PlaylistService/CreatePlaylist",
5038
4318
);
5039
4319
let mut req = request.into_request();
5040
-
req.extensions_mut()
5041
-
.insert(
5042
-
GrpcMethod::new("rockbox.v1alpha1.PlaylistService", "CreatePlaylist"),
5043
-
);
4320
+
req.extensions_mut().insert(GrpcMethod::new(
4321
+
"rockbox.v1alpha1.PlaylistService",
4322
+
"CreatePlaylist",
4323
+
));
5044
4324
self.inner.unary(req, path, codec).await
5045
4325
}
5046
4326
pub async fn insert_tracks(
5047
4327
&mut self,
5048
4328
request: impl tonic::IntoRequest<super::InsertTracksRequest>,
5049
-
) -> std::result::Result<
5050
-
tonic::Response<super::InsertTracksResponse>,
5051
-
tonic::Status,
5052
-
> {
5053
-
self.inner
5054
-
.ready()
5055
-
.await
5056
-
.map_err(|e| {
5057
-
tonic::Status::unknown(
5058
-
format!("Service was not ready: {}", e.into()),
5059
-
)
5060
-
})?;
4329
+
) -> std::result::Result<tonic::Response<super::InsertTracksResponse>, tonic::Status>
4330
+
{
4331
+
self.inner.ready().await.map_err(|e| {
4332
+
tonic::Status::unknown(format!("Service was not ready: {}", e.into()))
4333
+
})?;
5061
4334
let codec = tonic::codec::ProstCodec::default();
5062
4335
let path = http::uri::PathAndQuery::from_static(
5063
4336
"/rockbox.v1alpha1.PlaylistService/InsertTracks",
5064
4337
);
5065
4338
let mut req = request.into_request();
5066
-
req.extensions_mut()
5067
-
.insert(
5068
-
GrpcMethod::new("rockbox.v1alpha1.PlaylistService", "InsertTracks"),
5069
-
);
4339
+
req.extensions_mut().insert(GrpcMethod::new(
4340
+
"rockbox.v1alpha1.PlaylistService",
4341
+
"InsertTracks",
4342
+
));
5070
4343
self.inner.unary(req, path, codec).await
5071
4344
}
5072
4345
pub async fn insert_directory(
5073
4346
&mut self,
5074
4347
request: impl tonic::IntoRequest<super::InsertDirectoryRequest>,
5075
-
) -> std::result::Result<
5076
-
tonic::Response<super::InsertDirectoryResponse>,
5077
-
tonic::Status,
5078
-
> {
5079
-
self.inner
5080
-
.ready()
5081
-
.await
5082
-
.map_err(|e| {
5083
-
tonic::Status::unknown(
5084
-
format!("Service was not ready: {}", e.into()),
5085
-
)
5086
-
})?;
4348
+
) -> std::result::Result<tonic::Response<super::InsertDirectoryResponse>, tonic::Status>
4349
+
{
4350
+
self.inner.ready().await.map_err(|e| {
4351
+
tonic::Status::unknown(format!("Service was not ready: {}", e.into()))
4352
+
})?;
5087
4353
let codec = tonic::codec::ProstCodec::default();
5088
4354
let path = http::uri::PathAndQuery::from_static(
5089
4355
"/rockbox.v1alpha1.PlaylistService/InsertDirectory",
5090
4356
);
5091
4357
let mut req = request.into_request();
5092
-
req.extensions_mut()
5093
-
.insert(
5094
-
GrpcMethod::new(
5095
-
"rockbox.v1alpha1.PlaylistService",
5096
-
"InsertDirectory",
5097
-
),
5098
-
);
4358
+
req.extensions_mut().insert(GrpcMethod::new(
4359
+
"rockbox.v1alpha1.PlaylistService",
4360
+
"InsertDirectory",
4361
+
));
5099
4362
self.inner.unary(req, path, codec).await
5100
4363
}
5101
4364
pub async fn insert_playlist(
5102
4365
&mut self,
5103
4366
request: impl tonic::IntoRequest<super::InsertPlaylistRequest>,
5104
-
) -> std::result::Result<
5105
-
tonic::Response<super::InsertPlaylistResponse>,
5106
-
tonic::Status,
5107
-
> {
5108
-
self.inner
5109
-
.ready()
5110
-
.await
5111
-
.map_err(|e| {
5112
-
tonic::Status::unknown(
5113
-
format!("Service was not ready: {}", e.into()),
5114
-
)
5115
-
})?;
4367
+
) -> std::result::Result<tonic::Response<super::InsertPlaylistResponse>, tonic::Status>
4368
+
{
4369
+
self.inner.ready().await.map_err(|e| {
4370
+
tonic::Status::unknown(format!("Service was not ready: {}", e.into()))
4371
+
})?;
5116
4372
let codec = tonic::codec::ProstCodec::default();
5117
4373
let path = http::uri::PathAndQuery::from_static(
5118
4374
"/rockbox.v1alpha1.PlaylistService/InsertPlaylist",
5119
4375
);
5120
4376
let mut req = request.into_request();
5121
-
req.extensions_mut()
5122
-
.insert(
5123
-
GrpcMethod::new("rockbox.v1alpha1.PlaylistService", "InsertPlaylist"),
5124
-
);
4377
+
req.extensions_mut().insert(GrpcMethod::new(
4378
+
"rockbox.v1alpha1.PlaylistService",
4379
+
"InsertPlaylist",
4380
+
));
5125
4381
self.inner.unary(req, path, codec).await
5126
4382
}
5127
4383
pub async fn insert_album(
5128
4384
&mut self,
5129
4385
request: impl tonic::IntoRequest<super::InsertAlbumRequest>,
5130
-
) -> std::result::Result<
5131
-
tonic::Response<super::InsertAlbumResponse>,
5132
-
tonic::Status,
5133
-
> {
5134
-
self.inner
5135
-
.ready()
5136
-
.await
5137
-
.map_err(|e| {
5138
-
tonic::Status::unknown(
5139
-
format!("Service was not ready: {}", e.into()),
5140
-
)
5141
-
})?;
4386
+
) -> std::result::Result<tonic::Response<super::InsertAlbumResponse>, tonic::Status>
4387
+
{
4388
+
self.inner.ready().await.map_err(|e| {
4389
+
tonic::Status::unknown(format!("Service was not ready: {}", e.into()))
4390
+
})?;
5142
4391
let codec = tonic::codec::ProstCodec::default();
5143
4392
let path = http::uri::PathAndQuery::from_static(
5144
4393
"/rockbox.v1alpha1.PlaylistService/InsertAlbum",
5145
4394
);
5146
4395
let mut req = request.into_request();
5147
-
req.extensions_mut()
5148
-
.insert(
5149
-
GrpcMethod::new("rockbox.v1alpha1.PlaylistService", "InsertAlbum"),
5150
-
);
4396
+
req.extensions_mut().insert(GrpcMethod::new(
4397
+
"rockbox.v1alpha1.PlaylistService",
4398
+
"InsertAlbum",
4399
+
));
5151
4400
self.inner.unary(req, path, codec).await
5152
4401
}
5153
4402
pub async fn insert_artist_tracks(
5154
4403
&mut self,
5155
4404
request: impl tonic::IntoRequest<super::InsertArtistTracksRequest>,
5156
-
) -> std::result::Result<
5157
-
tonic::Response<super::InsertArtistTracksResponse>,
5158
-
tonic::Status,
5159
-
> {
5160
-
self.inner
5161
-
.ready()
5162
-
.await
5163
-
.map_err(|e| {
5164
-
tonic::Status::unknown(
5165
-
format!("Service was not ready: {}", e.into()),
5166
-
)
5167
-
})?;
4405
+
) -> std::result::Result<tonic::Response<super::InsertArtistTracksResponse>, tonic::Status>
4406
+
{
4407
+
self.inner.ready().await.map_err(|e| {
4408
+
tonic::Status::unknown(format!("Service was not ready: {}", e.into()))
4409
+
})?;
5168
4410
let codec = tonic::codec::ProstCodec::default();
5169
4411
let path = http::uri::PathAndQuery::from_static(
5170
4412
"/rockbox.v1alpha1.PlaylistService/InsertArtistTracks",
5171
4413
);
5172
4414
let mut req = request.into_request();
5173
-
req.extensions_mut()
5174
-
.insert(
5175
-
GrpcMethod::new(
5176
-
"rockbox.v1alpha1.PlaylistService",
5177
-
"InsertArtistTracks",
5178
-
),
5179
-
);
4415
+
req.extensions_mut().insert(GrpcMethod::new(
4416
+
"rockbox.v1alpha1.PlaylistService",
4417
+
"InsertArtistTracks",
4418
+
));
5180
4419
self.inner.unary(req, path, codec).await
5181
4420
}
5182
4421
pub async fn shuffle_playlist(
5183
4422
&mut self,
5184
4423
request: impl tonic::IntoRequest<super::ShufflePlaylistRequest>,
5185
-
) -> std::result::Result<
5186
-
tonic::Response<super::ShufflePlaylistResponse>,
5187
-
tonic::Status,
5188
-
> {
5189
-
self.inner
5190
-
.ready()
5191
-
.await
5192
-
.map_err(|e| {
5193
-
tonic::Status::unknown(
5194
-
format!("Service was not ready: {}", e.into()),
5195
-
)
5196
-
})?;
4424
+
) -> std::result::Result<tonic::Response<super::ShufflePlaylistResponse>, tonic::Status>
4425
+
{
4426
+
self.inner.ready().await.map_err(|e| {
4427
+
tonic::Status::unknown(format!("Service was not ready: {}", e.into()))
4428
+
})?;
5197
4429
let codec = tonic::codec::ProstCodec::default();
5198
4430
let path = http::uri::PathAndQuery::from_static(
5199
4431
"/rockbox.v1alpha1.PlaylistService/ShufflePlaylist",
5200
4432
);
5201
4433
let mut req = request.into_request();
5202
-
req.extensions_mut()
5203
-
.insert(
5204
-
GrpcMethod::new(
5205
-
"rockbox.v1alpha1.PlaylistService",
5206
-
"ShufflePlaylist",
5207
-
),
5208
-
);
4434
+
req.extensions_mut().insert(GrpcMethod::new(
4435
+
"rockbox.v1alpha1.PlaylistService",
4436
+
"ShufflePlaylist",
4437
+
));
5209
4438
self.inner.unary(req, path, codec).await
5210
4439
}
5211
4440
}
···
5217
4446
dead_code,
5218
4447
missing_docs,
5219
4448
clippy::wildcard_imports,
5220
-
clippy::let_unit_value,
4449
+
clippy::let_unit_value
5221
4450
)]
5222
4451
use tonic::codegen::*;
5223
4452
/// Generated trait containing gRPC methods that should be implemented for use with PlaylistServiceServer.
···
5226
4455
async fn get_current(
5227
4456
&self,
5228
4457
request: tonic::Request<super::GetCurrentRequest>,
5229
-
) -> std::result::Result<
5230
-
tonic::Response<super::GetCurrentResponse>,
5231
-
tonic::Status,
5232
-
>;
4458
+
) -> std::result::Result<tonic::Response<super::GetCurrentResponse>, tonic::Status>;
5233
4459
async fn get_resume_info(
5234
4460
&self,
5235
4461
request: tonic::Request<super::GetResumeInfoRequest>,
5236
-
) -> std::result::Result<
5237
-
tonic::Response<super::GetResumeInfoResponse>,
5238
-
tonic::Status,
5239
-
>;
4462
+
) -> std::result::Result<tonic::Response<super::GetResumeInfoResponse>, tonic::Status>;
5240
4463
async fn get_track_info(
5241
4464
&self,
5242
4465
request: tonic::Request<super::GetTrackInfoRequest>,
5243
-
) -> std::result::Result<
5244
-
tonic::Response<super::GetTrackInfoResponse>,
5245
-
tonic::Status,
5246
-
>;
4466
+
) -> std::result::Result<tonic::Response<super::GetTrackInfoResponse>, tonic::Status>;
5247
4467
async fn get_first_index(
5248
4468
&self,
5249
4469
request: tonic::Request<super::GetFirstIndexRequest>,
5250
-
) -> std::result::Result<
5251
-
tonic::Response<super::GetFirstIndexResponse>,
5252
-
tonic::Status,
5253
-
>;
4470
+
) -> std::result::Result<tonic::Response<super::GetFirstIndexResponse>, tonic::Status>;
5254
4471
async fn get_display_index(
5255
4472
&self,
5256
4473
request: tonic::Request<super::GetDisplayIndexRequest>,
5257
-
) -> std::result::Result<
5258
-
tonic::Response<super::GetDisplayIndexResponse>,
5259
-
tonic::Status,
5260
-
>;
4474
+
) -> std::result::Result<tonic::Response<super::GetDisplayIndexResponse>, tonic::Status>;
5261
4475
async fn amount(
5262
4476
&self,
5263
4477
request: tonic::Request<super::AmountRequest>,
···
5265
4479
async fn playlist_resume(
5266
4480
&self,
5267
4481
request: tonic::Request<super::PlaylistResumeRequest>,
5268
-
) -> std::result::Result<
5269
-
tonic::Response<super::PlaylistResumeResponse>,
5270
-
tonic::Status,
5271
-
>;
4482
+
) -> std::result::Result<tonic::Response<super::PlaylistResumeResponse>, tonic::Status>;
5272
4483
async fn resume_track(
5273
4484
&self,
5274
4485
request: tonic::Request<super::ResumeTrackRequest>,
5275
-
) -> std::result::Result<
5276
-
tonic::Response<super::ResumeTrackResponse>,
5277
-
tonic::Status,
5278
-
>;
4486
+
) -> std::result::Result<tonic::Response<super::ResumeTrackResponse>, tonic::Status>;
5279
4487
async fn set_modified(
5280
4488
&self,
5281
4489
request: tonic::Request<super::SetModifiedRequest>,
5282
-
) -> std::result::Result<
5283
-
tonic::Response<super::SetModifiedResponse>,
5284
-
tonic::Status,
5285
-
>;
4490
+
) -> std::result::Result<tonic::Response<super::SetModifiedResponse>, tonic::Status>;
5286
4491
async fn start(
5287
4492
&self,
5288
4493
request: tonic::Request<super::StartRequest>,
···
5294
4499
async fn remove_all_tracks(
5295
4500
&self,
5296
4501
request: tonic::Request<super::RemoveAllTracksRequest>,
5297
-
) -> std::result::Result<
5298
-
tonic::Response<super::RemoveAllTracksResponse>,
5299
-
tonic::Status,
5300
-
>;
4502
+
) -> std::result::Result<tonic::Response<super::RemoveAllTracksResponse>, tonic::Status>;
5301
4503
async fn remove_tracks(
5302
4504
&self,
5303
4505
request: tonic::Request<super::RemoveTracksRequest>,
5304
-
) -> std::result::Result<
5305
-
tonic::Response<super::RemoveTracksResponse>,
5306
-
tonic::Status,
5307
-
>;
4506
+
) -> std::result::Result<tonic::Response<super::RemoveTracksResponse>, tonic::Status>;
5308
4507
async fn create_playlist(
5309
4508
&self,
5310
4509
request: tonic::Request<super::CreatePlaylistRequest>,
5311
-
) -> std::result::Result<
5312
-
tonic::Response<super::CreatePlaylistResponse>,
5313
-
tonic::Status,
5314
-
>;
4510
+
) -> std::result::Result<tonic::Response<super::CreatePlaylistResponse>, tonic::Status>;
5315
4511
async fn insert_tracks(
5316
4512
&self,
5317
4513
request: tonic::Request<super::InsertTracksRequest>,
5318
-
) -> std::result::Result<
5319
-
tonic::Response<super::InsertTracksResponse>,
5320
-
tonic::Status,
5321
-
>;
4514
+
) -> std::result::Result<tonic::Response<super::InsertTracksResponse>, tonic::Status>;
5322
4515
async fn insert_directory(
5323
4516
&self,
5324
4517
request: tonic::Request<super::InsertDirectoryRequest>,
5325
-
) -> std::result::Result<
5326
-
tonic::Response<super::InsertDirectoryResponse>,
5327
-
tonic::Status,
5328
-
>;
4518
+
) -> std::result::Result<tonic::Response<super::InsertDirectoryResponse>, tonic::Status>;
5329
4519
async fn insert_playlist(
5330
4520
&self,
5331
4521
request: tonic::Request<super::InsertPlaylistRequest>,
5332
-
) -> std::result::Result<
5333
-
tonic::Response<super::InsertPlaylistResponse>,
5334
-
tonic::Status,
5335
-
>;
4522
+
) -> std::result::Result<tonic::Response<super::InsertPlaylistResponse>, tonic::Status>;
5336
4523
async fn insert_album(
5337
4524
&self,
5338
4525
request: tonic::Request<super::InsertAlbumRequest>,
5339
-
) -> std::result::Result<
5340
-
tonic::Response<super::InsertAlbumResponse>,
5341
-
tonic::Status,
5342
-
>;
4526
+
) -> std::result::Result<tonic::Response<super::InsertAlbumResponse>, tonic::Status>;
5343
4527
async fn insert_artist_tracks(
5344
4528
&self,
5345
4529
request: tonic::Request<super::InsertArtistTracksRequest>,
5346
-
) -> std::result::Result<
5347
-
tonic::Response<super::InsertArtistTracksResponse>,
5348
-
tonic::Status,
5349
-
>;
4530
+
) -> std::result::Result<tonic::Response<super::InsertArtistTracksResponse>, tonic::Status>;
5350
4531
async fn shuffle_playlist(
5351
4532
&self,
5352
4533
request: tonic::Request<super::ShufflePlaylistRequest>,
5353
-
) -> std::result::Result<
5354
-
tonic::Response<super::ShufflePlaylistResponse>,
5355
-
tonic::Status,
5356
-
>;
4534
+
) -> std::result::Result<tonic::Response<super::ShufflePlaylistResponse>, tonic::Status>;
5357
4535
}
5358
4536
#[derive(Debug)]
5359
4537
pub struct PlaylistServiceServer<T> {
···
5376
4554
max_encoding_message_size: None,
5377
4555
}
5378
4556
}
5379
-
pub fn with_interceptor<F>(
5380
-
inner: T,
5381
-
interceptor: F,
5382
-
) -> InterceptedService<Self, F>
4557
+
pub fn with_interceptor<F>(inner: T, interceptor: F) -> InterceptedService<Self, F>
5383
4558
where
5384
4559
F: tonic::service::Interceptor,
5385
4560
{
···
5434
4609
"/rockbox.v1alpha1.PlaylistService/GetCurrent" => {
5435
4610
#[allow(non_camel_case_types)]
5436
4611
struct GetCurrentSvc<T: PlaylistService>(pub Arc<T>);
5437
-
impl<
5438
-
T: PlaylistService,
5439
-
> tonic::server::UnaryService<super::GetCurrentRequest>
5440
-
for GetCurrentSvc<T> {
4612
+
impl<T: PlaylistService> tonic::server::UnaryService<super::GetCurrentRequest>
4613
+
for GetCurrentSvc<T>
4614
+
{
5441
4615
type Response = super::GetCurrentResponse;
5442
-
type Future = BoxFuture<
5443
-
tonic::Response<Self::Response>,
5444
-
tonic::Status,
5445
-
>;
4616
+
type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
5446
4617
fn call(
5447
4618
&mut self,
5448
4619
request: tonic::Request<super::GetCurrentRequest>,
···
5479
4650
"/rockbox.v1alpha1.PlaylistService/GetResumeInfo" => {
5480
4651
#[allow(non_camel_case_types)]
5481
4652
struct GetResumeInfoSvc<T: PlaylistService>(pub Arc<T>);
5482
-
impl<
5483
-
T: PlaylistService,
5484
-
> tonic::server::UnaryService<super::GetResumeInfoRequest>
5485
-
for GetResumeInfoSvc<T> {
4653
+
impl<T: PlaylistService>
4654
+
tonic::server::UnaryService<super::GetResumeInfoRequest>
4655
+
for GetResumeInfoSvc<T>
4656
+
{
5486
4657
type Response = super::GetResumeInfoResponse;
5487
-
type Future = BoxFuture<
5488
-
tonic::Response<Self::Response>,
5489
-
tonic::Status,
5490
-
>;
4658
+
type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
5491
4659
fn call(
5492
4660
&mut self,
5493
4661
request: tonic::Request<super::GetResumeInfoRequest>,
5494
4662
) -> Self::Future {
5495
4663
let inner = Arc::clone(&self.0);
5496
4664
let fut = async move {
5497
-
<T as PlaylistService>::get_resume_info(&inner, request)
5498
-
.await
4665
+
<T as PlaylistService>::get_resume_info(&inner, request).await
5499
4666
};
5500
4667
Box::pin(fut)
5501
4668
}
···
5525
4692
"/rockbox.v1alpha1.PlaylistService/GetTrackInfo" => {
5526
4693
#[allow(non_camel_case_types)]
5527
4694
struct GetTrackInfoSvc<T: PlaylistService>(pub Arc<T>);
5528
-
impl<
5529
-
T: PlaylistService,
5530
-
> tonic::server::UnaryService<super::GetTrackInfoRequest>
5531
-
for GetTrackInfoSvc<T> {
4695
+
impl<T: PlaylistService> tonic::server::UnaryService<super::GetTrackInfoRequest>
4696
+
for GetTrackInfoSvc<T>
4697
+
{
5532
4698
type Response = super::GetTrackInfoResponse;
5533
-
type Future = BoxFuture<
5534
-
tonic::Response<Self::Response>,
5535
-
tonic::Status,
5536
-
>;
4699
+
type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
5537
4700
fn call(
5538
4701
&mut self,
5539
4702
request: tonic::Request<super::GetTrackInfoRequest>,
5540
4703
) -> Self::Future {
5541
4704
let inner = Arc::clone(&self.0);
5542
4705
let fut = async move {
5543
-
<T as PlaylistService>::get_track_info(&inner, request)
5544
-
.await
4706
+
<T as PlaylistService>::get_track_info(&inner, request).await
5545
4707
};
5546
4708
Box::pin(fut)
5547
4709
}
···
5571
4733
"/rockbox.v1alpha1.PlaylistService/GetFirstIndex" => {
5572
4734
#[allow(non_camel_case_types)]
5573
4735
struct GetFirstIndexSvc<T: PlaylistService>(pub Arc<T>);
5574
-
impl<
5575
-
T: PlaylistService,
5576
-
> tonic::server::UnaryService<super::GetFirstIndexRequest>
5577
-
for GetFirstIndexSvc<T> {
4736
+
impl<T: PlaylistService>
4737
+
tonic::server::UnaryService<super::GetFirstIndexRequest>
4738
+
for GetFirstIndexSvc<T>
4739
+
{
5578
4740
type Response = super::GetFirstIndexResponse;
5579
-
type Future = BoxFuture<
5580
-
tonic::Response<Self::Response>,
5581
-
tonic::Status,
5582
-
>;
4741
+
type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
5583
4742
fn call(
5584
4743
&mut self,
5585
4744
request: tonic::Request<super::GetFirstIndexRequest>,
5586
4745
) -> Self::Future {
5587
4746
let inner = Arc::clone(&self.0);
5588
4747
let fut = async move {
5589
-
<T as PlaylistService>::get_first_index(&inner, request)
5590
-
.await
4748
+
<T as PlaylistService>::get_first_index(&inner, request).await
5591
4749
};
5592
4750
Box::pin(fut)
5593
4751
}
···
5617
4775
"/rockbox.v1alpha1.PlaylistService/GetDisplayIndex" => {
5618
4776
#[allow(non_camel_case_types)]
5619
4777
struct GetDisplayIndexSvc<T: PlaylistService>(pub Arc<T>);
5620
-
impl<
5621
-
T: PlaylistService,
5622
-
> tonic::server::UnaryService<super::GetDisplayIndexRequest>
5623
-
for GetDisplayIndexSvc<T> {
4778
+
impl<T: PlaylistService>
4779
+
tonic::server::UnaryService<super::GetDisplayIndexRequest>
4780
+
for GetDisplayIndexSvc<T>
4781
+
{
5624
4782
type Response = super::GetDisplayIndexResponse;
5625
-
type Future = BoxFuture<
5626
-
tonic::Response<Self::Response>,
5627
-
tonic::Status,
5628
-
>;
4783
+
type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
5629
4784
fn call(
5630
4785
&mut self,
5631
4786
request: tonic::Request<super::GetDisplayIndexRequest>,
5632
4787
) -> Self::Future {
5633
4788
let inner = Arc::clone(&self.0);
5634
4789
let fut = async move {
5635
-
<T as PlaylistService>::get_display_index(&inner, request)
5636
-
.await
4790
+
<T as PlaylistService>::get_display_index(&inner, request).await
5637
4791
};
5638
4792
Box::pin(fut)
5639
4793
}
···
5663
4817
"/rockbox.v1alpha1.PlaylistService/Amount" => {
5664
4818
#[allow(non_camel_case_types)]
5665
4819
struct AmountSvc<T: PlaylistService>(pub Arc<T>);
5666
-
impl<
5667
-
T: PlaylistService,
5668
-
> tonic::server::UnaryService<super::AmountRequest>
5669
-
for AmountSvc<T> {
4820
+
impl<T: PlaylistService> tonic::server::UnaryService<super::AmountRequest> for AmountSvc<T> {
5670
4821
type Response = super::AmountResponse;
5671
-
type Future = BoxFuture<
5672
-
tonic::Response<Self::Response>,
5673
-
tonic::Status,
5674
-
>;
4822
+
type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
5675
4823
fn call(
5676
4824
&mut self,
5677
4825
request: tonic::Request<super::AmountRequest>,
···
5708
4856
"/rockbox.v1alpha1.PlaylistService/PlaylistResume" => {
5709
4857
#[allow(non_camel_case_types)]
5710
4858
struct PlaylistResumeSvc<T: PlaylistService>(pub Arc<T>);
5711
-
impl<
5712
-
T: PlaylistService,
5713
-
> tonic::server::UnaryService<super::PlaylistResumeRequest>
5714
-
for PlaylistResumeSvc<T> {
4859
+
impl<T: PlaylistService>
4860
+
tonic::server::UnaryService<super::PlaylistResumeRequest>
4861
+
for PlaylistResumeSvc<T>
4862
+
{
5715
4863
type Response = super::PlaylistResumeResponse;
5716
-
type Future = BoxFuture<
5717
-
tonic::Response<Self::Response>,
5718
-
tonic::Status,
5719
-
>;
4864
+
type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
5720
4865
fn call(
5721
4866
&mut self,
5722
4867
request: tonic::Request<super::PlaylistResumeRequest>,
5723
4868
) -> Self::Future {
5724
4869
let inner = Arc::clone(&self.0);
5725
4870
let fut = async move {
5726
-
<T as PlaylistService>::playlist_resume(&inner, request)
5727
-
.await
4871
+
<T as PlaylistService>::playlist_resume(&inner, request).await
5728
4872
};
5729
4873
Box::pin(fut)
5730
4874
}
···
5754
4898
"/rockbox.v1alpha1.PlaylistService/ResumeTrack" => {
5755
4899
#[allow(non_camel_case_types)]
5756
4900
struct ResumeTrackSvc<T: PlaylistService>(pub Arc<T>);
5757
-
impl<
5758
-
T: PlaylistService,
5759
-
> tonic::server::UnaryService<super::ResumeTrackRequest>
5760
-
for ResumeTrackSvc<T> {
4901
+
impl<T: PlaylistService> tonic::server::UnaryService<super::ResumeTrackRequest>
4902
+
for ResumeTrackSvc<T>
4903
+
{
5761
4904
type Response = super::ResumeTrackResponse;
5762
-
type Future = BoxFuture<
5763
-
tonic::Response<Self::Response>,
5764
-
tonic::Status,
5765
-
>;
4905
+
type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
5766
4906
fn call(
5767
4907
&mut self,
5768
4908
request: tonic::Request<super::ResumeTrackRequest>,
···
5799
4939
"/rockbox.v1alpha1.PlaylistService/SetModified" => {
5800
4940
#[allow(non_camel_case_types)]
5801
4941
struct SetModifiedSvc<T: PlaylistService>(pub Arc<T>);
5802
-
impl<
5803
-
T: PlaylistService,
5804
-
> tonic::server::UnaryService<super::SetModifiedRequest>
5805
-
for SetModifiedSvc<T> {
4942
+
impl<T: PlaylistService> tonic::server::UnaryService<super::SetModifiedRequest>
4943
+
for SetModifiedSvc<T>
4944
+
{
5806
4945
type Response = super::SetModifiedResponse;
5807
-
type Future = BoxFuture<
5808
-
tonic::Response<Self::Response>,
5809
-
tonic::Status,
5810
-
>;
4946
+
type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
5811
4947
fn call(
5812
4948
&mut self,
5813
4949
request: tonic::Request<super::SetModifiedRequest>,
···
5844
4980
"/rockbox.v1alpha1.PlaylistService/Start" => {
5845
4981
#[allow(non_camel_case_types)]
5846
4982
struct StartSvc<T: PlaylistService>(pub Arc<T>);
5847
-
impl<
5848
-
T: PlaylistService,
5849
-
> tonic::server::UnaryService<super::StartRequest> for StartSvc<T> {
4983
+
impl<T: PlaylistService> tonic::server::UnaryService<super::StartRequest> for StartSvc<T> {
5850
4984
type Response = super::StartResponse;
5851
-
type Future = BoxFuture<
5852
-
tonic::Response<Self::Response>,
5853
-
tonic::Status,
5854
-
>;
4985
+
type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
5855
4986
fn call(
5856
4987
&mut self,
5857
4988
request: tonic::Request<super::StartRequest>,
5858
4989
) -> Self::Future {
5859
4990
let inner = Arc::clone(&self.0);
5860
-
let fut = async move {
5861
-
<T as PlaylistService>::start(&inner, request).await
5862
-
};
4991
+
let fut =
4992
+
async move { <T as PlaylistService>::start(&inner, request).await };
5863
4993
Box::pin(fut)
5864
4994
}
5865
4995
}
···
5888
5018
"/rockbox.v1alpha1.PlaylistService/Sync" => {
5889
5019
#[allow(non_camel_case_types)]
5890
5020
struct SyncSvc<T: PlaylistService>(pub Arc<T>);
5891
-
impl<
5892
-
T: PlaylistService,
5893
-
> tonic::server::UnaryService<super::SyncRequest> for SyncSvc<T> {
5021
+
impl<T: PlaylistService> tonic::server::UnaryService<super::SyncRequest> for SyncSvc<T> {
5894
5022
type Response = super::SyncResponse;
5895
-
type Future = BoxFuture<
5896
-
tonic::Response<Self::Response>,
5897
-
tonic::Status,
5898
-
>;
5023
+
type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
5899
5024
fn call(
5900
5025
&mut self,
5901
5026
request: tonic::Request<super::SyncRequest>,
5902
5027
) -> Self::Future {
5903
5028
let inner = Arc::clone(&self.0);
5904
-
let fut = async move {
5905
-
<T as PlaylistService>::sync(&inner, request).await
5906
-
};
5029
+
let fut =
5030
+
async move { <T as PlaylistService>::sync(&inner, request).await };
5907
5031
Box::pin(fut)
5908
5032
}
5909
5033
}
···
5932
5056
"/rockbox.v1alpha1.PlaylistService/RemoveAllTracks" => {
5933
5057
#[allow(non_camel_case_types)]
5934
5058
struct RemoveAllTracksSvc<T: PlaylistService>(pub Arc<T>);
5935
-
impl<
5936
-
T: PlaylistService,
5937
-
> tonic::server::UnaryService<super::RemoveAllTracksRequest>
5938
-
for RemoveAllTracksSvc<T> {
5059
+
impl<T: PlaylistService>
5060
+
tonic::server::UnaryService<super::RemoveAllTracksRequest>
5061
+
for RemoveAllTracksSvc<T>
5062
+
{
5939
5063
type Response = super::RemoveAllTracksResponse;
5940
-
type Future = BoxFuture<
5941
-
tonic::Response<Self::Response>,
5942
-
tonic::Status,
5943
-
>;
5064
+
type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
5944
5065
fn call(
5945
5066
&mut self,
5946
5067
request: tonic::Request<super::RemoveAllTracksRequest>,
5947
5068
) -> Self::Future {
5948
5069
let inner = Arc::clone(&self.0);
5949
5070
let fut = async move {
5950
-
<T as PlaylistService>::remove_all_tracks(&inner, request)
5951
-
.await
5071
+
<T as PlaylistService>::remove_all_tracks(&inner, request).await
5952
5072
};
5953
5073
Box::pin(fut)
5954
5074
}
···
5978
5098
"/rockbox.v1alpha1.PlaylistService/RemoveTracks" => {
5979
5099
#[allow(non_camel_case_types)]
5980
5100
struct RemoveTracksSvc<T: PlaylistService>(pub Arc<T>);
5981
-
impl<
5982
-
T: PlaylistService,
5983
-
> tonic::server::UnaryService<super::RemoveTracksRequest>
5984
-
for RemoveTracksSvc<T> {
5101
+
impl<T: PlaylistService> tonic::server::UnaryService<super::RemoveTracksRequest>
5102
+
for RemoveTracksSvc<T>
5103
+
{
5985
5104
type Response = super::RemoveTracksResponse;
5986
-
type Future = BoxFuture<
5987
-
tonic::Response<Self::Response>,
5988
-
tonic::Status,
5989
-
>;
5105
+
type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
5990
5106
fn call(
5991
5107
&mut self,
5992
5108
request: tonic::Request<super::RemoveTracksRequest>,
···
6023
5139
"/rockbox.v1alpha1.PlaylistService/CreatePlaylist" => {
6024
5140
#[allow(non_camel_case_types)]
6025
5141
struct CreatePlaylistSvc<T: PlaylistService>(pub Arc<T>);
6026
-
impl<
6027
-
T: PlaylistService,
6028
-
> tonic::server::UnaryService<super::CreatePlaylistRequest>
6029
-
for CreatePlaylistSvc<T> {
5142
+
impl<T: PlaylistService>
5143
+
tonic::server::UnaryService<super::CreatePlaylistRequest>
5144
+
for CreatePlaylistSvc<T>
5145
+
{
6030
5146
type Response = super::CreatePlaylistResponse;
6031
-
type Future = BoxFuture<
6032
-
tonic::Response<Self::Response>,
6033
-
tonic::Status,
6034
-
>;
5147
+
type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
6035
5148
fn call(
6036
5149
&mut self,
6037
5150
request: tonic::Request<super::CreatePlaylistRequest>,
6038
5151
) -> Self::Future {
6039
5152
let inner = Arc::clone(&self.0);
6040
5153
let fut = async move {
6041
-
<T as PlaylistService>::create_playlist(&inner, request)
6042
-
.await
5154
+
<T as PlaylistService>::create_playlist(&inner, request).await
6043
5155
};
6044
5156
Box::pin(fut)
6045
5157
}
···
6069
5181
"/rockbox.v1alpha1.PlaylistService/InsertTracks" => {
6070
5182
#[allow(non_camel_case_types)]
6071
5183
struct InsertTracksSvc<T: PlaylistService>(pub Arc<T>);
6072
-
impl<
6073
-
T: PlaylistService,
6074
-
> tonic::server::UnaryService<super::InsertTracksRequest>
6075
-
for InsertTracksSvc<T> {
5184
+
impl<T: PlaylistService> tonic::server::UnaryService<super::InsertTracksRequest>
5185
+
for InsertTracksSvc<T>
5186
+
{
6076
5187
type Response = super::InsertTracksResponse;
6077
-
type Future = BoxFuture<
6078
-
tonic::Response<Self::Response>,
6079
-
tonic::Status,
6080
-
>;
5188
+
type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
6081
5189
fn call(
6082
5190
&mut self,
6083
5191
request: tonic::Request<super::InsertTracksRequest>,
···
6114
5222
"/rockbox.v1alpha1.PlaylistService/InsertDirectory" => {
6115
5223
#[allow(non_camel_case_types)]
6116
5224
struct InsertDirectorySvc<T: PlaylistService>(pub Arc<T>);
6117
-
impl<
6118
-
T: PlaylistService,
6119
-
> tonic::server::UnaryService<super::InsertDirectoryRequest>
6120
-
for InsertDirectorySvc<T> {
5225
+
impl<T: PlaylistService>
5226
+
tonic::server::UnaryService<super::InsertDirectoryRequest>
5227
+
for InsertDirectorySvc<T>
5228
+
{
6121
5229
type Response = super::InsertDirectoryResponse;
6122
-
type Future = BoxFuture<
6123
-
tonic::Response<Self::Response>,
6124
-
tonic::Status,
6125
-
>;
5230
+
type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
6126
5231
fn call(
6127
5232
&mut self,
6128
5233
request: tonic::Request<super::InsertDirectoryRequest>,
6129
5234
) -> Self::Future {
6130
5235
let inner = Arc::clone(&self.0);
6131
5236
let fut = async move {
6132
-
<T as PlaylistService>::insert_directory(&inner, request)
6133
-
.await
5237
+
<T as PlaylistService>::insert_directory(&inner, request).await
6134
5238
};
6135
5239
Box::pin(fut)
6136
5240
}
···
6160
5264
"/rockbox.v1alpha1.PlaylistService/InsertPlaylist" => {
6161
5265
#[allow(non_camel_case_types)]
6162
5266
struct InsertPlaylistSvc<T: PlaylistService>(pub Arc<T>);
6163
-
impl<
6164
-
T: PlaylistService,
6165
-
> tonic::server::UnaryService<super::InsertPlaylistRequest>
6166
-
for InsertPlaylistSvc<T> {
5267
+
impl<T: PlaylistService>
5268
+
tonic::server::UnaryService<super::InsertPlaylistRequest>
5269
+
for InsertPlaylistSvc<T>
5270
+
{
6167
5271
type Response = super::InsertPlaylistResponse;
6168
-
type Future = BoxFuture<
6169
-
tonic::Response<Self::Response>,
6170
-
tonic::Status,
6171
-
>;
5272
+
type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
6172
5273
fn call(
6173
5274
&mut self,
6174
5275
request: tonic::Request<super::InsertPlaylistRequest>,
6175
5276
) -> Self::Future {
6176
5277
let inner = Arc::clone(&self.0);
6177
5278
let fut = async move {
6178
-
<T as PlaylistService>::insert_playlist(&inner, request)
6179
-
.await
5279
+
<T as PlaylistService>::insert_playlist(&inner, request).await
6180
5280
};
6181
5281
Box::pin(fut)
6182
5282
}
···
6206
5306
"/rockbox.v1alpha1.PlaylistService/InsertAlbum" => {
6207
5307
#[allow(non_camel_case_types)]
6208
5308
struct InsertAlbumSvc<T: PlaylistService>(pub Arc<T>);
6209
-
impl<
6210
-
T: PlaylistService,
6211
-
> tonic::server::UnaryService<super::InsertAlbumRequest>
6212
-
for InsertAlbumSvc<T> {
5309
+
impl<T: PlaylistService> tonic::server::UnaryService<super::InsertAlbumRequest>
5310
+
for InsertAlbumSvc<T>
5311
+
{
6213
5312
type Response = super::InsertAlbumResponse;
6214
-
type Future = BoxFuture<
6215
-
tonic::Response<Self::Response>,
6216
-
tonic::Status,
6217
-
>;
5313
+
type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
6218
5314
fn call(
6219
5315
&mut self,
6220
5316
request: tonic::Request<super::InsertAlbumRequest>,
···
6251
5347
"/rockbox.v1alpha1.PlaylistService/InsertArtistTracks" => {
6252
5348
#[allow(non_camel_case_types)]
6253
5349
struct InsertArtistTracksSvc<T: PlaylistService>(pub Arc<T>);
6254
-
impl<
6255
-
T: PlaylistService,
6256
-
> tonic::server::UnaryService<super::InsertArtistTracksRequest>
6257
-
for InsertArtistTracksSvc<T> {
5350
+
impl<T: PlaylistService>
5351
+
tonic::server::UnaryService<super::InsertArtistTracksRequest>
5352
+
for InsertArtistTracksSvc<T>
5353
+
{
6258
5354
type Response = super::InsertArtistTracksResponse;
6259
-
type Future = BoxFuture<
6260
-
tonic::Response<Self::Response>,
6261
-
tonic::Status,
6262
-
>;
5355
+
type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
6263
5356
fn call(
6264
5357
&mut self,
6265
5358
request: tonic::Request<super::InsertArtistTracksRequest>,
6266
5359
) -> Self::Future {
6267
5360
let inner = Arc::clone(&self.0);
6268
5361
let fut = async move {
6269
-
<T as PlaylistService>::insert_artist_tracks(
6270
-
&inner,
6271
-
request,
6272
-
)
6273
-
.await
5362
+
<T as PlaylistService>::insert_artist_tracks(&inner, request).await
6274
5363
};
6275
5364
Box::pin(fut)
6276
5365
}
···
6300
5389
"/rockbox.v1alpha1.PlaylistService/ShufflePlaylist" => {
6301
5390
#[allow(non_camel_case_types)]
6302
5391
struct ShufflePlaylistSvc<T: PlaylistService>(pub Arc<T>);
6303
-
impl<
6304
-
T: PlaylistService,
6305
-
> tonic::server::UnaryService<super::ShufflePlaylistRequest>
6306
-
for ShufflePlaylistSvc<T> {
5392
+
impl<T: PlaylistService>
5393
+
tonic::server::UnaryService<super::ShufflePlaylistRequest>
5394
+
for ShufflePlaylistSvc<T>
5395
+
{
6307
5396
type Response = super::ShufflePlaylistResponse;
6308
-
type Future = BoxFuture<
6309
-
tonic::Response<Self::Response>,
6310
-
tonic::Status,
6311
-
>;
5397
+
type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
6312
5398
fn call(
6313
5399
&mut self,
6314
5400
request: tonic::Request<super::ShufflePlaylistRequest>,
6315
5401
) -> Self::Future {
6316
5402
let inner = Arc::clone(&self.0);
6317
5403
let fut = async move {
6318
-
<T as PlaylistService>::shuffle_playlist(&inner, request)
6319
-
.await
5404
+
<T as PlaylistService>::shuffle_playlist(&inner, request).await
6320
5405
};
6321
5406
Box::pin(fut)
6322
5407
}
···
6343
5428
};
6344
5429
Box::pin(fut)
6345
5430
}
6346
-
_ => {
6347
-
Box::pin(async move {
6348
-
let mut response = http::Response::new(empty_body());
6349
-
let headers = response.headers_mut();
6350
-
headers
6351
-
.insert(
6352
-
tonic::Status::GRPC_STATUS,
6353
-
(tonic::Code::Unimplemented as i32).into(),
6354
-
);
6355
-
headers
6356
-
.insert(
6357
-
http::header::CONTENT_TYPE,
6358
-
tonic::metadata::GRPC_CONTENT_TYPE,
6359
-
);
6360
-
Ok(response)
6361
-
})
6362
-
}
5431
+
_ => Box::pin(async move {
5432
+
let mut response = http::Response::new(empty_body());
5433
+
let headers = response.headers_mut();
5434
+
headers.insert(
5435
+
tonic::Status::GRPC_STATUS,
5436
+
(tonic::Code::Unimplemented as i32).into(),
5437
+
);
5438
+
headers.insert(
5439
+
http::header::CONTENT_TYPE,
5440
+
tonic::metadata::GRPC_CONTENT_TYPE,
5441
+
);
5442
+
Ok(response)
5443
+
}),
6363
5444
}
6364
5445
}
6365
5446
}
···
6867
5948
dead_code,
6868
5949
missing_docs,
6869
5950
clippy::wildcard_imports,
6870
-
clippy::let_unit_value,
5951
+
clippy::let_unit_value
6871
5952
)]
6872
-
use tonic::codegen::*;
6873
5953
use tonic::codegen::http::Uri;
5954
+
use tonic::codegen::*;
6874
5955
#[derive(Debug, Clone)]
6875
5956
pub struct SettingsServiceClient<T> {
6876
5957
inner: tonic::client::Grpc<T>,
···
6914
5995
<T as tonic::client::GrpcService<tonic::body::BoxBody>>::ResponseBody,
6915
5996
>,
6916
5997
>,
6917
-
<T as tonic::codegen::Service<
6918
-
http::Request<tonic::body::BoxBody>,
6919
-
>>::Error: Into<StdError> + std::marker::Send + std::marker::Sync,
5998
+
<T as tonic::codegen::Service<http::Request<tonic::body::BoxBody>>>::Error:
5999
+
Into<StdError> + std::marker::Send + std::marker::Sync,
6920
6000
{
6921
6001
SettingsServiceClient::new(InterceptedService::new(inner, interceptor))
6922
6002
}
···
6954
6034
pub async fn get_settings_list(
6955
6035
&mut self,
6956
6036
request: impl tonic::IntoRequest<super::GetSettingsListRequest>,
6957
-
) -> std::result::Result<
6958
-
tonic::Response<super::GetSettingsListResponse>,
6959
-
tonic::Status,
6960
-
> {
6961
-
self.inner
6962
-
.ready()
6963
-
.await
6964
-
.map_err(|e| {
6965
-
tonic::Status::unknown(
6966
-
format!("Service was not ready: {}", e.into()),
6967
-
)
6968
-
})?;
6037
+
) -> std::result::Result<tonic::Response<super::GetSettingsListResponse>, tonic::Status>
6038
+
{
6039
+
self.inner.ready().await.map_err(|e| {
6040
+
tonic::Status::unknown(format!("Service was not ready: {}", e.into()))
6041
+
})?;
6969
6042
let codec = tonic::codec::ProstCodec::default();
6970
6043
let path = http::uri::PathAndQuery::from_static(
6971
6044
"/rockbox.v1alpha1.SettingsService/GetSettingsList",
6972
6045
);
6973
6046
let mut req = request.into_request();
6974
-
req.extensions_mut()
6975
-
.insert(
6976
-
GrpcMethod::new(
6977
-
"rockbox.v1alpha1.SettingsService",
6978
-
"GetSettingsList",
6979
-
),
6980
-
);
6047
+
req.extensions_mut().insert(GrpcMethod::new(
6048
+
"rockbox.v1alpha1.SettingsService",
6049
+
"GetSettingsList",
6050
+
));
6981
6051
self.inner.unary(req, path, codec).await
6982
6052
}
6983
6053
pub async fn get_global_settings(
6984
6054
&mut self,
6985
6055
request: impl tonic::IntoRequest<super::GetGlobalSettingsRequest>,
6986
-
) -> std::result::Result<
6987
-
tonic::Response<super::GetGlobalSettingsResponse>,
6988
-
tonic::Status,
6989
-
> {
6990
-
self.inner
6991
-
.ready()
6992
-
.await
6993
-
.map_err(|e| {
6994
-
tonic::Status::unknown(
6995
-
format!("Service was not ready: {}", e.into()),
6996
-
)
6997
-
})?;
6056
+
) -> std::result::Result<tonic::Response<super::GetGlobalSettingsResponse>, tonic::Status>
6057
+
{
6058
+
self.inner.ready().await.map_err(|e| {
6059
+
tonic::Status::unknown(format!("Service was not ready: {}", e.into()))
6060
+
})?;
6998
6061
let codec = tonic::codec::ProstCodec::default();
6999
6062
let path = http::uri::PathAndQuery::from_static(
7000
6063
"/rockbox.v1alpha1.SettingsService/GetGlobalSettings",
7001
6064
);
7002
6065
let mut req = request.into_request();
7003
-
req.extensions_mut()
7004
-
.insert(
7005
-
GrpcMethod::new(
7006
-
"rockbox.v1alpha1.SettingsService",
7007
-
"GetGlobalSettings",
7008
-
),
7009
-
);
6066
+
req.extensions_mut().insert(GrpcMethod::new(
6067
+
"rockbox.v1alpha1.SettingsService",
6068
+
"GetGlobalSettings",
6069
+
));
7010
6070
self.inner.unary(req, path, codec).await
7011
6071
}
7012
6072
pub async fn save_settings(
7013
6073
&mut self,
7014
6074
request: impl tonic::IntoRequest<super::SaveSettingsRequest>,
7015
-
) -> std::result::Result<
7016
-
tonic::Response<super::SaveSettingsResponse>,
7017
-
tonic::Status,
7018
-
> {
7019
-
self.inner
7020
-
.ready()
7021
-
.await
7022
-
.map_err(|e| {
7023
-
tonic::Status::unknown(
7024
-
format!("Service was not ready: {}", e.into()),
7025
-
)
7026
-
})?;
6075
+
) -> std::result::Result<tonic::Response<super::SaveSettingsResponse>, tonic::Status>
6076
+
{
6077
+
self.inner.ready().await.map_err(|e| {
6078
+
tonic::Status::unknown(format!("Service was not ready: {}", e.into()))
6079
+
})?;
7027
6080
let codec = tonic::codec::ProstCodec::default();
7028
6081
let path = http::uri::PathAndQuery::from_static(
7029
6082
"/rockbox.v1alpha1.SettingsService/SaveSettings",
7030
6083
);
7031
6084
let mut req = request.into_request();
7032
-
req.extensions_mut()
7033
-
.insert(
7034
-
GrpcMethod::new("rockbox.v1alpha1.SettingsService", "SaveSettings"),
7035
-
);
6085
+
req.extensions_mut().insert(GrpcMethod::new(
6086
+
"rockbox.v1alpha1.SettingsService",
6087
+
"SaveSettings",
6088
+
));
7036
6089
self.inner.unary(req, path, codec).await
7037
6090
}
7038
6091
}
···
7044
6097
dead_code,
7045
6098
missing_docs,
7046
6099
clippy::wildcard_imports,
7047
-
clippy::let_unit_value,
6100
+
clippy::let_unit_value
7048
6101
)]
7049
6102
use tonic::codegen::*;
7050
6103
/// Generated trait containing gRPC methods that should be implemented for use with SettingsServiceServer.
···
7053
6106
async fn get_settings_list(
7054
6107
&self,
7055
6108
request: tonic::Request<super::GetSettingsListRequest>,
7056
-
) -> std::result::Result<
7057
-
tonic::Response<super::GetSettingsListResponse>,
7058
-
tonic::Status,
7059
-
>;
6109
+
) -> std::result::Result<tonic::Response<super::GetSettingsListResponse>, tonic::Status>;
7060
6110
async fn get_global_settings(
7061
6111
&self,
7062
6112
request: tonic::Request<super::GetGlobalSettingsRequest>,
7063
-
) -> std::result::Result<
7064
-
tonic::Response<super::GetGlobalSettingsResponse>,
7065
-
tonic::Status,
7066
-
>;
6113
+
) -> std::result::Result<tonic::Response<super::GetGlobalSettingsResponse>, tonic::Status>;
7067
6114
async fn save_settings(
7068
6115
&self,
7069
6116
request: tonic::Request<super::SaveSettingsRequest>,
7070
-
) -> std::result::Result<
7071
-
tonic::Response<super::SaveSettingsResponse>,
7072
-
tonic::Status,
7073
-
>;
6117
+
) -> std::result::Result<tonic::Response<super::SaveSettingsResponse>, tonic::Status>;
7074
6118
}
7075
6119
#[derive(Debug)]
7076
6120
pub struct SettingsServiceServer<T> {
···
7093
6137
max_encoding_message_size: None,
7094
6138
}
7095
6139
}
7096
-
pub fn with_interceptor<F>(
7097
-
inner: T,
7098
-
interceptor: F,
7099
-
) -> InterceptedService<Self, F>
6140
+
pub fn with_interceptor<F>(inner: T, interceptor: F) -> InterceptedService<Self, F>
7100
6141
where
7101
6142
F: tonic::service::Interceptor,
7102
6143
{
···
7151
6192
"/rockbox.v1alpha1.SettingsService/GetSettingsList" => {
7152
6193
#[allow(non_camel_case_types)]
7153
6194
struct GetSettingsListSvc<T: SettingsService>(pub Arc<T>);
7154
-
impl<
7155
-
T: SettingsService,
7156
-
> tonic::server::UnaryService<super::GetSettingsListRequest>
7157
-
for GetSettingsListSvc<T> {
6195
+
impl<T: SettingsService>
6196
+
tonic::server::UnaryService<super::GetSettingsListRequest>
6197
+
for GetSettingsListSvc<T>
6198
+
{
7158
6199
type Response = super::GetSettingsListResponse;
7159
-
type Future = BoxFuture<
7160
-
tonic::Response<Self::Response>,
7161
-
tonic::Status,
7162
-
>;
6200
+
type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
7163
6201
fn call(
7164
6202
&mut self,
7165
6203
request: tonic::Request<super::GetSettingsListRequest>,
7166
6204
) -> Self::Future {
7167
6205
let inner = Arc::clone(&self.0);
7168
6206
let fut = async move {
7169
-
<T as SettingsService>::get_settings_list(&inner, request)
7170
-
.await
6207
+
<T as SettingsService>::get_settings_list(&inner, request).await
7171
6208
};
7172
6209
Box::pin(fut)
7173
6210
}
···
7197
6234
"/rockbox.v1alpha1.SettingsService/GetGlobalSettings" => {
7198
6235
#[allow(non_camel_case_types)]
7199
6236
struct GetGlobalSettingsSvc<T: SettingsService>(pub Arc<T>);
7200
-
impl<
7201
-
T: SettingsService,
7202
-
> tonic::server::UnaryService<super::GetGlobalSettingsRequest>
7203
-
for GetGlobalSettingsSvc<T> {
6237
+
impl<T: SettingsService>
6238
+
tonic::server::UnaryService<super::GetGlobalSettingsRequest>
6239
+
for GetGlobalSettingsSvc<T>
6240
+
{
7204
6241
type Response = super::GetGlobalSettingsResponse;
7205
-
type Future = BoxFuture<
7206
-
tonic::Response<Self::Response>,
7207
-
tonic::Status,
7208
-
>;
6242
+
type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
7209
6243
fn call(
7210
6244
&mut self,
7211
6245
request: tonic::Request<super::GetGlobalSettingsRequest>,
7212
6246
) -> Self::Future {
7213
6247
let inner = Arc::clone(&self.0);
7214
6248
let fut = async move {
7215
-
<T as SettingsService>::get_global_settings(&inner, request)
7216
-
.await
6249
+
<T as SettingsService>::get_global_settings(&inner, request).await
7217
6250
};
7218
6251
Box::pin(fut)
7219
6252
}
···
7243
6276
"/rockbox.v1alpha1.SettingsService/SaveSettings" => {
7244
6277
#[allow(non_camel_case_types)]
7245
6278
struct SaveSettingsSvc<T: SettingsService>(pub Arc<T>);
7246
-
impl<
7247
-
T: SettingsService,
7248
-
> tonic::server::UnaryService<super::SaveSettingsRequest>
7249
-
for SaveSettingsSvc<T> {
6279
+
impl<T: SettingsService> tonic::server::UnaryService<super::SaveSettingsRequest>
6280
+
for SaveSettingsSvc<T>
6281
+
{
7250
6282
type Response = super::SaveSettingsResponse;
7251
-
type Future = BoxFuture<
7252
-
tonic::Response<Self::Response>,
7253
-
tonic::Status,
7254
-
>;
6283
+
type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
7255
6284
fn call(
7256
6285
&mut self,
7257
6286
request: tonic::Request<super::SaveSettingsRequest>,
···
7285
6314
};
7286
6315
Box::pin(fut)
7287
6316
}
7288
-
_ => {
7289
-
Box::pin(async move {
7290
-
let mut response = http::Response::new(empty_body());
7291
-
let headers = response.headers_mut();
7292
-
headers
7293
-
.insert(
7294
-
tonic::Status::GRPC_STATUS,
7295
-
(tonic::Code::Unimplemented as i32).into(),
7296
-
);
7297
-
headers
7298
-
.insert(
7299
-
http::header::CONTENT_TYPE,
7300
-
tonic::metadata::GRPC_CONTENT_TYPE,
7301
-
);
7302
-
Ok(response)
7303
-
})
7304
-
}
6317
+
_ => Box::pin(async move {
6318
+
let mut response = http::Response::new(empty_body());
6319
+
let headers = response.headers_mut();
6320
+
headers.insert(
6321
+
tonic::Status::GRPC_STATUS,
6322
+
(tonic::Code::Unimplemented as i32).into(),
6323
+
);
6324
+
headers.insert(
6325
+
http::header::CONTENT_TYPE,
6326
+
tonic::metadata::GRPC_CONTENT_TYPE,
6327
+
);
6328
+
Ok(response)
6329
+
}),
7305
6330
}
7306
6331
}
7307
6332
}
···
7459
6484
dead_code,
7460
6485
missing_docs,
7461
6486
clippy::wildcard_imports,
7462
-
clippy::let_unit_value,
6487
+
clippy::let_unit_value
7463
6488
)]
7464
-
use tonic::codegen::*;
7465
6489
use tonic::codegen::http::Uri;
6490
+
use tonic::codegen::*;
7466
6491
#[derive(Debug, Clone)]
7467
6492
pub struct SoundServiceClient<T> {
7468
6493
inner: tonic::client::Grpc<T>,
···
7506
6531
<T as tonic::client::GrpcService<tonic::body::BoxBody>>::ResponseBody,
7507
6532
>,
7508
6533
>,
7509
-
<T as tonic::codegen::Service<
7510
-
http::Request<tonic::body::BoxBody>,
7511
-
>>::Error: Into<StdError> + std::marker::Send + std::marker::Sync,
6534
+
<T as tonic::codegen::Service<http::Request<tonic::body::BoxBody>>>::Error:
6535
+
Into<StdError> + std::marker::Send + std::marker::Sync,
7512
6536
{
7513
6537
SoundServiceClient::new(InterceptedService::new(inner, interceptor))
7514
6538
}
···
7546
6570
pub async fn adjust_volume(
7547
6571
&mut self,
7548
6572
request: impl tonic::IntoRequest<super::AdjustVolumeRequest>,
7549
-
) -> std::result::Result<
7550
-
tonic::Response<super::AdjustVolumeResponse>,
7551
-
tonic::Status,
7552
-
> {
7553
-
self.inner
7554
-
.ready()
7555
-
.await
7556
-
.map_err(|e| {
7557
-
tonic::Status::unknown(
7558
-
format!("Service was not ready: {}", e.into()),
7559
-
)
7560
-
})?;
6573
+
) -> std::result::Result<tonic::Response<super::AdjustVolumeResponse>, tonic::Status>
6574
+
{
6575
+
self.inner.ready().await.map_err(|e| {
6576
+
tonic::Status::unknown(format!("Service was not ready: {}", e.into()))
6577
+
})?;
7561
6578
let codec = tonic::codec::ProstCodec::default();
7562
-
let path = http::uri::PathAndQuery::from_static(
7563
-
"/rockbox.v1alpha1.SoundService/AdjustVolume",
7564
-
);
6579
+
let path =
6580
+
http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.SoundService/AdjustVolume");
7565
6581
let mut req = request.into_request();
7566
-
req.extensions_mut()
7567
-
.insert(
7568
-
GrpcMethod::new("rockbox.v1alpha1.SoundService", "AdjustVolume"),
7569
-
);
6582
+
req.extensions_mut().insert(GrpcMethod::new(
6583
+
"rockbox.v1alpha1.SoundService",
6584
+
"AdjustVolume",
6585
+
));
7570
6586
self.inner.unary(req, path, codec).await
7571
6587
}
7572
6588
pub async fn sound_set(
7573
6589
&mut self,
7574
6590
request: impl tonic::IntoRequest<super::SoundSetRequest>,
7575
-
) -> std::result::Result<
7576
-
tonic::Response<super::SoundSetResponse>,
7577
-
tonic::Status,
7578
-
> {
7579
-
self.inner
7580
-
.ready()
7581
-
.await
7582
-
.map_err(|e| {
7583
-
tonic::Status::unknown(
7584
-
format!("Service was not ready: {}", e.into()),
7585
-
)
7586
-
})?;
6591
+
) -> std::result::Result<tonic::Response<super::SoundSetResponse>, tonic::Status> {
6592
+
self.inner.ready().await.map_err(|e| {
6593
+
tonic::Status::unknown(format!("Service was not ready: {}", e.into()))
6594
+
})?;
7587
6595
let codec = tonic::codec::ProstCodec::default();
7588
-
let path = http::uri::PathAndQuery::from_static(
7589
-
"/rockbox.v1alpha1.SoundService/SoundSet",
7590
-
);
6596
+
let path =
6597
+
http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.SoundService/SoundSet");
7591
6598
let mut req = request.into_request();
7592
6599
req.extensions_mut()
7593
6600
.insert(GrpcMethod::new("rockbox.v1alpha1.SoundService", "SoundSet"));
···
7596
6603
pub async fn sound_current(
7597
6604
&mut self,
7598
6605
request: impl tonic::IntoRequest<super::SoundCurrentRequest>,
7599
-
) -> std::result::Result<
7600
-
tonic::Response<super::SoundCurrentResponse>,
7601
-
tonic::Status,
7602
-
> {
7603
-
self.inner
7604
-
.ready()
7605
-
.await
7606
-
.map_err(|e| {
7607
-
tonic::Status::unknown(
7608
-
format!("Service was not ready: {}", e.into()),
7609
-
)
7610
-
})?;
6606
+
) -> std::result::Result<tonic::Response<super::SoundCurrentResponse>, tonic::Status>
6607
+
{
6608
+
self.inner.ready().await.map_err(|e| {
6609
+
tonic::Status::unknown(format!("Service was not ready: {}", e.into()))
6610
+
})?;
7611
6611
let codec = tonic::codec::ProstCodec::default();
7612
-
let path = http::uri::PathAndQuery::from_static(
7613
-
"/rockbox.v1alpha1.SoundService/SoundCurrent",
7614
-
);
6612
+
let path =
6613
+
http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.SoundService/SoundCurrent");
7615
6614
let mut req = request.into_request();
7616
-
req.extensions_mut()
7617
-
.insert(
7618
-
GrpcMethod::new("rockbox.v1alpha1.SoundService", "SoundCurrent"),
7619
-
);
6615
+
req.extensions_mut().insert(GrpcMethod::new(
6616
+
"rockbox.v1alpha1.SoundService",
6617
+
"SoundCurrent",
6618
+
));
7620
6619
self.inner.unary(req, path, codec).await
7621
6620
}
7622
6621
pub async fn sound_default(
7623
6622
&mut self,
7624
6623
request: impl tonic::IntoRequest<super::SoundDefaultRequest>,
7625
-
) -> std::result::Result<
7626
-
tonic::Response<super::SoundDefaultResponse>,
7627
-
tonic::Status,
7628
-
> {
7629
-
self.inner
7630
-
.ready()
7631
-
.await
7632
-
.map_err(|e| {
7633
-
tonic::Status::unknown(
7634
-
format!("Service was not ready: {}", e.into()),
7635
-
)
7636
-
})?;
6624
+
) -> std::result::Result<tonic::Response<super::SoundDefaultResponse>, tonic::Status>
6625
+
{
6626
+
self.inner.ready().await.map_err(|e| {
6627
+
tonic::Status::unknown(format!("Service was not ready: {}", e.into()))
6628
+
})?;
7637
6629
let codec = tonic::codec::ProstCodec::default();
7638
-
let path = http::uri::PathAndQuery::from_static(
7639
-
"/rockbox.v1alpha1.SoundService/SoundDefault",
7640
-
);
6630
+
let path =
6631
+
http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.SoundService/SoundDefault");
7641
6632
let mut req = request.into_request();
7642
-
req.extensions_mut()
7643
-
.insert(
7644
-
GrpcMethod::new("rockbox.v1alpha1.SoundService", "SoundDefault"),
7645
-
);
6633
+
req.extensions_mut().insert(GrpcMethod::new(
6634
+
"rockbox.v1alpha1.SoundService",
6635
+
"SoundDefault",
6636
+
));
7646
6637
self.inner.unary(req, path, codec).await
7647
6638
}
7648
6639
pub async fn sound_min(
7649
6640
&mut self,
7650
6641
request: impl tonic::IntoRequest<super::SoundMinRequest>,
7651
-
) -> std::result::Result<
7652
-
tonic::Response<super::SoundMinResponse>,
7653
-
tonic::Status,
7654
-
> {
7655
-
self.inner
7656
-
.ready()
7657
-
.await
7658
-
.map_err(|e| {
7659
-
tonic::Status::unknown(
7660
-
format!("Service was not ready: {}", e.into()),
7661
-
)
7662
-
})?;
6642
+
) -> std::result::Result<tonic::Response<super::SoundMinResponse>, tonic::Status> {
6643
+
self.inner.ready().await.map_err(|e| {
6644
+
tonic::Status::unknown(format!("Service was not ready: {}", e.into()))
6645
+
})?;
7663
6646
let codec = tonic::codec::ProstCodec::default();
7664
-
let path = http::uri::PathAndQuery::from_static(
7665
-
"/rockbox.v1alpha1.SoundService/SoundMin",
7666
-
);
6647
+
let path =
6648
+
http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.SoundService/SoundMin");
7667
6649
let mut req = request.into_request();
7668
6650
req.extensions_mut()
7669
6651
.insert(GrpcMethod::new("rockbox.v1alpha1.SoundService", "SoundMin"));
···
7672
6654
pub async fn sound_max(
7673
6655
&mut self,
7674
6656
request: impl tonic::IntoRequest<super::SoundMaxRequest>,
7675
-
) -> std::result::Result<
7676
-
tonic::Response<super::SoundMaxResponse>,
7677
-
tonic::Status,
7678
-
> {
7679
-
self.inner
7680
-
.ready()
7681
-
.await
7682
-
.map_err(|e| {
7683
-
tonic::Status::unknown(
7684
-
format!("Service was not ready: {}", e.into()),
7685
-
)
7686
-
})?;
6657
+
) -> std::result::Result<tonic::Response<super::SoundMaxResponse>, tonic::Status> {
6658
+
self.inner.ready().await.map_err(|e| {
6659
+
tonic::Status::unknown(format!("Service was not ready: {}", e.into()))
6660
+
})?;
7687
6661
let codec = tonic::codec::ProstCodec::default();
7688
-
let path = http::uri::PathAndQuery::from_static(
7689
-
"/rockbox.v1alpha1.SoundService/SoundMax",
7690
-
);
6662
+
let path =
6663
+
http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.SoundService/SoundMax");
7691
6664
let mut req = request.into_request();
7692
6665
req.extensions_mut()
7693
6666
.insert(GrpcMethod::new("rockbox.v1alpha1.SoundService", "SoundMax"));
···
7696
6669
pub async fn sound_unit(
7697
6670
&mut self,
7698
6671
request: impl tonic::IntoRequest<super::SoundUnitRequest>,
7699
-
) -> std::result::Result<
7700
-
tonic::Response<super::SoundUnitResponse>,
7701
-
tonic::Status,
7702
-
> {
7703
-
self.inner
7704
-
.ready()
7705
-
.await
7706
-
.map_err(|e| {
7707
-
tonic::Status::unknown(
7708
-
format!("Service was not ready: {}", e.into()),
7709
-
)
7710
-
})?;
6672
+
) -> std::result::Result<tonic::Response<super::SoundUnitResponse>, tonic::Status> {
6673
+
self.inner.ready().await.map_err(|e| {
6674
+
tonic::Status::unknown(format!("Service was not ready: {}", e.into()))
6675
+
})?;
7711
6676
let codec = tonic::codec::ProstCodec::default();
7712
-
let path = http::uri::PathAndQuery::from_static(
7713
-
"/rockbox.v1alpha1.SoundService/SoundUnit",
7714
-
);
6677
+
let path =
6678
+
http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.SoundService/SoundUnit");
7715
6679
let mut req = request.into_request();
7716
-
req.extensions_mut()
7717
-
.insert(GrpcMethod::new("rockbox.v1alpha1.SoundService", "SoundUnit"));
6680
+
req.extensions_mut().insert(GrpcMethod::new(
6681
+
"rockbox.v1alpha1.SoundService",
6682
+
"SoundUnit",
6683
+
));
7718
6684
self.inner.unary(req, path, codec).await
7719
6685
}
7720
6686
pub async fn sound_val2_phys(
7721
6687
&mut self,
7722
6688
request: impl tonic::IntoRequest<super::SoundVal2PhysRequest>,
7723
-
) -> std::result::Result<
7724
-
tonic::Response<super::SoundVal2PhysResponse>,
7725
-
tonic::Status,
7726
-
> {
7727
-
self.inner
7728
-
.ready()
7729
-
.await
7730
-
.map_err(|e| {
7731
-
tonic::Status::unknown(
7732
-
format!("Service was not ready: {}", e.into()),
7733
-
)
7734
-
})?;
6689
+
) -> std::result::Result<tonic::Response<super::SoundVal2PhysResponse>, tonic::Status>
6690
+
{
6691
+
self.inner.ready().await.map_err(|e| {
6692
+
tonic::Status::unknown(format!("Service was not ready: {}", e.into()))
6693
+
})?;
7735
6694
let codec = tonic::codec::ProstCodec::default();
7736
6695
let path = http::uri::PathAndQuery::from_static(
7737
6696
"/rockbox.v1alpha1.SoundService/SoundVal2Phys",
7738
6697
);
7739
6698
let mut req = request.into_request();
7740
-
req.extensions_mut()
7741
-
.insert(
7742
-
GrpcMethod::new("rockbox.v1alpha1.SoundService", "SoundVal2Phys"),
7743
-
);
6699
+
req.extensions_mut().insert(GrpcMethod::new(
6700
+
"rockbox.v1alpha1.SoundService",
6701
+
"SoundVal2Phys",
6702
+
));
7744
6703
self.inner.unary(req, path, codec).await
7745
6704
}
7746
6705
pub async fn get_pitch(
7747
6706
&mut self,
7748
6707
request: impl tonic::IntoRequest<super::GetPitchRequest>,
7749
-
) -> std::result::Result<
7750
-
tonic::Response<super::GetPitchResponse>,
7751
-
tonic::Status,
7752
-
> {
7753
-
self.inner
7754
-
.ready()
7755
-
.await
7756
-
.map_err(|e| {
7757
-
tonic::Status::unknown(
7758
-
format!("Service was not ready: {}", e.into()),
7759
-
)
7760
-
})?;
6708
+
) -> std::result::Result<tonic::Response<super::GetPitchResponse>, tonic::Status> {
6709
+
self.inner.ready().await.map_err(|e| {
6710
+
tonic::Status::unknown(format!("Service was not ready: {}", e.into()))
6711
+
})?;
7761
6712
let codec = tonic::codec::ProstCodec::default();
7762
-
let path = http::uri::PathAndQuery::from_static(
7763
-
"/rockbox.v1alpha1.SoundService/GetPitch",
7764
-
);
6713
+
let path =
6714
+
http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.SoundService/GetPitch");
7765
6715
let mut req = request.into_request();
7766
6716
req.extensions_mut()
7767
6717
.insert(GrpcMethod::new("rockbox.v1alpha1.SoundService", "GetPitch"));
···
7770
6720
pub async fn set_pitch(
7771
6721
&mut self,
7772
6722
request: impl tonic::IntoRequest<super::SetPitchRequest>,
7773
-
) -> std::result::Result<
7774
-
tonic::Response<super::SetPitchResponse>,
7775
-
tonic::Status,
7776
-
> {
7777
-
self.inner
7778
-
.ready()
7779
-
.await
7780
-
.map_err(|e| {
7781
-
tonic::Status::unknown(
7782
-
format!("Service was not ready: {}", e.into()),
7783
-
)
7784
-
})?;
6723
+
) -> std::result::Result<tonic::Response<super::SetPitchResponse>, tonic::Status> {
6724
+
self.inner.ready().await.map_err(|e| {
6725
+
tonic::Status::unknown(format!("Service was not ready: {}", e.into()))
6726
+
})?;
7785
6727
let codec = tonic::codec::ProstCodec::default();
7786
-
let path = http::uri::PathAndQuery::from_static(
7787
-
"/rockbox.v1alpha1.SoundService/SetPitch",
7788
-
);
6728
+
let path =
6729
+
http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.SoundService/SetPitch");
7789
6730
let mut req = request.into_request();
7790
6731
req.extensions_mut()
7791
6732
.insert(GrpcMethod::new("rockbox.v1alpha1.SoundService", "SetPitch"));
···
7794
6735
pub async fn beep_play(
7795
6736
&mut self,
7796
6737
request: impl tonic::IntoRequest<super::BeepPlayRequest>,
7797
-
) -> std::result::Result<
7798
-
tonic::Response<super::BeepPlayResponse>,
7799
-
tonic::Status,
7800
-
> {
7801
-
self.inner
7802
-
.ready()
7803
-
.await
7804
-
.map_err(|e| {
7805
-
tonic::Status::unknown(
7806
-
format!("Service was not ready: {}", e.into()),
7807
-
)
7808
-
})?;
6738
+
) -> std::result::Result<tonic::Response<super::BeepPlayResponse>, tonic::Status> {
6739
+
self.inner.ready().await.map_err(|e| {
6740
+
tonic::Status::unknown(format!("Service was not ready: {}", e.into()))
6741
+
})?;
7809
6742
let codec = tonic::codec::ProstCodec::default();
7810
-
let path = http::uri::PathAndQuery::from_static(
7811
-
"/rockbox.v1alpha1.SoundService/BeepPlay",
7812
-
);
6743
+
let path =
6744
+
http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.SoundService/BeepPlay");
7813
6745
let mut req = request.into_request();
7814
6746
req.extensions_mut()
7815
6747
.insert(GrpcMethod::new("rockbox.v1alpha1.SoundService", "BeepPlay"));
···
7818
6750
pub async fn pcmbuf_fade(
7819
6751
&mut self,
7820
6752
request: impl tonic::IntoRequest<super::PcmbufFadeRequest>,
7821
-
) -> std::result::Result<
7822
-
tonic::Response<super::PcmbufFadeResponse>,
7823
-
tonic::Status,
7824
-
> {
7825
-
self.inner
7826
-
.ready()
7827
-
.await
7828
-
.map_err(|e| {
7829
-
tonic::Status::unknown(
7830
-
format!("Service was not ready: {}", e.into()),
7831
-
)
7832
-
})?;
6753
+
) -> std::result::Result<tonic::Response<super::PcmbufFadeResponse>, tonic::Status>
6754
+
{
6755
+
self.inner.ready().await.map_err(|e| {
6756
+
tonic::Status::unknown(format!("Service was not ready: {}", e.into()))
6757
+
})?;
7833
6758
let codec = tonic::codec::ProstCodec::default();
7834
-
let path = http::uri::PathAndQuery::from_static(
7835
-
"/rockbox.v1alpha1.SoundService/PcmbufFade",
7836
-
);
6759
+
let path =
6760
+
http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.SoundService/PcmbufFade");
7837
6761
let mut req = request.into_request();
7838
-
req.extensions_mut()
7839
-
.insert(GrpcMethod::new("rockbox.v1alpha1.SoundService", "PcmbufFade"));
6762
+
req.extensions_mut().insert(GrpcMethod::new(
6763
+
"rockbox.v1alpha1.SoundService",
6764
+
"PcmbufFade",
6765
+
));
7840
6766
self.inner.unary(req, path, codec).await
7841
6767
}
7842
6768
pub async fn pcmbuf_set_low_latency(
7843
6769
&mut self,
7844
6770
request: impl tonic::IntoRequest<super::PcmbufSetLowLatencyRequest>,
7845
-
) -> std::result::Result<
7846
-
tonic::Response<super::PcmbufSetLowLatencyResponse>,
7847
-
tonic::Status,
7848
-
> {
7849
-
self.inner
7850
-
.ready()
7851
-
.await
7852
-
.map_err(|e| {
7853
-
tonic::Status::unknown(
7854
-
format!("Service was not ready: {}", e.into()),
7855
-
)
7856
-
})?;
6771
+
) -> std::result::Result<tonic::Response<super::PcmbufSetLowLatencyResponse>, tonic::Status>
6772
+
{
6773
+
self.inner.ready().await.map_err(|e| {
6774
+
tonic::Status::unknown(format!("Service was not ready: {}", e.into()))
6775
+
})?;
7857
6776
let codec = tonic::codec::ProstCodec::default();
7858
6777
let path = http::uri::PathAndQuery::from_static(
7859
6778
"/rockbox.v1alpha1.SoundService/PcmbufSetLowLatency",
7860
6779
);
7861
6780
let mut req = request.into_request();
7862
-
req.extensions_mut()
7863
-
.insert(
7864
-
GrpcMethod::new(
7865
-
"rockbox.v1alpha1.SoundService",
7866
-
"PcmbufSetLowLatency",
7867
-
),
7868
-
);
6781
+
req.extensions_mut().insert(GrpcMethod::new(
6782
+
"rockbox.v1alpha1.SoundService",
6783
+
"PcmbufSetLowLatency",
6784
+
));
7869
6785
self.inner.unary(req, path, codec).await
7870
6786
}
7871
6787
pub async fn system_sound_play(
7872
6788
&mut self,
7873
6789
request: impl tonic::IntoRequest<super::SystemSoundPlayRequest>,
7874
-
) -> std::result::Result<
7875
-
tonic::Response<super::SystemSoundPlayResponse>,
7876
-
tonic::Status,
7877
-
> {
7878
-
self.inner
7879
-
.ready()
7880
-
.await
7881
-
.map_err(|e| {
7882
-
tonic::Status::unknown(
7883
-
format!("Service was not ready: {}", e.into()),
7884
-
)
7885
-
})?;
6790
+
) -> std::result::Result<tonic::Response<super::SystemSoundPlayResponse>, tonic::Status>
6791
+
{
6792
+
self.inner.ready().await.map_err(|e| {
6793
+
tonic::Status::unknown(format!("Service was not ready: {}", e.into()))
6794
+
})?;
7886
6795
let codec = tonic::codec::ProstCodec::default();
7887
6796
let path = http::uri::PathAndQuery::from_static(
7888
6797
"/rockbox.v1alpha1.SoundService/SystemSoundPlay",
7889
6798
);
7890
6799
let mut req = request.into_request();
7891
-
req.extensions_mut()
7892
-
.insert(
7893
-
GrpcMethod::new("rockbox.v1alpha1.SoundService", "SystemSoundPlay"),
7894
-
);
6800
+
req.extensions_mut().insert(GrpcMethod::new(
6801
+
"rockbox.v1alpha1.SoundService",
6802
+
"SystemSoundPlay",
6803
+
));
7895
6804
self.inner.unary(req, path, codec).await
7896
6805
}
7897
6806
pub async fn keyclick_click(
7898
6807
&mut self,
7899
6808
request: impl tonic::IntoRequest<super::KeyclickClickRequest>,
7900
-
) -> std::result::Result<
7901
-
tonic::Response<super::KeyclickClickResponse>,
7902
-
tonic::Status,
7903
-
> {
7904
-
self.inner
7905
-
.ready()
7906
-
.await
7907
-
.map_err(|e| {
7908
-
tonic::Status::unknown(
7909
-
format!("Service was not ready: {}", e.into()),
7910
-
)
7911
-
})?;
6809
+
) -> std::result::Result<tonic::Response<super::KeyclickClickResponse>, tonic::Status>
6810
+
{
6811
+
self.inner.ready().await.map_err(|e| {
6812
+
tonic::Status::unknown(format!("Service was not ready: {}", e.into()))
6813
+
})?;
7912
6814
let codec = tonic::codec::ProstCodec::default();
7913
6815
let path = http::uri::PathAndQuery::from_static(
7914
6816
"/rockbox.v1alpha1.SoundService/KeyclickClick",
7915
6817
);
7916
6818
let mut req = request.into_request();
7917
-
req.extensions_mut()
7918
-
.insert(
7919
-
GrpcMethod::new("rockbox.v1alpha1.SoundService", "KeyclickClick"),
7920
-
);
6819
+
req.extensions_mut().insert(GrpcMethod::new(
6820
+
"rockbox.v1alpha1.SoundService",
6821
+
"KeyclickClick",
6822
+
));
7921
6823
self.inner.unary(req, path, codec).await
7922
6824
}
7923
6825
}
···
7929
6831
dead_code,
7930
6832
missing_docs,
7931
6833
clippy::wildcard_imports,
7932
-
clippy::let_unit_value,
6834
+
clippy::let_unit_value
7933
6835
)]
7934
6836
use tonic::codegen::*;
7935
6837
/// Generated trait containing gRPC methods that should be implemented for use with SoundServiceServer.
···
7938
6840
async fn adjust_volume(
7939
6841
&self,
7940
6842
request: tonic::Request<super::AdjustVolumeRequest>,
7941
-
) -> std::result::Result<
7942
-
tonic::Response<super::AdjustVolumeResponse>,
7943
-
tonic::Status,
7944
-
>;
6843
+
) -> std::result::Result<tonic::Response<super::AdjustVolumeResponse>, tonic::Status>;
7945
6844
async fn sound_set(
7946
6845
&self,
7947
6846
request: tonic::Request<super::SoundSetRequest>,
7948
-
) -> std::result::Result<
7949
-
tonic::Response<super::SoundSetResponse>,
7950
-
tonic::Status,
7951
-
>;
6847
+
) -> std::result::Result<tonic::Response<super::SoundSetResponse>, tonic::Status>;
7952
6848
async fn sound_current(
7953
6849
&self,
7954
6850
request: tonic::Request<super::SoundCurrentRequest>,
7955
-
) -> std::result::Result<
7956
-
tonic::Response<super::SoundCurrentResponse>,
7957
-
tonic::Status,
7958
-
>;
6851
+
) -> std::result::Result<tonic::Response<super::SoundCurrentResponse>, tonic::Status>;
7959
6852
async fn sound_default(
7960
6853
&self,
7961
6854
request: tonic::Request<super::SoundDefaultRequest>,
7962
-
) -> std::result::Result<
7963
-
tonic::Response<super::SoundDefaultResponse>,
7964
-
tonic::Status,
7965
-
>;
6855
+
) -> std::result::Result<tonic::Response<super::SoundDefaultResponse>, tonic::Status>;
7966
6856
async fn sound_min(
7967
6857
&self,
7968
6858
request: tonic::Request<super::SoundMinRequest>,
7969
-
) -> std::result::Result<
7970
-
tonic::Response<super::SoundMinResponse>,
7971
-
tonic::Status,
7972
-
>;
6859
+
) -> std::result::Result<tonic::Response<super::SoundMinResponse>, tonic::Status>;
7973
6860
async fn sound_max(
7974
6861
&self,
7975
6862
request: tonic::Request<super::SoundMaxRequest>,
7976
-
) -> std::result::Result<
7977
-
tonic::Response<super::SoundMaxResponse>,
7978
-
tonic::Status,
7979
-
>;
6863
+
) -> std::result::Result<tonic::Response<super::SoundMaxResponse>, tonic::Status>;
7980
6864
async fn sound_unit(
7981
6865
&self,
7982
6866
request: tonic::Request<super::SoundUnitRequest>,
7983
-
) -> std::result::Result<
7984
-
tonic::Response<super::SoundUnitResponse>,
7985
-
tonic::Status,
7986
-
>;
6867
+
) -> std::result::Result<tonic::Response<super::SoundUnitResponse>, tonic::Status>;
7987
6868
async fn sound_val2_phys(
7988
6869
&self,
7989
6870
request: tonic::Request<super::SoundVal2PhysRequest>,
7990
-
) -> std::result::Result<
7991
-
tonic::Response<super::SoundVal2PhysResponse>,
7992
-
tonic::Status,
7993
-
>;
6871
+
) -> std::result::Result<tonic::Response<super::SoundVal2PhysResponse>, tonic::Status>;
7994
6872
async fn get_pitch(
7995
6873
&self,
7996
6874
request: tonic::Request<super::GetPitchRequest>,
7997
-
) -> std::result::Result<
7998
-
tonic::Response<super::GetPitchResponse>,
7999
-
tonic::Status,
8000
-
>;
6875
+
) -> std::result::Result<tonic::Response<super::GetPitchResponse>, tonic::Status>;
8001
6876
async fn set_pitch(
8002
6877
&self,
8003
6878
request: tonic::Request<super::SetPitchRequest>,
8004
-
) -> std::result::Result<
8005
-
tonic::Response<super::SetPitchResponse>,
8006
-
tonic::Status,
8007
-
>;
6879
+
) -> std::result::Result<tonic::Response<super::SetPitchResponse>, tonic::Status>;
8008
6880
async fn beep_play(
8009
6881
&self,
8010
6882
request: tonic::Request<super::BeepPlayRequest>,
8011
-
) -> std::result::Result<
8012
-
tonic::Response<super::BeepPlayResponse>,
8013
-
tonic::Status,
8014
-
>;
6883
+
) -> std::result::Result<tonic::Response<super::BeepPlayResponse>, tonic::Status>;
8015
6884
async fn pcmbuf_fade(
8016
6885
&self,
8017
6886
request: tonic::Request<super::PcmbufFadeRequest>,
8018
-
) -> std::result::Result<
8019
-
tonic::Response<super::PcmbufFadeResponse>,
8020
-
tonic::Status,
8021
-
>;
6887
+
) -> std::result::Result<tonic::Response<super::PcmbufFadeResponse>, tonic::Status>;
8022
6888
async fn pcmbuf_set_low_latency(
8023
6889
&self,
8024
6890
request: tonic::Request<super::PcmbufSetLowLatencyRequest>,
8025
-
) -> std::result::Result<
8026
-
tonic::Response<super::PcmbufSetLowLatencyResponse>,
8027
-
tonic::Status,
8028
-
>;
6891
+
) -> std::result::Result<tonic::Response<super::PcmbufSetLowLatencyResponse>, tonic::Status>;
8029
6892
async fn system_sound_play(
8030
6893
&self,
8031
6894
request: tonic::Request<super::SystemSoundPlayRequest>,
8032
-
) -> std::result::Result<
8033
-
tonic::Response<super::SystemSoundPlayResponse>,
8034
-
tonic::Status,
8035
-
>;
6895
+
) -> std::result::Result<tonic::Response<super::SystemSoundPlayResponse>, tonic::Status>;
8036
6896
async fn keyclick_click(
8037
6897
&self,
8038
6898
request: tonic::Request<super::KeyclickClickRequest>,
8039
-
) -> std::result::Result<
8040
-
tonic::Response<super::KeyclickClickResponse>,
8041
-
tonic::Status,
8042
-
>;
6899
+
) -> std::result::Result<tonic::Response<super::KeyclickClickResponse>, tonic::Status>;
8043
6900
}
8044
6901
#[derive(Debug)]
8045
6902
pub struct SoundServiceServer<T> {
···
8062
6919
max_encoding_message_size: None,
8063
6920
}
8064
6921
}
8065
-
pub fn with_interceptor<F>(
8066
-
inner: T,
8067
-
interceptor: F,
8068
-
) -> InterceptedService<Self, F>
6922
+
pub fn with_interceptor<F>(inner: T, interceptor: F) -> InterceptedService<Self, F>
8069
6923
where
8070
6924
F: tonic::service::Interceptor,
8071
6925
{
···
8120
6974
"/rockbox.v1alpha1.SoundService/AdjustVolume" => {
8121
6975
#[allow(non_camel_case_types)]
8122
6976
struct AdjustVolumeSvc<T: SoundService>(pub Arc<T>);
8123
-
impl<
8124
-
T: SoundService,
8125
-
> tonic::server::UnaryService<super::AdjustVolumeRequest>
8126
-
for AdjustVolumeSvc<T> {
6977
+
impl<T: SoundService> tonic::server::UnaryService<super::AdjustVolumeRequest>
6978
+
for AdjustVolumeSvc<T>
6979
+
{
8127
6980
type Response = super::AdjustVolumeResponse;
8128
-
type Future = BoxFuture<
8129
-
tonic::Response<Self::Response>,
8130
-
tonic::Status,
8131
-
>;
6981
+
type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
8132
6982
fn call(
8133
6983
&mut self,
8134
6984
request: tonic::Request<super::AdjustVolumeRequest>,
···
8165
7015
"/rockbox.v1alpha1.SoundService/SoundSet" => {
8166
7016
#[allow(non_camel_case_types)]
8167
7017
struct SoundSetSvc<T: SoundService>(pub Arc<T>);
8168
-
impl<
8169
-
T: SoundService,
8170
-
> tonic::server::UnaryService<super::SoundSetRequest>
8171
-
for SoundSetSvc<T> {
7018
+
impl<T: SoundService> tonic::server::UnaryService<super::SoundSetRequest> for SoundSetSvc<T> {
8172
7019
type Response = super::SoundSetResponse;
8173
-
type Future = BoxFuture<
8174
-
tonic::Response<Self::Response>,
8175
-
tonic::Status,
8176
-
>;
7020
+
type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
8177
7021
fn call(
8178
7022
&mut self,
8179
7023
request: tonic::Request<super::SoundSetRequest>,
···
8210
7054
"/rockbox.v1alpha1.SoundService/SoundCurrent" => {
8211
7055
#[allow(non_camel_case_types)]
8212
7056
struct SoundCurrentSvc<T: SoundService>(pub Arc<T>);
8213
-
impl<
8214
-
T: SoundService,
8215
-
> tonic::server::UnaryService<super::SoundCurrentRequest>
8216
-
for SoundCurrentSvc<T> {
7057
+
impl<T: SoundService> tonic::server::UnaryService<super::SoundCurrentRequest>
7058
+
for SoundCurrentSvc<T>
7059
+
{
8217
7060
type Response = super::SoundCurrentResponse;
8218
-
type Future = BoxFuture<
8219
-
tonic::Response<Self::Response>,
8220
-
tonic::Status,
8221
-
>;
7061
+
type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
8222
7062
fn call(
8223
7063
&mut self,
8224
7064
request: tonic::Request<super::SoundCurrentRequest>,
···
8255
7095
"/rockbox.v1alpha1.SoundService/SoundDefault" => {
8256
7096
#[allow(non_camel_case_types)]
8257
7097
struct SoundDefaultSvc<T: SoundService>(pub Arc<T>);
8258
-
impl<
8259
-
T: SoundService,
8260
-
> tonic::server::UnaryService<super::SoundDefaultRequest>
8261
-
for SoundDefaultSvc<T> {
7098
+
impl<T: SoundService> tonic::server::UnaryService<super::SoundDefaultRequest>
7099
+
for SoundDefaultSvc<T>
7100
+
{
8262
7101
type Response = super::SoundDefaultResponse;
8263
-
type Future = BoxFuture<
8264
-
tonic::Response<Self::Response>,
8265
-
tonic::Status,
8266
-
>;
7102
+
type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
8267
7103
fn call(
8268
7104
&mut self,
8269
7105
request: tonic::Request<super::SoundDefaultRequest>,
···
8300
7136
"/rockbox.v1alpha1.SoundService/SoundMin" => {
8301
7137
#[allow(non_camel_case_types)]
8302
7138
struct SoundMinSvc<T: SoundService>(pub Arc<T>);
8303
-
impl<
8304
-
T: SoundService,
8305
-
> tonic::server::UnaryService<super::SoundMinRequest>
8306
-
for SoundMinSvc<T> {
7139
+
impl<T: SoundService> tonic::server::UnaryService<super::SoundMinRequest> for SoundMinSvc<T> {
8307
7140
type Response = super::SoundMinResponse;
8308
-
type Future = BoxFuture<
8309
-
tonic::Response<Self::Response>,
8310
-
tonic::Status,
8311
-
>;
7141
+
type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
8312
7142
fn call(
8313
7143
&mut self,
8314
7144
request: tonic::Request<super::SoundMinRequest>,
···
8345
7175
"/rockbox.v1alpha1.SoundService/SoundMax" => {
8346
7176
#[allow(non_camel_case_types)]
8347
7177
struct SoundMaxSvc<T: SoundService>(pub Arc<T>);
8348
-
impl<
8349
-
T: SoundService,
8350
-
> tonic::server::UnaryService<super::SoundMaxRequest>
8351
-
for SoundMaxSvc<T> {
7178
+
impl<T: SoundService> tonic::server::UnaryService<super::SoundMaxRequest> for SoundMaxSvc<T> {
8352
7179
type Response = super::SoundMaxResponse;
8353
-
type Future = BoxFuture<
8354
-
tonic::Response<Self::Response>,
8355
-
tonic::Status,
8356
-
>;
7180
+
type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
8357
7181
fn call(
8358
7182
&mut self,
8359
7183
request: tonic::Request<super::SoundMaxRequest>,
···
8390
7214
"/rockbox.v1alpha1.SoundService/SoundUnit" => {
8391
7215
#[allow(non_camel_case_types)]
8392
7216
struct SoundUnitSvc<T: SoundService>(pub Arc<T>);
8393
-
impl<
8394
-
T: SoundService,
8395
-
> tonic::server::UnaryService<super::SoundUnitRequest>
8396
-
for SoundUnitSvc<T> {
7217
+
impl<T: SoundService> tonic::server::UnaryService<super::SoundUnitRequest> for SoundUnitSvc<T> {
8397
7218
type Response = super::SoundUnitResponse;
8398
-
type Future = BoxFuture<
8399
-
tonic::Response<Self::Response>,
8400
-
tonic::Status,
8401
-
>;
7219
+
type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
8402
7220
fn call(
8403
7221
&mut self,
8404
7222
request: tonic::Request<super::SoundUnitRequest>,
···
8435
7253
"/rockbox.v1alpha1.SoundService/SoundVal2Phys" => {
8436
7254
#[allow(non_camel_case_types)]
8437
7255
struct SoundVal2PhysSvc<T: SoundService>(pub Arc<T>);
8438
-
impl<
8439
-
T: SoundService,
8440
-
> tonic::server::UnaryService<super::SoundVal2PhysRequest>
8441
-
for SoundVal2PhysSvc<T> {
7256
+
impl<T: SoundService> tonic::server::UnaryService<super::SoundVal2PhysRequest>
7257
+
for SoundVal2PhysSvc<T>
7258
+
{
8442
7259
type Response = super::SoundVal2PhysResponse;
8443
-
type Future = BoxFuture<
8444
-
tonic::Response<Self::Response>,
8445
-
tonic::Status,
8446
-
>;
7260
+
type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
8447
7261
fn call(
8448
7262
&mut self,
8449
7263
request: tonic::Request<super::SoundVal2PhysRequest>,
···
8480
7294
"/rockbox.v1alpha1.SoundService/GetPitch" => {
8481
7295
#[allow(non_camel_case_types)]
8482
7296
struct GetPitchSvc<T: SoundService>(pub Arc<T>);
8483
-
impl<
8484
-
T: SoundService,
8485
-
> tonic::server::UnaryService<super::GetPitchRequest>
8486
-
for GetPitchSvc<T> {
7297
+
impl<T: SoundService> tonic::server::UnaryService<super::GetPitchRequest> for GetPitchSvc<T> {
8487
7298
type Response = super::GetPitchResponse;
8488
-
type Future = BoxFuture<
8489
-
tonic::Response<Self::Response>,
8490
-
tonic::Status,
8491
-
>;
7299
+
type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
8492
7300
fn call(
8493
7301
&mut self,
8494
7302
request: tonic::Request<super::GetPitchRequest>,
···
8525
7333
"/rockbox.v1alpha1.SoundService/SetPitch" => {
8526
7334
#[allow(non_camel_case_types)]
8527
7335
struct SetPitchSvc<T: SoundService>(pub Arc<T>);
8528
-
impl<
8529
-
T: SoundService,
8530
-
> tonic::server::UnaryService<super::SetPitchRequest>
8531
-
for SetPitchSvc<T> {
7336
+
impl<T: SoundService> tonic::server::UnaryService<super::SetPitchRequest> for SetPitchSvc<T> {
8532
7337
type Response = super::SetPitchResponse;
8533
-
type Future = BoxFuture<
8534
-
tonic::Response<Self::Response>,
8535
-
tonic::Status,
8536
-
>;
7338
+
type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
8537
7339
fn call(
8538
7340
&mut self,
8539
7341
request: tonic::Request<super::SetPitchRequest>,
···
8570
7372
"/rockbox.v1alpha1.SoundService/BeepPlay" => {
8571
7373
#[allow(non_camel_case_types)]
8572
7374
struct BeepPlaySvc<T: SoundService>(pub Arc<T>);
8573
-
impl<
8574
-
T: SoundService,
8575
-
> tonic::server::UnaryService<super::BeepPlayRequest>
8576
-
for BeepPlaySvc<T> {
7375
+
impl<T: SoundService> tonic::server::UnaryService<super::BeepPlayRequest> for BeepPlaySvc<T> {
8577
7376
type Response = super::BeepPlayResponse;
8578
-
type Future = BoxFuture<
8579
-
tonic::Response<Self::Response>,
8580
-
tonic::Status,
8581
-
>;
7377
+
type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
8582
7378
fn call(
8583
7379
&mut self,
8584
7380
request: tonic::Request<super::BeepPlayRequest>,
···
8615
7411
"/rockbox.v1alpha1.SoundService/PcmbufFade" => {
8616
7412
#[allow(non_camel_case_types)]
8617
7413
struct PcmbufFadeSvc<T: SoundService>(pub Arc<T>);
8618
-
impl<
8619
-
T: SoundService,
8620
-
> tonic::server::UnaryService<super::PcmbufFadeRequest>
8621
-
for PcmbufFadeSvc<T> {
7414
+
impl<T: SoundService> tonic::server::UnaryService<super::PcmbufFadeRequest> for PcmbufFadeSvc<T> {
8622
7415
type Response = super::PcmbufFadeResponse;
8623
-
type Future = BoxFuture<
8624
-
tonic::Response<Self::Response>,
8625
-
tonic::Status,
8626
-
>;
7416
+
type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
8627
7417
fn call(
8628
7418
&mut self,
8629
7419
request: tonic::Request<super::PcmbufFadeRequest>,
···
8660
7450
"/rockbox.v1alpha1.SoundService/PcmbufSetLowLatency" => {
8661
7451
#[allow(non_camel_case_types)]
8662
7452
struct PcmbufSetLowLatencySvc<T: SoundService>(pub Arc<T>);
8663
-
impl<
8664
-
T: SoundService,
8665
-
> tonic::server::UnaryService<super::PcmbufSetLowLatencyRequest>
8666
-
for PcmbufSetLowLatencySvc<T> {
7453
+
impl<T: SoundService>
7454
+
tonic::server::UnaryService<super::PcmbufSetLowLatencyRequest>
7455
+
for PcmbufSetLowLatencySvc<T>
7456
+
{
8667
7457
type Response = super::PcmbufSetLowLatencyResponse;
8668
-
type Future = BoxFuture<
8669
-
tonic::Response<Self::Response>,
8670
-
tonic::Status,
8671
-
>;
7458
+
type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
8672
7459
fn call(
8673
7460
&mut self,
8674
7461
request: tonic::Request<super::PcmbufSetLowLatencyRequest>,
8675
7462
) -> Self::Future {
8676
7463
let inner = Arc::clone(&self.0);
8677
7464
let fut = async move {
8678
-
<T as SoundService>::pcmbuf_set_low_latency(&inner, request)
8679
-
.await
7465
+
<T as SoundService>::pcmbuf_set_low_latency(&inner, request).await
8680
7466
};
8681
7467
Box::pin(fut)
8682
7468
}
···
8706
7492
"/rockbox.v1alpha1.SoundService/SystemSoundPlay" => {
8707
7493
#[allow(non_camel_case_types)]
8708
7494
struct SystemSoundPlaySvc<T: SoundService>(pub Arc<T>);
8709
-
impl<
8710
-
T: SoundService,
8711
-
> tonic::server::UnaryService<super::SystemSoundPlayRequest>
8712
-
for SystemSoundPlaySvc<T> {
7495
+
impl<T: SoundService> tonic::server::UnaryService<super::SystemSoundPlayRequest>
7496
+
for SystemSoundPlaySvc<T>
7497
+
{
8713
7498
type Response = super::SystemSoundPlayResponse;
8714
-
type Future = BoxFuture<
8715
-
tonic::Response<Self::Response>,
8716
-
tonic::Status,
8717
-
>;
7499
+
type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
8718
7500
fn call(
8719
7501
&mut self,
8720
7502
request: tonic::Request<super::SystemSoundPlayRequest>,
8721
7503
) -> Self::Future {
8722
7504
let inner = Arc::clone(&self.0);
8723
7505
let fut = async move {
8724
-
<T as SoundService>::system_sound_play(&inner, request)
8725
-
.await
7506
+
<T as SoundService>::system_sound_play(&inner, request).await
8726
7507
};
8727
7508
Box::pin(fut)
8728
7509
}
···
8752
7533
"/rockbox.v1alpha1.SoundService/KeyclickClick" => {
8753
7534
#[allow(non_camel_case_types)]
8754
7535
struct KeyclickClickSvc<T: SoundService>(pub Arc<T>);
8755
-
impl<
8756
-
T: SoundService,
8757
-
> tonic::server::UnaryService<super::KeyclickClickRequest>
8758
-
for KeyclickClickSvc<T> {
7536
+
impl<T: SoundService> tonic::server::UnaryService<super::KeyclickClickRequest>
7537
+
for KeyclickClickSvc<T>
7538
+
{
8759
7539
type Response = super::KeyclickClickResponse;
8760
-
type Future = BoxFuture<
8761
-
tonic::Response<Self::Response>,
8762
-
tonic::Status,
8763
-
>;
7540
+
type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
8764
7541
fn call(
8765
7542
&mut self,
8766
7543
request: tonic::Request<super::KeyclickClickRequest>,
···
8794
7571
};
8795
7572
Box::pin(fut)
8796
7573
}
8797
-
_ => {
8798
-
Box::pin(async move {
8799
-
let mut response = http::Response::new(empty_body());
8800
-
let headers = response.headers_mut();
8801
-
headers
8802
-
.insert(
8803
-
tonic::Status::GRPC_STATUS,
8804
-
(tonic::Code::Unimplemented as i32).into(),
8805
-
);
8806
-
headers
8807
-
.insert(
8808
-
http::header::CONTENT_TYPE,
8809
-
tonic::metadata::GRPC_CONTENT_TYPE,
8810
-
);
8811
-
Ok(response)
8812
-
})
8813
-
}
7574
+
_ => Box::pin(async move {
7575
+
let mut response = http::Response::new(empty_body());
7576
+
let headers = response.headers_mut();
7577
+
headers.insert(
7578
+
tonic::Status::GRPC_STATUS,
7579
+
(tonic::Code::Unimplemented as i32).into(),
7580
+
);
7581
+
headers.insert(
7582
+
http::header::CONTENT_TYPE,
7583
+
tonic::metadata::GRPC_CONTENT_TYPE,
7584
+
);
7585
+
Ok(response)
7586
+
}),
8814
7587
}
8815
7588
}
8816
7589
}
···
8871
7644
dead_code,
8872
7645
missing_docs,
8873
7646
clippy::wildcard_imports,
8874
-
clippy::let_unit_value,
7647
+
clippy::let_unit_value
8875
7648
)]
7649
+
use tonic::codegen::http::Uri;
8876
7650
use tonic::codegen::*;
8877
-
use tonic::codegen::http::Uri;
8878
7651
#[derive(Debug, Clone)]
8879
7652
pub struct SystemServiceClient<T> {
8880
7653
inner: tonic::client::Grpc<T>,
···
8918
7691
<T as tonic::client::GrpcService<tonic::body::BoxBody>>::ResponseBody,
8919
7692
>,
8920
7693
>,
8921
-
<T as tonic::codegen::Service<
8922
-
http::Request<tonic::body::BoxBody>,
8923
-
>>::Error: Into<StdError> + std::marker::Send + std::marker::Sync,
7694
+
<T as tonic::codegen::Service<http::Request<tonic::body::BoxBody>>>::Error:
7695
+
Into<StdError> + std::marker::Send + std::marker::Sync,
8924
7696
{
8925
7697
SystemServiceClient::new(InterceptedService::new(inner, interceptor))
8926
7698
}
···
8958
7730
pub async fn get_rockbox_version(
8959
7731
&mut self,
8960
7732
request: impl tonic::IntoRequest<super::GetRockboxVersionRequest>,
8961
-
) -> std::result::Result<
8962
-
tonic::Response<super::GetRockboxVersionResponse>,
8963
-
tonic::Status,
8964
-
> {
8965
-
self.inner
8966
-
.ready()
8967
-
.await
8968
-
.map_err(|e| {
8969
-
tonic::Status::unknown(
8970
-
format!("Service was not ready: {}", e.into()),
8971
-
)
8972
-
})?;
7733
+
) -> std::result::Result<tonic::Response<super::GetRockboxVersionResponse>, tonic::Status>
7734
+
{
7735
+
self.inner.ready().await.map_err(|e| {
7736
+
tonic::Status::unknown(format!("Service was not ready: {}", e.into()))
7737
+
})?;
8973
7738
let codec = tonic::codec::ProstCodec::default();
8974
7739
let path = http::uri::PathAndQuery::from_static(
8975
7740
"/rockbox.v1alpha1.SystemService/GetRockboxVersion",
8976
7741
);
8977
7742
let mut req = request.into_request();
8978
-
req.extensions_mut()
8979
-
.insert(
8980
-
GrpcMethod::new(
8981
-
"rockbox.v1alpha1.SystemService",
8982
-
"GetRockboxVersion",
8983
-
),
8984
-
);
7743
+
req.extensions_mut().insert(GrpcMethod::new(
7744
+
"rockbox.v1alpha1.SystemService",
7745
+
"GetRockboxVersion",
7746
+
));
8985
7747
self.inner.unary(req, path, codec).await
8986
7748
}
8987
7749
pub async fn get_global_status(
8988
7750
&mut self,
8989
7751
request: impl tonic::IntoRequest<super::GetGlobalStatusRequest>,
8990
-
) -> std::result::Result<
8991
-
tonic::Response<super::GetGlobalStatusResponse>,
8992
-
tonic::Status,
8993
-
> {
8994
-
self.inner
8995
-
.ready()
8996
-
.await
8997
-
.map_err(|e| {
8998
-
tonic::Status::unknown(
8999
-
format!("Service was not ready: {}", e.into()),
9000
-
)
9001
-
})?;
7752
+
) -> std::result::Result<tonic::Response<super::GetGlobalStatusResponse>, tonic::Status>
7753
+
{
7754
+
self.inner.ready().await.map_err(|e| {
7755
+
tonic::Status::unknown(format!("Service was not ready: {}", e.into()))
7756
+
})?;
9002
7757
let codec = tonic::codec::ProstCodec::default();
9003
7758
let path = http::uri::PathAndQuery::from_static(
9004
7759
"/rockbox.v1alpha1.SystemService/GetGlobalStatus",
9005
7760
);
9006
7761
let mut req = request.into_request();
9007
-
req.extensions_mut()
9008
-
.insert(
9009
-
GrpcMethod::new("rockbox.v1alpha1.SystemService", "GetGlobalStatus"),
9010
-
);
7762
+
req.extensions_mut().insert(GrpcMethod::new(
7763
+
"rockbox.v1alpha1.SystemService",
7764
+
"GetGlobalStatus",
7765
+
));
9011
7766
self.inner.unary(req, path, codec).await
9012
7767
}
9013
7768
}
···
9019
7774
dead_code,
9020
7775
missing_docs,
9021
7776
clippy::wildcard_imports,
9022
-
clippy::let_unit_value,
7777
+
clippy::let_unit_value
9023
7778
)]
9024
7779
use tonic::codegen::*;
9025
7780
/// Generated trait containing gRPC methods that should be implemented for use with SystemServiceServer.
···
9028
7783
async fn get_rockbox_version(
9029
7784
&self,
9030
7785
request: tonic::Request<super::GetRockboxVersionRequest>,
9031
-
) -> std::result::Result<
9032
-
tonic::Response<super::GetRockboxVersionResponse>,
9033
-
tonic::Status,
9034
-
>;
7786
+
) -> std::result::Result<tonic::Response<super::GetRockboxVersionResponse>, tonic::Status>;
9035
7787
async fn get_global_status(
9036
7788
&self,
9037
7789
request: tonic::Request<super::GetGlobalStatusRequest>,
9038
-
) -> std::result::Result<
9039
-
tonic::Response<super::GetGlobalStatusResponse>,
9040
-
tonic::Status,
9041
-
>;
7790
+
) -> std::result::Result<tonic::Response<super::GetGlobalStatusResponse>, tonic::Status>;
9042
7791
}
9043
7792
#[derive(Debug)]
9044
7793
pub struct SystemServiceServer<T> {
···
9061
7810
max_encoding_message_size: None,
9062
7811
}
9063
7812
}
9064
-
pub fn with_interceptor<F>(
9065
-
inner: T,
9066
-
interceptor: F,
9067
-
) -> InterceptedService<Self, F>
7813
+
pub fn with_interceptor<F>(inner: T, interceptor: F) -> InterceptedService<Self, F>
9068
7814
where
9069
7815
F: tonic::service::Interceptor,
9070
7816
{
···
9119
7865
"/rockbox.v1alpha1.SystemService/GetRockboxVersion" => {
9120
7866
#[allow(non_camel_case_types)]
9121
7867
struct GetRockboxVersionSvc<T: SystemService>(pub Arc<T>);
9122
-
impl<
9123
-
T: SystemService,
9124
-
> tonic::server::UnaryService<super::GetRockboxVersionRequest>
9125
-
for GetRockboxVersionSvc<T> {
7868
+
impl<T: SystemService>
7869
+
tonic::server::UnaryService<super::GetRockboxVersionRequest>
7870
+
for GetRockboxVersionSvc<T>
7871
+
{
9126
7872
type Response = super::GetRockboxVersionResponse;
9127
-
type Future = BoxFuture<
9128
-
tonic::Response<Self::Response>,
9129
-
tonic::Status,
9130
-
>;
7873
+
type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
9131
7874
fn call(
9132
7875
&mut self,
9133
7876
request: tonic::Request<super::GetRockboxVersionRequest>,
9134
7877
) -> Self::Future {
9135
7878
let inner = Arc::clone(&self.0);
9136
7879
let fut = async move {
9137
-
<T as SystemService>::get_rockbox_version(&inner, request)
9138
-
.await
7880
+
<T as SystemService>::get_rockbox_version(&inner, request).await
9139
7881
};
9140
7882
Box::pin(fut)
9141
7883
}
···
9165
7907
"/rockbox.v1alpha1.SystemService/GetGlobalStatus" => {
9166
7908
#[allow(non_camel_case_types)]
9167
7909
struct GetGlobalStatusSvc<T: SystemService>(pub Arc<T>);
9168
-
impl<
9169
-
T: SystemService,
9170
-
> tonic::server::UnaryService<super::GetGlobalStatusRequest>
9171
-
for GetGlobalStatusSvc<T> {
7910
+
impl<T: SystemService>
7911
+
tonic::server::UnaryService<super::GetGlobalStatusRequest>
7912
+
for GetGlobalStatusSvc<T>
7913
+
{
9172
7914
type Response = super::GetGlobalStatusResponse;
9173
-
type Future = BoxFuture<
9174
-
tonic::Response<Self::Response>,
9175
-
tonic::Status,
9176
-
>;
7915
+
type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
9177
7916
fn call(
9178
7917
&mut self,
9179
7918
request: tonic::Request<super::GetGlobalStatusRequest>,
9180
7919
) -> Self::Future {
9181
7920
let inner = Arc::clone(&self.0);
9182
7921
let fut = async move {
9183
-
<T as SystemService>::get_global_status(&inner, request)
9184
-
.await
7922
+
<T as SystemService>::get_global_status(&inner, request).await
9185
7923
};
9186
7924
Box::pin(fut)
9187
7925
}
···
9208
7946
};
9209
7947
Box::pin(fut)
9210
7948
}
9211
-
_ => {
9212
-
Box::pin(async move {
9213
-
let mut response = http::Response::new(empty_body());
9214
-
let headers = response.headers_mut();
9215
-
headers
9216
-
.insert(
9217
-
tonic::Status::GRPC_STATUS,
9218
-
(tonic::Code::Unimplemented as i32).into(),
9219
-
);
9220
-
headers
9221
-
.insert(
9222
-
http::header::CONTENT_TYPE,
9223
-
tonic::metadata::GRPC_CONTENT_TYPE,
9224
-
);
9225
-
Ok(response)
9226
-
})
9227
-
}
7949
+
_ => Box::pin(async move {
7950
+
let mut response = http::Response::new(empty_body());
7951
+
let headers = response.headers_mut();
7952
+
headers.insert(
7953
+
tonic::Status::GRPC_STATUS,
7954
+
(tonic::Code::Unimplemented as i32).into(),
7955
+
);
7956
+
headers.insert(
7957
+
http::header::CONTENT_TYPE,
7958
+
tonic::metadata::GRPC_CONTENT_TYPE,
7959
+
);
7960
+
Ok(response)
7961
+
}),
9228
7962
}
9229
7963
}
9230
7964
}
+1210
-2442
gtk/src/api/rockbox.v1alpha1.rs
+1210
-2442
gtk/src/api/rockbox.v1alpha1.rs
···
43
43
dead_code,
44
44
missing_docs,
45
45
clippy::wildcard_imports,
46
-
clippy::let_unit_value,
46
+
clippy::let_unit_value
47
47
)]
48
-
use tonic::codegen::*;
49
48
use tonic::codegen::http::Uri;
49
+
use tonic::codegen::*;
50
50
#[derive(Debug, Clone)]
51
51
pub struct BrowseServiceClient<T> {
52
52
inner: tonic::client::Grpc<T>,
···
90
90
<T as tonic::client::GrpcService<tonic::body::BoxBody>>::ResponseBody,
91
91
>,
92
92
>,
93
-
<T as tonic::codegen::Service<
94
-
http::Request<tonic::body::BoxBody>,
95
-
>>::Error: Into<StdError> + std::marker::Send + std::marker::Sync,
93
+
<T as tonic::codegen::Service<http::Request<tonic::body::BoxBody>>>::Error:
94
+
Into<StdError> + std::marker::Send + std::marker::Sync,
96
95
{
97
96
BrowseServiceClient::new(InterceptedService::new(inner, interceptor))
98
97
}
···
130
129
pub async fn tree_get_entries(
131
130
&mut self,
132
131
request: impl tonic::IntoRequest<super::TreeGetEntriesRequest>,
133
-
) -> std::result::Result<
134
-
tonic::Response<super::TreeGetEntriesResponse>,
135
-
tonic::Status,
136
-
> {
137
-
self.inner
138
-
.ready()
139
-
.await
140
-
.map_err(|e| {
141
-
tonic::Status::unknown(
142
-
format!("Service was not ready: {}", e.into()),
143
-
)
144
-
})?;
132
+
) -> std::result::Result<tonic::Response<super::TreeGetEntriesResponse>, tonic::Status>
133
+
{
134
+
self.inner.ready().await.map_err(|e| {
135
+
tonic::Status::unknown(format!("Service was not ready: {}", e.into()))
136
+
})?;
145
137
let codec = tonic::codec::ProstCodec::default();
146
138
let path = http::uri::PathAndQuery::from_static(
147
139
"/rockbox.v1alpha1.BrowseService/TreeGetEntries",
148
140
);
149
141
let mut req = request.into_request();
150
-
req.extensions_mut()
151
-
.insert(
152
-
GrpcMethod::new("rockbox.v1alpha1.BrowseService", "TreeGetEntries"),
153
-
);
142
+
req.extensions_mut().insert(GrpcMethod::new(
143
+
"rockbox.v1alpha1.BrowseService",
144
+
"TreeGetEntries",
145
+
));
154
146
self.inner.unary(req, path, codec).await
155
147
}
156
148
}
···
162
154
dead_code,
163
155
missing_docs,
164
156
clippy::wildcard_imports,
165
-
clippy::let_unit_value,
157
+
clippy::let_unit_value
166
158
)]
167
159
use tonic::codegen::*;
168
160
/// Generated trait containing gRPC methods that should be implemented for use with BrowseServiceServer.
···
171
163
async fn tree_get_entries(
172
164
&self,
173
165
request: tonic::Request<super::TreeGetEntriesRequest>,
174
-
) -> std::result::Result<
175
-
tonic::Response<super::TreeGetEntriesResponse>,
176
-
tonic::Status,
177
-
>;
166
+
) -> std::result::Result<tonic::Response<super::TreeGetEntriesResponse>, tonic::Status>;
178
167
}
179
168
#[derive(Debug)]
180
169
pub struct BrowseServiceServer<T> {
···
197
186
max_encoding_message_size: None,
198
187
}
199
188
}
200
-
pub fn with_interceptor<F>(
201
-
inner: T,
202
-
interceptor: F,
203
-
) -> InterceptedService<Self, F>
189
+
pub fn with_interceptor<F>(inner: T, interceptor: F) -> InterceptedService<Self, F>
204
190
where
205
191
F: tonic::service::Interceptor,
206
192
{
···
255
241
"/rockbox.v1alpha1.BrowseService/TreeGetEntries" => {
256
242
#[allow(non_camel_case_types)]
257
243
struct TreeGetEntriesSvc<T: BrowseService>(pub Arc<T>);
258
-
impl<
259
-
T: BrowseService,
260
-
> tonic::server::UnaryService<super::TreeGetEntriesRequest>
261
-
for TreeGetEntriesSvc<T> {
244
+
impl<T: BrowseService> tonic::server::UnaryService<super::TreeGetEntriesRequest>
245
+
for TreeGetEntriesSvc<T>
246
+
{
262
247
type Response = super::TreeGetEntriesResponse;
263
-
type Future = BoxFuture<
264
-
tonic::Response<Self::Response>,
265
-
tonic::Status,
266
-
>;
248
+
type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
267
249
fn call(
268
250
&mut self,
269
251
request: tonic::Request<super::TreeGetEntriesRequest>,
270
252
) -> Self::Future {
271
253
let inner = Arc::clone(&self.0);
272
254
let fut = async move {
273
-
<T as BrowseService>::tree_get_entries(&inner, request)
274
-
.await
255
+
<T as BrowseService>::tree_get_entries(&inner, request).await
275
256
};
276
257
Box::pin(fut)
277
258
}
···
298
279
};
299
280
Box::pin(fut)
300
281
}
301
-
_ => {
302
-
Box::pin(async move {
303
-
let mut response = http::Response::new(empty_body());
304
-
let headers = response.headers_mut();
305
-
headers
306
-
.insert(
307
-
tonic::Status::GRPC_STATUS,
308
-
(tonic::Code::Unimplemented as i32).into(),
309
-
);
310
-
headers
311
-
.insert(
312
-
http::header::CONTENT_TYPE,
313
-
tonic::metadata::GRPC_CONTENT_TYPE,
314
-
);
315
-
Ok(response)
316
-
})
317
-
}
282
+
_ => Box::pin(async move {
283
+
let mut response = http::Response::new(empty_body());
284
+
let headers = response.headers_mut();
285
+
headers.insert(
286
+
tonic::Status::GRPC_STATUS,
287
+
(tonic::Code::Unimplemented as i32).into(),
288
+
);
289
+
headers.insert(
290
+
http::header::CONTENT_TYPE,
291
+
tonic::metadata::GRPC_CONTENT_TYPE,
292
+
);
293
+
Ok(response)
294
+
}),
318
295
}
319
296
}
320
297
}
···
542
519
dead_code,
543
520
missing_docs,
544
521
clippy::wildcard_imports,
545
-
clippy::let_unit_value,
522
+
clippy::let_unit_value
546
523
)]
547
-
use tonic::codegen::*;
548
524
use tonic::codegen::http::Uri;
525
+
use tonic::codegen::*;
549
526
#[derive(Debug, Clone)]
550
527
pub struct LibraryServiceClient<T> {
551
528
inner: tonic::client::Grpc<T>,
···
589
566
<T as tonic::client::GrpcService<tonic::body::BoxBody>>::ResponseBody,
590
567
>,
591
568
>,
592
-
<T as tonic::codegen::Service<
593
-
http::Request<tonic::body::BoxBody>,
594
-
>>::Error: Into<StdError> + std::marker::Send + std::marker::Sync,
569
+
<T as tonic::codegen::Service<http::Request<tonic::body::BoxBody>>>::Error:
570
+
Into<StdError> + std::marker::Send + std::marker::Sync,
595
571
{
596
572
LibraryServiceClient::new(InterceptedService::new(inner, interceptor))
597
573
}
···
629
605
pub async fn get_albums(
630
606
&mut self,
631
607
request: impl tonic::IntoRequest<super::GetAlbumsRequest>,
632
-
) -> std::result::Result<
633
-
tonic::Response<super::GetAlbumsResponse>,
634
-
tonic::Status,
635
-
> {
636
-
self.inner
637
-
.ready()
638
-
.await
639
-
.map_err(|e| {
640
-
tonic::Status::unknown(
641
-
format!("Service was not ready: {}", e.into()),
642
-
)
643
-
})?;
608
+
) -> std::result::Result<tonic::Response<super::GetAlbumsResponse>, tonic::Status> {
609
+
self.inner.ready().await.map_err(|e| {
610
+
tonic::Status::unknown(format!("Service was not ready: {}", e.into()))
611
+
})?;
644
612
let codec = tonic::codec::ProstCodec::default();
645
-
let path = http::uri::PathAndQuery::from_static(
646
-
"/rockbox.v1alpha1.LibraryService/GetAlbums",
647
-
);
613
+
let path =
614
+
http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.LibraryService/GetAlbums");
648
615
let mut req = request.into_request();
649
-
req.extensions_mut()
650
-
.insert(GrpcMethod::new("rockbox.v1alpha1.LibraryService", "GetAlbums"));
616
+
req.extensions_mut().insert(GrpcMethod::new(
617
+
"rockbox.v1alpha1.LibraryService",
618
+
"GetAlbums",
619
+
));
651
620
self.inner.unary(req, path, codec).await
652
621
}
653
622
pub async fn get_artists(
654
623
&mut self,
655
624
request: impl tonic::IntoRequest<super::GetArtistsRequest>,
656
-
) -> std::result::Result<
657
-
tonic::Response<super::GetArtistsResponse>,
658
-
tonic::Status,
659
-
> {
660
-
self.inner
661
-
.ready()
662
-
.await
663
-
.map_err(|e| {
664
-
tonic::Status::unknown(
665
-
format!("Service was not ready: {}", e.into()),
666
-
)
667
-
})?;
625
+
) -> std::result::Result<tonic::Response<super::GetArtistsResponse>, tonic::Status>
626
+
{
627
+
self.inner.ready().await.map_err(|e| {
628
+
tonic::Status::unknown(format!("Service was not ready: {}", e.into()))
629
+
})?;
668
630
let codec = tonic::codec::ProstCodec::default();
669
-
let path = http::uri::PathAndQuery::from_static(
670
-
"/rockbox.v1alpha1.LibraryService/GetArtists",
671
-
);
631
+
let path =
632
+
http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.LibraryService/GetArtists");
672
633
let mut req = request.into_request();
673
-
req.extensions_mut()
674
-
.insert(
675
-
GrpcMethod::new("rockbox.v1alpha1.LibraryService", "GetArtists"),
676
-
);
634
+
req.extensions_mut().insert(GrpcMethod::new(
635
+
"rockbox.v1alpha1.LibraryService",
636
+
"GetArtists",
637
+
));
677
638
self.inner.unary(req, path, codec).await
678
639
}
679
640
pub async fn get_tracks(
680
641
&mut self,
681
642
request: impl tonic::IntoRequest<super::GetTracksRequest>,
682
-
) -> std::result::Result<
683
-
tonic::Response<super::GetTracksResponse>,
684
-
tonic::Status,
685
-
> {
686
-
self.inner
687
-
.ready()
688
-
.await
689
-
.map_err(|e| {
690
-
tonic::Status::unknown(
691
-
format!("Service was not ready: {}", e.into()),
692
-
)
693
-
})?;
643
+
) -> std::result::Result<tonic::Response<super::GetTracksResponse>, tonic::Status> {
644
+
self.inner.ready().await.map_err(|e| {
645
+
tonic::Status::unknown(format!("Service was not ready: {}", e.into()))
646
+
})?;
694
647
let codec = tonic::codec::ProstCodec::default();
695
-
let path = http::uri::PathAndQuery::from_static(
696
-
"/rockbox.v1alpha1.LibraryService/GetTracks",
697
-
);
648
+
let path =
649
+
http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.LibraryService/GetTracks");
698
650
let mut req = request.into_request();
699
-
req.extensions_mut()
700
-
.insert(GrpcMethod::new("rockbox.v1alpha1.LibraryService", "GetTracks"));
651
+
req.extensions_mut().insert(GrpcMethod::new(
652
+
"rockbox.v1alpha1.LibraryService",
653
+
"GetTracks",
654
+
));
701
655
self.inner.unary(req, path, codec).await
702
656
}
703
657
pub async fn get_album(
704
658
&mut self,
705
659
request: impl tonic::IntoRequest<super::GetAlbumRequest>,
706
-
) -> std::result::Result<
707
-
tonic::Response<super::GetAlbumResponse>,
708
-
tonic::Status,
709
-
> {
710
-
self.inner
711
-
.ready()
712
-
.await
713
-
.map_err(|e| {
714
-
tonic::Status::unknown(
715
-
format!("Service was not ready: {}", e.into()),
716
-
)
717
-
})?;
660
+
) -> std::result::Result<tonic::Response<super::GetAlbumResponse>, tonic::Status> {
661
+
self.inner.ready().await.map_err(|e| {
662
+
tonic::Status::unknown(format!("Service was not ready: {}", e.into()))
663
+
})?;
718
664
let codec = tonic::codec::ProstCodec::default();
719
-
let path = http::uri::PathAndQuery::from_static(
720
-
"/rockbox.v1alpha1.LibraryService/GetAlbum",
721
-
);
665
+
let path =
666
+
http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.LibraryService/GetAlbum");
722
667
let mut req = request.into_request();
723
-
req.extensions_mut()
724
-
.insert(GrpcMethod::new("rockbox.v1alpha1.LibraryService", "GetAlbum"));
668
+
req.extensions_mut().insert(GrpcMethod::new(
669
+
"rockbox.v1alpha1.LibraryService",
670
+
"GetAlbum",
671
+
));
725
672
self.inner.unary(req, path, codec).await
726
673
}
727
674
pub async fn get_artist(
728
675
&mut self,
729
676
request: impl tonic::IntoRequest<super::GetArtistRequest>,
730
-
) -> std::result::Result<
731
-
tonic::Response<super::GetArtistResponse>,
732
-
tonic::Status,
733
-
> {
734
-
self.inner
735
-
.ready()
736
-
.await
737
-
.map_err(|e| {
738
-
tonic::Status::unknown(
739
-
format!("Service was not ready: {}", e.into()),
740
-
)
741
-
})?;
677
+
) -> std::result::Result<tonic::Response<super::GetArtistResponse>, tonic::Status> {
678
+
self.inner.ready().await.map_err(|e| {
679
+
tonic::Status::unknown(format!("Service was not ready: {}", e.into()))
680
+
})?;
742
681
let codec = tonic::codec::ProstCodec::default();
743
-
let path = http::uri::PathAndQuery::from_static(
744
-
"/rockbox.v1alpha1.LibraryService/GetArtist",
745
-
);
682
+
let path =
683
+
http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.LibraryService/GetArtist");
746
684
let mut req = request.into_request();
747
-
req.extensions_mut()
748
-
.insert(GrpcMethod::new("rockbox.v1alpha1.LibraryService", "GetArtist"));
685
+
req.extensions_mut().insert(GrpcMethod::new(
686
+
"rockbox.v1alpha1.LibraryService",
687
+
"GetArtist",
688
+
));
749
689
self.inner.unary(req, path, codec).await
750
690
}
751
691
pub async fn get_track(
752
692
&mut self,
753
693
request: impl tonic::IntoRequest<super::GetTrackRequest>,
754
-
) -> std::result::Result<
755
-
tonic::Response<super::GetTrackResponse>,
756
-
tonic::Status,
757
-
> {
758
-
self.inner
759
-
.ready()
760
-
.await
761
-
.map_err(|e| {
762
-
tonic::Status::unknown(
763
-
format!("Service was not ready: {}", e.into()),
764
-
)
765
-
})?;
694
+
) -> std::result::Result<tonic::Response<super::GetTrackResponse>, tonic::Status> {
695
+
self.inner.ready().await.map_err(|e| {
696
+
tonic::Status::unknown(format!("Service was not ready: {}", e.into()))
697
+
})?;
766
698
let codec = tonic::codec::ProstCodec::default();
767
-
let path = http::uri::PathAndQuery::from_static(
768
-
"/rockbox.v1alpha1.LibraryService/GetTrack",
769
-
);
699
+
let path =
700
+
http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.LibraryService/GetTrack");
770
701
let mut req = request.into_request();
771
-
req.extensions_mut()
772
-
.insert(GrpcMethod::new("rockbox.v1alpha1.LibraryService", "GetTrack"));
702
+
req.extensions_mut().insert(GrpcMethod::new(
703
+
"rockbox.v1alpha1.LibraryService",
704
+
"GetTrack",
705
+
));
773
706
self.inner.unary(req, path, codec).await
774
707
}
775
708
pub async fn like_track(
776
709
&mut self,
777
710
request: impl tonic::IntoRequest<super::LikeTrackRequest>,
778
-
) -> std::result::Result<
779
-
tonic::Response<super::LikeTrackResponse>,
780
-
tonic::Status,
781
-
> {
782
-
self.inner
783
-
.ready()
784
-
.await
785
-
.map_err(|e| {
786
-
tonic::Status::unknown(
787
-
format!("Service was not ready: {}", e.into()),
788
-
)
789
-
})?;
711
+
) -> std::result::Result<tonic::Response<super::LikeTrackResponse>, tonic::Status> {
712
+
self.inner.ready().await.map_err(|e| {
713
+
tonic::Status::unknown(format!("Service was not ready: {}", e.into()))
714
+
})?;
790
715
let codec = tonic::codec::ProstCodec::default();
791
-
let path = http::uri::PathAndQuery::from_static(
792
-
"/rockbox.v1alpha1.LibraryService/LikeTrack",
793
-
);
716
+
let path =
717
+
http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.LibraryService/LikeTrack");
794
718
let mut req = request.into_request();
795
-
req.extensions_mut()
796
-
.insert(GrpcMethod::new("rockbox.v1alpha1.LibraryService", "LikeTrack"));
719
+
req.extensions_mut().insert(GrpcMethod::new(
720
+
"rockbox.v1alpha1.LibraryService",
721
+
"LikeTrack",
722
+
));
797
723
self.inner.unary(req, path, codec).await
798
724
}
799
725
pub async fn unlike_track(
800
726
&mut self,
801
727
request: impl tonic::IntoRequest<super::UnlikeTrackRequest>,
802
-
) -> std::result::Result<
803
-
tonic::Response<super::UnlikeTrackResponse>,
804
-
tonic::Status,
805
-
> {
806
-
self.inner
807
-
.ready()
808
-
.await
809
-
.map_err(|e| {
810
-
tonic::Status::unknown(
811
-
format!("Service was not ready: {}", e.into()),
812
-
)
813
-
})?;
728
+
) -> std::result::Result<tonic::Response<super::UnlikeTrackResponse>, tonic::Status>
729
+
{
730
+
self.inner.ready().await.map_err(|e| {
731
+
tonic::Status::unknown(format!("Service was not ready: {}", e.into()))
732
+
})?;
814
733
let codec = tonic::codec::ProstCodec::default();
815
734
let path = http::uri::PathAndQuery::from_static(
816
735
"/rockbox.v1alpha1.LibraryService/UnlikeTrack",
817
736
);
818
737
let mut req = request.into_request();
819
-
req.extensions_mut()
820
-
.insert(
821
-
GrpcMethod::new("rockbox.v1alpha1.LibraryService", "UnlikeTrack"),
822
-
);
738
+
req.extensions_mut().insert(GrpcMethod::new(
739
+
"rockbox.v1alpha1.LibraryService",
740
+
"UnlikeTrack",
741
+
));
823
742
self.inner.unary(req, path, codec).await
824
743
}
825
744
pub async fn like_album(
826
745
&mut self,
827
746
request: impl tonic::IntoRequest<super::LikeAlbumRequest>,
828
-
) -> std::result::Result<
829
-
tonic::Response<super::LikeAlbumResponse>,
830
-
tonic::Status,
831
-
> {
832
-
self.inner
833
-
.ready()
834
-
.await
835
-
.map_err(|e| {
836
-
tonic::Status::unknown(
837
-
format!("Service was not ready: {}", e.into()),
838
-
)
839
-
})?;
747
+
) -> std::result::Result<tonic::Response<super::LikeAlbumResponse>, tonic::Status> {
748
+
self.inner.ready().await.map_err(|e| {
749
+
tonic::Status::unknown(format!("Service was not ready: {}", e.into()))
750
+
})?;
840
751
let codec = tonic::codec::ProstCodec::default();
841
-
let path = http::uri::PathAndQuery::from_static(
842
-
"/rockbox.v1alpha1.LibraryService/LikeAlbum",
843
-
);
752
+
let path =
753
+
http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.LibraryService/LikeAlbum");
844
754
let mut req = request.into_request();
845
-
req.extensions_mut()
846
-
.insert(GrpcMethod::new("rockbox.v1alpha1.LibraryService", "LikeAlbum"));
755
+
req.extensions_mut().insert(GrpcMethod::new(
756
+
"rockbox.v1alpha1.LibraryService",
757
+
"LikeAlbum",
758
+
));
847
759
self.inner.unary(req, path, codec).await
848
760
}
849
761
pub async fn unlike_album(
850
762
&mut self,
851
763
request: impl tonic::IntoRequest<super::UnlikeAlbumRequest>,
852
-
) -> std::result::Result<
853
-
tonic::Response<super::UnlikeAlbumResponse>,
854
-
tonic::Status,
855
-
> {
856
-
self.inner
857
-
.ready()
858
-
.await
859
-
.map_err(|e| {
860
-
tonic::Status::unknown(
861
-
format!("Service was not ready: {}", e.into()),
862
-
)
863
-
})?;
764
+
) -> std::result::Result<tonic::Response<super::UnlikeAlbumResponse>, tonic::Status>
765
+
{
766
+
self.inner.ready().await.map_err(|e| {
767
+
tonic::Status::unknown(format!("Service was not ready: {}", e.into()))
768
+
})?;
864
769
let codec = tonic::codec::ProstCodec::default();
865
770
let path = http::uri::PathAndQuery::from_static(
866
771
"/rockbox.v1alpha1.LibraryService/UnlikeAlbum",
867
772
);
868
773
let mut req = request.into_request();
869
-
req.extensions_mut()
870
-
.insert(
871
-
GrpcMethod::new("rockbox.v1alpha1.LibraryService", "UnlikeAlbum"),
872
-
);
774
+
req.extensions_mut().insert(GrpcMethod::new(
775
+
"rockbox.v1alpha1.LibraryService",
776
+
"UnlikeAlbum",
777
+
));
873
778
self.inner.unary(req, path, codec).await
874
779
}
875
780
pub async fn get_liked_tracks(
876
781
&mut self,
877
782
request: impl tonic::IntoRequest<super::GetLikedTracksRequest>,
878
-
) -> std::result::Result<
879
-
tonic::Response<super::GetLikedTracksResponse>,
880
-
tonic::Status,
881
-
> {
882
-
self.inner
883
-
.ready()
884
-
.await
885
-
.map_err(|e| {
886
-
tonic::Status::unknown(
887
-
format!("Service was not ready: {}", e.into()),
888
-
)
889
-
})?;
783
+
) -> std::result::Result<tonic::Response<super::GetLikedTracksResponse>, tonic::Status>
784
+
{
785
+
self.inner.ready().await.map_err(|e| {
786
+
tonic::Status::unknown(format!("Service was not ready: {}", e.into()))
787
+
})?;
890
788
let codec = tonic::codec::ProstCodec::default();
891
789
let path = http::uri::PathAndQuery::from_static(
892
790
"/rockbox.v1alpha1.LibraryService/GetLikedTracks",
893
791
);
894
792
let mut req = request.into_request();
895
-
req.extensions_mut()
896
-
.insert(
897
-
GrpcMethod::new("rockbox.v1alpha1.LibraryService", "GetLikedTracks"),
898
-
);
793
+
req.extensions_mut().insert(GrpcMethod::new(
794
+
"rockbox.v1alpha1.LibraryService",
795
+
"GetLikedTracks",
796
+
));
899
797
self.inner.unary(req, path, codec).await
900
798
}
901
799
pub async fn get_liked_albums(
902
800
&mut self,
903
801
request: impl tonic::IntoRequest<super::GetLikedAlbumsRequest>,
904
-
) -> std::result::Result<
905
-
tonic::Response<super::GetLikedAlbumsResponse>,
906
-
tonic::Status,
907
-
> {
908
-
self.inner
909
-
.ready()
910
-
.await
911
-
.map_err(|e| {
912
-
tonic::Status::unknown(
913
-
format!("Service was not ready: {}", e.into()),
914
-
)
915
-
})?;
802
+
) -> std::result::Result<tonic::Response<super::GetLikedAlbumsResponse>, tonic::Status>
803
+
{
804
+
self.inner.ready().await.map_err(|e| {
805
+
tonic::Status::unknown(format!("Service was not ready: {}", e.into()))
806
+
})?;
916
807
let codec = tonic::codec::ProstCodec::default();
917
808
let path = http::uri::PathAndQuery::from_static(
918
809
"/rockbox.v1alpha1.LibraryService/GetLikedAlbums",
919
810
);
920
811
let mut req = request.into_request();
921
-
req.extensions_mut()
922
-
.insert(
923
-
GrpcMethod::new("rockbox.v1alpha1.LibraryService", "GetLikedAlbums"),
924
-
);
812
+
req.extensions_mut().insert(GrpcMethod::new(
813
+
"rockbox.v1alpha1.LibraryService",
814
+
"GetLikedAlbums",
815
+
));
925
816
self.inner.unary(req, path, codec).await
926
817
}
927
818
pub async fn scan_library(
928
819
&mut self,
929
820
request: impl tonic::IntoRequest<super::ScanLibraryRequest>,
930
-
) -> std::result::Result<
931
-
tonic::Response<super::ScanLibraryResponse>,
932
-
tonic::Status,
933
-
> {
934
-
self.inner
935
-
.ready()
936
-
.await
937
-
.map_err(|e| {
938
-
tonic::Status::unknown(
939
-
format!("Service was not ready: {}", e.into()),
940
-
)
941
-
})?;
821
+
) -> std::result::Result<tonic::Response<super::ScanLibraryResponse>, tonic::Status>
822
+
{
823
+
self.inner.ready().await.map_err(|e| {
824
+
tonic::Status::unknown(format!("Service was not ready: {}", e.into()))
825
+
})?;
942
826
let codec = tonic::codec::ProstCodec::default();
943
827
let path = http::uri::PathAndQuery::from_static(
944
828
"/rockbox.v1alpha1.LibraryService/ScanLibrary",
945
829
);
946
830
let mut req = request.into_request();
947
-
req.extensions_mut()
948
-
.insert(
949
-
GrpcMethod::new("rockbox.v1alpha1.LibraryService", "ScanLibrary"),
950
-
);
831
+
req.extensions_mut().insert(GrpcMethod::new(
832
+
"rockbox.v1alpha1.LibraryService",
833
+
"ScanLibrary",
834
+
));
951
835
self.inner.unary(req, path, codec).await
952
836
}
953
837
pub async fn search(
954
838
&mut self,
955
839
request: impl tonic::IntoRequest<super::SearchRequest>,
956
840
) -> std::result::Result<tonic::Response<super::SearchResponse>, tonic::Status> {
957
-
self.inner
958
-
.ready()
959
-
.await
960
-
.map_err(|e| {
961
-
tonic::Status::unknown(
962
-
format!("Service was not ready: {}", e.into()),
963
-
)
964
-
})?;
841
+
self.inner.ready().await.map_err(|e| {
842
+
tonic::Status::unknown(format!("Service was not ready: {}", e.into()))
843
+
})?;
965
844
let codec = tonic::codec::ProstCodec::default();
966
-
let path = http::uri::PathAndQuery::from_static(
967
-
"/rockbox.v1alpha1.LibraryService/Search",
968
-
);
845
+
let path =
846
+
http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.LibraryService/Search");
969
847
let mut req = request.into_request();
970
848
req.extensions_mut()
971
849
.insert(GrpcMethod::new("rockbox.v1alpha1.LibraryService", "Search"));
···
980
858
dead_code,
981
859
missing_docs,
982
860
clippy::wildcard_imports,
983
-
clippy::let_unit_value,
861
+
clippy::let_unit_value
984
862
)]
985
863
use tonic::codegen::*;
986
864
/// Generated trait containing gRPC methods that should be implemented for use with LibraryServiceServer.
···
989
867
async fn get_albums(
990
868
&self,
991
869
request: tonic::Request<super::GetAlbumsRequest>,
992
-
) -> std::result::Result<
993
-
tonic::Response<super::GetAlbumsResponse>,
994
-
tonic::Status,
995
-
>;
870
+
) -> std::result::Result<tonic::Response<super::GetAlbumsResponse>, tonic::Status>;
996
871
async fn get_artists(
997
872
&self,
998
873
request: tonic::Request<super::GetArtistsRequest>,
999
-
) -> std::result::Result<
1000
-
tonic::Response<super::GetArtistsResponse>,
1001
-
tonic::Status,
1002
-
>;
874
+
) -> std::result::Result<tonic::Response<super::GetArtistsResponse>, tonic::Status>;
1003
875
async fn get_tracks(
1004
876
&self,
1005
877
request: tonic::Request<super::GetTracksRequest>,
1006
-
) -> std::result::Result<
1007
-
tonic::Response<super::GetTracksResponse>,
1008
-
tonic::Status,
1009
-
>;
878
+
) -> std::result::Result<tonic::Response<super::GetTracksResponse>, tonic::Status>;
1010
879
async fn get_album(
1011
880
&self,
1012
881
request: tonic::Request<super::GetAlbumRequest>,
1013
-
) -> std::result::Result<
1014
-
tonic::Response<super::GetAlbumResponse>,
1015
-
tonic::Status,
1016
-
>;
882
+
) -> std::result::Result<tonic::Response<super::GetAlbumResponse>, tonic::Status>;
1017
883
async fn get_artist(
1018
884
&self,
1019
885
request: tonic::Request<super::GetArtistRequest>,
1020
-
) -> std::result::Result<
1021
-
tonic::Response<super::GetArtistResponse>,
1022
-
tonic::Status,
1023
-
>;
886
+
) -> std::result::Result<tonic::Response<super::GetArtistResponse>, tonic::Status>;
1024
887
async fn get_track(
1025
888
&self,
1026
889
request: tonic::Request<super::GetTrackRequest>,
1027
-
) -> std::result::Result<
1028
-
tonic::Response<super::GetTrackResponse>,
1029
-
tonic::Status,
1030
-
>;
890
+
) -> std::result::Result<tonic::Response<super::GetTrackResponse>, tonic::Status>;
1031
891
async fn like_track(
1032
892
&self,
1033
893
request: tonic::Request<super::LikeTrackRequest>,
1034
-
) -> std::result::Result<
1035
-
tonic::Response<super::LikeTrackResponse>,
1036
-
tonic::Status,
1037
-
>;
894
+
) -> std::result::Result<tonic::Response<super::LikeTrackResponse>, tonic::Status>;
1038
895
async fn unlike_track(
1039
896
&self,
1040
897
request: tonic::Request<super::UnlikeTrackRequest>,
1041
-
) -> std::result::Result<
1042
-
tonic::Response<super::UnlikeTrackResponse>,
1043
-
tonic::Status,
1044
-
>;
898
+
) -> std::result::Result<tonic::Response<super::UnlikeTrackResponse>, tonic::Status>;
1045
899
async fn like_album(
1046
900
&self,
1047
901
request: tonic::Request<super::LikeAlbumRequest>,
1048
-
) -> std::result::Result<
1049
-
tonic::Response<super::LikeAlbumResponse>,
1050
-
tonic::Status,
1051
-
>;
902
+
) -> std::result::Result<tonic::Response<super::LikeAlbumResponse>, tonic::Status>;
1052
903
async fn unlike_album(
1053
904
&self,
1054
905
request: tonic::Request<super::UnlikeAlbumRequest>,
1055
-
) -> std::result::Result<
1056
-
tonic::Response<super::UnlikeAlbumResponse>,
1057
-
tonic::Status,
1058
-
>;
906
+
) -> std::result::Result<tonic::Response<super::UnlikeAlbumResponse>, tonic::Status>;
1059
907
async fn get_liked_tracks(
1060
908
&self,
1061
909
request: tonic::Request<super::GetLikedTracksRequest>,
1062
-
) -> std::result::Result<
1063
-
tonic::Response<super::GetLikedTracksResponse>,
1064
-
tonic::Status,
1065
-
>;
910
+
) -> std::result::Result<tonic::Response<super::GetLikedTracksResponse>, tonic::Status>;
1066
911
async fn get_liked_albums(
1067
912
&self,
1068
913
request: tonic::Request<super::GetLikedAlbumsRequest>,
1069
-
) -> std::result::Result<
1070
-
tonic::Response<super::GetLikedAlbumsResponse>,
1071
-
tonic::Status,
1072
-
>;
914
+
) -> std::result::Result<tonic::Response<super::GetLikedAlbumsResponse>, tonic::Status>;
1073
915
async fn scan_library(
1074
916
&self,
1075
917
request: tonic::Request<super::ScanLibraryRequest>,
1076
-
) -> std::result::Result<
1077
-
tonic::Response<super::ScanLibraryResponse>,
1078
-
tonic::Status,
1079
-
>;
918
+
) -> std::result::Result<tonic::Response<super::ScanLibraryResponse>, tonic::Status>;
1080
919
async fn search(
1081
920
&self,
1082
921
request: tonic::Request<super::SearchRequest>,
···
1103
942
max_encoding_message_size: None,
1104
943
}
1105
944
}
1106
-
pub fn with_interceptor<F>(
1107
-
inner: T,
1108
-
interceptor: F,
1109
-
) -> InterceptedService<Self, F>
945
+
pub fn with_interceptor<F>(inner: T, interceptor: F) -> InterceptedService<Self, F>
1110
946
where
1111
947
F: tonic::service::Interceptor,
1112
948
{
···
1161
997
"/rockbox.v1alpha1.LibraryService/GetAlbums" => {
1162
998
#[allow(non_camel_case_types)]
1163
999
struct GetAlbumsSvc<T: LibraryService>(pub Arc<T>);
1164
-
impl<
1165
-
T: LibraryService,
1166
-
> tonic::server::UnaryService<super::GetAlbumsRequest>
1167
-
for GetAlbumsSvc<T> {
1000
+
impl<T: LibraryService> tonic::server::UnaryService<super::GetAlbumsRequest> for GetAlbumsSvc<T> {
1168
1001
type Response = super::GetAlbumsResponse;
1169
-
type Future = BoxFuture<
1170
-
tonic::Response<Self::Response>,
1171
-
tonic::Status,
1172
-
>;
1002
+
type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
1173
1003
fn call(
1174
1004
&mut self,
1175
1005
request: tonic::Request<super::GetAlbumsRequest>,
···
1206
1036
"/rockbox.v1alpha1.LibraryService/GetArtists" => {
1207
1037
#[allow(non_camel_case_types)]
1208
1038
struct GetArtistsSvc<T: LibraryService>(pub Arc<T>);
1209
-
impl<
1210
-
T: LibraryService,
1211
-
> tonic::server::UnaryService<super::GetArtistsRequest>
1212
-
for GetArtistsSvc<T> {
1039
+
impl<T: LibraryService> tonic::server::UnaryService<super::GetArtistsRequest> for GetArtistsSvc<T> {
1213
1040
type Response = super::GetArtistsResponse;
1214
-
type Future = BoxFuture<
1215
-
tonic::Response<Self::Response>,
1216
-
tonic::Status,
1217
-
>;
1041
+
type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
1218
1042
fn call(
1219
1043
&mut self,
1220
1044
request: tonic::Request<super::GetArtistsRequest>,
···
1251
1075
"/rockbox.v1alpha1.LibraryService/GetTracks" => {
1252
1076
#[allow(non_camel_case_types)]
1253
1077
struct GetTracksSvc<T: LibraryService>(pub Arc<T>);
1254
-
impl<
1255
-
T: LibraryService,
1256
-
> tonic::server::UnaryService<super::GetTracksRequest>
1257
-
for GetTracksSvc<T> {
1078
+
impl<T: LibraryService> tonic::server::UnaryService<super::GetTracksRequest> for GetTracksSvc<T> {
1258
1079
type Response = super::GetTracksResponse;
1259
-
type Future = BoxFuture<
1260
-
tonic::Response<Self::Response>,
1261
-
tonic::Status,
1262
-
>;
1080
+
type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
1263
1081
fn call(
1264
1082
&mut self,
1265
1083
request: tonic::Request<super::GetTracksRequest>,
···
1296
1114
"/rockbox.v1alpha1.LibraryService/GetAlbum" => {
1297
1115
#[allow(non_camel_case_types)]
1298
1116
struct GetAlbumSvc<T: LibraryService>(pub Arc<T>);
1299
-
impl<
1300
-
T: LibraryService,
1301
-
> tonic::server::UnaryService<super::GetAlbumRequest>
1302
-
for GetAlbumSvc<T> {
1117
+
impl<T: LibraryService> tonic::server::UnaryService<super::GetAlbumRequest> for GetAlbumSvc<T> {
1303
1118
type Response = super::GetAlbumResponse;
1304
-
type Future = BoxFuture<
1305
-
tonic::Response<Self::Response>,
1306
-
tonic::Status,
1307
-
>;
1119
+
type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
1308
1120
fn call(
1309
1121
&mut self,
1310
1122
request: tonic::Request<super::GetAlbumRequest>,
···
1341
1153
"/rockbox.v1alpha1.LibraryService/GetArtist" => {
1342
1154
#[allow(non_camel_case_types)]
1343
1155
struct GetArtistSvc<T: LibraryService>(pub Arc<T>);
1344
-
impl<
1345
-
T: LibraryService,
1346
-
> tonic::server::UnaryService<super::GetArtistRequest>
1347
-
for GetArtistSvc<T> {
1156
+
impl<T: LibraryService> tonic::server::UnaryService<super::GetArtistRequest> for GetArtistSvc<T> {
1348
1157
type Response = super::GetArtistResponse;
1349
-
type Future = BoxFuture<
1350
-
tonic::Response<Self::Response>,
1351
-
tonic::Status,
1352
-
>;
1158
+
type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
1353
1159
fn call(
1354
1160
&mut self,
1355
1161
request: tonic::Request<super::GetArtistRequest>,
···
1386
1192
"/rockbox.v1alpha1.LibraryService/GetTrack" => {
1387
1193
#[allow(non_camel_case_types)]
1388
1194
struct GetTrackSvc<T: LibraryService>(pub Arc<T>);
1389
-
impl<
1390
-
T: LibraryService,
1391
-
> tonic::server::UnaryService<super::GetTrackRequest>
1392
-
for GetTrackSvc<T> {
1195
+
impl<T: LibraryService> tonic::server::UnaryService<super::GetTrackRequest> for GetTrackSvc<T> {
1393
1196
type Response = super::GetTrackResponse;
1394
-
type Future = BoxFuture<
1395
-
tonic::Response<Self::Response>,
1396
-
tonic::Status,
1397
-
>;
1197
+
type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
1398
1198
fn call(
1399
1199
&mut self,
1400
1200
request: tonic::Request<super::GetTrackRequest>,
···
1431
1231
"/rockbox.v1alpha1.LibraryService/LikeTrack" => {
1432
1232
#[allow(non_camel_case_types)]
1433
1233
struct LikeTrackSvc<T: LibraryService>(pub Arc<T>);
1434
-
impl<
1435
-
T: LibraryService,
1436
-
> tonic::server::UnaryService<super::LikeTrackRequest>
1437
-
for LikeTrackSvc<T> {
1234
+
impl<T: LibraryService> tonic::server::UnaryService<super::LikeTrackRequest> for LikeTrackSvc<T> {
1438
1235
type Response = super::LikeTrackResponse;
1439
-
type Future = BoxFuture<
1440
-
tonic::Response<Self::Response>,
1441
-
tonic::Status,
1442
-
>;
1236
+
type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
1443
1237
fn call(
1444
1238
&mut self,
1445
1239
request: tonic::Request<super::LikeTrackRequest>,
···
1476
1270
"/rockbox.v1alpha1.LibraryService/UnlikeTrack" => {
1477
1271
#[allow(non_camel_case_types)]
1478
1272
struct UnlikeTrackSvc<T: LibraryService>(pub Arc<T>);
1479
-
impl<
1480
-
T: LibraryService,
1481
-
> tonic::server::UnaryService<super::UnlikeTrackRequest>
1482
-
for UnlikeTrackSvc<T> {
1273
+
impl<T: LibraryService> tonic::server::UnaryService<super::UnlikeTrackRequest>
1274
+
for UnlikeTrackSvc<T>
1275
+
{
1483
1276
type Response = super::UnlikeTrackResponse;
1484
-
type Future = BoxFuture<
1485
-
tonic::Response<Self::Response>,
1486
-
tonic::Status,
1487
-
>;
1277
+
type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
1488
1278
fn call(
1489
1279
&mut self,
1490
1280
request: tonic::Request<super::UnlikeTrackRequest>,
···
1521
1311
"/rockbox.v1alpha1.LibraryService/LikeAlbum" => {
1522
1312
#[allow(non_camel_case_types)]
1523
1313
struct LikeAlbumSvc<T: LibraryService>(pub Arc<T>);
1524
-
impl<
1525
-
T: LibraryService,
1526
-
> tonic::server::UnaryService<super::LikeAlbumRequest>
1527
-
for LikeAlbumSvc<T> {
1314
+
impl<T: LibraryService> tonic::server::UnaryService<super::LikeAlbumRequest> for LikeAlbumSvc<T> {
1528
1315
type Response = super::LikeAlbumResponse;
1529
-
type Future = BoxFuture<
1530
-
tonic::Response<Self::Response>,
1531
-
tonic::Status,
1532
-
>;
1316
+
type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
1533
1317
fn call(
1534
1318
&mut self,
1535
1319
request: tonic::Request<super::LikeAlbumRequest>,
···
1566
1350
"/rockbox.v1alpha1.LibraryService/UnlikeAlbum" => {
1567
1351
#[allow(non_camel_case_types)]
1568
1352
struct UnlikeAlbumSvc<T: LibraryService>(pub Arc<T>);
1569
-
impl<
1570
-
T: LibraryService,
1571
-
> tonic::server::UnaryService<super::UnlikeAlbumRequest>
1572
-
for UnlikeAlbumSvc<T> {
1353
+
impl<T: LibraryService> tonic::server::UnaryService<super::UnlikeAlbumRequest>
1354
+
for UnlikeAlbumSvc<T>
1355
+
{
1573
1356
type Response = super::UnlikeAlbumResponse;
1574
-
type Future = BoxFuture<
1575
-
tonic::Response<Self::Response>,
1576
-
tonic::Status,
1577
-
>;
1357
+
type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
1578
1358
fn call(
1579
1359
&mut self,
1580
1360
request: tonic::Request<super::UnlikeAlbumRequest>,
···
1611
1391
"/rockbox.v1alpha1.LibraryService/GetLikedTracks" => {
1612
1392
#[allow(non_camel_case_types)]
1613
1393
struct GetLikedTracksSvc<T: LibraryService>(pub Arc<T>);
1614
-
impl<
1615
-
T: LibraryService,
1616
-
> tonic::server::UnaryService<super::GetLikedTracksRequest>
1617
-
for GetLikedTracksSvc<T> {
1394
+
impl<T: LibraryService>
1395
+
tonic::server::UnaryService<super::GetLikedTracksRequest>
1396
+
for GetLikedTracksSvc<T>
1397
+
{
1618
1398
type Response = super::GetLikedTracksResponse;
1619
-
type Future = BoxFuture<
1620
-
tonic::Response<Self::Response>,
1621
-
tonic::Status,
1622
-
>;
1399
+
type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
1623
1400
fn call(
1624
1401
&mut self,
1625
1402
request: tonic::Request<super::GetLikedTracksRequest>,
1626
1403
) -> Self::Future {
1627
1404
let inner = Arc::clone(&self.0);
1628
1405
let fut = async move {
1629
-
<T as LibraryService>::get_liked_tracks(&inner, request)
1630
-
.await
1406
+
<T as LibraryService>::get_liked_tracks(&inner, request).await
1631
1407
};
1632
1408
Box::pin(fut)
1633
1409
}
···
1657
1433
"/rockbox.v1alpha1.LibraryService/GetLikedAlbums" => {
1658
1434
#[allow(non_camel_case_types)]
1659
1435
struct GetLikedAlbumsSvc<T: LibraryService>(pub Arc<T>);
1660
-
impl<
1661
-
T: LibraryService,
1662
-
> tonic::server::UnaryService<super::GetLikedAlbumsRequest>
1663
-
for GetLikedAlbumsSvc<T> {
1436
+
impl<T: LibraryService>
1437
+
tonic::server::UnaryService<super::GetLikedAlbumsRequest>
1438
+
for GetLikedAlbumsSvc<T>
1439
+
{
1664
1440
type Response = super::GetLikedAlbumsResponse;
1665
-
type Future = BoxFuture<
1666
-
tonic::Response<Self::Response>,
1667
-
tonic::Status,
1668
-
>;
1441
+
type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
1669
1442
fn call(
1670
1443
&mut self,
1671
1444
request: tonic::Request<super::GetLikedAlbumsRequest>,
1672
1445
) -> Self::Future {
1673
1446
let inner = Arc::clone(&self.0);
1674
1447
let fut = async move {
1675
-
<T as LibraryService>::get_liked_albums(&inner, request)
1676
-
.await
1448
+
<T as LibraryService>::get_liked_albums(&inner, request).await
1677
1449
};
1678
1450
Box::pin(fut)
1679
1451
}
···
1703
1475
"/rockbox.v1alpha1.LibraryService/ScanLibrary" => {
1704
1476
#[allow(non_camel_case_types)]
1705
1477
struct ScanLibrarySvc<T: LibraryService>(pub Arc<T>);
1706
-
impl<
1707
-
T: LibraryService,
1708
-
> tonic::server::UnaryService<super::ScanLibraryRequest>
1709
-
for ScanLibrarySvc<T> {
1478
+
impl<T: LibraryService> tonic::server::UnaryService<super::ScanLibraryRequest>
1479
+
for ScanLibrarySvc<T>
1480
+
{
1710
1481
type Response = super::ScanLibraryResponse;
1711
-
type Future = BoxFuture<
1712
-
tonic::Response<Self::Response>,
1713
-
tonic::Status,
1714
-
>;
1482
+
type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
1715
1483
fn call(
1716
1484
&mut self,
1717
1485
request: tonic::Request<super::ScanLibraryRequest>,
···
1748
1516
"/rockbox.v1alpha1.LibraryService/Search" => {
1749
1517
#[allow(non_camel_case_types)]
1750
1518
struct SearchSvc<T: LibraryService>(pub Arc<T>);
1751
-
impl<
1752
-
T: LibraryService,
1753
-
> tonic::server::UnaryService<super::SearchRequest>
1754
-
for SearchSvc<T> {
1519
+
impl<T: LibraryService> tonic::server::UnaryService<super::SearchRequest> for SearchSvc<T> {
1755
1520
type Response = super::SearchResponse;
1756
-
type Future = BoxFuture<
1757
-
tonic::Response<Self::Response>,
1758
-
tonic::Status,
1759
-
>;
1521
+
type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
1760
1522
fn call(
1761
1523
&mut self,
1762
1524
request: tonic::Request<super::SearchRequest>,
1763
1525
) -> Self::Future {
1764
1526
let inner = Arc::clone(&self.0);
1765
-
let fut = async move {
1766
-
<T as LibraryService>::search(&inner, request).await
1767
-
};
1527
+
let fut =
1528
+
async move { <T as LibraryService>::search(&inner, request).await };
1768
1529
Box::pin(fut)
1769
1530
}
1770
1531
}
···
1790
1551
};
1791
1552
Box::pin(fut)
1792
1553
}
1793
-
_ => {
1794
-
Box::pin(async move {
1795
-
let mut response = http::Response::new(empty_body());
1796
-
let headers = response.headers_mut();
1797
-
headers
1798
-
.insert(
1799
-
tonic::Status::GRPC_STATUS,
1800
-
(tonic::Code::Unimplemented as i32).into(),
1801
-
);
1802
-
headers
1803
-
.insert(
1804
-
http::header::CONTENT_TYPE,
1805
-
tonic::metadata::GRPC_CONTENT_TYPE,
1806
-
);
1807
-
Ok(response)
1808
-
})
1809
-
}
1554
+
_ => Box::pin(async move {
1555
+
let mut response = http::Response::new(empty_body());
1556
+
let headers = response.headers_mut();
1557
+
headers.insert(
1558
+
tonic::Status::GRPC_STATUS,
1559
+
(tonic::Code::Unimplemented as i32).into(),
1560
+
);
1561
+
headers.insert(
1562
+
http::header::CONTENT_TYPE,
1563
+
tonic::metadata::GRPC_CONTENT_TYPE,
1564
+
);
1565
+
Ok(response)
1566
+
}),
1810
1567
}
1811
1568
}
1812
1569
}
···
1835
1592
dead_code,
1836
1593
missing_docs,
1837
1594
clippy::wildcard_imports,
1838
-
clippy::let_unit_value,
1595
+
clippy::let_unit_value
1839
1596
)]
1840
-
use tonic::codegen::*;
1841
1597
use tonic::codegen::http::Uri;
1598
+
use tonic::codegen::*;
1842
1599
#[derive(Debug, Clone)]
1843
1600
pub struct MetadataServiceClient<T> {
1844
1601
inner: tonic::client::Grpc<T>,
···
1882
1639
<T as tonic::client::GrpcService<tonic::body::BoxBody>>::ResponseBody,
1883
1640
>,
1884
1641
>,
1885
-
<T as tonic::codegen::Service<
1886
-
http::Request<tonic::body::BoxBody>,
1887
-
>>::Error: Into<StdError> + std::marker::Send + std::marker::Sync,
1642
+
<T as tonic::codegen::Service<http::Request<tonic::body::BoxBody>>>::Error:
1643
+
Into<StdError> + std::marker::Send + std::marker::Sync,
1888
1644
{
1889
1645
MetadataServiceClient::new(InterceptedService::new(inner, interceptor))
1890
1646
}
···
1928
1684
dead_code,
1929
1685
missing_docs,
1930
1686
clippy::wildcard_imports,
1931
-
clippy::let_unit_value,
1687
+
clippy::let_unit_value
1932
1688
)]
1933
1689
use tonic::codegen::*;
1934
1690
/// Generated trait containing gRPC methods that should be implemented for use with MetadataServiceServer.
···
1955
1711
max_encoding_message_size: None,
1956
1712
}
1957
1713
}
1958
-
pub fn with_interceptor<F>(
1959
-
inner: T,
1960
-
interceptor: F,
1961
-
) -> InterceptedService<Self, F>
1714
+
pub fn with_interceptor<F>(inner: T, interceptor: F) -> InterceptedService<Self, F>
1962
1715
where
1963
1716
F: tonic::service::Interceptor,
1964
1717
{
···
2010
1763
}
2011
1764
fn call(&mut self, req: http::Request<B>) -> Self::Future {
2012
1765
match req.uri().path() {
2013
-
_ => {
2014
-
Box::pin(async move {
2015
-
let mut response = http::Response::new(empty_body());
2016
-
let headers = response.headers_mut();
2017
-
headers
2018
-
.insert(
2019
-
tonic::Status::GRPC_STATUS,
2020
-
(tonic::Code::Unimplemented as i32).into(),
2021
-
);
2022
-
headers
2023
-
.insert(
2024
-
http::header::CONTENT_TYPE,
2025
-
tonic::metadata::GRPC_CONTENT_TYPE,
2026
-
);
2027
-
Ok(response)
2028
-
})
2029
-
}
1766
+
_ => Box::pin(async move {
1767
+
let mut response = http::Response::new(empty_body());
1768
+
let headers = response.headers_mut();
1769
+
headers.insert(
1770
+
tonic::Status::GRPC_STATUS,
1771
+
(tonic::Code::Unimplemented as i32).into(),
1772
+
);
1773
+
headers.insert(
1774
+
http::header::CONTENT_TYPE,
1775
+
tonic::metadata::GRPC_CONTENT_TYPE,
1776
+
);
1777
+
Ok(response)
1778
+
}),
2030
1779
}
2031
1780
}
2032
1781
}
···
2295
2044
dead_code,
2296
2045
missing_docs,
2297
2046
clippy::wildcard_imports,
2298
-
clippy::let_unit_value,
2047
+
clippy::let_unit_value
2299
2048
)]
2300
-
use tonic::codegen::*;
2301
2049
use tonic::codegen::http::Uri;
2050
+
use tonic::codegen::*;
2302
2051
#[derive(Debug, Clone)]
2303
2052
pub struct PlaybackServiceClient<T> {
2304
2053
inner: tonic::client::Grpc<T>,
···
2342
2091
<T as tonic::client::GrpcService<tonic::body::BoxBody>>::ResponseBody,
2343
2092
>,
2344
2093
>,
2345
-
<T as tonic::codegen::Service<
2346
-
http::Request<tonic::body::BoxBody>,
2347
-
>>::Error: Into<StdError> + std::marker::Send + std::marker::Sync,
2094
+
<T as tonic::codegen::Service<http::Request<tonic::body::BoxBody>>>::Error:
2095
+
Into<StdError> + std::marker::Send + std::marker::Sync,
2348
2096
{
2349
2097
PlaybackServiceClient::new(InterceptedService::new(inner, interceptor))
2350
2098
}
···
2383
2131
&mut self,
2384
2132
request: impl tonic::IntoRequest<super::PlayRequest>,
2385
2133
) -> std::result::Result<tonic::Response<super::PlayResponse>, tonic::Status> {
2386
-
self.inner
2387
-
.ready()
2388
-
.await
2389
-
.map_err(|e| {
2390
-
tonic::Status::unknown(
2391
-
format!("Service was not ready: {}", e.into()),
2392
-
)
2393
-
})?;
2134
+
self.inner.ready().await.map_err(|e| {
2135
+
tonic::Status::unknown(format!("Service was not ready: {}", e.into()))
2136
+
})?;
2394
2137
let codec = tonic::codec::ProstCodec::default();
2395
-
let path = http::uri::PathAndQuery::from_static(
2396
-
"/rockbox.v1alpha1.PlaybackService/Play",
2397
-
);
2138
+
let path =
2139
+
http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.PlaybackService/Play");
2398
2140
let mut req = request.into_request();
2399
2141
req.extensions_mut()
2400
2142
.insert(GrpcMethod::new("rockbox.v1alpha1.PlaybackService", "Play"));
···
2404
2146
&mut self,
2405
2147
request: impl tonic::IntoRequest<super::PauseRequest>,
2406
2148
) -> std::result::Result<tonic::Response<super::PauseResponse>, tonic::Status> {
2407
-
self.inner
2408
-
.ready()
2409
-
.await
2410
-
.map_err(|e| {
2411
-
tonic::Status::unknown(
2412
-
format!("Service was not ready: {}", e.into()),
2413
-
)
2414
-
})?;
2149
+
self.inner.ready().await.map_err(|e| {
2150
+
tonic::Status::unknown(format!("Service was not ready: {}", e.into()))
2151
+
})?;
2415
2152
let codec = tonic::codec::ProstCodec::default();
2416
-
let path = http::uri::PathAndQuery::from_static(
2417
-
"/rockbox.v1alpha1.PlaybackService/Pause",
2418
-
);
2153
+
let path =
2154
+
http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.PlaybackService/Pause");
2419
2155
let mut req = request.into_request();
2420
2156
req.extensions_mut()
2421
2157
.insert(GrpcMethod::new("rockbox.v1alpha1.PlaybackService", "Pause"));
···
2425
2161
&mut self,
2426
2162
request: impl tonic::IntoRequest<super::ResumeRequest>,
2427
2163
) -> std::result::Result<tonic::Response<super::ResumeResponse>, tonic::Status> {
2428
-
self.inner
2429
-
.ready()
2430
-
.await
2431
-
.map_err(|e| {
2432
-
tonic::Status::unknown(
2433
-
format!("Service was not ready: {}", e.into()),
2434
-
)
2435
-
})?;
2164
+
self.inner.ready().await.map_err(|e| {
2165
+
tonic::Status::unknown(format!("Service was not ready: {}", e.into()))
2166
+
})?;
2436
2167
let codec = tonic::codec::ProstCodec::default();
2437
-
let path = http::uri::PathAndQuery::from_static(
2438
-
"/rockbox.v1alpha1.PlaybackService/Resume",
2439
-
);
2168
+
let path =
2169
+
http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.PlaybackService/Resume");
2440
2170
let mut req = request.into_request();
2441
-
req.extensions_mut()
2442
-
.insert(GrpcMethod::new("rockbox.v1alpha1.PlaybackService", "Resume"));
2171
+
req.extensions_mut().insert(GrpcMethod::new(
2172
+
"rockbox.v1alpha1.PlaybackService",
2173
+
"Resume",
2174
+
));
2443
2175
self.inner.unary(req, path, codec).await
2444
2176
}
2445
2177
pub async fn next(
2446
2178
&mut self,
2447
2179
request: impl tonic::IntoRequest<super::NextRequest>,
2448
2180
) -> std::result::Result<tonic::Response<super::NextResponse>, tonic::Status> {
2449
-
self.inner
2450
-
.ready()
2451
-
.await
2452
-
.map_err(|e| {
2453
-
tonic::Status::unknown(
2454
-
format!("Service was not ready: {}", e.into()),
2455
-
)
2456
-
})?;
2181
+
self.inner.ready().await.map_err(|e| {
2182
+
tonic::Status::unknown(format!("Service was not ready: {}", e.into()))
2183
+
})?;
2457
2184
let codec = tonic::codec::ProstCodec::default();
2458
-
let path = http::uri::PathAndQuery::from_static(
2459
-
"/rockbox.v1alpha1.PlaybackService/Next",
2460
-
);
2185
+
let path =
2186
+
http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.PlaybackService/Next");
2461
2187
let mut req = request.into_request();
2462
2188
req.extensions_mut()
2463
2189
.insert(GrpcMethod::new("rockbox.v1alpha1.PlaybackService", "Next"));
···
2466
2192
pub async fn previous(
2467
2193
&mut self,
2468
2194
request: impl tonic::IntoRequest<super::PreviousRequest>,
2469
-
) -> std::result::Result<
2470
-
tonic::Response<super::PreviousResponse>,
2471
-
tonic::Status,
2472
-
> {
2473
-
self.inner
2474
-
.ready()
2475
-
.await
2476
-
.map_err(|e| {
2477
-
tonic::Status::unknown(
2478
-
format!("Service was not ready: {}", e.into()),
2479
-
)
2480
-
})?;
2195
+
) -> std::result::Result<tonic::Response<super::PreviousResponse>, tonic::Status> {
2196
+
self.inner.ready().await.map_err(|e| {
2197
+
tonic::Status::unknown(format!("Service was not ready: {}", e.into()))
2198
+
})?;
2481
2199
let codec = tonic::codec::ProstCodec::default();
2482
-
let path = http::uri::PathAndQuery::from_static(
2483
-
"/rockbox.v1alpha1.PlaybackService/Previous",
2484
-
);
2200
+
let path =
2201
+
http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.PlaybackService/Previous");
2485
2202
let mut req = request.into_request();
2486
-
req.extensions_mut()
2487
-
.insert(GrpcMethod::new("rockbox.v1alpha1.PlaybackService", "Previous"));
2203
+
req.extensions_mut().insert(GrpcMethod::new(
2204
+
"rockbox.v1alpha1.PlaybackService",
2205
+
"Previous",
2206
+
));
2488
2207
self.inner.unary(req, path, codec).await
2489
2208
}
2490
2209
pub async fn fast_forward_rewind(
2491
2210
&mut self,
2492
2211
request: impl tonic::IntoRequest<super::FastForwardRewindRequest>,
2493
-
) -> std::result::Result<
2494
-
tonic::Response<super::FastForwardRewindResponse>,
2495
-
tonic::Status,
2496
-
> {
2497
-
self.inner
2498
-
.ready()
2499
-
.await
2500
-
.map_err(|e| {
2501
-
tonic::Status::unknown(
2502
-
format!("Service was not ready: {}", e.into()),
2503
-
)
2504
-
})?;
2212
+
) -> std::result::Result<tonic::Response<super::FastForwardRewindResponse>, tonic::Status>
2213
+
{
2214
+
self.inner.ready().await.map_err(|e| {
2215
+
tonic::Status::unknown(format!("Service was not ready: {}", e.into()))
2216
+
})?;
2505
2217
let codec = tonic::codec::ProstCodec::default();
2506
2218
let path = http::uri::PathAndQuery::from_static(
2507
2219
"/rockbox.v1alpha1.PlaybackService/FastForwardRewind",
2508
2220
);
2509
2221
let mut req = request.into_request();
2510
-
req.extensions_mut()
2511
-
.insert(
2512
-
GrpcMethod::new(
2513
-
"rockbox.v1alpha1.PlaybackService",
2514
-
"FastForwardRewind",
2515
-
),
2516
-
);
2222
+
req.extensions_mut().insert(GrpcMethod::new(
2223
+
"rockbox.v1alpha1.PlaybackService",
2224
+
"FastForwardRewind",
2225
+
));
2517
2226
self.inner.unary(req, path, codec).await
2518
2227
}
2519
2228
pub async fn status(
2520
2229
&mut self,
2521
2230
request: impl tonic::IntoRequest<super::StatusRequest>,
2522
2231
) -> std::result::Result<tonic::Response<super::StatusResponse>, tonic::Status> {
2523
-
self.inner
2524
-
.ready()
2525
-
.await
2526
-
.map_err(|e| {
2527
-
tonic::Status::unknown(
2528
-
format!("Service was not ready: {}", e.into()),
2529
-
)
2530
-
})?;
2232
+
self.inner.ready().await.map_err(|e| {
2233
+
tonic::Status::unknown(format!("Service was not ready: {}", e.into()))
2234
+
})?;
2531
2235
let codec = tonic::codec::ProstCodec::default();
2532
-
let path = http::uri::PathAndQuery::from_static(
2533
-
"/rockbox.v1alpha1.PlaybackService/Status",
2534
-
);
2236
+
let path =
2237
+
http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.PlaybackService/Status");
2535
2238
let mut req = request.into_request();
2536
-
req.extensions_mut()
2537
-
.insert(GrpcMethod::new("rockbox.v1alpha1.PlaybackService", "Status"));
2239
+
req.extensions_mut().insert(GrpcMethod::new(
2240
+
"rockbox.v1alpha1.PlaybackService",
2241
+
"Status",
2242
+
));
2538
2243
self.inner.unary(req, path, codec).await
2539
2244
}
2540
2245
pub async fn current_track(
2541
2246
&mut self,
2542
2247
request: impl tonic::IntoRequest<super::CurrentTrackRequest>,
2543
-
) -> std::result::Result<
2544
-
tonic::Response<super::CurrentTrackResponse>,
2545
-
tonic::Status,
2546
-
> {
2547
-
self.inner
2548
-
.ready()
2549
-
.await
2550
-
.map_err(|e| {
2551
-
tonic::Status::unknown(
2552
-
format!("Service was not ready: {}", e.into()),
2553
-
)
2554
-
})?;
2248
+
) -> std::result::Result<tonic::Response<super::CurrentTrackResponse>, tonic::Status>
2249
+
{
2250
+
self.inner.ready().await.map_err(|e| {
2251
+
tonic::Status::unknown(format!("Service was not ready: {}", e.into()))
2252
+
})?;
2555
2253
let codec = tonic::codec::ProstCodec::default();
2556
2254
let path = http::uri::PathAndQuery::from_static(
2557
2255
"/rockbox.v1alpha1.PlaybackService/CurrentTrack",
2558
2256
);
2559
2257
let mut req = request.into_request();
2560
-
req.extensions_mut()
2561
-
.insert(
2562
-
GrpcMethod::new("rockbox.v1alpha1.PlaybackService", "CurrentTrack"),
2563
-
);
2258
+
req.extensions_mut().insert(GrpcMethod::new(
2259
+
"rockbox.v1alpha1.PlaybackService",
2260
+
"CurrentTrack",
2261
+
));
2564
2262
self.inner.unary(req, path, codec).await
2565
2263
}
2566
2264
pub async fn next_track(
2567
2265
&mut self,
2568
2266
request: impl tonic::IntoRequest<super::NextTrackRequest>,
2569
-
) -> std::result::Result<
2570
-
tonic::Response<super::NextTrackResponse>,
2571
-
tonic::Status,
2572
-
> {
2573
-
self.inner
2574
-
.ready()
2575
-
.await
2576
-
.map_err(|e| {
2577
-
tonic::Status::unknown(
2578
-
format!("Service was not ready: {}", e.into()),
2579
-
)
2580
-
})?;
2267
+
) -> std::result::Result<tonic::Response<super::NextTrackResponse>, tonic::Status> {
2268
+
self.inner.ready().await.map_err(|e| {
2269
+
tonic::Status::unknown(format!("Service was not ready: {}", e.into()))
2270
+
})?;
2581
2271
let codec = tonic::codec::ProstCodec::default();
2582
-
let path = http::uri::PathAndQuery::from_static(
2583
-
"/rockbox.v1alpha1.PlaybackService/NextTrack",
2584
-
);
2272
+
let path =
2273
+
http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.PlaybackService/NextTrack");
2585
2274
let mut req = request.into_request();
2586
-
req.extensions_mut()
2587
-
.insert(
2588
-
GrpcMethod::new("rockbox.v1alpha1.PlaybackService", "NextTrack"),
2589
-
);
2275
+
req.extensions_mut().insert(GrpcMethod::new(
2276
+
"rockbox.v1alpha1.PlaybackService",
2277
+
"NextTrack",
2278
+
));
2590
2279
self.inner.unary(req, path, codec).await
2591
2280
}
2592
2281
pub async fn flush_and_reload_tracks(
2593
2282
&mut self,
2594
2283
request: impl tonic::IntoRequest<super::FlushAndReloadTracksRequest>,
2595
-
) -> std::result::Result<
2596
-
tonic::Response<super::FlushAndReloadTracksResponse>,
2597
-
tonic::Status,
2598
-
> {
2599
-
self.inner
2600
-
.ready()
2601
-
.await
2602
-
.map_err(|e| {
2603
-
tonic::Status::unknown(
2604
-
format!("Service was not ready: {}", e.into()),
2605
-
)
2606
-
})?;
2284
+
) -> std::result::Result<tonic::Response<super::FlushAndReloadTracksResponse>, tonic::Status>
2285
+
{
2286
+
self.inner.ready().await.map_err(|e| {
2287
+
tonic::Status::unknown(format!("Service was not ready: {}", e.into()))
2288
+
})?;
2607
2289
let codec = tonic::codec::ProstCodec::default();
2608
2290
let path = http::uri::PathAndQuery::from_static(
2609
2291
"/rockbox.v1alpha1.PlaybackService/FlushAndReloadTracks",
2610
2292
);
2611
2293
let mut req = request.into_request();
2612
-
req.extensions_mut()
2613
-
.insert(
2614
-
GrpcMethod::new(
2615
-
"rockbox.v1alpha1.PlaybackService",
2616
-
"FlushAndReloadTracks",
2617
-
),
2618
-
);
2294
+
req.extensions_mut().insert(GrpcMethod::new(
2295
+
"rockbox.v1alpha1.PlaybackService",
2296
+
"FlushAndReloadTracks",
2297
+
));
2619
2298
self.inner.unary(req, path, codec).await
2620
2299
}
2621
2300
pub async fn get_file_position(
2622
2301
&mut self,
2623
2302
request: impl tonic::IntoRequest<super::GetFilePositionRequest>,
2624
-
) -> std::result::Result<
2625
-
tonic::Response<super::GetFilePositionResponse>,
2626
-
tonic::Status,
2627
-
> {
2628
-
self.inner
2629
-
.ready()
2630
-
.await
2631
-
.map_err(|e| {
2632
-
tonic::Status::unknown(
2633
-
format!("Service was not ready: {}", e.into()),
2634
-
)
2635
-
})?;
2303
+
) -> std::result::Result<tonic::Response<super::GetFilePositionResponse>, tonic::Status>
2304
+
{
2305
+
self.inner.ready().await.map_err(|e| {
2306
+
tonic::Status::unknown(format!("Service was not ready: {}", e.into()))
2307
+
})?;
2636
2308
let codec = tonic::codec::ProstCodec::default();
2637
2309
let path = http::uri::PathAndQuery::from_static(
2638
2310
"/rockbox.v1alpha1.PlaybackService/GetFilePosition",
2639
2311
);
2640
2312
let mut req = request.into_request();
2641
-
req.extensions_mut()
2642
-
.insert(
2643
-
GrpcMethod::new(
2644
-
"rockbox.v1alpha1.PlaybackService",
2645
-
"GetFilePosition",
2646
-
),
2647
-
);
2313
+
req.extensions_mut().insert(GrpcMethod::new(
2314
+
"rockbox.v1alpha1.PlaybackService",
2315
+
"GetFilePosition",
2316
+
));
2648
2317
self.inner.unary(req, path, codec).await
2649
2318
}
2650
2319
pub async fn hard_stop(
2651
2320
&mut self,
2652
2321
request: impl tonic::IntoRequest<super::HardStopRequest>,
2653
-
) -> std::result::Result<
2654
-
tonic::Response<super::HardStopResponse>,
2655
-
tonic::Status,
2656
-
> {
2657
-
self.inner
2658
-
.ready()
2659
-
.await
2660
-
.map_err(|e| {
2661
-
tonic::Status::unknown(
2662
-
format!("Service was not ready: {}", e.into()),
2663
-
)
2664
-
})?;
2322
+
) -> std::result::Result<tonic::Response<super::HardStopResponse>, tonic::Status> {
2323
+
self.inner.ready().await.map_err(|e| {
2324
+
tonic::Status::unknown(format!("Service was not ready: {}", e.into()))
2325
+
})?;
2665
2326
let codec = tonic::codec::ProstCodec::default();
2666
-
let path = http::uri::PathAndQuery::from_static(
2667
-
"/rockbox.v1alpha1.PlaybackService/HardStop",
2668
-
);
2327
+
let path =
2328
+
http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.PlaybackService/HardStop");
2669
2329
let mut req = request.into_request();
2670
-
req.extensions_mut()
2671
-
.insert(GrpcMethod::new("rockbox.v1alpha1.PlaybackService", "HardStop"));
2330
+
req.extensions_mut().insert(GrpcMethod::new(
2331
+
"rockbox.v1alpha1.PlaybackService",
2332
+
"HardStop",
2333
+
));
2672
2334
self.inner.unary(req, path, codec).await
2673
2335
}
2674
2336
pub async fn play_album(
2675
2337
&mut self,
2676
2338
request: impl tonic::IntoRequest<super::PlayAlbumRequest>,
2677
-
) -> std::result::Result<
2678
-
tonic::Response<super::PlayAlbumResponse>,
2679
-
tonic::Status,
2680
-
> {
2681
-
self.inner
2682
-
.ready()
2683
-
.await
2684
-
.map_err(|e| {
2685
-
tonic::Status::unknown(
2686
-
format!("Service was not ready: {}", e.into()),
2687
-
)
2688
-
})?;
2339
+
) -> std::result::Result<tonic::Response<super::PlayAlbumResponse>, tonic::Status> {
2340
+
self.inner.ready().await.map_err(|e| {
2341
+
tonic::Status::unknown(format!("Service was not ready: {}", e.into()))
2342
+
})?;
2689
2343
let codec = tonic::codec::ProstCodec::default();
2690
-
let path = http::uri::PathAndQuery::from_static(
2691
-
"/rockbox.v1alpha1.PlaybackService/PlayAlbum",
2692
-
);
2344
+
let path =
2345
+
http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.PlaybackService/PlayAlbum");
2693
2346
let mut req = request.into_request();
2694
-
req.extensions_mut()
2695
-
.insert(
2696
-
GrpcMethod::new("rockbox.v1alpha1.PlaybackService", "PlayAlbum"),
2697
-
);
2347
+
req.extensions_mut().insert(GrpcMethod::new(
2348
+
"rockbox.v1alpha1.PlaybackService",
2349
+
"PlayAlbum",
2350
+
));
2698
2351
self.inner.unary(req, path, codec).await
2699
2352
}
2700
2353
pub async fn play_artist_tracks(
2701
2354
&mut self,
2702
2355
request: impl tonic::IntoRequest<super::PlayArtistTracksRequest>,
2703
-
) -> std::result::Result<
2704
-
tonic::Response<super::PlayArtistTracksResponse>,
2705
-
tonic::Status,
2706
-
> {
2707
-
self.inner
2708
-
.ready()
2709
-
.await
2710
-
.map_err(|e| {
2711
-
tonic::Status::unknown(
2712
-
format!("Service was not ready: {}", e.into()),
2713
-
)
2714
-
})?;
2356
+
) -> std::result::Result<tonic::Response<super::PlayArtistTracksResponse>, tonic::Status>
2357
+
{
2358
+
self.inner.ready().await.map_err(|e| {
2359
+
tonic::Status::unknown(format!("Service was not ready: {}", e.into()))
2360
+
})?;
2715
2361
let codec = tonic::codec::ProstCodec::default();
2716
2362
let path = http::uri::PathAndQuery::from_static(
2717
2363
"/rockbox.v1alpha1.PlaybackService/PlayArtistTracks",
2718
2364
);
2719
2365
let mut req = request.into_request();
2720
-
req.extensions_mut()
2721
-
.insert(
2722
-
GrpcMethod::new(
2723
-
"rockbox.v1alpha1.PlaybackService",
2724
-
"PlayArtistTracks",
2725
-
),
2726
-
);
2366
+
req.extensions_mut().insert(GrpcMethod::new(
2367
+
"rockbox.v1alpha1.PlaybackService",
2368
+
"PlayArtistTracks",
2369
+
));
2727
2370
self.inner.unary(req, path, codec).await
2728
2371
}
2729
2372
pub async fn play_playlist(
2730
2373
&mut self,
2731
2374
request: impl tonic::IntoRequest<super::PlayPlaylistRequest>,
2732
-
) -> std::result::Result<
2733
-
tonic::Response<super::PlayPlaylistResponse>,
2734
-
tonic::Status,
2735
-
> {
2736
-
self.inner
2737
-
.ready()
2738
-
.await
2739
-
.map_err(|e| {
2740
-
tonic::Status::unknown(
2741
-
format!("Service was not ready: {}", e.into()),
2742
-
)
2743
-
})?;
2375
+
) -> std::result::Result<tonic::Response<super::PlayPlaylistResponse>, tonic::Status>
2376
+
{
2377
+
self.inner.ready().await.map_err(|e| {
2378
+
tonic::Status::unknown(format!("Service was not ready: {}", e.into()))
2379
+
})?;
2744
2380
let codec = tonic::codec::ProstCodec::default();
2745
2381
let path = http::uri::PathAndQuery::from_static(
2746
2382
"/rockbox.v1alpha1.PlaybackService/PlayPlaylist",
2747
2383
);
2748
2384
let mut req = request.into_request();
2749
-
req.extensions_mut()
2750
-
.insert(
2751
-
GrpcMethod::new("rockbox.v1alpha1.PlaybackService", "PlayPlaylist"),
2752
-
);
2385
+
req.extensions_mut().insert(GrpcMethod::new(
2386
+
"rockbox.v1alpha1.PlaybackService",
2387
+
"PlayPlaylist",
2388
+
));
2753
2389
self.inner.unary(req, path, codec).await
2754
2390
}
2755
2391
pub async fn play_directory(
2756
2392
&mut self,
2757
2393
request: impl tonic::IntoRequest<super::PlayDirectoryRequest>,
2758
-
) -> std::result::Result<
2759
-
tonic::Response<super::PlayDirectoryResponse>,
2760
-
tonic::Status,
2761
-
> {
2762
-
self.inner
2763
-
.ready()
2764
-
.await
2765
-
.map_err(|e| {
2766
-
tonic::Status::unknown(
2767
-
format!("Service was not ready: {}", e.into()),
2768
-
)
2769
-
})?;
2394
+
) -> std::result::Result<tonic::Response<super::PlayDirectoryResponse>, tonic::Status>
2395
+
{
2396
+
self.inner.ready().await.map_err(|e| {
2397
+
tonic::Status::unknown(format!("Service was not ready: {}", e.into()))
2398
+
})?;
2770
2399
let codec = tonic::codec::ProstCodec::default();
2771
2400
let path = http::uri::PathAndQuery::from_static(
2772
2401
"/rockbox.v1alpha1.PlaybackService/PlayDirectory",
2773
2402
);
2774
2403
let mut req = request.into_request();
2775
-
req.extensions_mut()
2776
-
.insert(
2777
-
GrpcMethod::new("rockbox.v1alpha1.PlaybackService", "PlayDirectory"),
2778
-
);
2404
+
req.extensions_mut().insert(GrpcMethod::new(
2405
+
"rockbox.v1alpha1.PlaybackService",
2406
+
"PlayDirectory",
2407
+
));
2779
2408
self.inner.unary(req, path, codec).await
2780
2409
}
2781
2410
pub async fn play_track(
2782
2411
&mut self,
2783
2412
request: impl tonic::IntoRequest<super::PlayTrackRequest>,
2784
-
) -> std::result::Result<
2785
-
tonic::Response<super::PlayTrackResponse>,
2786
-
tonic::Status,
2787
-
> {
2788
-
self.inner
2789
-
.ready()
2790
-
.await
2791
-
.map_err(|e| {
2792
-
tonic::Status::unknown(
2793
-
format!("Service was not ready: {}", e.into()),
2794
-
)
2795
-
})?;
2413
+
) -> std::result::Result<tonic::Response<super::PlayTrackResponse>, tonic::Status> {
2414
+
self.inner.ready().await.map_err(|e| {
2415
+
tonic::Status::unknown(format!("Service was not ready: {}", e.into()))
2416
+
})?;
2796
2417
let codec = tonic::codec::ProstCodec::default();
2797
-
let path = http::uri::PathAndQuery::from_static(
2798
-
"/rockbox.v1alpha1.PlaybackService/PlayTrack",
2799
-
);
2418
+
let path =
2419
+
http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.PlaybackService/PlayTrack");
2800
2420
let mut req = request.into_request();
2801
-
req.extensions_mut()
2802
-
.insert(
2803
-
GrpcMethod::new("rockbox.v1alpha1.PlaybackService", "PlayTrack"),
2804
-
);
2421
+
req.extensions_mut().insert(GrpcMethod::new(
2422
+
"rockbox.v1alpha1.PlaybackService",
2423
+
"PlayTrack",
2424
+
));
2805
2425
self.inner.unary(req, path, codec).await
2806
2426
}
2807
2427
pub async fn play_liked_tracks(
2808
2428
&mut self,
2809
2429
request: impl tonic::IntoRequest<super::PlayLikedTracksRequest>,
2810
-
) -> std::result::Result<
2811
-
tonic::Response<super::PlayLikedTracksResponse>,
2812
-
tonic::Status,
2813
-
> {
2814
-
self.inner
2815
-
.ready()
2816
-
.await
2817
-
.map_err(|e| {
2818
-
tonic::Status::unknown(
2819
-
format!("Service was not ready: {}", e.into()),
2820
-
)
2821
-
})?;
2430
+
) -> std::result::Result<tonic::Response<super::PlayLikedTracksResponse>, tonic::Status>
2431
+
{
2432
+
self.inner.ready().await.map_err(|e| {
2433
+
tonic::Status::unknown(format!("Service was not ready: {}", e.into()))
2434
+
})?;
2822
2435
let codec = tonic::codec::ProstCodec::default();
2823
2436
let path = http::uri::PathAndQuery::from_static(
2824
2437
"/rockbox.v1alpha1.PlaybackService/PlayLikedTracks",
2825
2438
);
2826
2439
let mut req = request.into_request();
2827
-
req.extensions_mut()
2828
-
.insert(
2829
-
GrpcMethod::new(
2830
-
"rockbox.v1alpha1.PlaybackService",
2831
-
"PlayLikedTracks",
2832
-
),
2833
-
);
2440
+
req.extensions_mut().insert(GrpcMethod::new(
2441
+
"rockbox.v1alpha1.PlaybackService",
2442
+
"PlayLikedTracks",
2443
+
));
2834
2444
self.inner.unary(req, path, codec).await
2835
2445
}
2836
2446
pub async fn play_all_tracks(
2837
2447
&mut self,
2838
2448
request: impl tonic::IntoRequest<super::PlayAllTracksRequest>,
2839
-
) -> std::result::Result<
2840
-
tonic::Response<super::PlayAllTracksResponse>,
2841
-
tonic::Status,
2842
-
> {
2843
-
self.inner
2844
-
.ready()
2845
-
.await
2846
-
.map_err(|e| {
2847
-
tonic::Status::unknown(
2848
-
format!("Service was not ready: {}", e.into()),
2849
-
)
2850
-
})?;
2449
+
) -> std::result::Result<tonic::Response<super::PlayAllTracksResponse>, tonic::Status>
2450
+
{
2451
+
self.inner.ready().await.map_err(|e| {
2452
+
tonic::Status::unknown(format!("Service was not ready: {}", e.into()))
2453
+
})?;
2851
2454
let codec = tonic::codec::ProstCodec::default();
2852
2455
let path = http::uri::PathAndQuery::from_static(
2853
2456
"/rockbox.v1alpha1.PlaybackService/PlayAllTracks",
2854
2457
);
2855
2458
let mut req = request.into_request();
2856
-
req.extensions_mut()
2857
-
.insert(
2858
-
GrpcMethod::new("rockbox.v1alpha1.PlaybackService", "PlayAllTracks"),
2859
-
);
2459
+
req.extensions_mut().insert(GrpcMethod::new(
2460
+
"rockbox.v1alpha1.PlaybackService",
2461
+
"PlayAllTracks",
2462
+
));
2860
2463
self.inner.unary(req, path, codec).await
2861
2464
}
2862
2465
pub async fn stream_current_track(
···
2866
2469
tonic::Response<tonic::codec::Streaming<super::CurrentTrackResponse>>,
2867
2470
tonic::Status,
2868
2471
> {
2869
-
self.inner
2870
-
.ready()
2871
-
.await
2872
-
.map_err(|e| {
2873
-
tonic::Status::unknown(
2874
-
format!("Service was not ready: {}", e.into()),
2875
-
)
2876
-
})?;
2472
+
self.inner.ready().await.map_err(|e| {
2473
+
tonic::Status::unknown(format!("Service was not ready: {}", e.into()))
2474
+
})?;
2877
2475
let codec = tonic::codec::ProstCodec::default();
2878
2476
let path = http::uri::PathAndQuery::from_static(
2879
2477
"/rockbox.v1alpha1.PlaybackService/StreamCurrentTrack",
2880
2478
);
2881
2479
let mut req = request.into_request();
2882
-
req.extensions_mut()
2883
-
.insert(
2884
-
GrpcMethod::new(
2885
-
"rockbox.v1alpha1.PlaybackService",
2886
-
"StreamCurrentTrack",
2887
-
),
2888
-
);
2480
+
req.extensions_mut().insert(GrpcMethod::new(
2481
+
"rockbox.v1alpha1.PlaybackService",
2482
+
"StreamCurrentTrack",
2483
+
));
2889
2484
self.inner.server_streaming(req, path, codec).await
2890
2485
}
2891
2486
pub async fn stream_status(
···
2895
2490
tonic::Response<tonic::codec::Streaming<super::StatusResponse>>,
2896
2491
tonic::Status,
2897
2492
> {
2898
-
self.inner
2899
-
.ready()
2900
-
.await
2901
-
.map_err(|e| {
2902
-
tonic::Status::unknown(
2903
-
format!("Service was not ready: {}", e.into()),
2904
-
)
2905
-
})?;
2493
+
self.inner.ready().await.map_err(|e| {
2494
+
tonic::Status::unknown(format!("Service was not ready: {}", e.into()))
2495
+
})?;
2906
2496
let codec = tonic::codec::ProstCodec::default();
2907
2497
let path = http::uri::PathAndQuery::from_static(
2908
2498
"/rockbox.v1alpha1.PlaybackService/StreamStatus",
2909
2499
);
2910
2500
let mut req = request.into_request();
2911
-
req.extensions_mut()
2912
-
.insert(
2913
-
GrpcMethod::new("rockbox.v1alpha1.PlaybackService", "StreamStatus"),
2914
-
);
2501
+
req.extensions_mut().insert(GrpcMethod::new(
2502
+
"rockbox.v1alpha1.PlaybackService",
2503
+
"StreamStatus",
2504
+
));
2915
2505
self.inner.server_streaming(req, path, codec).await
2916
2506
}
2917
2507
pub async fn stream_playlist(
···
2921
2511
tonic::Response<tonic::codec::Streaming<super::PlaylistResponse>>,
2922
2512
tonic::Status,
2923
2513
> {
2924
-
self.inner
2925
-
.ready()
2926
-
.await
2927
-
.map_err(|e| {
2928
-
tonic::Status::unknown(
2929
-
format!("Service was not ready: {}", e.into()),
2930
-
)
2931
-
})?;
2514
+
self.inner.ready().await.map_err(|e| {
2515
+
tonic::Status::unknown(format!("Service was not ready: {}", e.into()))
2516
+
})?;
2932
2517
let codec = tonic::codec::ProstCodec::default();
2933
2518
let path = http::uri::PathAndQuery::from_static(
2934
2519
"/rockbox.v1alpha1.PlaybackService/StreamPlaylist",
2935
2520
);
2936
2521
let mut req = request.into_request();
2937
-
req.extensions_mut()
2938
-
.insert(
2939
-
GrpcMethod::new("rockbox.v1alpha1.PlaybackService", "StreamPlaylist"),
2940
-
);
2522
+
req.extensions_mut().insert(GrpcMethod::new(
2523
+
"rockbox.v1alpha1.PlaybackService",
2524
+
"StreamPlaylist",
2525
+
));
2941
2526
self.inner.server_streaming(req, path, codec).await
2942
2527
}
2943
2528
}
···
2949
2534
dead_code,
2950
2535
missing_docs,
2951
2536
clippy::wildcard_imports,
2952
-
clippy::let_unit_value,
2537
+
clippy::let_unit_value
2953
2538
)]
2954
2539
use tonic::codegen::*;
2955
2540
/// Generated trait containing gRPC methods that should be implemented for use with PlaybackServiceServer.
···
2974
2559
async fn previous(
2975
2560
&self,
2976
2561
request: tonic::Request<super::PreviousRequest>,
2977
-
) -> std::result::Result<
2978
-
tonic::Response<super::PreviousResponse>,
2979
-
tonic::Status,
2980
-
>;
2562
+
) -> std::result::Result<tonic::Response<super::PreviousResponse>, tonic::Status>;
2981
2563
async fn fast_forward_rewind(
2982
2564
&self,
2983
2565
request: tonic::Request<super::FastForwardRewindRequest>,
2984
-
) -> std::result::Result<
2985
-
tonic::Response<super::FastForwardRewindResponse>,
2986
-
tonic::Status,
2987
-
>;
2566
+
) -> std::result::Result<tonic::Response<super::FastForwardRewindResponse>, tonic::Status>;
2988
2567
async fn status(
2989
2568
&self,
2990
2569
request: tonic::Request<super::StatusRequest>,
···
2992
2571
async fn current_track(
2993
2572
&self,
2994
2573
request: tonic::Request<super::CurrentTrackRequest>,
2995
-
) -> std::result::Result<
2996
-
tonic::Response<super::CurrentTrackResponse>,
2997
-
tonic::Status,
2998
-
>;
2574
+
) -> std::result::Result<tonic::Response<super::CurrentTrackResponse>, tonic::Status>;
2999
2575
async fn next_track(
3000
2576
&self,
3001
2577
request: tonic::Request<super::NextTrackRequest>,
3002
-
) -> std::result::Result<
3003
-
tonic::Response<super::NextTrackResponse>,
3004
-
tonic::Status,
3005
-
>;
2578
+
) -> std::result::Result<tonic::Response<super::NextTrackResponse>, tonic::Status>;
3006
2579
async fn flush_and_reload_tracks(
3007
2580
&self,
3008
2581
request: tonic::Request<super::FlushAndReloadTracksRequest>,
3009
-
) -> std::result::Result<
3010
-
tonic::Response<super::FlushAndReloadTracksResponse>,
3011
-
tonic::Status,
3012
-
>;
2582
+
) -> std::result::Result<tonic::Response<super::FlushAndReloadTracksResponse>, tonic::Status>;
3013
2583
async fn get_file_position(
3014
2584
&self,
3015
2585
request: tonic::Request<super::GetFilePositionRequest>,
3016
-
) -> std::result::Result<
3017
-
tonic::Response<super::GetFilePositionResponse>,
3018
-
tonic::Status,
3019
-
>;
2586
+
) -> std::result::Result<tonic::Response<super::GetFilePositionResponse>, tonic::Status>;
3020
2587
async fn hard_stop(
3021
2588
&self,
3022
2589
request: tonic::Request<super::HardStopRequest>,
3023
-
) -> std::result::Result<
3024
-
tonic::Response<super::HardStopResponse>,
3025
-
tonic::Status,
3026
-
>;
2590
+
) -> std::result::Result<tonic::Response<super::HardStopResponse>, tonic::Status>;
3027
2591
async fn play_album(
3028
2592
&self,
3029
2593
request: tonic::Request<super::PlayAlbumRequest>,
3030
-
) -> std::result::Result<
3031
-
tonic::Response<super::PlayAlbumResponse>,
3032
-
tonic::Status,
3033
-
>;
2594
+
) -> std::result::Result<tonic::Response<super::PlayAlbumResponse>, tonic::Status>;
3034
2595
async fn play_artist_tracks(
3035
2596
&self,
3036
2597
request: tonic::Request<super::PlayArtistTracksRequest>,
3037
-
) -> std::result::Result<
3038
-
tonic::Response<super::PlayArtistTracksResponse>,
3039
-
tonic::Status,
3040
-
>;
2598
+
) -> std::result::Result<tonic::Response<super::PlayArtistTracksResponse>, tonic::Status>;
3041
2599
async fn play_playlist(
3042
2600
&self,
3043
2601
request: tonic::Request<super::PlayPlaylistRequest>,
3044
-
) -> std::result::Result<
3045
-
tonic::Response<super::PlayPlaylistResponse>,
3046
-
tonic::Status,
3047
-
>;
2602
+
) -> std::result::Result<tonic::Response<super::PlayPlaylistResponse>, tonic::Status>;
3048
2603
async fn play_directory(
3049
2604
&self,
3050
2605
request: tonic::Request<super::PlayDirectoryRequest>,
3051
-
) -> std::result::Result<
3052
-
tonic::Response<super::PlayDirectoryResponse>,
3053
-
tonic::Status,
3054
-
>;
2606
+
) -> std::result::Result<tonic::Response<super::PlayDirectoryResponse>, tonic::Status>;
3055
2607
async fn play_track(
3056
2608
&self,
3057
2609
request: tonic::Request<super::PlayTrackRequest>,
3058
-
) -> std::result::Result<
3059
-
tonic::Response<super::PlayTrackResponse>,
3060
-
tonic::Status,
3061
-
>;
2610
+
) -> std::result::Result<tonic::Response<super::PlayTrackResponse>, tonic::Status>;
3062
2611
async fn play_liked_tracks(
3063
2612
&self,
3064
2613
request: tonic::Request<super::PlayLikedTracksRequest>,
3065
-
) -> std::result::Result<
3066
-
tonic::Response<super::PlayLikedTracksResponse>,
3067
-
tonic::Status,
3068
-
>;
2614
+
) -> std::result::Result<tonic::Response<super::PlayLikedTracksResponse>, tonic::Status>;
3069
2615
async fn play_all_tracks(
3070
2616
&self,
3071
2617
request: tonic::Request<super::PlayAllTracksRequest>,
3072
-
) -> std::result::Result<
3073
-
tonic::Response<super::PlayAllTracksResponse>,
3074
-
tonic::Status,
3075
-
>;
2618
+
) -> std::result::Result<tonic::Response<super::PlayAllTracksResponse>, tonic::Status>;
3076
2619
/// Server streaming response type for the StreamCurrentTrack method.
3077
2620
type StreamCurrentTrackStream: tonic::codegen::tokio_stream::Stream<
3078
2621
Item = std::result::Result<super::CurrentTrackResponse, tonic::Status>,
3079
-
>
3080
-
+ std::marker::Send
2622
+
> + std::marker::Send
3081
2623
+ 'static;
3082
2624
async fn stream_current_track(
3083
2625
&self,
3084
2626
request: tonic::Request<super::StreamCurrentTrackRequest>,
3085
-
) -> std::result::Result<
3086
-
tonic::Response<Self::StreamCurrentTrackStream>,
3087
-
tonic::Status,
3088
-
>;
2627
+
) -> std::result::Result<tonic::Response<Self::StreamCurrentTrackStream>, tonic::Status>;
3089
2628
/// Server streaming response type for the StreamStatus method.
3090
2629
type StreamStatusStream: tonic::codegen::tokio_stream::Stream<
3091
2630
Item = std::result::Result<super::StatusResponse, tonic::Status>,
3092
-
>
3093
-
+ std::marker::Send
2631
+
> + std::marker::Send
3094
2632
+ 'static;
3095
2633
async fn stream_status(
3096
2634
&self,
3097
2635
request: tonic::Request<super::StreamStatusRequest>,
3098
-
) -> std::result::Result<
3099
-
tonic::Response<Self::StreamStatusStream>,
3100
-
tonic::Status,
3101
-
>;
2636
+
) -> std::result::Result<tonic::Response<Self::StreamStatusStream>, tonic::Status>;
3102
2637
/// Server streaming response type for the StreamPlaylist method.
3103
2638
type StreamPlaylistStream: tonic::codegen::tokio_stream::Stream<
3104
2639
Item = std::result::Result<super::PlaylistResponse, tonic::Status>,
3105
-
>
3106
-
+ std::marker::Send
2640
+
> + std::marker::Send
3107
2641
+ 'static;
3108
2642
async fn stream_playlist(
3109
2643
&self,
3110
2644
request: tonic::Request<super::StreamPlaylistRequest>,
3111
-
) -> std::result::Result<
3112
-
tonic::Response<Self::StreamPlaylistStream>,
3113
-
tonic::Status,
3114
-
>;
2645
+
) -> std::result::Result<tonic::Response<Self::StreamPlaylistStream>, tonic::Status>;
3115
2646
}
3116
2647
#[derive(Debug)]
3117
2648
pub struct PlaybackServiceServer<T> {
···
3134
2665
max_encoding_message_size: None,
3135
2666
}
3136
2667
}
3137
-
pub fn with_interceptor<F>(
3138
-
inner: T,
3139
-
interceptor: F,
3140
-
) -> InterceptedService<Self, F>
2668
+
pub fn with_interceptor<F>(inner: T, interceptor: F) -> InterceptedService<Self, F>
3141
2669
where
3142
2670
F: tonic::service::Interceptor,
3143
2671
{
···
3192
2720
"/rockbox.v1alpha1.PlaybackService/Play" => {
3193
2721
#[allow(non_camel_case_types)]
3194
2722
struct PlaySvc<T: PlaybackService>(pub Arc<T>);
3195
-
impl<
3196
-
T: PlaybackService,
3197
-
> tonic::server::UnaryService<super::PlayRequest> for PlaySvc<T> {
2723
+
impl<T: PlaybackService> tonic::server::UnaryService<super::PlayRequest> for PlaySvc<T> {
3198
2724
type Response = super::PlayResponse;
3199
-
type Future = BoxFuture<
3200
-
tonic::Response<Self::Response>,
3201
-
tonic::Status,
3202
-
>;
2725
+
type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
3203
2726
fn call(
3204
2727
&mut self,
3205
2728
request: tonic::Request<super::PlayRequest>,
3206
2729
) -> Self::Future {
3207
2730
let inner = Arc::clone(&self.0);
3208
-
let fut = async move {
3209
-
<T as PlaybackService>::play(&inner, request).await
3210
-
};
2731
+
let fut =
2732
+
async move { <T as PlaybackService>::play(&inner, request).await };
3211
2733
Box::pin(fut)
3212
2734
}
3213
2735
}
···
3236
2758
"/rockbox.v1alpha1.PlaybackService/Pause" => {
3237
2759
#[allow(non_camel_case_types)]
3238
2760
struct PauseSvc<T: PlaybackService>(pub Arc<T>);
3239
-
impl<
3240
-
T: PlaybackService,
3241
-
> tonic::server::UnaryService<super::PauseRequest> for PauseSvc<T> {
2761
+
impl<T: PlaybackService> tonic::server::UnaryService<super::PauseRequest> for PauseSvc<T> {
3242
2762
type Response = super::PauseResponse;
3243
-
type Future = BoxFuture<
3244
-
tonic::Response<Self::Response>,
3245
-
tonic::Status,
3246
-
>;
2763
+
type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
3247
2764
fn call(
3248
2765
&mut self,
3249
2766
request: tonic::Request<super::PauseRequest>,
3250
2767
) -> Self::Future {
3251
2768
let inner = Arc::clone(&self.0);
3252
-
let fut = async move {
3253
-
<T as PlaybackService>::pause(&inner, request).await
3254
-
};
2769
+
let fut =
2770
+
async move { <T as PlaybackService>::pause(&inner, request).await };
3255
2771
Box::pin(fut)
3256
2772
}
3257
2773
}
···
3280
2796
"/rockbox.v1alpha1.PlaybackService/Resume" => {
3281
2797
#[allow(non_camel_case_types)]
3282
2798
struct ResumeSvc<T: PlaybackService>(pub Arc<T>);
3283
-
impl<
3284
-
T: PlaybackService,
3285
-
> tonic::server::UnaryService<super::ResumeRequest>
3286
-
for ResumeSvc<T> {
2799
+
impl<T: PlaybackService> tonic::server::UnaryService<super::ResumeRequest> for ResumeSvc<T> {
3287
2800
type Response = super::ResumeResponse;
3288
-
type Future = BoxFuture<
3289
-
tonic::Response<Self::Response>,
3290
-
tonic::Status,
3291
-
>;
2801
+
type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
3292
2802
fn call(
3293
2803
&mut self,
3294
2804
request: tonic::Request<super::ResumeRequest>,
···
3325
2835
"/rockbox.v1alpha1.PlaybackService/Next" => {
3326
2836
#[allow(non_camel_case_types)]
3327
2837
struct NextSvc<T: PlaybackService>(pub Arc<T>);
3328
-
impl<
3329
-
T: PlaybackService,
3330
-
> tonic::server::UnaryService<super::NextRequest> for NextSvc<T> {
2838
+
impl<T: PlaybackService> tonic::server::UnaryService<super::NextRequest> for NextSvc<T> {
3331
2839
type Response = super::NextResponse;
3332
-
type Future = BoxFuture<
3333
-
tonic::Response<Self::Response>,
3334
-
tonic::Status,
3335
-
>;
2840
+
type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
3336
2841
fn call(
3337
2842
&mut self,
3338
2843
request: tonic::Request<super::NextRequest>,
3339
2844
) -> Self::Future {
3340
2845
let inner = Arc::clone(&self.0);
3341
-
let fut = async move {
3342
-
<T as PlaybackService>::next(&inner, request).await
3343
-
};
2846
+
let fut =
2847
+
async move { <T as PlaybackService>::next(&inner, request).await };
3344
2848
Box::pin(fut)
3345
2849
}
3346
2850
}
···
3369
2873
"/rockbox.v1alpha1.PlaybackService/Previous" => {
3370
2874
#[allow(non_camel_case_types)]
3371
2875
struct PreviousSvc<T: PlaybackService>(pub Arc<T>);
3372
-
impl<
3373
-
T: PlaybackService,
3374
-
> tonic::server::UnaryService<super::PreviousRequest>
3375
-
for PreviousSvc<T> {
2876
+
impl<T: PlaybackService> tonic::server::UnaryService<super::PreviousRequest> for PreviousSvc<T> {
3376
2877
type Response = super::PreviousResponse;
3377
-
type Future = BoxFuture<
3378
-
tonic::Response<Self::Response>,
3379
-
tonic::Status,
3380
-
>;
2878
+
type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
3381
2879
fn call(
3382
2880
&mut self,
3383
2881
request: tonic::Request<super::PreviousRequest>,
···
3414
2912
"/rockbox.v1alpha1.PlaybackService/FastForwardRewind" => {
3415
2913
#[allow(non_camel_case_types)]
3416
2914
struct FastForwardRewindSvc<T: PlaybackService>(pub Arc<T>);
3417
-
impl<
3418
-
T: PlaybackService,
3419
-
> tonic::server::UnaryService<super::FastForwardRewindRequest>
3420
-
for FastForwardRewindSvc<T> {
2915
+
impl<T: PlaybackService>
2916
+
tonic::server::UnaryService<super::FastForwardRewindRequest>
2917
+
for FastForwardRewindSvc<T>
2918
+
{
3421
2919
type Response = super::FastForwardRewindResponse;
3422
-
type Future = BoxFuture<
3423
-
tonic::Response<Self::Response>,
3424
-
tonic::Status,
3425
-
>;
2920
+
type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
3426
2921
fn call(
3427
2922
&mut self,
3428
2923
request: tonic::Request<super::FastForwardRewindRequest>,
3429
2924
) -> Self::Future {
3430
2925
let inner = Arc::clone(&self.0);
3431
2926
let fut = async move {
3432
-
<T as PlaybackService>::fast_forward_rewind(&inner, request)
3433
-
.await
2927
+
<T as PlaybackService>::fast_forward_rewind(&inner, request).await
3434
2928
};
3435
2929
Box::pin(fut)
3436
2930
}
···
3460
2954
"/rockbox.v1alpha1.PlaybackService/Status" => {
3461
2955
#[allow(non_camel_case_types)]
3462
2956
struct StatusSvc<T: PlaybackService>(pub Arc<T>);
3463
-
impl<
3464
-
T: PlaybackService,
3465
-
> tonic::server::UnaryService<super::StatusRequest>
3466
-
for StatusSvc<T> {
2957
+
impl<T: PlaybackService> tonic::server::UnaryService<super::StatusRequest> for StatusSvc<T> {
3467
2958
type Response = super::StatusResponse;
3468
-
type Future = BoxFuture<
3469
-
tonic::Response<Self::Response>,
3470
-
tonic::Status,
3471
-
>;
2959
+
type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
3472
2960
fn call(
3473
2961
&mut self,
3474
2962
request: tonic::Request<super::StatusRequest>,
···
3505
2993
"/rockbox.v1alpha1.PlaybackService/CurrentTrack" => {
3506
2994
#[allow(non_camel_case_types)]
3507
2995
struct CurrentTrackSvc<T: PlaybackService>(pub Arc<T>);
3508
-
impl<
3509
-
T: PlaybackService,
3510
-
> tonic::server::UnaryService<super::CurrentTrackRequest>
3511
-
for CurrentTrackSvc<T> {
2996
+
impl<T: PlaybackService> tonic::server::UnaryService<super::CurrentTrackRequest>
2997
+
for CurrentTrackSvc<T>
2998
+
{
3512
2999
type Response = super::CurrentTrackResponse;
3513
-
type Future = BoxFuture<
3514
-
tonic::Response<Self::Response>,
3515
-
tonic::Status,
3516
-
>;
3000
+
type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
3517
3001
fn call(
3518
3002
&mut self,
3519
3003
request: tonic::Request<super::CurrentTrackRequest>,
···
3550
3034
"/rockbox.v1alpha1.PlaybackService/NextTrack" => {
3551
3035
#[allow(non_camel_case_types)]
3552
3036
struct NextTrackSvc<T: PlaybackService>(pub Arc<T>);
3553
-
impl<
3554
-
T: PlaybackService,
3555
-
> tonic::server::UnaryService<super::NextTrackRequest>
3556
-
for NextTrackSvc<T> {
3037
+
impl<T: PlaybackService> tonic::server::UnaryService<super::NextTrackRequest> for NextTrackSvc<T> {
3557
3038
type Response = super::NextTrackResponse;
3558
-
type Future = BoxFuture<
3559
-
tonic::Response<Self::Response>,
3560
-
tonic::Status,
3561
-
>;
3039
+
type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
3562
3040
fn call(
3563
3041
&mut self,
3564
3042
request: tonic::Request<super::NextTrackRequest>,
···
3595
3073
"/rockbox.v1alpha1.PlaybackService/FlushAndReloadTracks" => {
3596
3074
#[allow(non_camel_case_types)]
3597
3075
struct FlushAndReloadTracksSvc<T: PlaybackService>(pub Arc<T>);
3598
-
impl<
3599
-
T: PlaybackService,
3600
-
> tonic::server::UnaryService<super::FlushAndReloadTracksRequest>
3601
-
for FlushAndReloadTracksSvc<T> {
3076
+
impl<T: PlaybackService>
3077
+
tonic::server::UnaryService<super::FlushAndReloadTracksRequest>
3078
+
for FlushAndReloadTracksSvc<T>
3079
+
{
3602
3080
type Response = super::FlushAndReloadTracksResponse;
3603
-
type Future = BoxFuture<
3604
-
tonic::Response<Self::Response>,
3605
-
tonic::Status,
3606
-
>;
3081
+
type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
3607
3082
fn call(
3608
3083
&mut self,
3609
3084
request: tonic::Request<super::FlushAndReloadTracksRequest>,
3610
3085
) -> Self::Future {
3611
3086
let inner = Arc::clone(&self.0);
3612
3087
let fut = async move {
3613
-
<T as PlaybackService>::flush_and_reload_tracks(
3614
-
&inner,
3615
-
request,
3616
-
)
3088
+
<T as PlaybackService>::flush_and_reload_tracks(&inner, request)
3617
3089
.await
3618
3090
};
3619
3091
Box::pin(fut)
···
3644
3116
"/rockbox.v1alpha1.PlaybackService/GetFilePosition" => {
3645
3117
#[allow(non_camel_case_types)]
3646
3118
struct GetFilePositionSvc<T: PlaybackService>(pub Arc<T>);
3647
-
impl<
3648
-
T: PlaybackService,
3649
-
> tonic::server::UnaryService<super::GetFilePositionRequest>
3650
-
for GetFilePositionSvc<T> {
3119
+
impl<T: PlaybackService>
3120
+
tonic::server::UnaryService<super::GetFilePositionRequest>
3121
+
for GetFilePositionSvc<T>
3122
+
{
3651
3123
type Response = super::GetFilePositionResponse;
3652
-
type Future = BoxFuture<
3653
-
tonic::Response<Self::Response>,
3654
-
tonic::Status,
3655
-
>;
3124
+
type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
3656
3125
fn call(
3657
3126
&mut self,
3658
3127
request: tonic::Request<super::GetFilePositionRequest>,
3659
3128
) -> Self::Future {
3660
3129
let inner = Arc::clone(&self.0);
3661
3130
let fut = async move {
3662
-
<T as PlaybackService>::get_file_position(&inner, request)
3663
-
.await
3131
+
<T as PlaybackService>::get_file_position(&inner, request).await
3664
3132
};
3665
3133
Box::pin(fut)
3666
3134
}
···
3690
3158
"/rockbox.v1alpha1.PlaybackService/HardStop" => {
3691
3159
#[allow(non_camel_case_types)]
3692
3160
struct HardStopSvc<T: PlaybackService>(pub Arc<T>);
3693
-
impl<
3694
-
T: PlaybackService,
3695
-
> tonic::server::UnaryService<super::HardStopRequest>
3696
-
for HardStopSvc<T> {
3161
+
impl<T: PlaybackService> tonic::server::UnaryService<super::HardStopRequest> for HardStopSvc<T> {
3697
3162
type Response = super::HardStopResponse;
3698
-
type Future = BoxFuture<
3699
-
tonic::Response<Self::Response>,
3700
-
tonic::Status,
3701
-
>;
3163
+
type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
3702
3164
fn call(
3703
3165
&mut self,
3704
3166
request: tonic::Request<super::HardStopRequest>,
···
3735
3197
"/rockbox.v1alpha1.PlaybackService/PlayAlbum" => {
3736
3198
#[allow(non_camel_case_types)]
3737
3199
struct PlayAlbumSvc<T: PlaybackService>(pub Arc<T>);
3738
-
impl<
3739
-
T: PlaybackService,
3740
-
> tonic::server::UnaryService<super::PlayAlbumRequest>
3741
-
for PlayAlbumSvc<T> {
3200
+
impl<T: PlaybackService> tonic::server::UnaryService<super::PlayAlbumRequest> for PlayAlbumSvc<T> {
3742
3201
type Response = super::PlayAlbumResponse;
3743
-
type Future = BoxFuture<
3744
-
tonic::Response<Self::Response>,
3745
-
tonic::Status,
3746
-
>;
3202
+
type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
3747
3203
fn call(
3748
3204
&mut self,
3749
3205
request: tonic::Request<super::PlayAlbumRequest>,
···
3780
3236
"/rockbox.v1alpha1.PlaybackService/PlayArtistTracks" => {
3781
3237
#[allow(non_camel_case_types)]
3782
3238
struct PlayArtistTracksSvc<T: PlaybackService>(pub Arc<T>);
3783
-
impl<
3784
-
T: PlaybackService,
3785
-
> tonic::server::UnaryService<super::PlayArtistTracksRequest>
3786
-
for PlayArtistTracksSvc<T> {
3239
+
impl<T: PlaybackService>
3240
+
tonic::server::UnaryService<super::PlayArtistTracksRequest>
3241
+
for PlayArtistTracksSvc<T>
3242
+
{
3787
3243
type Response = super::PlayArtistTracksResponse;
3788
-
type Future = BoxFuture<
3789
-
tonic::Response<Self::Response>,
3790
-
tonic::Status,
3791
-
>;
3244
+
type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
3792
3245
fn call(
3793
3246
&mut self,
3794
3247
request: tonic::Request<super::PlayArtistTracksRequest>,
3795
3248
) -> Self::Future {
3796
3249
let inner = Arc::clone(&self.0);
3797
3250
let fut = async move {
3798
-
<T as PlaybackService>::play_artist_tracks(&inner, request)
3799
-
.await
3251
+
<T as PlaybackService>::play_artist_tracks(&inner, request).await
3800
3252
};
3801
3253
Box::pin(fut)
3802
3254
}
···
3826
3278
"/rockbox.v1alpha1.PlaybackService/PlayPlaylist" => {
3827
3279
#[allow(non_camel_case_types)]
3828
3280
struct PlayPlaylistSvc<T: PlaybackService>(pub Arc<T>);
3829
-
impl<
3830
-
T: PlaybackService,
3831
-
> tonic::server::UnaryService<super::PlayPlaylistRequest>
3832
-
for PlayPlaylistSvc<T> {
3281
+
impl<T: PlaybackService> tonic::server::UnaryService<super::PlayPlaylistRequest>
3282
+
for PlayPlaylistSvc<T>
3283
+
{
3833
3284
type Response = super::PlayPlaylistResponse;
3834
-
type Future = BoxFuture<
3835
-
tonic::Response<Self::Response>,
3836
-
tonic::Status,
3837
-
>;
3285
+
type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
3838
3286
fn call(
3839
3287
&mut self,
3840
3288
request: tonic::Request<super::PlayPlaylistRequest>,
···
3871
3319
"/rockbox.v1alpha1.PlaybackService/PlayDirectory" => {
3872
3320
#[allow(non_camel_case_types)]
3873
3321
struct PlayDirectorySvc<T: PlaybackService>(pub Arc<T>);
3874
-
impl<
3875
-
T: PlaybackService,
3876
-
> tonic::server::UnaryService<super::PlayDirectoryRequest>
3877
-
for PlayDirectorySvc<T> {
3322
+
impl<T: PlaybackService>
3323
+
tonic::server::UnaryService<super::PlayDirectoryRequest>
3324
+
for PlayDirectorySvc<T>
3325
+
{
3878
3326
type Response = super::PlayDirectoryResponse;
3879
-
type Future = BoxFuture<
3880
-
tonic::Response<Self::Response>,
3881
-
tonic::Status,
3882
-
>;
3327
+
type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
3883
3328
fn call(
3884
3329
&mut self,
3885
3330
request: tonic::Request<super::PlayDirectoryRequest>,
3886
3331
) -> Self::Future {
3887
3332
let inner = Arc::clone(&self.0);
3888
3333
let fut = async move {
3889
-
<T as PlaybackService>::play_directory(&inner, request)
3890
-
.await
3334
+
<T as PlaybackService>::play_directory(&inner, request).await
3891
3335
};
3892
3336
Box::pin(fut)
3893
3337
}
···
3917
3361
"/rockbox.v1alpha1.PlaybackService/PlayTrack" => {
3918
3362
#[allow(non_camel_case_types)]
3919
3363
struct PlayTrackSvc<T: PlaybackService>(pub Arc<T>);
3920
-
impl<
3921
-
T: PlaybackService,
3922
-
> tonic::server::UnaryService<super::PlayTrackRequest>
3923
-
for PlayTrackSvc<T> {
3364
+
impl<T: PlaybackService> tonic::server::UnaryService<super::PlayTrackRequest> for PlayTrackSvc<T> {
3924
3365
type Response = super::PlayTrackResponse;
3925
-
type Future = BoxFuture<
3926
-
tonic::Response<Self::Response>,
3927
-
tonic::Status,
3928
-
>;
3366
+
type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
3929
3367
fn call(
3930
3368
&mut self,
3931
3369
request: tonic::Request<super::PlayTrackRequest>,
···
3962
3400
"/rockbox.v1alpha1.PlaybackService/PlayLikedTracks" => {
3963
3401
#[allow(non_camel_case_types)]
3964
3402
struct PlayLikedTracksSvc<T: PlaybackService>(pub Arc<T>);
3965
-
impl<
3966
-
T: PlaybackService,
3967
-
> tonic::server::UnaryService<super::PlayLikedTracksRequest>
3968
-
for PlayLikedTracksSvc<T> {
3403
+
impl<T: PlaybackService>
3404
+
tonic::server::UnaryService<super::PlayLikedTracksRequest>
3405
+
for PlayLikedTracksSvc<T>
3406
+
{
3969
3407
type Response = super::PlayLikedTracksResponse;
3970
-
type Future = BoxFuture<
3971
-
tonic::Response<Self::Response>,
3972
-
tonic::Status,
3973
-
>;
3408
+
type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
3974
3409
fn call(
3975
3410
&mut self,
3976
3411
request: tonic::Request<super::PlayLikedTracksRequest>,
3977
3412
) -> Self::Future {
3978
3413
let inner = Arc::clone(&self.0);
3979
3414
let fut = async move {
3980
-
<T as PlaybackService>::play_liked_tracks(&inner, request)
3981
-
.await
3415
+
<T as PlaybackService>::play_liked_tracks(&inner, request).await
3982
3416
};
3983
3417
Box::pin(fut)
3984
3418
}
···
4008
3442
"/rockbox.v1alpha1.PlaybackService/PlayAllTracks" => {
4009
3443
#[allow(non_camel_case_types)]
4010
3444
struct PlayAllTracksSvc<T: PlaybackService>(pub Arc<T>);
4011
-
impl<
4012
-
T: PlaybackService,
4013
-
> tonic::server::UnaryService<super::PlayAllTracksRequest>
4014
-
for PlayAllTracksSvc<T> {
3445
+
impl<T: PlaybackService>
3446
+
tonic::server::UnaryService<super::PlayAllTracksRequest>
3447
+
for PlayAllTracksSvc<T>
3448
+
{
4015
3449
type Response = super::PlayAllTracksResponse;
4016
-
type Future = BoxFuture<
4017
-
tonic::Response<Self::Response>,
4018
-
tonic::Status,
4019
-
>;
3450
+
type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
4020
3451
fn call(
4021
3452
&mut self,
4022
3453
request: tonic::Request<super::PlayAllTracksRequest>,
4023
3454
) -> Self::Future {
4024
3455
let inner = Arc::clone(&self.0);
4025
3456
let fut = async move {
4026
-
<T as PlaybackService>::play_all_tracks(&inner, request)
4027
-
.await
3457
+
<T as PlaybackService>::play_all_tracks(&inner, request).await
4028
3458
};
4029
3459
Box::pin(fut)
4030
3460
}
···
4054
3484
"/rockbox.v1alpha1.PlaybackService/StreamCurrentTrack" => {
4055
3485
#[allow(non_camel_case_types)]
4056
3486
struct StreamCurrentTrackSvc<T: PlaybackService>(pub Arc<T>);
4057
-
impl<
4058
-
T: PlaybackService,
4059
-
> tonic::server::ServerStreamingService<
4060
-
super::StreamCurrentTrackRequest,
4061
-
> for StreamCurrentTrackSvc<T> {
3487
+
impl<T: PlaybackService>
3488
+
tonic::server::ServerStreamingService<super::StreamCurrentTrackRequest>
3489
+
for StreamCurrentTrackSvc<T>
3490
+
{
4062
3491
type Response = super::CurrentTrackResponse;
4063
3492
type ResponseStream = T::StreamCurrentTrackStream;
4064
-
type Future = BoxFuture<
4065
-
tonic::Response<Self::ResponseStream>,
4066
-
tonic::Status,
4067
-
>;
3493
+
type Future =
3494
+
BoxFuture<tonic::Response<Self::ResponseStream>, tonic::Status>;
4068
3495
fn call(
4069
3496
&mut self,
4070
3497
request: tonic::Request<super::StreamCurrentTrackRequest>,
4071
3498
) -> Self::Future {
4072
3499
let inner = Arc::clone(&self.0);
4073
3500
let fut = async move {
4074
-
<T as PlaybackService>::stream_current_track(
4075
-
&inner,
4076
-
request,
4077
-
)
4078
-
.await
3501
+
<T as PlaybackService>::stream_current_track(&inner, request).await
4079
3502
};
4080
3503
Box::pin(fut)
4081
3504
}
···
4105
3528
"/rockbox.v1alpha1.PlaybackService/StreamStatus" => {
4106
3529
#[allow(non_camel_case_types)]
4107
3530
struct StreamStatusSvc<T: PlaybackService>(pub Arc<T>);
4108
-
impl<
4109
-
T: PlaybackService,
4110
-
> tonic::server::ServerStreamingService<super::StreamStatusRequest>
4111
-
for StreamStatusSvc<T> {
3531
+
impl<T: PlaybackService>
3532
+
tonic::server::ServerStreamingService<super::StreamStatusRequest>
3533
+
for StreamStatusSvc<T>
3534
+
{
4112
3535
type Response = super::StatusResponse;
4113
3536
type ResponseStream = T::StreamStatusStream;
4114
-
type Future = BoxFuture<
4115
-
tonic::Response<Self::ResponseStream>,
4116
-
tonic::Status,
4117
-
>;
3537
+
type Future =
3538
+
BoxFuture<tonic::Response<Self::ResponseStream>, tonic::Status>;
4118
3539
fn call(
4119
3540
&mut self,
4120
3541
request: tonic::Request<super::StreamStatusRequest>,
···
4151
3572
"/rockbox.v1alpha1.PlaybackService/StreamPlaylist" => {
4152
3573
#[allow(non_camel_case_types)]
4153
3574
struct StreamPlaylistSvc<T: PlaybackService>(pub Arc<T>);
4154
-
impl<
4155
-
T: PlaybackService,
4156
-
> tonic::server::ServerStreamingService<super::StreamPlaylistRequest>
4157
-
for StreamPlaylistSvc<T> {
3575
+
impl<T: PlaybackService>
3576
+
tonic::server::ServerStreamingService<super::StreamPlaylistRequest>
3577
+
for StreamPlaylistSvc<T>
3578
+
{
4158
3579
type Response = super::PlaylistResponse;
4159
3580
type ResponseStream = T::StreamPlaylistStream;
4160
-
type Future = BoxFuture<
4161
-
tonic::Response<Self::ResponseStream>,
4162
-
tonic::Status,
4163
-
>;
3581
+
type Future =
3582
+
BoxFuture<tonic::Response<Self::ResponseStream>, tonic::Status>;
4164
3583
fn call(
4165
3584
&mut self,
4166
3585
request: tonic::Request<super::StreamPlaylistRequest>,
4167
3586
) -> Self::Future {
4168
3587
let inner = Arc::clone(&self.0);
4169
3588
let fut = async move {
4170
-
<T as PlaybackService>::stream_playlist(&inner, request)
4171
-
.await
3589
+
<T as PlaybackService>::stream_playlist(&inner, request).await
4172
3590
};
4173
3591
Box::pin(fut)
4174
3592
}
···
4195
3613
};
4196
3614
Box::pin(fut)
4197
3615
}
4198
-
_ => {
4199
-
Box::pin(async move {
4200
-
let mut response = http::Response::new(empty_body());
4201
-
let headers = response.headers_mut();
4202
-
headers
4203
-
.insert(
4204
-
tonic::Status::GRPC_STATUS,
4205
-
(tonic::Code::Unimplemented as i32).into(),
4206
-
);
4207
-
headers
4208
-
.insert(
4209
-
http::header::CONTENT_TYPE,
4210
-
tonic::metadata::GRPC_CONTENT_TYPE,
4211
-
);
4212
-
Ok(response)
4213
-
})
4214
-
}
3616
+
_ => Box::pin(async move {
3617
+
let mut response = http::Response::new(empty_body());
3618
+
let headers = response.headers_mut();
3619
+
headers.insert(
3620
+
tonic::Status::GRPC_STATUS,
3621
+
(tonic::Code::Unimplemented as i32).into(),
3622
+
);
3623
+
headers.insert(
3624
+
http::header::CONTENT_TYPE,
3625
+
tonic::metadata::GRPC_CONTENT_TYPE,
3626
+
);
3627
+
Ok(response)
3628
+
}),
4215
3629
}
4216
3630
}
4217
3631
}
···
4416
3830
dead_code,
4417
3831
missing_docs,
4418
3832
clippy::wildcard_imports,
4419
-
clippy::let_unit_value,
3833
+
clippy::let_unit_value
4420
3834
)]
4421
-
use tonic::codegen::*;
4422
3835
use tonic::codegen::http::Uri;
3836
+
use tonic::codegen::*;
4423
3837
#[derive(Debug, Clone)]
4424
3838
pub struct PlaylistServiceClient<T> {
4425
3839
inner: tonic::client::Grpc<T>,
···
4463
3877
<T as tonic::client::GrpcService<tonic::body::BoxBody>>::ResponseBody,
4464
3878
>,
4465
3879
>,
4466
-
<T as tonic::codegen::Service<
4467
-
http::Request<tonic::body::BoxBody>,
4468
-
>>::Error: Into<StdError> + std::marker::Send + std::marker::Sync,
3880
+
<T as tonic::codegen::Service<http::Request<tonic::body::BoxBody>>>::Error:
3881
+
Into<StdError> + std::marker::Send + std::marker::Sync,
4469
3882
{
4470
3883
PlaylistServiceClient::new(InterceptedService::new(inner, interceptor))
4471
3884
}
···
4503
3916
pub async fn get_current(
4504
3917
&mut self,
4505
3918
request: impl tonic::IntoRequest<super::GetCurrentRequest>,
4506
-
) -> std::result::Result<
4507
-
tonic::Response<super::GetCurrentResponse>,
4508
-
tonic::Status,
4509
-
> {
4510
-
self.inner
4511
-
.ready()
4512
-
.await
4513
-
.map_err(|e| {
4514
-
tonic::Status::unknown(
4515
-
format!("Service was not ready: {}", e.into()),
4516
-
)
4517
-
})?;
3919
+
) -> std::result::Result<tonic::Response<super::GetCurrentResponse>, tonic::Status>
3920
+
{
3921
+
self.inner.ready().await.map_err(|e| {
3922
+
tonic::Status::unknown(format!("Service was not ready: {}", e.into()))
3923
+
})?;
4518
3924
let codec = tonic::codec::ProstCodec::default();
4519
3925
let path = http::uri::PathAndQuery::from_static(
4520
3926
"/rockbox.v1alpha1.PlaylistService/GetCurrent",
4521
3927
);
4522
3928
let mut req = request.into_request();
4523
-
req.extensions_mut()
4524
-
.insert(
4525
-
GrpcMethod::new("rockbox.v1alpha1.PlaylistService", "GetCurrent"),
4526
-
);
3929
+
req.extensions_mut().insert(GrpcMethod::new(
3930
+
"rockbox.v1alpha1.PlaylistService",
3931
+
"GetCurrent",
3932
+
));
4527
3933
self.inner.unary(req, path, codec).await
4528
3934
}
4529
3935
pub async fn get_resume_info(
4530
3936
&mut self,
4531
3937
request: impl tonic::IntoRequest<super::GetResumeInfoRequest>,
4532
-
) -> std::result::Result<
4533
-
tonic::Response<super::GetResumeInfoResponse>,
4534
-
tonic::Status,
4535
-
> {
4536
-
self.inner
4537
-
.ready()
4538
-
.await
4539
-
.map_err(|e| {
4540
-
tonic::Status::unknown(
4541
-
format!("Service was not ready: {}", e.into()),
4542
-
)
4543
-
})?;
3938
+
) -> std::result::Result<tonic::Response<super::GetResumeInfoResponse>, tonic::Status>
3939
+
{
3940
+
self.inner.ready().await.map_err(|e| {
3941
+
tonic::Status::unknown(format!("Service was not ready: {}", e.into()))
3942
+
})?;
4544
3943
let codec = tonic::codec::ProstCodec::default();
4545
3944
let path = http::uri::PathAndQuery::from_static(
4546
3945
"/rockbox.v1alpha1.PlaylistService/GetResumeInfo",
4547
3946
);
4548
3947
let mut req = request.into_request();
4549
-
req.extensions_mut()
4550
-
.insert(
4551
-
GrpcMethod::new("rockbox.v1alpha1.PlaylistService", "GetResumeInfo"),
4552
-
);
3948
+
req.extensions_mut().insert(GrpcMethod::new(
3949
+
"rockbox.v1alpha1.PlaylistService",
3950
+
"GetResumeInfo",
3951
+
));
4553
3952
self.inner.unary(req, path, codec).await
4554
3953
}
4555
3954
pub async fn get_track_info(
4556
3955
&mut self,
4557
3956
request: impl tonic::IntoRequest<super::GetTrackInfoRequest>,
4558
-
) -> std::result::Result<
4559
-
tonic::Response<super::GetTrackInfoResponse>,
4560
-
tonic::Status,
4561
-
> {
4562
-
self.inner
4563
-
.ready()
4564
-
.await
4565
-
.map_err(|e| {
4566
-
tonic::Status::unknown(
4567
-
format!("Service was not ready: {}", e.into()),
4568
-
)
4569
-
})?;
3957
+
) -> std::result::Result<tonic::Response<super::GetTrackInfoResponse>, tonic::Status>
3958
+
{
3959
+
self.inner.ready().await.map_err(|e| {
3960
+
tonic::Status::unknown(format!("Service was not ready: {}", e.into()))
3961
+
})?;
4570
3962
let codec = tonic::codec::ProstCodec::default();
4571
3963
let path = http::uri::PathAndQuery::from_static(
4572
3964
"/rockbox.v1alpha1.PlaylistService/GetTrackInfo",
4573
3965
);
4574
3966
let mut req = request.into_request();
4575
-
req.extensions_mut()
4576
-
.insert(
4577
-
GrpcMethod::new("rockbox.v1alpha1.PlaylistService", "GetTrackInfo"),
4578
-
);
3967
+
req.extensions_mut().insert(GrpcMethod::new(
3968
+
"rockbox.v1alpha1.PlaylistService",
3969
+
"GetTrackInfo",
3970
+
));
4579
3971
self.inner.unary(req, path, codec).await
4580
3972
}
4581
3973
pub async fn get_first_index(
4582
3974
&mut self,
4583
3975
request: impl tonic::IntoRequest<super::GetFirstIndexRequest>,
4584
-
) -> std::result::Result<
4585
-
tonic::Response<super::GetFirstIndexResponse>,
4586
-
tonic::Status,
4587
-
> {
4588
-
self.inner
4589
-
.ready()
4590
-
.await
4591
-
.map_err(|e| {
4592
-
tonic::Status::unknown(
4593
-
format!("Service was not ready: {}", e.into()),
4594
-
)
4595
-
})?;
3976
+
) -> std::result::Result<tonic::Response<super::GetFirstIndexResponse>, tonic::Status>
3977
+
{
3978
+
self.inner.ready().await.map_err(|e| {
3979
+
tonic::Status::unknown(format!("Service was not ready: {}", e.into()))
3980
+
})?;
4596
3981
let codec = tonic::codec::ProstCodec::default();
4597
3982
let path = http::uri::PathAndQuery::from_static(
4598
3983
"/rockbox.v1alpha1.PlaylistService/GetFirstIndex",
4599
3984
);
4600
3985
let mut req = request.into_request();
4601
-
req.extensions_mut()
4602
-
.insert(
4603
-
GrpcMethod::new("rockbox.v1alpha1.PlaylistService", "GetFirstIndex"),
4604
-
);
3986
+
req.extensions_mut().insert(GrpcMethod::new(
3987
+
"rockbox.v1alpha1.PlaylistService",
3988
+
"GetFirstIndex",
3989
+
));
4605
3990
self.inner.unary(req, path, codec).await
4606
3991
}
4607
3992
pub async fn get_display_index(
4608
3993
&mut self,
4609
3994
request: impl tonic::IntoRequest<super::GetDisplayIndexRequest>,
4610
-
) -> std::result::Result<
4611
-
tonic::Response<super::GetDisplayIndexResponse>,
4612
-
tonic::Status,
4613
-
> {
4614
-
self.inner
4615
-
.ready()
4616
-
.await
4617
-
.map_err(|e| {
4618
-
tonic::Status::unknown(
4619
-
format!("Service was not ready: {}", e.into()),
4620
-
)
4621
-
})?;
3995
+
) -> std::result::Result<tonic::Response<super::GetDisplayIndexResponse>, tonic::Status>
3996
+
{
3997
+
self.inner.ready().await.map_err(|e| {
3998
+
tonic::Status::unknown(format!("Service was not ready: {}", e.into()))
3999
+
})?;
4622
4000
let codec = tonic::codec::ProstCodec::default();
4623
4001
let path = http::uri::PathAndQuery::from_static(
4624
4002
"/rockbox.v1alpha1.PlaylistService/GetDisplayIndex",
4625
4003
);
4626
4004
let mut req = request.into_request();
4627
-
req.extensions_mut()
4628
-
.insert(
4629
-
GrpcMethod::new(
4630
-
"rockbox.v1alpha1.PlaylistService",
4631
-
"GetDisplayIndex",
4632
-
),
4633
-
);
4005
+
req.extensions_mut().insert(GrpcMethod::new(
4006
+
"rockbox.v1alpha1.PlaylistService",
4007
+
"GetDisplayIndex",
4008
+
));
4634
4009
self.inner.unary(req, path, codec).await
4635
4010
}
4636
4011
pub async fn amount(
4637
4012
&mut self,
4638
4013
request: impl tonic::IntoRequest<super::AmountRequest>,
4639
4014
) -> std::result::Result<tonic::Response<super::AmountResponse>, tonic::Status> {
4640
-
self.inner
4641
-
.ready()
4642
-
.await
4643
-
.map_err(|e| {
4644
-
tonic::Status::unknown(
4645
-
format!("Service was not ready: {}", e.into()),
4646
-
)
4647
-
})?;
4015
+
self.inner.ready().await.map_err(|e| {
4016
+
tonic::Status::unknown(format!("Service was not ready: {}", e.into()))
4017
+
})?;
4648
4018
let codec = tonic::codec::ProstCodec::default();
4649
-
let path = http::uri::PathAndQuery::from_static(
4650
-
"/rockbox.v1alpha1.PlaylistService/Amount",
4651
-
);
4019
+
let path =
4020
+
http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.PlaylistService/Amount");
4652
4021
let mut req = request.into_request();
4653
-
req.extensions_mut()
4654
-
.insert(GrpcMethod::new("rockbox.v1alpha1.PlaylistService", "Amount"));
4022
+
req.extensions_mut().insert(GrpcMethod::new(
4023
+
"rockbox.v1alpha1.PlaylistService",
4024
+
"Amount",
4025
+
));
4655
4026
self.inner.unary(req, path, codec).await
4656
4027
}
4657
4028
pub async fn playlist_resume(
4658
4029
&mut self,
4659
4030
request: impl tonic::IntoRequest<super::PlaylistResumeRequest>,
4660
-
) -> std::result::Result<
4661
-
tonic::Response<super::PlaylistResumeResponse>,
4662
-
tonic::Status,
4663
-
> {
4664
-
self.inner
4665
-
.ready()
4666
-
.await
4667
-
.map_err(|e| {
4668
-
tonic::Status::unknown(
4669
-
format!("Service was not ready: {}", e.into()),
4670
-
)
4671
-
})?;
4031
+
) -> std::result::Result<tonic::Response<super::PlaylistResumeResponse>, tonic::Status>
4032
+
{
4033
+
self.inner.ready().await.map_err(|e| {
4034
+
tonic::Status::unknown(format!("Service was not ready: {}", e.into()))
4035
+
})?;
4672
4036
let codec = tonic::codec::ProstCodec::default();
4673
4037
let path = http::uri::PathAndQuery::from_static(
4674
4038
"/rockbox.v1alpha1.PlaylistService/PlaylistResume",
4675
4039
);
4676
4040
let mut req = request.into_request();
4677
-
req.extensions_mut()
4678
-
.insert(
4679
-
GrpcMethod::new("rockbox.v1alpha1.PlaylistService", "PlaylistResume"),
4680
-
);
4041
+
req.extensions_mut().insert(GrpcMethod::new(
4042
+
"rockbox.v1alpha1.PlaylistService",
4043
+
"PlaylistResume",
4044
+
));
4681
4045
self.inner.unary(req, path, codec).await
4682
4046
}
4683
4047
pub async fn resume_track(
4684
4048
&mut self,
4685
4049
request: impl tonic::IntoRequest<super::ResumeTrackRequest>,
4686
-
) -> std::result::Result<
4687
-
tonic::Response<super::ResumeTrackResponse>,
4688
-
tonic::Status,
4689
-
> {
4690
-
self.inner
4691
-
.ready()
4692
-
.await
4693
-
.map_err(|e| {
4694
-
tonic::Status::unknown(
4695
-
format!("Service was not ready: {}", e.into()),
4696
-
)
4697
-
})?;
4050
+
) -> std::result::Result<tonic::Response<super::ResumeTrackResponse>, tonic::Status>
4051
+
{
4052
+
self.inner.ready().await.map_err(|e| {
4053
+
tonic::Status::unknown(format!("Service was not ready: {}", e.into()))
4054
+
})?;
4698
4055
let codec = tonic::codec::ProstCodec::default();
4699
4056
let path = http::uri::PathAndQuery::from_static(
4700
4057
"/rockbox.v1alpha1.PlaylistService/ResumeTrack",
4701
4058
);
4702
4059
let mut req = request.into_request();
4703
-
req.extensions_mut()
4704
-
.insert(
4705
-
GrpcMethod::new("rockbox.v1alpha1.PlaylistService", "ResumeTrack"),
4706
-
);
4060
+
req.extensions_mut().insert(GrpcMethod::new(
4061
+
"rockbox.v1alpha1.PlaylistService",
4062
+
"ResumeTrack",
4063
+
));
4707
4064
self.inner.unary(req, path, codec).await
4708
4065
}
4709
4066
pub async fn set_modified(
4710
4067
&mut self,
4711
4068
request: impl tonic::IntoRequest<super::SetModifiedRequest>,
4712
-
) -> std::result::Result<
4713
-
tonic::Response<super::SetModifiedResponse>,
4714
-
tonic::Status,
4715
-
> {
4716
-
self.inner
4717
-
.ready()
4718
-
.await
4719
-
.map_err(|e| {
4720
-
tonic::Status::unknown(
4721
-
format!("Service was not ready: {}", e.into()),
4722
-
)
4723
-
})?;
4069
+
) -> std::result::Result<tonic::Response<super::SetModifiedResponse>, tonic::Status>
4070
+
{
4071
+
self.inner.ready().await.map_err(|e| {
4072
+
tonic::Status::unknown(format!("Service was not ready: {}", e.into()))
4073
+
})?;
4724
4074
let codec = tonic::codec::ProstCodec::default();
4725
4075
let path = http::uri::PathAndQuery::from_static(
4726
4076
"/rockbox.v1alpha1.PlaylistService/SetModified",
4727
4077
);
4728
4078
let mut req = request.into_request();
4729
-
req.extensions_mut()
4730
-
.insert(
4731
-
GrpcMethod::new("rockbox.v1alpha1.PlaylistService", "SetModified"),
4732
-
);
4079
+
req.extensions_mut().insert(GrpcMethod::new(
4080
+
"rockbox.v1alpha1.PlaylistService",
4081
+
"SetModified",
4082
+
));
4733
4083
self.inner.unary(req, path, codec).await
4734
4084
}
4735
4085
pub async fn start(
4736
4086
&mut self,
4737
4087
request: impl tonic::IntoRequest<super::StartRequest>,
4738
4088
) -> std::result::Result<tonic::Response<super::StartResponse>, tonic::Status> {
4739
-
self.inner
4740
-
.ready()
4741
-
.await
4742
-
.map_err(|e| {
4743
-
tonic::Status::unknown(
4744
-
format!("Service was not ready: {}", e.into()),
4745
-
)
4746
-
})?;
4089
+
self.inner.ready().await.map_err(|e| {
4090
+
tonic::Status::unknown(format!("Service was not ready: {}", e.into()))
4091
+
})?;
4747
4092
let codec = tonic::codec::ProstCodec::default();
4748
-
let path = http::uri::PathAndQuery::from_static(
4749
-
"/rockbox.v1alpha1.PlaylistService/Start",
4750
-
);
4093
+
let path =
4094
+
http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.PlaylistService/Start");
4751
4095
let mut req = request.into_request();
4752
4096
req.extensions_mut()
4753
4097
.insert(GrpcMethod::new("rockbox.v1alpha1.PlaylistService", "Start"));
···
4757
4101
&mut self,
4758
4102
request: impl tonic::IntoRequest<super::SyncRequest>,
4759
4103
) -> std::result::Result<tonic::Response<super::SyncResponse>, tonic::Status> {
4760
-
self.inner
4761
-
.ready()
4762
-
.await
4763
-
.map_err(|e| {
4764
-
tonic::Status::unknown(
4765
-
format!("Service was not ready: {}", e.into()),
4766
-
)
4767
-
})?;
4104
+
self.inner.ready().await.map_err(|e| {
4105
+
tonic::Status::unknown(format!("Service was not ready: {}", e.into()))
4106
+
})?;
4768
4107
let codec = tonic::codec::ProstCodec::default();
4769
-
let path = http::uri::PathAndQuery::from_static(
4770
-
"/rockbox.v1alpha1.PlaylistService/Sync",
4771
-
);
4108
+
let path =
4109
+
http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.PlaylistService/Sync");
4772
4110
let mut req = request.into_request();
4773
4111
req.extensions_mut()
4774
4112
.insert(GrpcMethod::new("rockbox.v1alpha1.PlaylistService", "Sync"));
···
4777
4115
pub async fn remove_all_tracks(
4778
4116
&mut self,
4779
4117
request: impl tonic::IntoRequest<super::RemoveAllTracksRequest>,
4780
-
) -> std::result::Result<
4781
-
tonic::Response<super::RemoveAllTracksResponse>,
4782
-
tonic::Status,
4783
-
> {
4784
-
self.inner
4785
-
.ready()
4786
-
.await
4787
-
.map_err(|e| {
4788
-
tonic::Status::unknown(
4789
-
format!("Service was not ready: {}", e.into()),
4790
-
)
4791
-
})?;
4118
+
) -> std::result::Result<tonic::Response<super::RemoveAllTracksResponse>, tonic::Status>
4119
+
{
4120
+
self.inner.ready().await.map_err(|e| {
4121
+
tonic::Status::unknown(format!("Service was not ready: {}", e.into()))
4122
+
})?;
4792
4123
let codec = tonic::codec::ProstCodec::default();
4793
4124
let path = http::uri::PathAndQuery::from_static(
4794
4125
"/rockbox.v1alpha1.PlaylistService/RemoveAllTracks",
4795
4126
);
4796
4127
let mut req = request.into_request();
4797
-
req.extensions_mut()
4798
-
.insert(
4799
-
GrpcMethod::new(
4800
-
"rockbox.v1alpha1.PlaylistService",
4801
-
"RemoveAllTracks",
4802
-
),
4803
-
);
4128
+
req.extensions_mut().insert(GrpcMethod::new(
4129
+
"rockbox.v1alpha1.PlaylistService",
4130
+
"RemoveAllTracks",
4131
+
));
4804
4132
self.inner.unary(req, path, codec).await
4805
4133
}
4806
4134
pub async fn remove_tracks(
4807
4135
&mut self,
4808
4136
request: impl tonic::IntoRequest<super::RemoveTracksRequest>,
4809
-
) -> std::result::Result<
4810
-
tonic::Response<super::RemoveTracksResponse>,
4811
-
tonic::Status,
4812
-
> {
4813
-
self.inner
4814
-
.ready()
4815
-
.await
4816
-
.map_err(|e| {
4817
-
tonic::Status::unknown(
4818
-
format!("Service was not ready: {}", e.into()),
4819
-
)
4820
-
})?;
4137
+
) -> std::result::Result<tonic::Response<super::RemoveTracksResponse>, tonic::Status>
4138
+
{
4139
+
self.inner.ready().await.map_err(|e| {
4140
+
tonic::Status::unknown(format!("Service was not ready: {}", e.into()))
4141
+
})?;
4821
4142
let codec = tonic::codec::ProstCodec::default();
4822
4143
let path = http::uri::PathAndQuery::from_static(
4823
4144
"/rockbox.v1alpha1.PlaylistService/RemoveTracks",
4824
4145
);
4825
4146
let mut req = request.into_request();
4826
-
req.extensions_mut()
4827
-
.insert(
4828
-
GrpcMethod::new("rockbox.v1alpha1.PlaylistService", "RemoveTracks"),
4829
-
);
4147
+
req.extensions_mut().insert(GrpcMethod::new(
4148
+
"rockbox.v1alpha1.PlaylistService",
4149
+
"RemoveTracks",
4150
+
));
4830
4151
self.inner.unary(req, path, codec).await
4831
4152
}
4832
4153
pub async fn create_playlist(
4833
4154
&mut self,
4834
4155
request: impl tonic::IntoRequest<super::CreatePlaylistRequest>,
4835
-
) -> std::result::Result<
4836
-
tonic::Response<super::CreatePlaylistResponse>,
4837
-
tonic::Status,
4838
-
> {
4839
-
self.inner
4840
-
.ready()
4841
-
.await
4842
-
.map_err(|e| {
4843
-
tonic::Status::unknown(
4844
-
format!("Service was not ready: {}", e.into()),
4845
-
)
4846
-
})?;
4156
+
) -> std::result::Result<tonic::Response<super::CreatePlaylistResponse>, tonic::Status>
4157
+
{
4158
+
self.inner.ready().await.map_err(|e| {
4159
+
tonic::Status::unknown(format!("Service was not ready: {}", e.into()))
4160
+
})?;
4847
4161
let codec = tonic::codec::ProstCodec::default();
4848
4162
let path = http::uri::PathAndQuery::from_static(
4849
4163
"/rockbox.v1alpha1.PlaylistService/CreatePlaylist",
4850
4164
);
4851
4165
let mut req = request.into_request();
4852
-
req.extensions_mut()
4853
-
.insert(
4854
-
GrpcMethod::new("rockbox.v1alpha1.PlaylistService", "CreatePlaylist"),
4855
-
);
4166
+
req.extensions_mut().insert(GrpcMethod::new(
4167
+
"rockbox.v1alpha1.PlaylistService",
4168
+
"CreatePlaylist",
4169
+
));
4856
4170
self.inner.unary(req, path, codec).await
4857
4171
}
4858
4172
pub async fn insert_tracks(
4859
4173
&mut self,
4860
4174
request: impl tonic::IntoRequest<super::InsertTracksRequest>,
4861
-
) -> std::result::Result<
4862
-
tonic::Response<super::InsertTracksResponse>,
4863
-
tonic::Status,
4864
-
> {
4865
-
self.inner
4866
-
.ready()
4867
-
.await
4868
-
.map_err(|e| {
4869
-
tonic::Status::unknown(
4870
-
format!("Service was not ready: {}", e.into()),
4871
-
)
4872
-
})?;
4175
+
) -> std::result::Result<tonic::Response<super::InsertTracksResponse>, tonic::Status>
4176
+
{
4177
+
self.inner.ready().await.map_err(|e| {
4178
+
tonic::Status::unknown(format!("Service was not ready: {}", e.into()))
4179
+
})?;
4873
4180
let codec = tonic::codec::ProstCodec::default();
4874
4181
let path = http::uri::PathAndQuery::from_static(
4875
4182
"/rockbox.v1alpha1.PlaylistService/InsertTracks",
4876
4183
);
4877
4184
let mut req = request.into_request();
4878
-
req.extensions_mut()
4879
-
.insert(
4880
-
GrpcMethod::new("rockbox.v1alpha1.PlaylistService", "InsertTracks"),
4881
-
);
4185
+
req.extensions_mut().insert(GrpcMethod::new(
4186
+
"rockbox.v1alpha1.PlaylistService",
4187
+
"InsertTracks",
4188
+
));
4882
4189
self.inner.unary(req, path, codec).await
4883
4190
}
4884
4191
pub async fn insert_directory(
4885
4192
&mut self,
4886
4193
request: impl tonic::IntoRequest<super::InsertDirectoryRequest>,
4887
-
) -> std::result::Result<
4888
-
tonic::Response<super::InsertDirectoryResponse>,
4889
-
tonic::Status,
4890
-
> {
4891
-
self.inner
4892
-
.ready()
4893
-
.await
4894
-
.map_err(|e| {
4895
-
tonic::Status::unknown(
4896
-
format!("Service was not ready: {}", e.into()),
4897
-
)
4898
-
})?;
4194
+
) -> std::result::Result<tonic::Response<super::InsertDirectoryResponse>, tonic::Status>
4195
+
{
4196
+
self.inner.ready().await.map_err(|e| {
4197
+
tonic::Status::unknown(format!("Service was not ready: {}", e.into()))
4198
+
})?;
4899
4199
let codec = tonic::codec::ProstCodec::default();
4900
4200
let path = http::uri::PathAndQuery::from_static(
4901
4201
"/rockbox.v1alpha1.PlaylistService/InsertDirectory",
4902
4202
);
4903
4203
let mut req = request.into_request();
4904
-
req.extensions_mut()
4905
-
.insert(
4906
-
GrpcMethod::new(
4907
-
"rockbox.v1alpha1.PlaylistService",
4908
-
"InsertDirectory",
4909
-
),
4910
-
);
4204
+
req.extensions_mut().insert(GrpcMethod::new(
4205
+
"rockbox.v1alpha1.PlaylistService",
4206
+
"InsertDirectory",
4207
+
));
4911
4208
self.inner.unary(req, path, codec).await
4912
4209
}
4913
4210
pub async fn insert_playlist(
4914
4211
&mut self,
4915
4212
request: impl tonic::IntoRequest<super::InsertPlaylistRequest>,
4916
-
) -> std::result::Result<
4917
-
tonic::Response<super::InsertPlaylistResponse>,
4918
-
tonic::Status,
4919
-
> {
4920
-
self.inner
4921
-
.ready()
4922
-
.await
4923
-
.map_err(|e| {
4924
-
tonic::Status::unknown(
4925
-
format!("Service was not ready: {}", e.into()),
4926
-
)
4927
-
})?;
4213
+
) -> std::result::Result<tonic::Response<super::InsertPlaylistResponse>, tonic::Status>
4214
+
{
4215
+
self.inner.ready().await.map_err(|e| {
4216
+
tonic::Status::unknown(format!("Service was not ready: {}", e.into()))
4217
+
})?;
4928
4218
let codec = tonic::codec::ProstCodec::default();
4929
4219
let path = http::uri::PathAndQuery::from_static(
4930
4220
"/rockbox.v1alpha1.PlaylistService/InsertPlaylist",
4931
4221
);
4932
4222
let mut req = request.into_request();
4933
-
req.extensions_mut()
4934
-
.insert(
4935
-
GrpcMethod::new("rockbox.v1alpha1.PlaylistService", "InsertPlaylist"),
4936
-
);
4223
+
req.extensions_mut().insert(GrpcMethod::new(
4224
+
"rockbox.v1alpha1.PlaylistService",
4225
+
"InsertPlaylist",
4226
+
));
4937
4227
self.inner.unary(req, path, codec).await
4938
4228
}
4939
4229
pub async fn insert_album(
4940
4230
&mut self,
4941
4231
request: impl tonic::IntoRequest<super::InsertAlbumRequest>,
4942
-
) -> std::result::Result<
4943
-
tonic::Response<super::InsertAlbumResponse>,
4944
-
tonic::Status,
4945
-
> {
4946
-
self.inner
4947
-
.ready()
4948
-
.await
4949
-
.map_err(|e| {
4950
-
tonic::Status::unknown(
4951
-
format!("Service was not ready: {}", e.into()),
4952
-
)
4953
-
})?;
4232
+
) -> std::result::Result<tonic::Response<super::InsertAlbumResponse>, tonic::Status>
4233
+
{
4234
+
self.inner.ready().await.map_err(|e| {
4235
+
tonic::Status::unknown(format!("Service was not ready: {}", e.into()))
4236
+
})?;
4954
4237
let codec = tonic::codec::ProstCodec::default();
4955
4238
let path = http::uri::PathAndQuery::from_static(
4956
4239
"/rockbox.v1alpha1.PlaylistService/InsertAlbum",
4957
4240
);
4958
4241
let mut req = request.into_request();
4959
-
req.extensions_mut()
4960
-
.insert(
4961
-
GrpcMethod::new("rockbox.v1alpha1.PlaylistService", "InsertAlbum"),
4962
-
);
4242
+
req.extensions_mut().insert(GrpcMethod::new(
4243
+
"rockbox.v1alpha1.PlaylistService",
4244
+
"InsertAlbum",
4245
+
));
4963
4246
self.inner.unary(req, path, codec).await
4964
4247
}
4965
4248
pub async fn insert_artist_tracks(
4966
4249
&mut self,
4967
4250
request: impl tonic::IntoRequest<super::InsertArtistTracksRequest>,
4968
-
) -> std::result::Result<
4969
-
tonic::Response<super::InsertArtistTracksResponse>,
4970
-
tonic::Status,
4971
-
> {
4972
-
self.inner
4973
-
.ready()
4974
-
.await
4975
-
.map_err(|e| {
4976
-
tonic::Status::unknown(
4977
-
format!("Service was not ready: {}", e.into()),
4978
-
)
4979
-
})?;
4251
+
) -> std::result::Result<tonic::Response<super::InsertArtistTracksResponse>, tonic::Status>
4252
+
{
4253
+
self.inner.ready().await.map_err(|e| {
4254
+
tonic::Status::unknown(format!("Service was not ready: {}", e.into()))
4255
+
})?;
4980
4256
let codec = tonic::codec::ProstCodec::default();
4981
4257
let path = http::uri::PathAndQuery::from_static(
4982
4258
"/rockbox.v1alpha1.PlaylistService/InsertArtistTracks",
4983
4259
);
4984
4260
let mut req = request.into_request();
4985
-
req.extensions_mut()
4986
-
.insert(
4987
-
GrpcMethod::new(
4988
-
"rockbox.v1alpha1.PlaylistService",
4989
-
"InsertArtistTracks",
4990
-
),
4991
-
);
4261
+
req.extensions_mut().insert(GrpcMethod::new(
4262
+
"rockbox.v1alpha1.PlaylistService",
4263
+
"InsertArtistTracks",
4264
+
));
4992
4265
self.inner.unary(req, path, codec).await
4993
4266
}
4994
4267
pub async fn shuffle_playlist(
4995
4268
&mut self,
4996
4269
request: impl tonic::IntoRequest<super::ShufflePlaylistRequest>,
4997
-
) -> std::result::Result<
4998
-
tonic::Response<super::ShufflePlaylistResponse>,
4999
-
tonic::Status,
5000
-
> {
5001
-
self.inner
5002
-
.ready()
5003
-
.await
5004
-
.map_err(|e| {
5005
-
tonic::Status::unknown(
5006
-
format!("Service was not ready: {}", e.into()),
5007
-
)
5008
-
})?;
4270
+
) -> std::result::Result<tonic::Response<super::ShufflePlaylistResponse>, tonic::Status>
4271
+
{
4272
+
self.inner.ready().await.map_err(|e| {
4273
+
tonic::Status::unknown(format!("Service was not ready: {}", e.into()))
4274
+
})?;
5009
4275
let codec = tonic::codec::ProstCodec::default();
5010
4276
let path = http::uri::PathAndQuery::from_static(
5011
4277
"/rockbox.v1alpha1.PlaylistService/ShufflePlaylist",
5012
4278
);
5013
4279
let mut req = request.into_request();
5014
-
req.extensions_mut()
5015
-
.insert(
5016
-
GrpcMethod::new(
5017
-
"rockbox.v1alpha1.PlaylistService",
5018
-
"ShufflePlaylist",
5019
-
),
5020
-
);
4280
+
req.extensions_mut().insert(GrpcMethod::new(
4281
+
"rockbox.v1alpha1.PlaylistService",
4282
+
"ShufflePlaylist",
4283
+
));
5021
4284
self.inner.unary(req, path, codec).await
5022
4285
}
5023
4286
}
···
5029
4292
dead_code,
5030
4293
missing_docs,
5031
4294
clippy::wildcard_imports,
5032
-
clippy::let_unit_value,
4295
+
clippy::let_unit_value
5033
4296
)]
5034
4297
use tonic::codegen::*;
5035
4298
/// Generated trait containing gRPC methods that should be implemented for use with PlaylistServiceServer.
···
5038
4301
async fn get_current(
5039
4302
&self,
5040
4303
request: tonic::Request<super::GetCurrentRequest>,
5041
-
) -> std::result::Result<
5042
-
tonic::Response<super::GetCurrentResponse>,
5043
-
tonic::Status,
5044
-
>;
4304
+
) -> std::result::Result<tonic::Response<super::GetCurrentResponse>, tonic::Status>;
5045
4305
async fn get_resume_info(
5046
4306
&self,
5047
4307
request: tonic::Request<super::GetResumeInfoRequest>,
5048
-
) -> std::result::Result<
5049
-
tonic::Response<super::GetResumeInfoResponse>,
5050
-
tonic::Status,
5051
-
>;
4308
+
) -> std::result::Result<tonic::Response<super::GetResumeInfoResponse>, tonic::Status>;
5052
4309
async fn get_track_info(
5053
4310
&self,
5054
4311
request: tonic::Request<super::GetTrackInfoRequest>,
5055
-
) -> std::result::Result<
5056
-
tonic::Response<super::GetTrackInfoResponse>,
5057
-
tonic::Status,
5058
-
>;
4312
+
) -> std::result::Result<tonic::Response<super::GetTrackInfoResponse>, tonic::Status>;
5059
4313
async fn get_first_index(
5060
4314
&self,
5061
4315
request: tonic::Request<super::GetFirstIndexRequest>,
5062
-
) -> std::result::Result<
5063
-
tonic::Response<super::GetFirstIndexResponse>,
5064
-
tonic::Status,
5065
-
>;
4316
+
) -> std::result::Result<tonic::Response<super::GetFirstIndexResponse>, tonic::Status>;
5066
4317
async fn get_display_index(
5067
4318
&self,
5068
4319
request: tonic::Request<super::GetDisplayIndexRequest>,
5069
-
) -> std::result::Result<
5070
-
tonic::Response<super::GetDisplayIndexResponse>,
5071
-
tonic::Status,
5072
-
>;
4320
+
) -> std::result::Result<tonic::Response<super::GetDisplayIndexResponse>, tonic::Status>;
5073
4321
async fn amount(
5074
4322
&self,
5075
4323
request: tonic::Request<super::AmountRequest>,
···
5077
4325
async fn playlist_resume(
5078
4326
&self,
5079
4327
request: tonic::Request<super::PlaylistResumeRequest>,
5080
-
) -> std::result::Result<
5081
-
tonic::Response<super::PlaylistResumeResponse>,
5082
-
tonic::Status,
5083
-
>;
4328
+
) -> std::result::Result<tonic::Response<super::PlaylistResumeResponse>, tonic::Status>;
5084
4329
async fn resume_track(
5085
4330
&self,
5086
4331
request: tonic::Request<super::ResumeTrackRequest>,
5087
-
) -> std::result::Result<
5088
-
tonic::Response<super::ResumeTrackResponse>,
5089
-
tonic::Status,
5090
-
>;
4332
+
) -> std::result::Result<tonic::Response<super::ResumeTrackResponse>, tonic::Status>;
5091
4333
async fn set_modified(
5092
4334
&self,
5093
4335
request: tonic::Request<super::SetModifiedRequest>,
5094
-
) -> std::result::Result<
5095
-
tonic::Response<super::SetModifiedResponse>,
5096
-
tonic::Status,
5097
-
>;
4336
+
) -> std::result::Result<tonic::Response<super::SetModifiedResponse>, tonic::Status>;
5098
4337
async fn start(
5099
4338
&self,
5100
4339
request: tonic::Request<super::StartRequest>,
···
5106
4345
async fn remove_all_tracks(
5107
4346
&self,
5108
4347
request: tonic::Request<super::RemoveAllTracksRequest>,
5109
-
) -> std::result::Result<
5110
-
tonic::Response<super::RemoveAllTracksResponse>,
5111
-
tonic::Status,
5112
-
>;
4348
+
) -> std::result::Result<tonic::Response<super::RemoveAllTracksResponse>, tonic::Status>;
5113
4349
async fn remove_tracks(
5114
4350
&self,
5115
4351
request: tonic::Request<super::RemoveTracksRequest>,
5116
-
) -> std::result::Result<
5117
-
tonic::Response<super::RemoveTracksResponse>,
5118
-
tonic::Status,
5119
-
>;
4352
+
) -> std::result::Result<tonic::Response<super::RemoveTracksResponse>, tonic::Status>;
5120
4353
async fn create_playlist(
5121
4354
&self,
5122
4355
request: tonic::Request<super::CreatePlaylistRequest>,
5123
-
) -> std::result::Result<
5124
-
tonic::Response<super::CreatePlaylistResponse>,
5125
-
tonic::Status,
5126
-
>;
4356
+
) -> std::result::Result<tonic::Response<super::CreatePlaylistResponse>, tonic::Status>;
5127
4357
async fn insert_tracks(
5128
4358
&self,
5129
4359
request: tonic::Request<super::InsertTracksRequest>,
5130
-
) -> std::result::Result<
5131
-
tonic::Response<super::InsertTracksResponse>,
5132
-
tonic::Status,
5133
-
>;
4360
+
) -> std::result::Result<tonic::Response<super::InsertTracksResponse>, tonic::Status>;
5134
4361
async fn insert_directory(
5135
4362
&self,
5136
4363
request: tonic::Request<super::InsertDirectoryRequest>,
5137
-
) -> std::result::Result<
5138
-
tonic::Response<super::InsertDirectoryResponse>,
5139
-
tonic::Status,
5140
-
>;
4364
+
) -> std::result::Result<tonic::Response<super::InsertDirectoryResponse>, tonic::Status>;
5141
4365
async fn insert_playlist(
5142
4366
&self,
5143
4367
request: tonic::Request<super::InsertPlaylistRequest>,
5144
-
) -> std::result::Result<
5145
-
tonic::Response<super::InsertPlaylistResponse>,
5146
-
tonic::Status,
5147
-
>;
4368
+
) -> std::result::Result<tonic::Response<super::InsertPlaylistResponse>, tonic::Status>;
5148
4369
async fn insert_album(
5149
4370
&self,
5150
4371
request: tonic::Request<super::InsertAlbumRequest>,
5151
-
) -> std::result::Result<
5152
-
tonic::Response<super::InsertAlbumResponse>,
5153
-
tonic::Status,
5154
-
>;
4372
+
) -> std::result::Result<tonic::Response<super::InsertAlbumResponse>, tonic::Status>;
5155
4373
async fn insert_artist_tracks(
5156
4374
&self,
5157
4375
request: tonic::Request<super::InsertArtistTracksRequest>,
5158
-
) -> std::result::Result<
5159
-
tonic::Response<super::InsertArtistTracksResponse>,
5160
-
tonic::Status,
5161
-
>;
4376
+
) -> std::result::Result<tonic::Response<super::InsertArtistTracksResponse>, tonic::Status>;
5162
4377
async fn shuffle_playlist(
5163
4378
&self,
5164
4379
request: tonic::Request<super::ShufflePlaylistRequest>,
5165
-
) -> std::result::Result<
5166
-
tonic::Response<super::ShufflePlaylistResponse>,
5167
-
tonic::Status,
5168
-
>;
4380
+
) -> std::result::Result<tonic::Response<super::ShufflePlaylistResponse>, tonic::Status>;
5169
4381
}
5170
4382
#[derive(Debug)]
5171
4383
pub struct PlaylistServiceServer<T> {
···
5188
4400
max_encoding_message_size: None,
5189
4401
}
5190
4402
}
5191
-
pub fn with_interceptor<F>(
5192
-
inner: T,
5193
-
interceptor: F,
5194
-
) -> InterceptedService<Self, F>
4403
+
pub fn with_interceptor<F>(inner: T, interceptor: F) -> InterceptedService<Self, F>
5195
4404
where
5196
4405
F: tonic::service::Interceptor,
5197
4406
{
···
5246
4455
"/rockbox.v1alpha1.PlaylistService/GetCurrent" => {
5247
4456
#[allow(non_camel_case_types)]
5248
4457
struct GetCurrentSvc<T: PlaylistService>(pub Arc<T>);
5249
-
impl<
5250
-
T: PlaylistService,
5251
-
> tonic::server::UnaryService<super::GetCurrentRequest>
5252
-
for GetCurrentSvc<T> {
4458
+
impl<T: PlaylistService> tonic::server::UnaryService<super::GetCurrentRequest>
4459
+
for GetCurrentSvc<T>
4460
+
{
5253
4461
type Response = super::GetCurrentResponse;
5254
-
type Future = BoxFuture<
5255
-
tonic::Response<Self::Response>,
5256
-
tonic::Status,
5257
-
>;
4462
+
type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
5258
4463
fn call(
5259
4464
&mut self,
5260
4465
request: tonic::Request<super::GetCurrentRequest>,
···
5291
4496
"/rockbox.v1alpha1.PlaylistService/GetResumeInfo" => {
5292
4497
#[allow(non_camel_case_types)]
5293
4498
struct GetResumeInfoSvc<T: PlaylistService>(pub Arc<T>);
5294
-
impl<
5295
-
T: PlaylistService,
5296
-
> tonic::server::UnaryService<super::GetResumeInfoRequest>
5297
-
for GetResumeInfoSvc<T> {
4499
+
impl<T: PlaylistService>
4500
+
tonic::server::UnaryService<super::GetResumeInfoRequest>
4501
+
for GetResumeInfoSvc<T>
4502
+
{
5298
4503
type Response = super::GetResumeInfoResponse;
5299
-
type Future = BoxFuture<
5300
-
tonic::Response<Self::Response>,
5301
-
tonic::Status,
5302
-
>;
4504
+
type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
5303
4505
fn call(
5304
4506
&mut self,
5305
4507
request: tonic::Request<super::GetResumeInfoRequest>,
5306
4508
) -> Self::Future {
5307
4509
let inner = Arc::clone(&self.0);
5308
4510
let fut = async move {
5309
-
<T as PlaylistService>::get_resume_info(&inner, request)
5310
-
.await
4511
+
<T as PlaylistService>::get_resume_info(&inner, request).await
5311
4512
};
5312
4513
Box::pin(fut)
5313
4514
}
···
5337
4538
"/rockbox.v1alpha1.PlaylistService/GetTrackInfo" => {
5338
4539
#[allow(non_camel_case_types)]
5339
4540
struct GetTrackInfoSvc<T: PlaylistService>(pub Arc<T>);
5340
-
impl<
5341
-
T: PlaylistService,
5342
-
> tonic::server::UnaryService<super::GetTrackInfoRequest>
5343
-
for GetTrackInfoSvc<T> {
4541
+
impl<T: PlaylistService> tonic::server::UnaryService<super::GetTrackInfoRequest>
4542
+
for GetTrackInfoSvc<T>
4543
+
{
5344
4544
type Response = super::GetTrackInfoResponse;
5345
-
type Future = BoxFuture<
5346
-
tonic::Response<Self::Response>,
5347
-
tonic::Status,
5348
-
>;
4545
+
type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
5349
4546
fn call(
5350
4547
&mut self,
5351
4548
request: tonic::Request<super::GetTrackInfoRequest>,
5352
4549
) -> Self::Future {
5353
4550
let inner = Arc::clone(&self.0);
5354
4551
let fut = async move {
5355
-
<T as PlaylistService>::get_track_info(&inner, request)
5356
-
.await
4552
+
<T as PlaylistService>::get_track_info(&inner, request).await
5357
4553
};
5358
4554
Box::pin(fut)
5359
4555
}
···
5383
4579
"/rockbox.v1alpha1.PlaylistService/GetFirstIndex" => {
5384
4580
#[allow(non_camel_case_types)]
5385
4581
struct GetFirstIndexSvc<T: PlaylistService>(pub Arc<T>);
5386
-
impl<
5387
-
T: PlaylistService,
5388
-
> tonic::server::UnaryService<super::GetFirstIndexRequest>
5389
-
for GetFirstIndexSvc<T> {
4582
+
impl<T: PlaylistService>
4583
+
tonic::server::UnaryService<super::GetFirstIndexRequest>
4584
+
for GetFirstIndexSvc<T>
4585
+
{
5390
4586
type Response = super::GetFirstIndexResponse;
5391
-
type Future = BoxFuture<
5392
-
tonic::Response<Self::Response>,
5393
-
tonic::Status,
5394
-
>;
4587
+
type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
5395
4588
fn call(
5396
4589
&mut self,
5397
4590
request: tonic::Request<super::GetFirstIndexRequest>,
5398
4591
) -> Self::Future {
5399
4592
let inner = Arc::clone(&self.0);
5400
4593
let fut = async move {
5401
-
<T as PlaylistService>::get_first_index(&inner, request)
5402
-
.await
4594
+
<T as PlaylistService>::get_first_index(&inner, request).await
5403
4595
};
5404
4596
Box::pin(fut)
5405
4597
}
···
5429
4621
"/rockbox.v1alpha1.PlaylistService/GetDisplayIndex" => {
5430
4622
#[allow(non_camel_case_types)]
5431
4623
struct GetDisplayIndexSvc<T: PlaylistService>(pub Arc<T>);
5432
-
impl<
5433
-
T: PlaylistService,
5434
-
> tonic::server::UnaryService<super::GetDisplayIndexRequest>
5435
-
for GetDisplayIndexSvc<T> {
4624
+
impl<T: PlaylistService>
4625
+
tonic::server::UnaryService<super::GetDisplayIndexRequest>
4626
+
for GetDisplayIndexSvc<T>
4627
+
{
5436
4628
type Response = super::GetDisplayIndexResponse;
5437
-
type Future = BoxFuture<
5438
-
tonic::Response<Self::Response>,
5439
-
tonic::Status,
5440
-
>;
4629
+
type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
5441
4630
fn call(
5442
4631
&mut self,
5443
4632
request: tonic::Request<super::GetDisplayIndexRequest>,
5444
4633
) -> Self::Future {
5445
4634
let inner = Arc::clone(&self.0);
5446
4635
let fut = async move {
5447
-
<T as PlaylistService>::get_display_index(&inner, request)
5448
-
.await
4636
+
<T as PlaylistService>::get_display_index(&inner, request).await
5449
4637
};
5450
4638
Box::pin(fut)
5451
4639
}
···
5475
4663
"/rockbox.v1alpha1.PlaylistService/Amount" => {
5476
4664
#[allow(non_camel_case_types)]
5477
4665
struct AmountSvc<T: PlaylistService>(pub Arc<T>);
5478
-
impl<
5479
-
T: PlaylistService,
5480
-
> tonic::server::UnaryService<super::AmountRequest>
5481
-
for AmountSvc<T> {
4666
+
impl<T: PlaylistService> tonic::server::UnaryService<super::AmountRequest> for AmountSvc<T> {
5482
4667
type Response = super::AmountResponse;
5483
-
type Future = BoxFuture<
5484
-
tonic::Response<Self::Response>,
5485
-
tonic::Status,
5486
-
>;
4668
+
type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
5487
4669
fn call(
5488
4670
&mut self,
5489
4671
request: tonic::Request<super::AmountRequest>,
···
5520
4702
"/rockbox.v1alpha1.PlaylistService/PlaylistResume" => {
5521
4703
#[allow(non_camel_case_types)]
5522
4704
struct PlaylistResumeSvc<T: PlaylistService>(pub Arc<T>);
5523
-
impl<
5524
-
T: PlaylistService,
5525
-
> tonic::server::UnaryService<super::PlaylistResumeRequest>
5526
-
for PlaylistResumeSvc<T> {
4705
+
impl<T: PlaylistService>
4706
+
tonic::server::UnaryService<super::PlaylistResumeRequest>
4707
+
for PlaylistResumeSvc<T>
4708
+
{
5527
4709
type Response = super::PlaylistResumeResponse;
5528
-
type Future = BoxFuture<
5529
-
tonic::Response<Self::Response>,
5530
-
tonic::Status,
5531
-
>;
4710
+
type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
5532
4711
fn call(
5533
4712
&mut self,
5534
4713
request: tonic::Request<super::PlaylistResumeRequest>,
5535
4714
) -> Self::Future {
5536
4715
let inner = Arc::clone(&self.0);
5537
4716
let fut = async move {
5538
-
<T as PlaylistService>::playlist_resume(&inner, request)
5539
-
.await
4717
+
<T as PlaylistService>::playlist_resume(&inner, request).await
5540
4718
};
5541
4719
Box::pin(fut)
5542
4720
}
···
5566
4744
"/rockbox.v1alpha1.PlaylistService/ResumeTrack" => {
5567
4745
#[allow(non_camel_case_types)]
5568
4746
struct ResumeTrackSvc<T: PlaylistService>(pub Arc<T>);
5569
-
impl<
5570
-
T: PlaylistService,
5571
-
> tonic::server::UnaryService<super::ResumeTrackRequest>
5572
-
for ResumeTrackSvc<T> {
4747
+
impl<T: PlaylistService> tonic::server::UnaryService<super::ResumeTrackRequest>
4748
+
for ResumeTrackSvc<T>
4749
+
{
5573
4750
type Response = super::ResumeTrackResponse;
5574
-
type Future = BoxFuture<
5575
-
tonic::Response<Self::Response>,
5576
-
tonic::Status,
5577
-
>;
4751
+
type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
5578
4752
fn call(
5579
4753
&mut self,
5580
4754
request: tonic::Request<super::ResumeTrackRequest>,
···
5611
4785
"/rockbox.v1alpha1.PlaylistService/SetModified" => {
5612
4786
#[allow(non_camel_case_types)]
5613
4787
struct SetModifiedSvc<T: PlaylistService>(pub Arc<T>);
5614
-
impl<
5615
-
T: PlaylistService,
5616
-
> tonic::server::UnaryService<super::SetModifiedRequest>
5617
-
for SetModifiedSvc<T> {
4788
+
impl<T: PlaylistService> tonic::server::UnaryService<super::SetModifiedRequest>
4789
+
for SetModifiedSvc<T>
4790
+
{
5618
4791
type Response = super::SetModifiedResponse;
5619
-
type Future = BoxFuture<
5620
-
tonic::Response<Self::Response>,
5621
-
tonic::Status,
5622
-
>;
4792
+
type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
5623
4793
fn call(
5624
4794
&mut self,
5625
4795
request: tonic::Request<super::SetModifiedRequest>,
···
5656
4826
"/rockbox.v1alpha1.PlaylistService/Start" => {
5657
4827
#[allow(non_camel_case_types)]
5658
4828
struct StartSvc<T: PlaylistService>(pub Arc<T>);
5659
-
impl<
5660
-
T: PlaylistService,
5661
-
> tonic::server::UnaryService<super::StartRequest> for StartSvc<T> {
4829
+
impl<T: PlaylistService> tonic::server::UnaryService<super::StartRequest> for StartSvc<T> {
5662
4830
type Response = super::StartResponse;
5663
-
type Future = BoxFuture<
5664
-
tonic::Response<Self::Response>,
5665
-
tonic::Status,
5666
-
>;
4831
+
type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
5667
4832
fn call(
5668
4833
&mut self,
5669
4834
request: tonic::Request<super::StartRequest>,
5670
4835
) -> Self::Future {
5671
4836
let inner = Arc::clone(&self.0);
5672
-
let fut = async move {
5673
-
<T as PlaylistService>::start(&inner, request).await
5674
-
};
4837
+
let fut =
4838
+
async move { <T as PlaylistService>::start(&inner, request).await };
5675
4839
Box::pin(fut)
5676
4840
}
5677
4841
}
···
5700
4864
"/rockbox.v1alpha1.PlaylistService/Sync" => {
5701
4865
#[allow(non_camel_case_types)]
5702
4866
struct SyncSvc<T: PlaylistService>(pub Arc<T>);
5703
-
impl<
5704
-
T: PlaylistService,
5705
-
> tonic::server::UnaryService<super::SyncRequest> for SyncSvc<T> {
4867
+
impl<T: PlaylistService> tonic::server::UnaryService<super::SyncRequest> for SyncSvc<T> {
5706
4868
type Response = super::SyncResponse;
5707
-
type Future = BoxFuture<
5708
-
tonic::Response<Self::Response>,
5709
-
tonic::Status,
5710
-
>;
4869
+
type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
5711
4870
fn call(
5712
4871
&mut self,
5713
4872
request: tonic::Request<super::SyncRequest>,
5714
4873
) -> Self::Future {
5715
4874
let inner = Arc::clone(&self.0);
5716
-
let fut = async move {
5717
-
<T as PlaylistService>::sync(&inner, request).await
5718
-
};
4875
+
let fut =
4876
+
async move { <T as PlaylistService>::sync(&inner, request).await };
5719
4877
Box::pin(fut)
5720
4878
}
5721
4879
}
···
5744
4902
"/rockbox.v1alpha1.PlaylistService/RemoveAllTracks" => {
5745
4903
#[allow(non_camel_case_types)]
5746
4904
struct RemoveAllTracksSvc<T: PlaylistService>(pub Arc<T>);
5747
-
impl<
5748
-
T: PlaylistService,
5749
-
> tonic::server::UnaryService<super::RemoveAllTracksRequest>
5750
-
for RemoveAllTracksSvc<T> {
4905
+
impl<T: PlaylistService>
4906
+
tonic::server::UnaryService<super::RemoveAllTracksRequest>
4907
+
for RemoveAllTracksSvc<T>
4908
+
{
5751
4909
type Response = super::RemoveAllTracksResponse;
5752
-
type Future = BoxFuture<
5753
-
tonic::Response<Self::Response>,
5754
-
tonic::Status,
5755
-
>;
4910
+
type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
5756
4911
fn call(
5757
4912
&mut self,
5758
4913
request: tonic::Request<super::RemoveAllTracksRequest>,
5759
4914
) -> Self::Future {
5760
4915
let inner = Arc::clone(&self.0);
5761
4916
let fut = async move {
5762
-
<T as PlaylistService>::remove_all_tracks(&inner, request)
5763
-
.await
4917
+
<T as PlaylistService>::remove_all_tracks(&inner, request).await
5764
4918
};
5765
4919
Box::pin(fut)
5766
4920
}
···
5790
4944
"/rockbox.v1alpha1.PlaylistService/RemoveTracks" => {
5791
4945
#[allow(non_camel_case_types)]
5792
4946
struct RemoveTracksSvc<T: PlaylistService>(pub Arc<T>);
5793
-
impl<
5794
-
T: PlaylistService,
5795
-
> tonic::server::UnaryService<super::RemoveTracksRequest>
5796
-
for RemoveTracksSvc<T> {
4947
+
impl<T: PlaylistService> tonic::server::UnaryService<super::RemoveTracksRequest>
4948
+
for RemoveTracksSvc<T>
4949
+
{
5797
4950
type Response = super::RemoveTracksResponse;
5798
-
type Future = BoxFuture<
5799
-
tonic::Response<Self::Response>,
5800
-
tonic::Status,
5801
-
>;
4951
+
type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
5802
4952
fn call(
5803
4953
&mut self,
5804
4954
request: tonic::Request<super::RemoveTracksRequest>,
···
5835
4985
"/rockbox.v1alpha1.PlaylistService/CreatePlaylist" => {
5836
4986
#[allow(non_camel_case_types)]
5837
4987
struct CreatePlaylistSvc<T: PlaylistService>(pub Arc<T>);
5838
-
impl<
5839
-
T: PlaylistService,
5840
-
> tonic::server::UnaryService<super::CreatePlaylistRequest>
5841
-
for CreatePlaylistSvc<T> {
4988
+
impl<T: PlaylistService>
4989
+
tonic::server::UnaryService<super::CreatePlaylistRequest>
4990
+
for CreatePlaylistSvc<T>
4991
+
{
5842
4992
type Response = super::CreatePlaylistResponse;
5843
-
type Future = BoxFuture<
5844
-
tonic::Response<Self::Response>,
5845
-
tonic::Status,
5846
-
>;
4993
+
type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
5847
4994
fn call(
5848
4995
&mut self,
5849
4996
request: tonic::Request<super::CreatePlaylistRequest>,
5850
4997
) -> Self::Future {
5851
4998
let inner = Arc::clone(&self.0);
5852
4999
let fut = async move {
5853
-
<T as PlaylistService>::create_playlist(&inner, request)
5854
-
.await
5000
+
<T as PlaylistService>::create_playlist(&inner, request).await
5855
5001
};
5856
5002
Box::pin(fut)
5857
5003
}
···
5881
5027
"/rockbox.v1alpha1.PlaylistService/InsertTracks" => {
5882
5028
#[allow(non_camel_case_types)]
5883
5029
struct InsertTracksSvc<T: PlaylistService>(pub Arc<T>);
5884
-
impl<
5885
-
T: PlaylistService,
5886
-
> tonic::server::UnaryService<super::InsertTracksRequest>
5887
-
for InsertTracksSvc<T> {
5030
+
impl<T: PlaylistService> tonic::server::UnaryService<super::InsertTracksRequest>
5031
+
for InsertTracksSvc<T>
5032
+
{
5888
5033
type Response = super::InsertTracksResponse;
5889
-
type Future = BoxFuture<
5890
-
tonic::Response<Self::Response>,
5891
-
tonic::Status,
5892
-
>;
5034
+
type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
5893
5035
fn call(
5894
5036
&mut self,
5895
5037
request: tonic::Request<super::InsertTracksRequest>,
···
5926
5068
"/rockbox.v1alpha1.PlaylistService/InsertDirectory" => {
5927
5069
#[allow(non_camel_case_types)]
5928
5070
struct InsertDirectorySvc<T: PlaylistService>(pub Arc<T>);
5929
-
impl<
5930
-
T: PlaylistService,
5931
-
> tonic::server::UnaryService<super::InsertDirectoryRequest>
5932
-
for InsertDirectorySvc<T> {
5071
+
impl<T: PlaylistService>
5072
+
tonic::server::UnaryService<super::InsertDirectoryRequest>
5073
+
for InsertDirectorySvc<T>
5074
+
{
5933
5075
type Response = super::InsertDirectoryResponse;
5934
-
type Future = BoxFuture<
5935
-
tonic::Response<Self::Response>,
5936
-
tonic::Status,
5937
-
>;
5076
+
type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
5938
5077
fn call(
5939
5078
&mut self,
5940
5079
request: tonic::Request<super::InsertDirectoryRequest>,
5941
5080
) -> Self::Future {
5942
5081
let inner = Arc::clone(&self.0);
5943
5082
let fut = async move {
5944
-
<T as PlaylistService>::insert_directory(&inner, request)
5945
-
.await
5083
+
<T as PlaylistService>::insert_directory(&inner, request).await
5946
5084
};
5947
5085
Box::pin(fut)
5948
5086
}
···
5972
5110
"/rockbox.v1alpha1.PlaylistService/InsertPlaylist" => {
5973
5111
#[allow(non_camel_case_types)]
5974
5112
struct InsertPlaylistSvc<T: PlaylistService>(pub Arc<T>);
5975
-
impl<
5976
-
T: PlaylistService,
5977
-
> tonic::server::UnaryService<super::InsertPlaylistRequest>
5978
-
for InsertPlaylistSvc<T> {
5113
+
impl<T: PlaylistService>
5114
+
tonic::server::UnaryService<super::InsertPlaylistRequest>
5115
+
for InsertPlaylistSvc<T>
5116
+
{
5979
5117
type Response = super::InsertPlaylistResponse;
5980
-
type Future = BoxFuture<
5981
-
tonic::Response<Self::Response>,
5982
-
tonic::Status,
5983
-
>;
5118
+
type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
5984
5119
fn call(
5985
5120
&mut self,
5986
5121
request: tonic::Request<super::InsertPlaylistRequest>,
5987
5122
) -> Self::Future {
5988
5123
let inner = Arc::clone(&self.0);
5989
5124
let fut = async move {
5990
-
<T as PlaylistService>::insert_playlist(&inner, request)
5991
-
.await
5125
+
<T as PlaylistService>::insert_playlist(&inner, request).await
5992
5126
};
5993
5127
Box::pin(fut)
5994
5128
}
···
6018
5152
"/rockbox.v1alpha1.PlaylistService/InsertAlbum" => {
6019
5153
#[allow(non_camel_case_types)]
6020
5154
struct InsertAlbumSvc<T: PlaylistService>(pub Arc<T>);
6021
-
impl<
6022
-
T: PlaylistService,
6023
-
> tonic::server::UnaryService<super::InsertAlbumRequest>
6024
-
for InsertAlbumSvc<T> {
5155
+
impl<T: PlaylistService> tonic::server::UnaryService<super::InsertAlbumRequest>
5156
+
for InsertAlbumSvc<T>
5157
+
{
6025
5158
type Response = super::InsertAlbumResponse;
6026
-
type Future = BoxFuture<
6027
-
tonic::Response<Self::Response>,
6028
-
tonic::Status,
6029
-
>;
5159
+
type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
6030
5160
fn call(
6031
5161
&mut self,
6032
5162
request: tonic::Request<super::InsertAlbumRequest>,
···
6063
5193
"/rockbox.v1alpha1.PlaylistService/InsertArtistTracks" => {
6064
5194
#[allow(non_camel_case_types)]
6065
5195
struct InsertArtistTracksSvc<T: PlaylistService>(pub Arc<T>);
6066
-
impl<
6067
-
T: PlaylistService,
6068
-
> tonic::server::UnaryService<super::InsertArtistTracksRequest>
6069
-
for InsertArtistTracksSvc<T> {
5196
+
impl<T: PlaylistService>
5197
+
tonic::server::UnaryService<super::InsertArtistTracksRequest>
5198
+
for InsertArtistTracksSvc<T>
5199
+
{
6070
5200
type Response = super::InsertArtistTracksResponse;
6071
-
type Future = BoxFuture<
6072
-
tonic::Response<Self::Response>,
6073
-
tonic::Status,
6074
-
>;
5201
+
type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
6075
5202
fn call(
6076
5203
&mut self,
6077
5204
request: tonic::Request<super::InsertArtistTracksRequest>,
6078
5205
) -> Self::Future {
6079
5206
let inner = Arc::clone(&self.0);
6080
5207
let fut = async move {
6081
-
<T as PlaylistService>::insert_artist_tracks(
6082
-
&inner,
6083
-
request,
6084
-
)
6085
-
.await
5208
+
<T as PlaylistService>::insert_artist_tracks(&inner, request).await
6086
5209
};
6087
5210
Box::pin(fut)
6088
5211
}
···
6112
5235
"/rockbox.v1alpha1.PlaylistService/ShufflePlaylist" => {
6113
5236
#[allow(non_camel_case_types)]
6114
5237
struct ShufflePlaylistSvc<T: PlaylistService>(pub Arc<T>);
6115
-
impl<
6116
-
T: PlaylistService,
6117
-
> tonic::server::UnaryService<super::ShufflePlaylistRequest>
6118
-
for ShufflePlaylistSvc<T> {
5238
+
impl<T: PlaylistService>
5239
+
tonic::server::UnaryService<super::ShufflePlaylistRequest>
5240
+
for ShufflePlaylistSvc<T>
5241
+
{
6119
5242
type Response = super::ShufflePlaylistResponse;
6120
-
type Future = BoxFuture<
6121
-
tonic::Response<Self::Response>,
6122
-
tonic::Status,
6123
-
>;
5243
+
type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
6124
5244
fn call(
6125
5245
&mut self,
6126
5246
request: tonic::Request<super::ShufflePlaylistRequest>,
6127
5247
) -> Self::Future {
6128
5248
let inner = Arc::clone(&self.0);
6129
5249
let fut = async move {
6130
-
<T as PlaylistService>::shuffle_playlist(&inner, request)
6131
-
.await
5250
+
<T as PlaylistService>::shuffle_playlist(&inner, request).await
6132
5251
};
6133
5252
Box::pin(fut)
6134
5253
}
···
6155
5274
};
6156
5275
Box::pin(fut)
6157
5276
}
6158
-
_ => {
6159
-
Box::pin(async move {
6160
-
let mut response = http::Response::new(empty_body());
6161
-
let headers = response.headers_mut();
6162
-
headers
6163
-
.insert(
6164
-
tonic::Status::GRPC_STATUS,
6165
-
(tonic::Code::Unimplemented as i32).into(),
6166
-
);
6167
-
headers
6168
-
.insert(
6169
-
http::header::CONTENT_TYPE,
6170
-
tonic::metadata::GRPC_CONTENT_TYPE,
6171
-
);
6172
-
Ok(response)
6173
-
})
6174
-
}
5277
+
_ => Box::pin(async move {
5278
+
let mut response = http::Response::new(empty_body());
5279
+
let headers = response.headers_mut();
5280
+
headers.insert(
5281
+
tonic::Status::GRPC_STATUS,
5282
+
(tonic::Code::Unimplemented as i32).into(),
5283
+
);
5284
+
headers.insert(
5285
+
http::header::CONTENT_TYPE,
5286
+
tonic::metadata::GRPC_CONTENT_TYPE,
5287
+
);
5288
+
Ok(response)
5289
+
}),
6175
5290
}
6176
5291
}
6177
5292
}
···
6679
5794
dead_code,
6680
5795
missing_docs,
6681
5796
clippy::wildcard_imports,
6682
-
clippy::let_unit_value,
5797
+
clippy::let_unit_value
6683
5798
)]
6684
-
use tonic::codegen::*;
6685
5799
use tonic::codegen::http::Uri;
5800
+
use tonic::codegen::*;
6686
5801
#[derive(Debug, Clone)]
6687
5802
pub struct SettingsServiceClient<T> {
6688
5803
inner: tonic::client::Grpc<T>,
···
6726
5841
<T as tonic::client::GrpcService<tonic::body::BoxBody>>::ResponseBody,
6727
5842
>,
6728
5843
>,
6729
-
<T as tonic::codegen::Service<
6730
-
http::Request<tonic::body::BoxBody>,
6731
-
>>::Error: Into<StdError> + std::marker::Send + std::marker::Sync,
5844
+
<T as tonic::codegen::Service<http::Request<tonic::body::BoxBody>>>::Error:
5845
+
Into<StdError> + std::marker::Send + std::marker::Sync,
6732
5846
{
6733
5847
SettingsServiceClient::new(InterceptedService::new(inner, interceptor))
6734
5848
}
···
6766
5880
pub async fn get_settings_list(
6767
5881
&mut self,
6768
5882
request: impl tonic::IntoRequest<super::GetSettingsListRequest>,
6769
-
) -> std::result::Result<
6770
-
tonic::Response<super::GetSettingsListResponse>,
6771
-
tonic::Status,
6772
-
> {
6773
-
self.inner
6774
-
.ready()
6775
-
.await
6776
-
.map_err(|e| {
6777
-
tonic::Status::unknown(
6778
-
format!("Service was not ready: {}", e.into()),
6779
-
)
6780
-
})?;
5883
+
) -> std::result::Result<tonic::Response<super::GetSettingsListResponse>, tonic::Status>
5884
+
{
5885
+
self.inner.ready().await.map_err(|e| {
5886
+
tonic::Status::unknown(format!("Service was not ready: {}", e.into()))
5887
+
})?;
6781
5888
let codec = tonic::codec::ProstCodec::default();
6782
5889
let path = http::uri::PathAndQuery::from_static(
6783
5890
"/rockbox.v1alpha1.SettingsService/GetSettingsList",
6784
5891
);
6785
5892
let mut req = request.into_request();
6786
-
req.extensions_mut()
6787
-
.insert(
6788
-
GrpcMethod::new(
6789
-
"rockbox.v1alpha1.SettingsService",
6790
-
"GetSettingsList",
6791
-
),
6792
-
);
5893
+
req.extensions_mut().insert(GrpcMethod::new(
5894
+
"rockbox.v1alpha1.SettingsService",
5895
+
"GetSettingsList",
5896
+
));
6793
5897
self.inner.unary(req, path, codec).await
6794
5898
}
6795
5899
pub async fn get_global_settings(
6796
5900
&mut self,
6797
5901
request: impl tonic::IntoRequest<super::GetGlobalSettingsRequest>,
6798
-
) -> std::result::Result<
6799
-
tonic::Response<super::GetGlobalSettingsResponse>,
6800
-
tonic::Status,
6801
-
> {
6802
-
self.inner
6803
-
.ready()
6804
-
.await
6805
-
.map_err(|e| {
6806
-
tonic::Status::unknown(
6807
-
format!("Service was not ready: {}", e.into()),
6808
-
)
6809
-
})?;
5902
+
) -> std::result::Result<tonic::Response<super::GetGlobalSettingsResponse>, tonic::Status>
5903
+
{
5904
+
self.inner.ready().await.map_err(|e| {
5905
+
tonic::Status::unknown(format!("Service was not ready: {}", e.into()))
5906
+
})?;
6810
5907
let codec = tonic::codec::ProstCodec::default();
6811
5908
let path = http::uri::PathAndQuery::from_static(
6812
5909
"/rockbox.v1alpha1.SettingsService/GetGlobalSettings",
6813
5910
);
6814
5911
let mut req = request.into_request();
6815
-
req.extensions_mut()
6816
-
.insert(
6817
-
GrpcMethod::new(
6818
-
"rockbox.v1alpha1.SettingsService",
6819
-
"GetGlobalSettings",
6820
-
),
6821
-
);
5912
+
req.extensions_mut().insert(GrpcMethod::new(
5913
+
"rockbox.v1alpha1.SettingsService",
5914
+
"GetGlobalSettings",
5915
+
));
6822
5916
self.inner.unary(req, path, codec).await
6823
5917
}
6824
5918
pub async fn save_settings(
6825
5919
&mut self,
6826
5920
request: impl tonic::IntoRequest<super::SaveSettingsRequest>,
6827
-
) -> std::result::Result<
6828
-
tonic::Response<super::SaveSettingsResponse>,
6829
-
tonic::Status,
6830
-
> {
6831
-
self.inner
6832
-
.ready()
6833
-
.await
6834
-
.map_err(|e| {
6835
-
tonic::Status::unknown(
6836
-
format!("Service was not ready: {}", e.into()),
6837
-
)
6838
-
})?;
5921
+
) -> std::result::Result<tonic::Response<super::SaveSettingsResponse>, tonic::Status>
5922
+
{
5923
+
self.inner.ready().await.map_err(|e| {
5924
+
tonic::Status::unknown(format!("Service was not ready: {}", e.into()))
5925
+
})?;
6839
5926
let codec = tonic::codec::ProstCodec::default();
6840
5927
let path = http::uri::PathAndQuery::from_static(
6841
5928
"/rockbox.v1alpha1.SettingsService/SaveSettings",
6842
5929
);
6843
5930
let mut req = request.into_request();
6844
-
req.extensions_mut()
6845
-
.insert(
6846
-
GrpcMethod::new("rockbox.v1alpha1.SettingsService", "SaveSettings"),
6847
-
);
5931
+
req.extensions_mut().insert(GrpcMethod::new(
5932
+
"rockbox.v1alpha1.SettingsService",
5933
+
"SaveSettings",
5934
+
));
6848
5935
self.inner.unary(req, path, codec).await
6849
5936
}
6850
5937
}
···
6856
5943
dead_code,
6857
5944
missing_docs,
6858
5945
clippy::wildcard_imports,
6859
-
clippy::let_unit_value,
5946
+
clippy::let_unit_value
6860
5947
)]
6861
5948
use tonic::codegen::*;
6862
5949
/// Generated trait containing gRPC methods that should be implemented for use with SettingsServiceServer.
···
6865
5952
async fn get_settings_list(
6866
5953
&self,
6867
5954
request: tonic::Request<super::GetSettingsListRequest>,
6868
-
) -> std::result::Result<
6869
-
tonic::Response<super::GetSettingsListResponse>,
6870
-
tonic::Status,
6871
-
>;
5955
+
) -> std::result::Result<tonic::Response<super::GetSettingsListResponse>, tonic::Status>;
6872
5956
async fn get_global_settings(
6873
5957
&self,
6874
5958
request: tonic::Request<super::GetGlobalSettingsRequest>,
6875
-
) -> std::result::Result<
6876
-
tonic::Response<super::GetGlobalSettingsResponse>,
6877
-
tonic::Status,
6878
-
>;
5959
+
) -> std::result::Result<tonic::Response<super::GetGlobalSettingsResponse>, tonic::Status>;
6879
5960
async fn save_settings(
6880
5961
&self,
6881
5962
request: tonic::Request<super::SaveSettingsRequest>,
6882
-
) -> std::result::Result<
6883
-
tonic::Response<super::SaveSettingsResponse>,
6884
-
tonic::Status,
6885
-
>;
5963
+
) -> std::result::Result<tonic::Response<super::SaveSettingsResponse>, tonic::Status>;
6886
5964
}
6887
5965
#[derive(Debug)]
6888
5966
pub struct SettingsServiceServer<T> {
···
6905
5983
max_encoding_message_size: None,
6906
5984
}
6907
5985
}
6908
-
pub fn with_interceptor<F>(
6909
-
inner: T,
6910
-
interceptor: F,
6911
-
) -> InterceptedService<Self, F>
5986
+
pub fn with_interceptor<F>(inner: T, interceptor: F) -> InterceptedService<Self, F>
6912
5987
where
6913
5988
F: tonic::service::Interceptor,
6914
5989
{
···
6963
6038
"/rockbox.v1alpha1.SettingsService/GetSettingsList" => {
6964
6039
#[allow(non_camel_case_types)]
6965
6040
struct GetSettingsListSvc<T: SettingsService>(pub Arc<T>);
6966
-
impl<
6967
-
T: SettingsService,
6968
-
> tonic::server::UnaryService<super::GetSettingsListRequest>
6969
-
for GetSettingsListSvc<T> {
6041
+
impl<T: SettingsService>
6042
+
tonic::server::UnaryService<super::GetSettingsListRequest>
6043
+
for GetSettingsListSvc<T>
6044
+
{
6970
6045
type Response = super::GetSettingsListResponse;
6971
-
type Future = BoxFuture<
6972
-
tonic::Response<Self::Response>,
6973
-
tonic::Status,
6974
-
>;
6046
+
type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
6975
6047
fn call(
6976
6048
&mut self,
6977
6049
request: tonic::Request<super::GetSettingsListRequest>,
6978
6050
) -> Self::Future {
6979
6051
let inner = Arc::clone(&self.0);
6980
6052
let fut = async move {
6981
-
<T as SettingsService>::get_settings_list(&inner, request)
6982
-
.await
6053
+
<T as SettingsService>::get_settings_list(&inner, request).await
6983
6054
};
6984
6055
Box::pin(fut)
6985
6056
}
···
7009
6080
"/rockbox.v1alpha1.SettingsService/GetGlobalSettings" => {
7010
6081
#[allow(non_camel_case_types)]
7011
6082
struct GetGlobalSettingsSvc<T: SettingsService>(pub Arc<T>);
7012
-
impl<
7013
-
T: SettingsService,
7014
-
> tonic::server::UnaryService<super::GetGlobalSettingsRequest>
7015
-
for GetGlobalSettingsSvc<T> {
6083
+
impl<T: SettingsService>
6084
+
tonic::server::UnaryService<super::GetGlobalSettingsRequest>
6085
+
for GetGlobalSettingsSvc<T>
6086
+
{
7016
6087
type Response = super::GetGlobalSettingsResponse;
7017
-
type Future = BoxFuture<
7018
-
tonic::Response<Self::Response>,
7019
-
tonic::Status,
7020
-
>;
6088
+
type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
7021
6089
fn call(
7022
6090
&mut self,
7023
6091
request: tonic::Request<super::GetGlobalSettingsRequest>,
7024
6092
) -> Self::Future {
7025
6093
let inner = Arc::clone(&self.0);
7026
6094
let fut = async move {
7027
-
<T as SettingsService>::get_global_settings(&inner, request)
7028
-
.await
6095
+
<T as SettingsService>::get_global_settings(&inner, request).await
7029
6096
};
7030
6097
Box::pin(fut)
7031
6098
}
···
7055
6122
"/rockbox.v1alpha1.SettingsService/SaveSettings" => {
7056
6123
#[allow(non_camel_case_types)]
7057
6124
struct SaveSettingsSvc<T: SettingsService>(pub Arc<T>);
7058
-
impl<
7059
-
T: SettingsService,
7060
-
> tonic::server::UnaryService<super::SaveSettingsRequest>
7061
-
for SaveSettingsSvc<T> {
6125
+
impl<T: SettingsService> tonic::server::UnaryService<super::SaveSettingsRequest>
6126
+
for SaveSettingsSvc<T>
6127
+
{
7062
6128
type Response = super::SaveSettingsResponse;
7063
-
type Future = BoxFuture<
7064
-
tonic::Response<Self::Response>,
7065
-
tonic::Status,
7066
-
>;
6129
+
type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
7067
6130
fn call(
7068
6131
&mut self,
7069
6132
request: tonic::Request<super::SaveSettingsRequest>,
···
7097
6160
};
7098
6161
Box::pin(fut)
7099
6162
}
7100
-
_ => {
7101
-
Box::pin(async move {
7102
-
let mut response = http::Response::new(empty_body());
7103
-
let headers = response.headers_mut();
7104
-
headers
7105
-
.insert(
7106
-
tonic::Status::GRPC_STATUS,
7107
-
(tonic::Code::Unimplemented as i32).into(),
7108
-
);
7109
-
headers
7110
-
.insert(
7111
-
http::header::CONTENT_TYPE,
7112
-
tonic::metadata::GRPC_CONTENT_TYPE,
7113
-
);
7114
-
Ok(response)
7115
-
})
7116
-
}
6163
+
_ => Box::pin(async move {
6164
+
let mut response = http::Response::new(empty_body());
6165
+
let headers = response.headers_mut();
6166
+
headers.insert(
6167
+
tonic::Status::GRPC_STATUS,
6168
+
(tonic::Code::Unimplemented as i32).into(),
6169
+
);
6170
+
headers.insert(
6171
+
http::header::CONTENT_TYPE,
6172
+
tonic::metadata::GRPC_CONTENT_TYPE,
6173
+
);
6174
+
Ok(response)
6175
+
}),
7117
6176
}
7118
6177
}
7119
6178
}
···
7271
6330
dead_code,
7272
6331
missing_docs,
7273
6332
clippy::wildcard_imports,
7274
-
clippy::let_unit_value,
6333
+
clippy::let_unit_value
7275
6334
)]
7276
-
use tonic::codegen::*;
7277
6335
use tonic::codegen::http::Uri;
6336
+
use tonic::codegen::*;
7278
6337
#[derive(Debug, Clone)]
7279
6338
pub struct SoundServiceClient<T> {
7280
6339
inner: tonic::client::Grpc<T>,
···
7318
6377
<T as tonic::client::GrpcService<tonic::body::BoxBody>>::ResponseBody,
7319
6378
>,
7320
6379
>,
7321
-
<T as tonic::codegen::Service<
7322
-
http::Request<tonic::body::BoxBody>,
7323
-
>>::Error: Into<StdError> + std::marker::Send + std::marker::Sync,
6380
+
<T as tonic::codegen::Service<http::Request<tonic::body::BoxBody>>>::Error:
6381
+
Into<StdError> + std::marker::Send + std::marker::Sync,
7324
6382
{
7325
6383
SoundServiceClient::new(InterceptedService::new(inner, interceptor))
7326
6384
}
···
7358
6416
pub async fn adjust_volume(
7359
6417
&mut self,
7360
6418
request: impl tonic::IntoRequest<super::AdjustVolumeRequest>,
7361
-
) -> std::result::Result<
7362
-
tonic::Response<super::AdjustVolumeResponse>,
7363
-
tonic::Status,
7364
-
> {
7365
-
self.inner
7366
-
.ready()
7367
-
.await
7368
-
.map_err(|e| {
7369
-
tonic::Status::unknown(
7370
-
format!("Service was not ready: {}", e.into()),
7371
-
)
7372
-
})?;
6419
+
) -> std::result::Result<tonic::Response<super::AdjustVolumeResponse>, tonic::Status>
6420
+
{
6421
+
self.inner.ready().await.map_err(|e| {
6422
+
tonic::Status::unknown(format!("Service was not ready: {}", e.into()))
6423
+
})?;
7373
6424
let codec = tonic::codec::ProstCodec::default();
7374
-
let path = http::uri::PathAndQuery::from_static(
7375
-
"/rockbox.v1alpha1.SoundService/AdjustVolume",
7376
-
);
6425
+
let path =
6426
+
http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.SoundService/AdjustVolume");
7377
6427
let mut req = request.into_request();
7378
-
req.extensions_mut()
7379
-
.insert(
7380
-
GrpcMethod::new("rockbox.v1alpha1.SoundService", "AdjustVolume"),
7381
-
);
6428
+
req.extensions_mut().insert(GrpcMethod::new(
6429
+
"rockbox.v1alpha1.SoundService",
6430
+
"AdjustVolume",
6431
+
));
7382
6432
self.inner.unary(req, path, codec).await
7383
6433
}
7384
6434
pub async fn sound_set(
7385
6435
&mut self,
7386
6436
request: impl tonic::IntoRequest<super::SoundSetRequest>,
7387
-
) -> std::result::Result<
7388
-
tonic::Response<super::SoundSetResponse>,
7389
-
tonic::Status,
7390
-
> {
7391
-
self.inner
7392
-
.ready()
7393
-
.await
7394
-
.map_err(|e| {
7395
-
tonic::Status::unknown(
7396
-
format!("Service was not ready: {}", e.into()),
7397
-
)
7398
-
})?;
6437
+
) -> std::result::Result<tonic::Response<super::SoundSetResponse>, tonic::Status> {
6438
+
self.inner.ready().await.map_err(|e| {
6439
+
tonic::Status::unknown(format!("Service was not ready: {}", e.into()))
6440
+
})?;
7399
6441
let codec = tonic::codec::ProstCodec::default();
7400
-
let path = http::uri::PathAndQuery::from_static(
7401
-
"/rockbox.v1alpha1.SoundService/SoundSet",
7402
-
);
6442
+
let path =
6443
+
http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.SoundService/SoundSet");
7403
6444
let mut req = request.into_request();
7404
6445
req.extensions_mut()
7405
6446
.insert(GrpcMethod::new("rockbox.v1alpha1.SoundService", "SoundSet"));
···
7408
6449
pub async fn sound_current(
7409
6450
&mut self,
7410
6451
request: impl tonic::IntoRequest<super::SoundCurrentRequest>,
7411
-
) -> std::result::Result<
7412
-
tonic::Response<super::SoundCurrentResponse>,
7413
-
tonic::Status,
7414
-
> {
7415
-
self.inner
7416
-
.ready()
7417
-
.await
7418
-
.map_err(|e| {
7419
-
tonic::Status::unknown(
7420
-
format!("Service was not ready: {}", e.into()),
7421
-
)
7422
-
})?;
6452
+
) -> std::result::Result<tonic::Response<super::SoundCurrentResponse>, tonic::Status>
6453
+
{
6454
+
self.inner.ready().await.map_err(|e| {
6455
+
tonic::Status::unknown(format!("Service was not ready: {}", e.into()))
6456
+
})?;
7423
6457
let codec = tonic::codec::ProstCodec::default();
7424
-
let path = http::uri::PathAndQuery::from_static(
7425
-
"/rockbox.v1alpha1.SoundService/SoundCurrent",
7426
-
);
6458
+
let path =
6459
+
http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.SoundService/SoundCurrent");
7427
6460
let mut req = request.into_request();
7428
-
req.extensions_mut()
7429
-
.insert(
7430
-
GrpcMethod::new("rockbox.v1alpha1.SoundService", "SoundCurrent"),
7431
-
);
6461
+
req.extensions_mut().insert(GrpcMethod::new(
6462
+
"rockbox.v1alpha1.SoundService",
6463
+
"SoundCurrent",
6464
+
));
7432
6465
self.inner.unary(req, path, codec).await
7433
6466
}
7434
6467
pub async fn sound_default(
7435
6468
&mut self,
7436
6469
request: impl tonic::IntoRequest<super::SoundDefaultRequest>,
7437
-
) -> std::result::Result<
7438
-
tonic::Response<super::SoundDefaultResponse>,
7439
-
tonic::Status,
7440
-
> {
7441
-
self.inner
7442
-
.ready()
7443
-
.await
7444
-
.map_err(|e| {
7445
-
tonic::Status::unknown(
7446
-
format!("Service was not ready: {}", e.into()),
7447
-
)
7448
-
})?;
6470
+
) -> std::result::Result<tonic::Response<super::SoundDefaultResponse>, tonic::Status>
6471
+
{
6472
+
self.inner.ready().await.map_err(|e| {
6473
+
tonic::Status::unknown(format!("Service was not ready: {}", e.into()))
6474
+
})?;
7449
6475
let codec = tonic::codec::ProstCodec::default();
7450
-
let path = http::uri::PathAndQuery::from_static(
7451
-
"/rockbox.v1alpha1.SoundService/SoundDefault",
7452
-
);
6476
+
let path =
6477
+
http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.SoundService/SoundDefault");
7453
6478
let mut req = request.into_request();
7454
-
req.extensions_mut()
7455
-
.insert(
7456
-
GrpcMethod::new("rockbox.v1alpha1.SoundService", "SoundDefault"),
7457
-
);
6479
+
req.extensions_mut().insert(GrpcMethod::new(
6480
+
"rockbox.v1alpha1.SoundService",
6481
+
"SoundDefault",
6482
+
));
7458
6483
self.inner.unary(req, path, codec).await
7459
6484
}
7460
6485
pub async fn sound_min(
7461
6486
&mut self,
7462
6487
request: impl tonic::IntoRequest<super::SoundMinRequest>,
7463
-
) -> std::result::Result<
7464
-
tonic::Response<super::SoundMinResponse>,
7465
-
tonic::Status,
7466
-
> {
7467
-
self.inner
7468
-
.ready()
7469
-
.await
7470
-
.map_err(|e| {
7471
-
tonic::Status::unknown(
7472
-
format!("Service was not ready: {}", e.into()),
7473
-
)
7474
-
})?;
6488
+
) -> std::result::Result<tonic::Response<super::SoundMinResponse>, tonic::Status> {
6489
+
self.inner.ready().await.map_err(|e| {
6490
+
tonic::Status::unknown(format!("Service was not ready: {}", e.into()))
6491
+
})?;
7475
6492
let codec = tonic::codec::ProstCodec::default();
7476
-
let path = http::uri::PathAndQuery::from_static(
7477
-
"/rockbox.v1alpha1.SoundService/SoundMin",
7478
-
);
6493
+
let path =
6494
+
http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.SoundService/SoundMin");
7479
6495
let mut req = request.into_request();
7480
6496
req.extensions_mut()
7481
6497
.insert(GrpcMethod::new("rockbox.v1alpha1.SoundService", "SoundMin"));
···
7484
6500
pub async fn sound_max(
7485
6501
&mut self,
7486
6502
request: impl tonic::IntoRequest<super::SoundMaxRequest>,
7487
-
) -> std::result::Result<
7488
-
tonic::Response<super::SoundMaxResponse>,
7489
-
tonic::Status,
7490
-
> {
7491
-
self.inner
7492
-
.ready()
7493
-
.await
7494
-
.map_err(|e| {
7495
-
tonic::Status::unknown(
7496
-
format!("Service was not ready: {}", e.into()),
7497
-
)
7498
-
})?;
6503
+
) -> std::result::Result<tonic::Response<super::SoundMaxResponse>, tonic::Status> {
6504
+
self.inner.ready().await.map_err(|e| {
6505
+
tonic::Status::unknown(format!("Service was not ready: {}", e.into()))
6506
+
})?;
7499
6507
let codec = tonic::codec::ProstCodec::default();
7500
-
let path = http::uri::PathAndQuery::from_static(
7501
-
"/rockbox.v1alpha1.SoundService/SoundMax",
7502
-
);
6508
+
let path =
6509
+
http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.SoundService/SoundMax");
7503
6510
let mut req = request.into_request();
7504
6511
req.extensions_mut()
7505
6512
.insert(GrpcMethod::new("rockbox.v1alpha1.SoundService", "SoundMax"));
···
7508
6515
pub async fn sound_unit(
7509
6516
&mut self,
7510
6517
request: impl tonic::IntoRequest<super::SoundUnitRequest>,
7511
-
) -> std::result::Result<
7512
-
tonic::Response<super::SoundUnitResponse>,
7513
-
tonic::Status,
7514
-
> {
7515
-
self.inner
7516
-
.ready()
7517
-
.await
7518
-
.map_err(|e| {
7519
-
tonic::Status::unknown(
7520
-
format!("Service was not ready: {}", e.into()),
7521
-
)
7522
-
})?;
6518
+
) -> std::result::Result<tonic::Response<super::SoundUnitResponse>, tonic::Status> {
6519
+
self.inner.ready().await.map_err(|e| {
6520
+
tonic::Status::unknown(format!("Service was not ready: {}", e.into()))
6521
+
})?;
7523
6522
let codec = tonic::codec::ProstCodec::default();
7524
-
let path = http::uri::PathAndQuery::from_static(
7525
-
"/rockbox.v1alpha1.SoundService/SoundUnit",
7526
-
);
6523
+
let path =
6524
+
http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.SoundService/SoundUnit");
7527
6525
let mut req = request.into_request();
7528
-
req.extensions_mut()
7529
-
.insert(GrpcMethod::new("rockbox.v1alpha1.SoundService", "SoundUnit"));
6526
+
req.extensions_mut().insert(GrpcMethod::new(
6527
+
"rockbox.v1alpha1.SoundService",
6528
+
"SoundUnit",
6529
+
));
7530
6530
self.inner.unary(req, path, codec).await
7531
6531
}
7532
6532
pub async fn sound_val2_phys(
7533
6533
&mut self,
7534
6534
request: impl tonic::IntoRequest<super::SoundVal2PhysRequest>,
7535
-
) -> std::result::Result<
7536
-
tonic::Response<super::SoundVal2PhysResponse>,
7537
-
tonic::Status,
7538
-
> {
7539
-
self.inner
7540
-
.ready()
7541
-
.await
7542
-
.map_err(|e| {
7543
-
tonic::Status::unknown(
7544
-
format!("Service was not ready: {}", e.into()),
7545
-
)
7546
-
})?;
6535
+
) -> std::result::Result<tonic::Response<super::SoundVal2PhysResponse>, tonic::Status>
6536
+
{
6537
+
self.inner.ready().await.map_err(|e| {
6538
+
tonic::Status::unknown(format!("Service was not ready: {}", e.into()))
6539
+
})?;
7547
6540
let codec = tonic::codec::ProstCodec::default();
7548
6541
let path = http::uri::PathAndQuery::from_static(
7549
6542
"/rockbox.v1alpha1.SoundService/SoundVal2Phys",
7550
6543
);
7551
6544
let mut req = request.into_request();
7552
-
req.extensions_mut()
7553
-
.insert(
7554
-
GrpcMethod::new("rockbox.v1alpha1.SoundService", "SoundVal2Phys"),
7555
-
);
6545
+
req.extensions_mut().insert(GrpcMethod::new(
6546
+
"rockbox.v1alpha1.SoundService",
6547
+
"SoundVal2Phys",
6548
+
));
7556
6549
self.inner.unary(req, path, codec).await
7557
6550
}
7558
6551
pub async fn get_pitch(
7559
6552
&mut self,
7560
6553
request: impl tonic::IntoRequest<super::GetPitchRequest>,
7561
-
) -> std::result::Result<
7562
-
tonic::Response<super::GetPitchResponse>,
7563
-
tonic::Status,
7564
-
> {
7565
-
self.inner
7566
-
.ready()
7567
-
.await
7568
-
.map_err(|e| {
7569
-
tonic::Status::unknown(
7570
-
format!("Service was not ready: {}", e.into()),
7571
-
)
7572
-
})?;
6554
+
) -> std::result::Result<tonic::Response<super::GetPitchResponse>, tonic::Status> {
6555
+
self.inner.ready().await.map_err(|e| {
6556
+
tonic::Status::unknown(format!("Service was not ready: {}", e.into()))
6557
+
})?;
7573
6558
let codec = tonic::codec::ProstCodec::default();
7574
-
let path = http::uri::PathAndQuery::from_static(
7575
-
"/rockbox.v1alpha1.SoundService/GetPitch",
7576
-
);
6559
+
let path =
6560
+
http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.SoundService/GetPitch");
7577
6561
let mut req = request.into_request();
7578
6562
req.extensions_mut()
7579
6563
.insert(GrpcMethod::new("rockbox.v1alpha1.SoundService", "GetPitch"));
···
7582
6566
pub async fn set_pitch(
7583
6567
&mut self,
7584
6568
request: impl tonic::IntoRequest<super::SetPitchRequest>,
7585
-
) -> std::result::Result<
7586
-
tonic::Response<super::SetPitchResponse>,
7587
-
tonic::Status,
7588
-
> {
7589
-
self.inner
7590
-
.ready()
7591
-
.await
7592
-
.map_err(|e| {
7593
-
tonic::Status::unknown(
7594
-
format!("Service was not ready: {}", e.into()),
7595
-
)
7596
-
})?;
6569
+
) -> std::result::Result<tonic::Response<super::SetPitchResponse>, tonic::Status> {
6570
+
self.inner.ready().await.map_err(|e| {
6571
+
tonic::Status::unknown(format!("Service was not ready: {}", e.into()))
6572
+
})?;
7597
6573
let codec = tonic::codec::ProstCodec::default();
7598
-
let path = http::uri::PathAndQuery::from_static(
7599
-
"/rockbox.v1alpha1.SoundService/SetPitch",
7600
-
);
6574
+
let path =
6575
+
http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.SoundService/SetPitch");
7601
6576
let mut req = request.into_request();
7602
6577
req.extensions_mut()
7603
6578
.insert(GrpcMethod::new("rockbox.v1alpha1.SoundService", "SetPitch"));
···
7606
6581
pub async fn beep_play(
7607
6582
&mut self,
7608
6583
request: impl tonic::IntoRequest<super::BeepPlayRequest>,
7609
-
) -> std::result::Result<
7610
-
tonic::Response<super::BeepPlayResponse>,
7611
-
tonic::Status,
7612
-
> {
7613
-
self.inner
7614
-
.ready()
7615
-
.await
7616
-
.map_err(|e| {
7617
-
tonic::Status::unknown(
7618
-
format!("Service was not ready: {}", e.into()),
7619
-
)
7620
-
})?;
6584
+
) -> std::result::Result<tonic::Response<super::BeepPlayResponse>, tonic::Status> {
6585
+
self.inner.ready().await.map_err(|e| {
6586
+
tonic::Status::unknown(format!("Service was not ready: {}", e.into()))
6587
+
})?;
7621
6588
let codec = tonic::codec::ProstCodec::default();
7622
-
let path = http::uri::PathAndQuery::from_static(
7623
-
"/rockbox.v1alpha1.SoundService/BeepPlay",
7624
-
);
6589
+
let path =
6590
+
http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.SoundService/BeepPlay");
7625
6591
let mut req = request.into_request();
7626
6592
req.extensions_mut()
7627
6593
.insert(GrpcMethod::new("rockbox.v1alpha1.SoundService", "BeepPlay"));
···
7630
6596
pub async fn pcmbuf_fade(
7631
6597
&mut self,
7632
6598
request: impl tonic::IntoRequest<super::PcmbufFadeRequest>,
7633
-
) -> std::result::Result<
7634
-
tonic::Response<super::PcmbufFadeResponse>,
7635
-
tonic::Status,
7636
-
> {
7637
-
self.inner
7638
-
.ready()
7639
-
.await
7640
-
.map_err(|e| {
7641
-
tonic::Status::unknown(
7642
-
format!("Service was not ready: {}", e.into()),
7643
-
)
7644
-
})?;
6599
+
) -> std::result::Result<tonic::Response<super::PcmbufFadeResponse>, tonic::Status>
6600
+
{
6601
+
self.inner.ready().await.map_err(|e| {
6602
+
tonic::Status::unknown(format!("Service was not ready: {}", e.into()))
6603
+
})?;
7645
6604
let codec = tonic::codec::ProstCodec::default();
7646
-
let path = http::uri::PathAndQuery::from_static(
7647
-
"/rockbox.v1alpha1.SoundService/PcmbufFade",
7648
-
);
6605
+
let path =
6606
+
http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.SoundService/PcmbufFade");
7649
6607
let mut req = request.into_request();
7650
-
req.extensions_mut()
7651
-
.insert(GrpcMethod::new("rockbox.v1alpha1.SoundService", "PcmbufFade"));
6608
+
req.extensions_mut().insert(GrpcMethod::new(
6609
+
"rockbox.v1alpha1.SoundService",
6610
+
"PcmbufFade",
6611
+
));
7652
6612
self.inner.unary(req, path, codec).await
7653
6613
}
7654
6614
pub async fn pcmbuf_set_low_latency(
7655
6615
&mut self,
7656
6616
request: impl tonic::IntoRequest<super::PcmbufSetLowLatencyRequest>,
7657
-
) -> std::result::Result<
7658
-
tonic::Response<super::PcmbufSetLowLatencyResponse>,
7659
-
tonic::Status,
7660
-
> {
7661
-
self.inner
7662
-
.ready()
7663
-
.await
7664
-
.map_err(|e| {
7665
-
tonic::Status::unknown(
7666
-
format!("Service was not ready: {}", e.into()),
7667
-
)
7668
-
})?;
6617
+
) -> std::result::Result<tonic::Response<super::PcmbufSetLowLatencyResponse>, tonic::Status>
6618
+
{
6619
+
self.inner.ready().await.map_err(|e| {
6620
+
tonic::Status::unknown(format!("Service was not ready: {}", e.into()))
6621
+
})?;
7669
6622
let codec = tonic::codec::ProstCodec::default();
7670
6623
let path = http::uri::PathAndQuery::from_static(
7671
6624
"/rockbox.v1alpha1.SoundService/PcmbufSetLowLatency",
7672
6625
);
7673
6626
let mut req = request.into_request();
7674
-
req.extensions_mut()
7675
-
.insert(
7676
-
GrpcMethod::new(
7677
-
"rockbox.v1alpha1.SoundService",
7678
-
"PcmbufSetLowLatency",
7679
-
),
7680
-
);
6627
+
req.extensions_mut().insert(GrpcMethod::new(
6628
+
"rockbox.v1alpha1.SoundService",
6629
+
"PcmbufSetLowLatency",
6630
+
));
7681
6631
self.inner.unary(req, path, codec).await
7682
6632
}
7683
6633
pub async fn system_sound_play(
7684
6634
&mut self,
7685
6635
request: impl tonic::IntoRequest<super::SystemSoundPlayRequest>,
7686
-
) -> std::result::Result<
7687
-
tonic::Response<super::SystemSoundPlayResponse>,
7688
-
tonic::Status,
7689
-
> {
7690
-
self.inner
7691
-
.ready()
7692
-
.await
7693
-
.map_err(|e| {
7694
-
tonic::Status::unknown(
7695
-
format!("Service was not ready: {}", e.into()),
7696
-
)
7697
-
})?;
6636
+
) -> std::result::Result<tonic::Response<super::SystemSoundPlayResponse>, tonic::Status>
6637
+
{
6638
+
self.inner.ready().await.map_err(|e| {
6639
+
tonic::Status::unknown(format!("Service was not ready: {}", e.into()))
6640
+
})?;
7698
6641
let codec = tonic::codec::ProstCodec::default();
7699
6642
let path = http::uri::PathAndQuery::from_static(
7700
6643
"/rockbox.v1alpha1.SoundService/SystemSoundPlay",
7701
6644
);
7702
6645
let mut req = request.into_request();
7703
-
req.extensions_mut()
7704
-
.insert(
7705
-
GrpcMethod::new("rockbox.v1alpha1.SoundService", "SystemSoundPlay"),
7706
-
);
6646
+
req.extensions_mut().insert(GrpcMethod::new(
6647
+
"rockbox.v1alpha1.SoundService",
6648
+
"SystemSoundPlay",
6649
+
));
7707
6650
self.inner.unary(req, path, codec).await
7708
6651
}
7709
6652
pub async fn keyclick_click(
7710
6653
&mut self,
7711
6654
request: impl tonic::IntoRequest<super::KeyclickClickRequest>,
7712
-
) -> std::result::Result<
7713
-
tonic::Response<super::KeyclickClickResponse>,
7714
-
tonic::Status,
7715
-
> {
7716
-
self.inner
7717
-
.ready()
7718
-
.await
7719
-
.map_err(|e| {
7720
-
tonic::Status::unknown(
7721
-
format!("Service was not ready: {}", e.into()),
7722
-
)
7723
-
})?;
6655
+
) -> std::result::Result<tonic::Response<super::KeyclickClickResponse>, tonic::Status>
6656
+
{
6657
+
self.inner.ready().await.map_err(|e| {
6658
+
tonic::Status::unknown(format!("Service was not ready: {}", e.into()))
6659
+
})?;
7724
6660
let codec = tonic::codec::ProstCodec::default();
7725
6661
let path = http::uri::PathAndQuery::from_static(
7726
6662
"/rockbox.v1alpha1.SoundService/KeyclickClick",
7727
6663
);
7728
6664
let mut req = request.into_request();
7729
-
req.extensions_mut()
7730
-
.insert(
7731
-
GrpcMethod::new("rockbox.v1alpha1.SoundService", "KeyclickClick"),
7732
-
);
6665
+
req.extensions_mut().insert(GrpcMethod::new(
6666
+
"rockbox.v1alpha1.SoundService",
6667
+
"KeyclickClick",
6668
+
));
7733
6669
self.inner.unary(req, path, codec).await
7734
6670
}
7735
6671
}
···
7741
6677
dead_code,
7742
6678
missing_docs,
7743
6679
clippy::wildcard_imports,
7744
-
clippy::let_unit_value,
6680
+
clippy::let_unit_value
7745
6681
)]
7746
6682
use tonic::codegen::*;
7747
6683
/// Generated trait containing gRPC methods that should be implemented for use with SoundServiceServer.
···
7750
6686
async fn adjust_volume(
7751
6687
&self,
7752
6688
request: tonic::Request<super::AdjustVolumeRequest>,
7753
-
) -> std::result::Result<
7754
-
tonic::Response<super::AdjustVolumeResponse>,
7755
-
tonic::Status,
7756
-
>;
6689
+
) -> std::result::Result<tonic::Response<super::AdjustVolumeResponse>, tonic::Status>;
7757
6690
async fn sound_set(
7758
6691
&self,
7759
6692
request: tonic::Request<super::SoundSetRequest>,
7760
-
) -> std::result::Result<
7761
-
tonic::Response<super::SoundSetResponse>,
7762
-
tonic::Status,
7763
-
>;
6693
+
) -> std::result::Result<tonic::Response<super::SoundSetResponse>, tonic::Status>;
7764
6694
async fn sound_current(
7765
6695
&self,
7766
6696
request: tonic::Request<super::SoundCurrentRequest>,
7767
-
) -> std::result::Result<
7768
-
tonic::Response<super::SoundCurrentResponse>,
7769
-
tonic::Status,
7770
-
>;
6697
+
) -> std::result::Result<tonic::Response<super::SoundCurrentResponse>, tonic::Status>;
7771
6698
async fn sound_default(
7772
6699
&self,
7773
6700
request: tonic::Request<super::SoundDefaultRequest>,
7774
-
) -> std::result::Result<
7775
-
tonic::Response<super::SoundDefaultResponse>,
7776
-
tonic::Status,
7777
-
>;
6701
+
) -> std::result::Result<tonic::Response<super::SoundDefaultResponse>, tonic::Status>;
7778
6702
async fn sound_min(
7779
6703
&self,
7780
6704
request: tonic::Request<super::SoundMinRequest>,
7781
-
) -> std::result::Result<
7782
-
tonic::Response<super::SoundMinResponse>,
7783
-
tonic::Status,
7784
-
>;
6705
+
) -> std::result::Result<tonic::Response<super::SoundMinResponse>, tonic::Status>;
7785
6706
async fn sound_max(
7786
6707
&self,
7787
6708
request: tonic::Request<super::SoundMaxRequest>,
7788
-
) -> std::result::Result<
7789
-
tonic::Response<super::SoundMaxResponse>,
7790
-
tonic::Status,
7791
-
>;
6709
+
) -> std::result::Result<tonic::Response<super::SoundMaxResponse>, tonic::Status>;
7792
6710
async fn sound_unit(
7793
6711
&self,
7794
6712
request: tonic::Request<super::SoundUnitRequest>,
7795
-
) -> std::result::Result<
7796
-
tonic::Response<super::SoundUnitResponse>,
7797
-
tonic::Status,
7798
-
>;
6713
+
) -> std::result::Result<tonic::Response<super::SoundUnitResponse>, tonic::Status>;
7799
6714
async fn sound_val2_phys(
7800
6715
&self,
7801
6716
request: tonic::Request<super::SoundVal2PhysRequest>,
7802
-
) -> std::result::Result<
7803
-
tonic::Response<super::SoundVal2PhysResponse>,
7804
-
tonic::Status,
7805
-
>;
6717
+
) -> std::result::Result<tonic::Response<super::SoundVal2PhysResponse>, tonic::Status>;
7806
6718
async fn get_pitch(
7807
6719
&self,
7808
6720
request: tonic::Request<super::GetPitchRequest>,
7809
-
) -> std::result::Result<
7810
-
tonic::Response<super::GetPitchResponse>,
7811
-
tonic::Status,
7812
-
>;
6721
+
) -> std::result::Result<tonic::Response<super::GetPitchResponse>, tonic::Status>;
7813
6722
async fn set_pitch(
7814
6723
&self,
7815
6724
request: tonic::Request<super::SetPitchRequest>,
7816
-
) -> std::result::Result<
7817
-
tonic::Response<super::SetPitchResponse>,
7818
-
tonic::Status,
7819
-
>;
6725
+
) -> std::result::Result<tonic::Response<super::SetPitchResponse>, tonic::Status>;
7820
6726
async fn beep_play(
7821
6727
&self,
7822
6728
request: tonic::Request<super::BeepPlayRequest>,
7823
-
) -> std::result::Result<
7824
-
tonic::Response<super::BeepPlayResponse>,
7825
-
tonic::Status,
7826
-
>;
6729
+
) -> std::result::Result<tonic::Response<super::BeepPlayResponse>, tonic::Status>;
7827
6730
async fn pcmbuf_fade(
7828
6731
&self,
7829
6732
request: tonic::Request<super::PcmbufFadeRequest>,
7830
-
) -> std::result::Result<
7831
-
tonic::Response<super::PcmbufFadeResponse>,
7832
-
tonic::Status,
7833
-
>;
6733
+
) -> std::result::Result<tonic::Response<super::PcmbufFadeResponse>, tonic::Status>;
7834
6734
async fn pcmbuf_set_low_latency(
7835
6735
&self,
7836
6736
request: tonic::Request<super::PcmbufSetLowLatencyRequest>,
7837
-
) -> std::result::Result<
7838
-
tonic::Response<super::PcmbufSetLowLatencyResponse>,
7839
-
tonic::Status,
7840
-
>;
6737
+
) -> std::result::Result<tonic::Response<super::PcmbufSetLowLatencyResponse>, tonic::Status>;
7841
6738
async fn system_sound_play(
7842
6739
&self,
7843
6740
request: tonic::Request<super::SystemSoundPlayRequest>,
7844
-
) -> std::result::Result<
7845
-
tonic::Response<super::SystemSoundPlayResponse>,
7846
-
tonic::Status,
7847
-
>;
6741
+
) -> std::result::Result<tonic::Response<super::SystemSoundPlayResponse>, tonic::Status>;
7848
6742
async fn keyclick_click(
7849
6743
&self,
7850
6744
request: tonic::Request<super::KeyclickClickRequest>,
7851
-
) -> std::result::Result<
7852
-
tonic::Response<super::KeyclickClickResponse>,
7853
-
tonic::Status,
7854
-
>;
6745
+
) -> std::result::Result<tonic::Response<super::KeyclickClickResponse>, tonic::Status>;
7855
6746
}
7856
6747
#[derive(Debug)]
7857
6748
pub struct SoundServiceServer<T> {
···
7874
6765
max_encoding_message_size: None,
7875
6766
}
7876
6767
}
7877
-
pub fn with_interceptor<F>(
7878
-
inner: T,
7879
-
interceptor: F,
7880
-
) -> InterceptedService<Self, F>
6768
+
pub fn with_interceptor<F>(inner: T, interceptor: F) -> InterceptedService<Self, F>
7881
6769
where
7882
6770
F: tonic::service::Interceptor,
7883
6771
{
···
7932
6820
"/rockbox.v1alpha1.SoundService/AdjustVolume" => {
7933
6821
#[allow(non_camel_case_types)]
7934
6822
struct AdjustVolumeSvc<T: SoundService>(pub Arc<T>);
7935
-
impl<
7936
-
T: SoundService,
7937
-
> tonic::server::UnaryService<super::AdjustVolumeRequest>
7938
-
for AdjustVolumeSvc<T> {
6823
+
impl<T: SoundService> tonic::server::UnaryService<super::AdjustVolumeRequest>
6824
+
for AdjustVolumeSvc<T>
6825
+
{
7939
6826
type Response = super::AdjustVolumeResponse;
7940
-
type Future = BoxFuture<
7941
-
tonic::Response<Self::Response>,
7942
-
tonic::Status,
7943
-
>;
6827
+
type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
7944
6828
fn call(
7945
6829
&mut self,
7946
6830
request: tonic::Request<super::AdjustVolumeRequest>,
···
7977
6861
"/rockbox.v1alpha1.SoundService/SoundSet" => {
7978
6862
#[allow(non_camel_case_types)]
7979
6863
struct SoundSetSvc<T: SoundService>(pub Arc<T>);
7980
-
impl<
7981
-
T: SoundService,
7982
-
> tonic::server::UnaryService<super::SoundSetRequest>
7983
-
for SoundSetSvc<T> {
6864
+
impl<T: SoundService> tonic::server::UnaryService<super::SoundSetRequest> for SoundSetSvc<T> {
7984
6865
type Response = super::SoundSetResponse;
7985
-
type Future = BoxFuture<
7986
-
tonic::Response<Self::Response>,
7987
-
tonic::Status,
7988
-
>;
6866
+
type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
7989
6867
fn call(
7990
6868
&mut self,
7991
6869
request: tonic::Request<super::SoundSetRequest>,
···
8022
6900
"/rockbox.v1alpha1.SoundService/SoundCurrent" => {
8023
6901
#[allow(non_camel_case_types)]
8024
6902
struct SoundCurrentSvc<T: SoundService>(pub Arc<T>);
8025
-
impl<
8026
-
T: SoundService,
8027
-
> tonic::server::UnaryService<super::SoundCurrentRequest>
8028
-
for SoundCurrentSvc<T> {
6903
+
impl<T: SoundService> tonic::server::UnaryService<super::SoundCurrentRequest>
6904
+
for SoundCurrentSvc<T>
6905
+
{
8029
6906
type Response = super::SoundCurrentResponse;
8030
-
type Future = BoxFuture<
8031
-
tonic::Response<Self::Response>,
8032
-
tonic::Status,
8033
-
>;
6907
+
type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
8034
6908
fn call(
8035
6909
&mut self,
8036
6910
request: tonic::Request<super::SoundCurrentRequest>,
···
8067
6941
"/rockbox.v1alpha1.SoundService/SoundDefault" => {
8068
6942
#[allow(non_camel_case_types)]
8069
6943
struct SoundDefaultSvc<T: SoundService>(pub Arc<T>);
8070
-
impl<
8071
-
T: SoundService,
8072
-
> tonic::server::UnaryService<super::SoundDefaultRequest>
8073
-
for SoundDefaultSvc<T> {
6944
+
impl<T: SoundService> tonic::server::UnaryService<super::SoundDefaultRequest>
6945
+
for SoundDefaultSvc<T>
6946
+
{
8074
6947
type Response = super::SoundDefaultResponse;
8075
-
type Future = BoxFuture<
8076
-
tonic::Response<Self::Response>,
8077
-
tonic::Status,
8078
-
>;
6948
+
type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
8079
6949
fn call(
8080
6950
&mut self,
8081
6951
request: tonic::Request<super::SoundDefaultRequest>,
···
8112
6982
"/rockbox.v1alpha1.SoundService/SoundMin" => {
8113
6983
#[allow(non_camel_case_types)]
8114
6984
struct SoundMinSvc<T: SoundService>(pub Arc<T>);
8115
-
impl<
8116
-
T: SoundService,
8117
-
> tonic::server::UnaryService<super::SoundMinRequest>
8118
-
for SoundMinSvc<T> {
6985
+
impl<T: SoundService> tonic::server::UnaryService<super::SoundMinRequest> for SoundMinSvc<T> {
8119
6986
type Response = super::SoundMinResponse;
8120
-
type Future = BoxFuture<
8121
-
tonic::Response<Self::Response>,
8122
-
tonic::Status,
8123
-
>;
6987
+
type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
8124
6988
fn call(
8125
6989
&mut self,
8126
6990
request: tonic::Request<super::SoundMinRequest>,
···
8157
7021
"/rockbox.v1alpha1.SoundService/SoundMax" => {
8158
7022
#[allow(non_camel_case_types)]
8159
7023
struct SoundMaxSvc<T: SoundService>(pub Arc<T>);
8160
-
impl<
8161
-
T: SoundService,
8162
-
> tonic::server::UnaryService<super::SoundMaxRequest>
8163
-
for SoundMaxSvc<T> {
7024
+
impl<T: SoundService> tonic::server::UnaryService<super::SoundMaxRequest> for SoundMaxSvc<T> {
8164
7025
type Response = super::SoundMaxResponse;
8165
-
type Future = BoxFuture<
8166
-
tonic::Response<Self::Response>,
8167
-
tonic::Status,
8168
-
>;
7026
+
type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
8169
7027
fn call(
8170
7028
&mut self,
8171
7029
request: tonic::Request<super::SoundMaxRequest>,
···
8202
7060
"/rockbox.v1alpha1.SoundService/SoundUnit" => {
8203
7061
#[allow(non_camel_case_types)]
8204
7062
struct SoundUnitSvc<T: SoundService>(pub Arc<T>);
8205
-
impl<
8206
-
T: SoundService,
8207
-
> tonic::server::UnaryService<super::SoundUnitRequest>
8208
-
for SoundUnitSvc<T> {
7063
+
impl<T: SoundService> tonic::server::UnaryService<super::SoundUnitRequest> for SoundUnitSvc<T> {
8209
7064
type Response = super::SoundUnitResponse;
8210
-
type Future = BoxFuture<
8211
-
tonic::Response<Self::Response>,
8212
-
tonic::Status,
8213
-
>;
7065
+
type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
8214
7066
fn call(
8215
7067
&mut self,
8216
7068
request: tonic::Request<super::SoundUnitRequest>,
···
8247
7099
"/rockbox.v1alpha1.SoundService/SoundVal2Phys" => {
8248
7100
#[allow(non_camel_case_types)]
8249
7101
struct SoundVal2PhysSvc<T: SoundService>(pub Arc<T>);
8250
-
impl<
8251
-
T: SoundService,
8252
-
> tonic::server::UnaryService<super::SoundVal2PhysRequest>
8253
-
for SoundVal2PhysSvc<T> {
7102
+
impl<T: SoundService> tonic::server::UnaryService<super::SoundVal2PhysRequest>
7103
+
for SoundVal2PhysSvc<T>
7104
+
{
8254
7105
type Response = super::SoundVal2PhysResponse;
8255
-
type Future = BoxFuture<
8256
-
tonic::Response<Self::Response>,
8257
-
tonic::Status,
8258
-
>;
7106
+
type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
8259
7107
fn call(
8260
7108
&mut self,
8261
7109
request: tonic::Request<super::SoundVal2PhysRequest>,
···
8292
7140
"/rockbox.v1alpha1.SoundService/GetPitch" => {
8293
7141
#[allow(non_camel_case_types)]
8294
7142
struct GetPitchSvc<T: SoundService>(pub Arc<T>);
8295
-
impl<
8296
-
T: SoundService,
8297
-
> tonic::server::UnaryService<super::GetPitchRequest>
8298
-
for GetPitchSvc<T> {
7143
+
impl<T: SoundService> tonic::server::UnaryService<super::GetPitchRequest> for GetPitchSvc<T> {
8299
7144
type Response = super::GetPitchResponse;
8300
-
type Future = BoxFuture<
8301
-
tonic::Response<Self::Response>,
8302
-
tonic::Status,
8303
-
>;
7145
+
type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
8304
7146
fn call(
8305
7147
&mut self,
8306
7148
request: tonic::Request<super::GetPitchRequest>,
···
8337
7179
"/rockbox.v1alpha1.SoundService/SetPitch" => {
8338
7180
#[allow(non_camel_case_types)]
8339
7181
struct SetPitchSvc<T: SoundService>(pub Arc<T>);
8340
-
impl<
8341
-
T: SoundService,
8342
-
> tonic::server::UnaryService<super::SetPitchRequest>
8343
-
for SetPitchSvc<T> {
7182
+
impl<T: SoundService> tonic::server::UnaryService<super::SetPitchRequest> for SetPitchSvc<T> {
8344
7183
type Response = super::SetPitchResponse;
8345
-
type Future = BoxFuture<
8346
-
tonic::Response<Self::Response>,
8347
-
tonic::Status,
8348
-
>;
7184
+
type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
8349
7185
fn call(
8350
7186
&mut self,
8351
7187
request: tonic::Request<super::SetPitchRequest>,
···
8382
7218
"/rockbox.v1alpha1.SoundService/BeepPlay" => {
8383
7219
#[allow(non_camel_case_types)]
8384
7220
struct BeepPlaySvc<T: SoundService>(pub Arc<T>);
8385
-
impl<
8386
-
T: SoundService,
8387
-
> tonic::server::UnaryService<super::BeepPlayRequest>
8388
-
for BeepPlaySvc<T> {
7221
+
impl<T: SoundService> tonic::server::UnaryService<super::BeepPlayRequest> for BeepPlaySvc<T> {
8389
7222
type Response = super::BeepPlayResponse;
8390
-
type Future = BoxFuture<
8391
-
tonic::Response<Self::Response>,
8392
-
tonic::Status,
8393
-
>;
7223
+
type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
8394
7224
fn call(
8395
7225
&mut self,
8396
7226
request: tonic::Request<super::BeepPlayRequest>,
···
8427
7257
"/rockbox.v1alpha1.SoundService/PcmbufFade" => {
8428
7258
#[allow(non_camel_case_types)]
8429
7259
struct PcmbufFadeSvc<T: SoundService>(pub Arc<T>);
8430
-
impl<
8431
-
T: SoundService,
8432
-
> tonic::server::UnaryService<super::PcmbufFadeRequest>
8433
-
for PcmbufFadeSvc<T> {
7260
+
impl<T: SoundService> tonic::server::UnaryService<super::PcmbufFadeRequest> for PcmbufFadeSvc<T> {
8434
7261
type Response = super::PcmbufFadeResponse;
8435
-
type Future = BoxFuture<
8436
-
tonic::Response<Self::Response>,
8437
-
tonic::Status,
8438
-
>;
7262
+
type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
8439
7263
fn call(
8440
7264
&mut self,
8441
7265
request: tonic::Request<super::PcmbufFadeRequest>,
···
8472
7296
"/rockbox.v1alpha1.SoundService/PcmbufSetLowLatency" => {
8473
7297
#[allow(non_camel_case_types)]
8474
7298
struct PcmbufSetLowLatencySvc<T: SoundService>(pub Arc<T>);
8475
-
impl<
8476
-
T: SoundService,
8477
-
> tonic::server::UnaryService<super::PcmbufSetLowLatencyRequest>
8478
-
for PcmbufSetLowLatencySvc<T> {
7299
+
impl<T: SoundService>
7300
+
tonic::server::UnaryService<super::PcmbufSetLowLatencyRequest>
7301
+
for PcmbufSetLowLatencySvc<T>
7302
+
{
8479
7303
type Response = super::PcmbufSetLowLatencyResponse;
8480
-
type Future = BoxFuture<
8481
-
tonic::Response<Self::Response>,
8482
-
tonic::Status,
8483
-
>;
7304
+
type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
8484
7305
fn call(
8485
7306
&mut self,
8486
7307
request: tonic::Request<super::PcmbufSetLowLatencyRequest>,
8487
7308
) -> Self::Future {
8488
7309
let inner = Arc::clone(&self.0);
8489
7310
let fut = async move {
8490
-
<T as SoundService>::pcmbuf_set_low_latency(&inner, request)
8491
-
.await
7311
+
<T as SoundService>::pcmbuf_set_low_latency(&inner, request).await
8492
7312
};
8493
7313
Box::pin(fut)
8494
7314
}
···
8518
7338
"/rockbox.v1alpha1.SoundService/SystemSoundPlay" => {
8519
7339
#[allow(non_camel_case_types)]
8520
7340
struct SystemSoundPlaySvc<T: SoundService>(pub Arc<T>);
8521
-
impl<
8522
-
T: SoundService,
8523
-
> tonic::server::UnaryService<super::SystemSoundPlayRequest>
8524
-
for SystemSoundPlaySvc<T> {
7341
+
impl<T: SoundService> tonic::server::UnaryService<super::SystemSoundPlayRequest>
7342
+
for SystemSoundPlaySvc<T>
7343
+
{
8525
7344
type Response = super::SystemSoundPlayResponse;
8526
-
type Future = BoxFuture<
8527
-
tonic::Response<Self::Response>,
8528
-
tonic::Status,
8529
-
>;
7345
+
type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
8530
7346
fn call(
8531
7347
&mut self,
8532
7348
request: tonic::Request<super::SystemSoundPlayRequest>,
8533
7349
) -> Self::Future {
8534
7350
let inner = Arc::clone(&self.0);
8535
7351
let fut = async move {
8536
-
<T as SoundService>::system_sound_play(&inner, request)
8537
-
.await
7352
+
<T as SoundService>::system_sound_play(&inner, request).await
8538
7353
};
8539
7354
Box::pin(fut)
8540
7355
}
···
8564
7379
"/rockbox.v1alpha1.SoundService/KeyclickClick" => {
8565
7380
#[allow(non_camel_case_types)]
8566
7381
struct KeyclickClickSvc<T: SoundService>(pub Arc<T>);
8567
-
impl<
8568
-
T: SoundService,
8569
-
> tonic::server::UnaryService<super::KeyclickClickRequest>
8570
-
for KeyclickClickSvc<T> {
7382
+
impl<T: SoundService> tonic::server::UnaryService<super::KeyclickClickRequest>
7383
+
for KeyclickClickSvc<T>
7384
+
{
8571
7385
type Response = super::KeyclickClickResponse;
8572
-
type Future = BoxFuture<
8573
-
tonic::Response<Self::Response>,
8574
-
tonic::Status,
8575
-
>;
7386
+
type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
8576
7387
fn call(
8577
7388
&mut self,
8578
7389
request: tonic::Request<super::KeyclickClickRequest>,
···
8606
7417
};
8607
7418
Box::pin(fut)
8608
7419
}
8609
-
_ => {
8610
-
Box::pin(async move {
8611
-
let mut response = http::Response::new(empty_body());
8612
-
let headers = response.headers_mut();
8613
-
headers
8614
-
.insert(
8615
-
tonic::Status::GRPC_STATUS,
8616
-
(tonic::Code::Unimplemented as i32).into(),
8617
-
);
8618
-
headers
8619
-
.insert(
8620
-
http::header::CONTENT_TYPE,
8621
-
tonic::metadata::GRPC_CONTENT_TYPE,
8622
-
);
8623
-
Ok(response)
8624
-
})
8625
-
}
7420
+
_ => Box::pin(async move {
7421
+
let mut response = http::Response::new(empty_body());
7422
+
let headers = response.headers_mut();
7423
+
headers.insert(
7424
+
tonic::Status::GRPC_STATUS,
7425
+
(tonic::Code::Unimplemented as i32).into(),
7426
+
);
7427
+
headers.insert(
7428
+
http::header::CONTENT_TYPE,
7429
+
tonic::metadata::GRPC_CONTENT_TYPE,
7430
+
);
7431
+
Ok(response)
7432
+
}),
8626
7433
}
8627
7434
}
8628
7435
}
···
8683
7490
dead_code,
8684
7491
missing_docs,
8685
7492
clippy::wildcard_imports,
8686
-
clippy::let_unit_value,
7493
+
clippy::let_unit_value
8687
7494
)]
8688
-
use tonic::codegen::*;
8689
7495
use tonic::codegen::http::Uri;
7496
+
use tonic::codegen::*;
8690
7497
#[derive(Debug, Clone)]
8691
7498
pub struct SystemServiceClient<T> {
8692
7499
inner: tonic::client::Grpc<T>,
···
8730
7537
<T as tonic::client::GrpcService<tonic::body::BoxBody>>::ResponseBody,
8731
7538
>,
8732
7539
>,
8733
-
<T as tonic::codegen::Service<
8734
-
http::Request<tonic::body::BoxBody>,
8735
-
>>::Error: Into<StdError> + std::marker::Send + std::marker::Sync,
7540
+
<T as tonic::codegen::Service<http::Request<tonic::body::BoxBody>>>::Error:
7541
+
Into<StdError> + std::marker::Send + std::marker::Sync,
8736
7542
{
8737
7543
SystemServiceClient::new(InterceptedService::new(inner, interceptor))
8738
7544
}
···
8770
7576
pub async fn get_rockbox_version(
8771
7577
&mut self,
8772
7578
request: impl tonic::IntoRequest<super::GetRockboxVersionRequest>,
8773
-
) -> std::result::Result<
8774
-
tonic::Response<super::GetRockboxVersionResponse>,
8775
-
tonic::Status,
8776
-
> {
8777
-
self.inner
8778
-
.ready()
8779
-
.await
8780
-
.map_err(|e| {
8781
-
tonic::Status::unknown(
8782
-
format!("Service was not ready: {}", e.into()),
8783
-
)
8784
-
})?;
7579
+
) -> std::result::Result<tonic::Response<super::GetRockboxVersionResponse>, tonic::Status>
7580
+
{
7581
+
self.inner.ready().await.map_err(|e| {
7582
+
tonic::Status::unknown(format!("Service was not ready: {}", e.into()))
7583
+
})?;
8785
7584
let codec = tonic::codec::ProstCodec::default();
8786
7585
let path = http::uri::PathAndQuery::from_static(
8787
7586
"/rockbox.v1alpha1.SystemService/GetRockboxVersion",
8788
7587
);
8789
7588
let mut req = request.into_request();
8790
-
req.extensions_mut()
8791
-
.insert(
8792
-
GrpcMethod::new(
8793
-
"rockbox.v1alpha1.SystemService",
8794
-
"GetRockboxVersion",
8795
-
),
8796
-
);
7589
+
req.extensions_mut().insert(GrpcMethod::new(
7590
+
"rockbox.v1alpha1.SystemService",
7591
+
"GetRockboxVersion",
7592
+
));
8797
7593
self.inner.unary(req, path, codec).await
8798
7594
}
8799
7595
pub async fn get_global_status(
8800
7596
&mut self,
8801
7597
request: impl tonic::IntoRequest<super::GetGlobalStatusRequest>,
8802
-
) -> std::result::Result<
8803
-
tonic::Response<super::GetGlobalStatusResponse>,
8804
-
tonic::Status,
8805
-
> {
8806
-
self.inner
8807
-
.ready()
8808
-
.await
8809
-
.map_err(|e| {
8810
-
tonic::Status::unknown(
8811
-
format!("Service was not ready: {}", e.into()),
8812
-
)
8813
-
})?;
7598
+
) -> std::result::Result<tonic::Response<super::GetGlobalStatusResponse>, tonic::Status>
7599
+
{
7600
+
self.inner.ready().await.map_err(|e| {
7601
+
tonic::Status::unknown(format!("Service was not ready: {}", e.into()))
7602
+
})?;
8814
7603
let codec = tonic::codec::ProstCodec::default();
8815
7604
let path = http::uri::PathAndQuery::from_static(
8816
7605
"/rockbox.v1alpha1.SystemService/GetGlobalStatus",
8817
7606
);
8818
7607
let mut req = request.into_request();
8819
-
req.extensions_mut()
8820
-
.insert(
8821
-
GrpcMethod::new("rockbox.v1alpha1.SystemService", "GetGlobalStatus"),
8822
-
);
7608
+
req.extensions_mut().insert(GrpcMethod::new(
7609
+
"rockbox.v1alpha1.SystemService",
7610
+
"GetGlobalStatus",
7611
+
));
8823
7612
self.inner.unary(req, path, codec).await
8824
7613
}
8825
7614
}
···
8831
7620
dead_code,
8832
7621
missing_docs,
8833
7622
clippy::wildcard_imports,
8834
-
clippy::let_unit_value,
7623
+
clippy::let_unit_value
8835
7624
)]
8836
7625
use tonic::codegen::*;
8837
7626
/// Generated trait containing gRPC methods that should be implemented for use with SystemServiceServer.
···
8840
7629
async fn get_rockbox_version(
8841
7630
&self,
8842
7631
request: tonic::Request<super::GetRockboxVersionRequest>,
8843
-
) -> std::result::Result<
8844
-
tonic::Response<super::GetRockboxVersionResponse>,
8845
-
tonic::Status,
8846
-
>;
7632
+
) -> std::result::Result<tonic::Response<super::GetRockboxVersionResponse>, tonic::Status>;
8847
7633
async fn get_global_status(
8848
7634
&self,
8849
7635
request: tonic::Request<super::GetGlobalStatusRequest>,
8850
-
) -> std::result::Result<
8851
-
tonic::Response<super::GetGlobalStatusResponse>,
8852
-
tonic::Status,
8853
-
>;
7636
+
) -> std::result::Result<tonic::Response<super::GetGlobalStatusResponse>, tonic::Status>;
8854
7637
}
8855
7638
#[derive(Debug)]
8856
7639
pub struct SystemServiceServer<T> {
···
8873
7656
max_encoding_message_size: None,
8874
7657
}
8875
7658
}
8876
-
pub fn with_interceptor<F>(
8877
-
inner: T,
8878
-
interceptor: F,
8879
-
) -> InterceptedService<Self, F>
7659
+
pub fn with_interceptor<F>(inner: T, interceptor: F) -> InterceptedService<Self, F>
8880
7660
where
8881
7661
F: tonic::service::Interceptor,
8882
7662
{
···
8931
7711
"/rockbox.v1alpha1.SystemService/GetRockboxVersion" => {
8932
7712
#[allow(non_camel_case_types)]
8933
7713
struct GetRockboxVersionSvc<T: SystemService>(pub Arc<T>);
8934
-
impl<
8935
-
T: SystemService,
8936
-
> tonic::server::UnaryService<super::GetRockboxVersionRequest>
8937
-
for GetRockboxVersionSvc<T> {
7714
+
impl<T: SystemService>
7715
+
tonic::server::UnaryService<super::GetRockboxVersionRequest>
7716
+
for GetRockboxVersionSvc<T>
7717
+
{
8938
7718
type Response = super::GetRockboxVersionResponse;
8939
-
type Future = BoxFuture<
8940
-
tonic::Response<Self::Response>,
8941
-
tonic::Status,
8942
-
>;
7719
+
type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
8943
7720
fn call(
8944
7721
&mut self,
8945
7722
request: tonic::Request<super::GetRockboxVersionRequest>,
8946
7723
) -> Self::Future {
8947
7724
let inner = Arc::clone(&self.0);
8948
7725
let fut = async move {
8949
-
<T as SystemService>::get_rockbox_version(&inner, request)
8950
-
.await
7726
+
<T as SystemService>::get_rockbox_version(&inner, request).await
8951
7727
};
8952
7728
Box::pin(fut)
8953
7729
}
···
8977
7753
"/rockbox.v1alpha1.SystemService/GetGlobalStatus" => {
8978
7754
#[allow(non_camel_case_types)]
8979
7755
struct GetGlobalStatusSvc<T: SystemService>(pub Arc<T>);
8980
-
impl<
8981
-
T: SystemService,
8982
-
> tonic::server::UnaryService<super::GetGlobalStatusRequest>
8983
-
for GetGlobalStatusSvc<T> {
7756
+
impl<T: SystemService>
7757
+
tonic::server::UnaryService<super::GetGlobalStatusRequest>
7758
+
for GetGlobalStatusSvc<T>
7759
+
{
8984
7760
type Response = super::GetGlobalStatusResponse;
8985
-
type Future = BoxFuture<
8986
-
tonic::Response<Self::Response>,
8987
-
tonic::Status,
8988
-
>;
7761
+
type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
8989
7762
fn call(
8990
7763
&mut self,
8991
7764
request: tonic::Request<super::GetGlobalStatusRequest>,
8992
7765
) -> Self::Future {
8993
7766
let inner = Arc::clone(&self.0);
8994
7767
let fut = async move {
8995
-
<T as SystemService>::get_global_status(&inner, request)
8996
-
.await
7768
+
<T as SystemService>::get_global_status(&inner, request).await
8997
7769
};
8998
7770
Box::pin(fut)
8999
7771
}
···
9020
7792
};
9021
7793
Box::pin(fut)
9022
7794
}
9023
-
_ => {
9024
-
Box::pin(async move {
9025
-
let mut response = http::Response::new(empty_body());
9026
-
let headers = response.headers_mut();
9027
-
headers
9028
-
.insert(
9029
-
tonic::Status::GRPC_STATUS,
9030
-
(tonic::Code::Unimplemented as i32).into(),
9031
-
);
9032
-
headers
9033
-
.insert(
9034
-
http::header::CONTENT_TYPE,
9035
-
tonic::metadata::GRPC_CONTENT_TYPE,
9036
-
);
9037
-
Ok(response)
9038
-
})
9039
-
}
7795
+
_ => Box::pin(async move {
7796
+
let mut response = http::Response::new(empty_body());
7797
+
let headers = response.headers_mut();
7798
+
headers.insert(
7799
+
tonic::Status::GRPC_STATUS,
7800
+
(tonic::Code::Unimplemented as i32).into(),
7801
+
);
7802
+
headers.insert(
7803
+
http::header::CONTENT_TYPE,
7804
+
tonic::metadata::GRPC_CONTENT_TYPE,
7805
+
);
7806
+
Ok(response)
7807
+
}),
9040
7808
}
9041
7809
}
9042
7810
}