fidl_fuchsia_update_channelcontrol/
fidl_fuchsia_update_channelcontrol.rs

1// WARNING: This file is machine generated by fidlgen.
2
3#![warn(clippy::all)]
4#![allow(unused_parens, unused_mut, unused_imports, nonstandard_style)]
5
6use bitflags::bitflags;
7use fidl::client::QueryResponseFut;
8use fidl::encoding::{MessageBufFor, ProxyChannelBox, ResourceDialect};
9use fidl::endpoints::{ControlHandle as _, Responder as _};
10pub use fidl_fuchsia_update_channelcontrol_common::*;
11use futures::future::{self, MaybeDone, TryFutureExt};
12use zx_status;
13
14#[derive(Debug, Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Hash)]
15pub struct ChannelControlMarker;
16
17impl fidl::endpoints::ProtocolMarker for ChannelControlMarker {
18    type Proxy = ChannelControlProxy;
19    type RequestStream = ChannelControlRequestStream;
20    #[cfg(target_os = "fuchsia")]
21    type SynchronousProxy = ChannelControlSynchronousProxy;
22
23    const DEBUG_NAME: &'static str = "fuchsia.update.channelcontrol.ChannelControl";
24}
25impl fidl::endpoints::DiscoverableProtocolMarker for ChannelControlMarker {}
26
27pub trait ChannelControlProxyInterface: Send + Sync {
28    type GetCurrentResponseFut: std::future::Future<Output = Result<String, fidl::Error>> + Send;
29    fn r#get_current(&self) -> Self::GetCurrentResponseFut;
30    type SetTargetResponseFut: std::future::Future<Output = Result<(), fidl::Error>> + Send;
31    fn r#set_target(&self, channel: &str) -> Self::SetTargetResponseFut;
32    type GetTargetResponseFut: std::future::Future<Output = Result<String, fidl::Error>> + Send;
33    fn r#get_target(&self) -> Self::GetTargetResponseFut;
34    type GetTargetListResponseFut: std::future::Future<Output = Result<Vec<String>, fidl::Error>>
35        + Send;
36    fn r#get_target_list(&self) -> Self::GetTargetListResponseFut;
37}
38#[derive(Debug)]
39#[cfg(target_os = "fuchsia")]
40pub struct ChannelControlSynchronousProxy {
41    client: fidl::client::sync::Client,
42}
43
44#[cfg(target_os = "fuchsia")]
45impl fidl::endpoints::SynchronousProxy for ChannelControlSynchronousProxy {
46    type Proxy = ChannelControlProxy;
47    type Protocol = ChannelControlMarker;
48
49    fn from_channel(inner: fidl::Channel) -> Self {
50        Self::new(inner)
51    }
52
53    fn into_channel(self) -> fidl::Channel {
54        self.client.into_channel()
55    }
56
57    fn as_channel(&self) -> &fidl::Channel {
58        self.client.as_channel()
59    }
60}
61
62#[cfg(target_os = "fuchsia")]
63impl ChannelControlSynchronousProxy {
64    pub fn new(channel: fidl::Channel) -> Self {
65        let protocol_name = <ChannelControlMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME;
66        Self { client: fidl::client::sync::Client::new(channel, protocol_name) }
67    }
68
69    pub fn into_channel(self) -> fidl::Channel {
70        self.client.into_channel()
71    }
72
73    /// Waits until an event arrives and returns it. It is safe for other
74    /// threads to make concurrent requests while waiting for an event.
75    pub fn wait_for_event(
76        &self,
77        deadline: zx::MonotonicInstant,
78    ) -> Result<ChannelControlEvent, fidl::Error> {
79        ChannelControlEvent::decode(self.client.wait_for_event(deadline)?)
80    }
81
82    /// Retrieve the currently active update channel.
83    ///
84    /// - response `channel` the currently active update channel.
85    pub fn r#get_current(&self, ___deadline: zx::MonotonicInstant) -> Result<String, fidl::Error> {
86        let _response = self.client.send_query::<
87            fidl::encoding::EmptyPayload,
88            fidl_fuchsia_update_channel::ProviderGetCurrentResponse,
89        >(
90            (),
91            0x15af055da76e5016,
92            fidl::encoding::DynamicFlags::empty(),
93            ___deadline,
94        )?;
95        Ok(_response.channel)
96    }
97
98    /// Set a new desired target channel.  This tells the updater to attempt to
99    /// check for updates using a new channel.  This is tentative, and won't be
100    /// persisted unless an update check on that channel is successful.
101    ///
102    /// A response is generated when the new target channel has been verified as
103    /// valid.
104    ///
105    /// + request `channel` the new target channel name (name used by the updater)
106    pub fn r#set_target(
107        &self,
108        mut channel: &str,
109        ___deadline: zx::MonotonicInstant,
110    ) -> Result<(), fidl::Error> {
111        let _response = self
112            .client
113            .send_query::<ChannelControlSetTargetRequest, fidl::encoding::EmptyPayload>(
114                (channel,),
115                0x45f0a54099a1752e,
116                fidl::encoding::DynamicFlags::empty(),
117                ___deadline,
118            )?;
119        Ok(_response)
120    }
121
122    /// Get the current tentative target channel for updates.
123    /// This returns the channel that the update client is using to perform update
124    /// checks.  It's always one of:
125    ///    - the current channel
126    ///    - the default channel
127    ///    - a new target that's different, but hasn't been OTA'd from yet.
128    ///
129    /// - response `channel` the current target channel.
130    pub fn r#get_target(&self, ___deadline: zx::MonotonicInstant) -> Result<String, fidl::Error> {
131        let _response = self
132            .client
133            .send_query::<fidl::encoding::EmptyPayload, ChannelControlGetTargetResponse>(
134                (),
135                0x3602953dfbabe7a2,
136                fidl::encoding::DynamicFlags::empty(),
137                ___deadline,
138            )?;
139        Ok(_response.channel)
140    }
141
142    /// Get the list of well-known target channels that can be passed to SetTarget().
143    /// There may be other, unlisted channels.
144    pub fn r#get_target_list(
145        &self,
146        ___deadline: zx::MonotonicInstant,
147    ) -> Result<Vec<String>, fidl::Error> {
148        let _response = self
149            .client
150            .send_query::<fidl::encoding::EmptyPayload, ChannelControlGetTargetListResponse>(
151                (),
152                0x727a95a911d8db11,
153                fidl::encoding::DynamicFlags::empty(),
154                ___deadline,
155            )?;
156        Ok(_response.channels)
157    }
158}
159
160#[cfg(target_os = "fuchsia")]
161impl From<ChannelControlSynchronousProxy> for zx::Handle {
162    fn from(value: ChannelControlSynchronousProxy) -> Self {
163        value.into_channel().into()
164    }
165}
166
167#[cfg(target_os = "fuchsia")]
168impl From<fidl::Channel> for ChannelControlSynchronousProxy {
169    fn from(value: fidl::Channel) -> Self {
170        Self::new(value)
171    }
172}
173
174#[derive(Debug, Clone)]
175pub struct ChannelControlProxy {
176    client: fidl::client::Client<fidl::encoding::DefaultFuchsiaResourceDialect>,
177}
178
179impl fidl::endpoints::Proxy for ChannelControlProxy {
180    type Protocol = ChannelControlMarker;
181
182    fn from_channel(inner: ::fidl::AsyncChannel) -> Self {
183        Self::new(inner)
184    }
185
186    fn into_channel(self) -> Result<::fidl::AsyncChannel, Self> {
187        self.client.into_channel().map_err(|client| Self { client })
188    }
189
190    fn as_channel(&self) -> &::fidl::AsyncChannel {
191        self.client.as_channel()
192    }
193}
194
195impl ChannelControlProxy {
196    /// Create a new Proxy for fuchsia.update.channelcontrol/ChannelControl.
197    pub fn new(channel: ::fidl::AsyncChannel) -> Self {
198        let protocol_name = <ChannelControlMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME;
199        Self { client: fidl::client::Client::new(channel, protocol_name) }
200    }
201
202    /// Get a Stream of events from the remote end of the protocol.
203    ///
204    /// # Panics
205    ///
206    /// Panics if the event stream was already taken.
207    pub fn take_event_stream(&self) -> ChannelControlEventStream {
208        ChannelControlEventStream { event_receiver: self.client.take_event_receiver() }
209    }
210
211    /// Retrieve the currently active update channel.
212    ///
213    /// - response `channel` the currently active update channel.
214    pub fn r#get_current(
215        &self,
216    ) -> fidl::client::QueryResponseFut<String, fidl::encoding::DefaultFuchsiaResourceDialect> {
217        ChannelControlProxyInterface::r#get_current(self)
218    }
219
220    /// Set a new desired target channel.  This tells the updater to attempt to
221    /// check for updates using a new channel.  This is tentative, and won't be
222    /// persisted unless an update check on that channel is successful.
223    ///
224    /// A response is generated when the new target channel has been verified as
225    /// valid.
226    ///
227    /// + request `channel` the new target channel name (name used by the updater)
228    pub fn r#set_target(
229        &self,
230        mut channel: &str,
231    ) -> fidl::client::QueryResponseFut<(), fidl::encoding::DefaultFuchsiaResourceDialect> {
232        ChannelControlProxyInterface::r#set_target(self, channel)
233    }
234
235    /// Get the current tentative target channel for updates.
236    /// This returns the channel that the update client is using to perform update
237    /// checks.  It's always one of:
238    ///    - the current channel
239    ///    - the default channel
240    ///    - a new target that's different, but hasn't been OTA'd from yet.
241    ///
242    /// - response `channel` the current target channel.
243    pub fn r#get_target(
244        &self,
245    ) -> fidl::client::QueryResponseFut<String, fidl::encoding::DefaultFuchsiaResourceDialect> {
246        ChannelControlProxyInterface::r#get_target(self)
247    }
248
249    /// Get the list of well-known target channels that can be passed to SetTarget().
250    /// There may be other, unlisted channels.
251    pub fn r#get_target_list(
252        &self,
253    ) -> fidl::client::QueryResponseFut<Vec<String>, fidl::encoding::DefaultFuchsiaResourceDialect>
254    {
255        ChannelControlProxyInterface::r#get_target_list(self)
256    }
257}
258
259impl ChannelControlProxyInterface for ChannelControlProxy {
260    type GetCurrentResponseFut =
261        fidl::client::QueryResponseFut<String, fidl::encoding::DefaultFuchsiaResourceDialect>;
262    fn r#get_current(&self) -> Self::GetCurrentResponseFut {
263        fn _decode(
264            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
265        ) -> Result<String, fidl::Error> {
266            let _response = fidl::client::decode_transaction_body::<
267                fidl_fuchsia_update_channel::ProviderGetCurrentResponse,
268                fidl::encoding::DefaultFuchsiaResourceDialect,
269                0x15af055da76e5016,
270            >(_buf?)?;
271            Ok(_response.channel)
272        }
273        self.client.send_query_and_decode::<fidl::encoding::EmptyPayload, String>(
274            (),
275            0x15af055da76e5016,
276            fidl::encoding::DynamicFlags::empty(),
277            _decode,
278        )
279    }
280
281    type SetTargetResponseFut =
282        fidl::client::QueryResponseFut<(), fidl::encoding::DefaultFuchsiaResourceDialect>;
283    fn r#set_target(&self, mut channel: &str) -> Self::SetTargetResponseFut {
284        fn _decode(
285            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
286        ) -> Result<(), fidl::Error> {
287            let _response = fidl::client::decode_transaction_body::<
288                fidl::encoding::EmptyPayload,
289                fidl::encoding::DefaultFuchsiaResourceDialect,
290                0x45f0a54099a1752e,
291            >(_buf?)?;
292            Ok(_response)
293        }
294        self.client.send_query_and_decode::<ChannelControlSetTargetRequest, ()>(
295            (channel,),
296            0x45f0a54099a1752e,
297            fidl::encoding::DynamicFlags::empty(),
298            _decode,
299        )
300    }
301
302    type GetTargetResponseFut =
303        fidl::client::QueryResponseFut<String, fidl::encoding::DefaultFuchsiaResourceDialect>;
304    fn r#get_target(&self) -> Self::GetTargetResponseFut {
305        fn _decode(
306            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
307        ) -> Result<String, fidl::Error> {
308            let _response = fidl::client::decode_transaction_body::<
309                ChannelControlGetTargetResponse,
310                fidl::encoding::DefaultFuchsiaResourceDialect,
311                0x3602953dfbabe7a2,
312            >(_buf?)?;
313            Ok(_response.channel)
314        }
315        self.client.send_query_and_decode::<fidl::encoding::EmptyPayload, String>(
316            (),
317            0x3602953dfbabe7a2,
318            fidl::encoding::DynamicFlags::empty(),
319            _decode,
320        )
321    }
322
323    type GetTargetListResponseFut =
324        fidl::client::QueryResponseFut<Vec<String>, fidl::encoding::DefaultFuchsiaResourceDialect>;
325    fn r#get_target_list(&self) -> Self::GetTargetListResponseFut {
326        fn _decode(
327            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
328        ) -> Result<Vec<String>, fidl::Error> {
329            let _response = fidl::client::decode_transaction_body::<
330                ChannelControlGetTargetListResponse,
331                fidl::encoding::DefaultFuchsiaResourceDialect,
332                0x727a95a911d8db11,
333            >(_buf?)?;
334            Ok(_response.channels)
335        }
336        self.client.send_query_and_decode::<fidl::encoding::EmptyPayload, Vec<String>>(
337            (),
338            0x727a95a911d8db11,
339            fidl::encoding::DynamicFlags::empty(),
340            _decode,
341        )
342    }
343}
344
345pub struct ChannelControlEventStream {
346    event_receiver: fidl::client::EventReceiver<fidl::encoding::DefaultFuchsiaResourceDialect>,
347}
348
349impl std::marker::Unpin for ChannelControlEventStream {}
350
351impl futures::stream::FusedStream for ChannelControlEventStream {
352    fn is_terminated(&self) -> bool {
353        self.event_receiver.is_terminated()
354    }
355}
356
357impl futures::Stream for ChannelControlEventStream {
358    type Item = Result<ChannelControlEvent, fidl::Error>;
359
360    fn poll_next(
361        mut self: std::pin::Pin<&mut Self>,
362        cx: &mut std::task::Context<'_>,
363    ) -> std::task::Poll<Option<Self::Item>> {
364        match futures::ready!(futures::stream::StreamExt::poll_next_unpin(
365            &mut self.event_receiver,
366            cx
367        )?) {
368            Some(buf) => std::task::Poll::Ready(Some(ChannelControlEvent::decode(buf))),
369            None => std::task::Poll::Ready(None),
370        }
371    }
372}
373
374#[derive(Debug)]
375pub enum ChannelControlEvent {}
376
377impl ChannelControlEvent {
378    /// Decodes a message buffer as a [`ChannelControlEvent`].
379    fn decode(
380        mut buf: <fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc,
381    ) -> Result<ChannelControlEvent, fidl::Error> {
382        let (bytes, _handles) = buf.split_mut();
383        let (tx_header, _body_bytes) = fidl::encoding::decode_transaction_header(bytes)?;
384        debug_assert_eq!(tx_header.tx_id, 0);
385        match tx_header.ordinal {
386            _ => Err(fidl::Error::UnknownOrdinal {
387                ordinal: tx_header.ordinal,
388                protocol_name:
389                    <ChannelControlMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
390            }),
391        }
392    }
393}
394
395/// A Stream of incoming requests for fuchsia.update.channelcontrol/ChannelControl.
396pub struct ChannelControlRequestStream {
397    inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
398    is_terminated: bool,
399}
400
401impl std::marker::Unpin for ChannelControlRequestStream {}
402
403impl futures::stream::FusedStream for ChannelControlRequestStream {
404    fn is_terminated(&self) -> bool {
405        self.is_terminated
406    }
407}
408
409impl fidl::endpoints::RequestStream for ChannelControlRequestStream {
410    type Protocol = ChannelControlMarker;
411    type ControlHandle = ChannelControlControlHandle;
412
413    fn from_channel(channel: ::fidl::AsyncChannel) -> Self {
414        Self { inner: std::sync::Arc::new(fidl::ServeInner::new(channel)), is_terminated: false }
415    }
416
417    fn control_handle(&self) -> Self::ControlHandle {
418        ChannelControlControlHandle { inner: self.inner.clone() }
419    }
420
421    fn into_inner(
422        self,
423    ) -> (::std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>, bool)
424    {
425        (self.inner, self.is_terminated)
426    }
427
428    fn from_inner(
429        inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
430        is_terminated: bool,
431    ) -> Self {
432        Self { inner, is_terminated }
433    }
434}
435
436impl futures::Stream for ChannelControlRequestStream {
437    type Item = Result<ChannelControlRequest, fidl::Error>;
438
439    fn poll_next(
440        mut self: std::pin::Pin<&mut Self>,
441        cx: &mut std::task::Context<'_>,
442    ) -> std::task::Poll<Option<Self::Item>> {
443        let this = &mut *self;
444        if this.inner.check_shutdown(cx) {
445            this.is_terminated = true;
446            return std::task::Poll::Ready(None);
447        }
448        if this.is_terminated {
449            panic!("polled ChannelControlRequestStream after completion");
450        }
451        fidl::encoding::with_tls_decode_buf::<_, fidl::encoding::DefaultFuchsiaResourceDialect>(
452            |bytes, handles| {
453                match this.inner.channel().read_etc(cx, bytes, handles) {
454                    std::task::Poll::Ready(Ok(())) => {}
455                    std::task::Poll::Pending => return std::task::Poll::Pending,
456                    std::task::Poll::Ready(Err(zx_status::Status::PEER_CLOSED)) => {
457                        this.is_terminated = true;
458                        return std::task::Poll::Ready(None);
459                    }
460                    std::task::Poll::Ready(Err(e)) => {
461                        return std::task::Poll::Ready(Some(Err(fidl::Error::ServerRequestRead(
462                            e.into(),
463                        ))))
464                    }
465                }
466
467                // A message has been received from the channel
468                let (header, _body_bytes) = fidl::encoding::decode_transaction_header(bytes)?;
469
470                std::task::Poll::Ready(Some(match header.ordinal {
471                    0x15af055da76e5016 => {
472                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
473                        let mut req = fidl::new_empty!(
474                            fidl::encoding::EmptyPayload,
475                            fidl::encoding::DefaultFuchsiaResourceDialect
476                        );
477                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
478                        let control_handle =
479                            ChannelControlControlHandle { inner: this.inner.clone() };
480                        Ok(ChannelControlRequest::GetCurrent {
481                            responder: ChannelControlGetCurrentResponder {
482                                control_handle: std::mem::ManuallyDrop::new(control_handle),
483                                tx_id: header.tx_id,
484                            },
485                        })
486                    }
487                    0x45f0a54099a1752e => {
488                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
489                        let mut req = fidl::new_empty!(
490                            ChannelControlSetTargetRequest,
491                            fidl::encoding::DefaultFuchsiaResourceDialect
492                        );
493                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<ChannelControlSetTargetRequest>(&header, _body_bytes, handles, &mut req)?;
494                        let control_handle =
495                            ChannelControlControlHandle { inner: this.inner.clone() };
496                        Ok(ChannelControlRequest::SetTarget {
497                            channel: req.channel,
498
499                            responder: ChannelControlSetTargetResponder {
500                                control_handle: std::mem::ManuallyDrop::new(control_handle),
501                                tx_id: header.tx_id,
502                            },
503                        })
504                    }
505                    0x3602953dfbabe7a2 => {
506                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
507                        let mut req = fidl::new_empty!(
508                            fidl::encoding::EmptyPayload,
509                            fidl::encoding::DefaultFuchsiaResourceDialect
510                        );
511                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
512                        let control_handle =
513                            ChannelControlControlHandle { inner: this.inner.clone() };
514                        Ok(ChannelControlRequest::GetTarget {
515                            responder: ChannelControlGetTargetResponder {
516                                control_handle: std::mem::ManuallyDrop::new(control_handle),
517                                tx_id: header.tx_id,
518                            },
519                        })
520                    }
521                    0x727a95a911d8db11 => {
522                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
523                        let mut req = fidl::new_empty!(
524                            fidl::encoding::EmptyPayload,
525                            fidl::encoding::DefaultFuchsiaResourceDialect
526                        );
527                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
528                        let control_handle =
529                            ChannelControlControlHandle { inner: this.inner.clone() };
530                        Ok(ChannelControlRequest::GetTargetList {
531                            responder: ChannelControlGetTargetListResponder {
532                                control_handle: std::mem::ManuallyDrop::new(control_handle),
533                                tx_id: header.tx_id,
534                            },
535                        })
536                    }
537                    _ => Err(fidl::Error::UnknownOrdinal {
538                        ordinal: header.ordinal,
539                        protocol_name:
540                            <ChannelControlMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
541                    }),
542                }))
543            },
544        )
545    }
546}
547
548/// Control the target update channel, this is the channel we will use on the next update check.
549#[derive(Debug)]
550pub enum ChannelControlRequest {
551    /// Retrieve the currently active update channel.
552    ///
553    /// - response `channel` the currently active update channel.
554    GetCurrent { responder: ChannelControlGetCurrentResponder },
555    /// Set a new desired target channel.  This tells the updater to attempt to
556    /// check for updates using a new channel.  This is tentative, and won't be
557    /// persisted unless an update check on that channel is successful.
558    ///
559    /// A response is generated when the new target channel has been verified as
560    /// valid.
561    ///
562    /// + request `channel` the new target channel name (name used by the updater)
563    SetTarget { channel: String, responder: ChannelControlSetTargetResponder },
564    /// Get the current tentative target channel for updates.
565    /// This returns the channel that the update client is using to perform update
566    /// checks.  It's always one of:
567    ///    - the current channel
568    ///    - the default channel
569    ///    - a new target that's different, but hasn't been OTA'd from yet.
570    ///
571    /// - response `channel` the current target channel.
572    GetTarget { responder: ChannelControlGetTargetResponder },
573    /// Get the list of well-known target channels that can be passed to SetTarget().
574    /// There may be other, unlisted channels.
575    GetTargetList { responder: ChannelControlGetTargetListResponder },
576}
577
578impl ChannelControlRequest {
579    #[allow(irrefutable_let_patterns)]
580    pub fn into_get_current(self) -> Option<(ChannelControlGetCurrentResponder)> {
581        if let ChannelControlRequest::GetCurrent { responder } = self {
582            Some((responder))
583        } else {
584            None
585        }
586    }
587
588    #[allow(irrefutable_let_patterns)]
589    pub fn into_set_target(self) -> Option<(String, ChannelControlSetTargetResponder)> {
590        if let ChannelControlRequest::SetTarget { channel, responder } = self {
591            Some((channel, responder))
592        } else {
593            None
594        }
595    }
596
597    #[allow(irrefutable_let_patterns)]
598    pub fn into_get_target(self) -> Option<(ChannelControlGetTargetResponder)> {
599        if let ChannelControlRequest::GetTarget { responder } = self {
600            Some((responder))
601        } else {
602            None
603        }
604    }
605
606    #[allow(irrefutable_let_patterns)]
607    pub fn into_get_target_list(self) -> Option<(ChannelControlGetTargetListResponder)> {
608        if let ChannelControlRequest::GetTargetList { responder } = self {
609            Some((responder))
610        } else {
611            None
612        }
613    }
614
615    /// Name of the method defined in FIDL
616    pub fn method_name(&self) -> &'static str {
617        match *self {
618            ChannelControlRequest::GetCurrent { .. } => "get_current",
619            ChannelControlRequest::SetTarget { .. } => "set_target",
620            ChannelControlRequest::GetTarget { .. } => "get_target",
621            ChannelControlRequest::GetTargetList { .. } => "get_target_list",
622        }
623    }
624}
625
626#[derive(Debug, Clone)]
627pub struct ChannelControlControlHandle {
628    inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
629}
630
631impl fidl::endpoints::ControlHandle for ChannelControlControlHandle {
632    fn shutdown(&self) {
633        self.inner.shutdown()
634    }
635    fn shutdown_with_epitaph(&self, status: zx_status::Status) {
636        self.inner.shutdown_with_epitaph(status)
637    }
638
639    fn is_closed(&self) -> bool {
640        self.inner.channel().is_closed()
641    }
642    fn on_closed(&self) -> fidl::OnSignalsRef<'_> {
643        self.inner.channel().on_closed()
644    }
645
646    #[cfg(target_os = "fuchsia")]
647    fn signal_peer(
648        &self,
649        clear_mask: zx::Signals,
650        set_mask: zx::Signals,
651    ) -> Result<(), zx_status::Status> {
652        use fidl::Peered;
653        self.inner.channel().signal_peer(clear_mask, set_mask)
654    }
655}
656
657impl ChannelControlControlHandle {}
658
659#[must_use = "FIDL methods require a response to be sent"]
660#[derive(Debug)]
661pub struct ChannelControlGetCurrentResponder {
662    control_handle: std::mem::ManuallyDrop<ChannelControlControlHandle>,
663    tx_id: u32,
664}
665
666/// Set the the channel to be shutdown (see [`ChannelControlControlHandle::shutdown`])
667/// if the responder is dropped without sending a response, so that the client
668/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
669impl std::ops::Drop for ChannelControlGetCurrentResponder {
670    fn drop(&mut self) {
671        self.control_handle.shutdown();
672        // Safety: drops once, never accessed again
673        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
674    }
675}
676
677impl fidl::endpoints::Responder for ChannelControlGetCurrentResponder {
678    type ControlHandle = ChannelControlControlHandle;
679
680    fn control_handle(&self) -> &ChannelControlControlHandle {
681        &self.control_handle
682    }
683
684    fn drop_without_shutdown(mut self) {
685        // Safety: drops once, never accessed again due to mem::forget
686        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
687        // Prevent Drop from running (which would shut down the channel)
688        std::mem::forget(self);
689    }
690}
691
692impl ChannelControlGetCurrentResponder {
693    /// Sends a response to the FIDL transaction.
694    ///
695    /// Sets the channel to shutdown if an error occurs.
696    pub fn send(self, mut channel: &str) -> Result<(), fidl::Error> {
697        let _result = self.send_raw(channel);
698        if _result.is_err() {
699            self.control_handle.shutdown();
700        }
701        self.drop_without_shutdown();
702        _result
703    }
704
705    /// Similar to "send" but does not shutdown the channel if an error occurs.
706    pub fn send_no_shutdown_on_err(self, mut channel: &str) -> Result<(), fidl::Error> {
707        let _result = self.send_raw(channel);
708        self.drop_without_shutdown();
709        _result
710    }
711
712    fn send_raw(&self, mut channel: &str) -> Result<(), fidl::Error> {
713        self.control_handle.inner.send::<fidl_fuchsia_update_channel::ProviderGetCurrentResponse>(
714            (channel,),
715            self.tx_id,
716            0x15af055da76e5016,
717            fidl::encoding::DynamicFlags::empty(),
718        )
719    }
720}
721
722#[must_use = "FIDL methods require a response to be sent"]
723#[derive(Debug)]
724pub struct ChannelControlSetTargetResponder {
725    control_handle: std::mem::ManuallyDrop<ChannelControlControlHandle>,
726    tx_id: u32,
727}
728
729/// Set the the channel to be shutdown (see [`ChannelControlControlHandle::shutdown`])
730/// if the responder is dropped without sending a response, so that the client
731/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
732impl std::ops::Drop for ChannelControlSetTargetResponder {
733    fn drop(&mut self) {
734        self.control_handle.shutdown();
735        // Safety: drops once, never accessed again
736        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
737    }
738}
739
740impl fidl::endpoints::Responder for ChannelControlSetTargetResponder {
741    type ControlHandle = ChannelControlControlHandle;
742
743    fn control_handle(&self) -> &ChannelControlControlHandle {
744        &self.control_handle
745    }
746
747    fn drop_without_shutdown(mut self) {
748        // Safety: drops once, never accessed again due to mem::forget
749        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
750        // Prevent Drop from running (which would shut down the channel)
751        std::mem::forget(self);
752    }
753}
754
755impl ChannelControlSetTargetResponder {
756    /// Sends a response to the FIDL transaction.
757    ///
758    /// Sets the channel to shutdown if an error occurs.
759    pub fn send(self) -> Result<(), fidl::Error> {
760        let _result = self.send_raw();
761        if _result.is_err() {
762            self.control_handle.shutdown();
763        }
764        self.drop_without_shutdown();
765        _result
766    }
767
768    /// Similar to "send" but does not shutdown the channel if an error occurs.
769    pub fn send_no_shutdown_on_err(self) -> Result<(), fidl::Error> {
770        let _result = self.send_raw();
771        self.drop_without_shutdown();
772        _result
773    }
774
775    fn send_raw(&self) -> Result<(), fidl::Error> {
776        self.control_handle.inner.send::<fidl::encoding::EmptyPayload>(
777            (),
778            self.tx_id,
779            0x45f0a54099a1752e,
780            fidl::encoding::DynamicFlags::empty(),
781        )
782    }
783}
784
785#[must_use = "FIDL methods require a response to be sent"]
786#[derive(Debug)]
787pub struct ChannelControlGetTargetResponder {
788    control_handle: std::mem::ManuallyDrop<ChannelControlControlHandle>,
789    tx_id: u32,
790}
791
792/// Set the the channel to be shutdown (see [`ChannelControlControlHandle::shutdown`])
793/// if the responder is dropped without sending a response, so that the client
794/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
795impl std::ops::Drop for ChannelControlGetTargetResponder {
796    fn drop(&mut self) {
797        self.control_handle.shutdown();
798        // Safety: drops once, never accessed again
799        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
800    }
801}
802
803impl fidl::endpoints::Responder for ChannelControlGetTargetResponder {
804    type ControlHandle = ChannelControlControlHandle;
805
806    fn control_handle(&self) -> &ChannelControlControlHandle {
807        &self.control_handle
808    }
809
810    fn drop_without_shutdown(mut self) {
811        // Safety: drops once, never accessed again due to mem::forget
812        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
813        // Prevent Drop from running (which would shut down the channel)
814        std::mem::forget(self);
815    }
816}
817
818impl ChannelControlGetTargetResponder {
819    /// Sends a response to the FIDL transaction.
820    ///
821    /// Sets the channel to shutdown if an error occurs.
822    pub fn send(self, mut channel: &str) -> Result<(), fidl::Error> {
823        let _result = self.send_raw(channel);
824        if _result.is_err() {
825            self.control_handle.shutdown();
826        }
827        self.drop_without_shutdown();
828        _result
829    }
830
831    /// Similar to "send" but does not shutdown the channel if an error occurs.
832    pub fn send_no_shutdown_on_err(self, mut channel: &str) -> Result<(), fidl::Error> {
833        let _result = self.send_raw(channel);
834        self.drop_without_shutdown();
835        _result
836    }
837
838    fn send_raw(&self, mut channel: &str) -> Result<(), fidl::Error> {
839        self.control_handle.inner.send::<ChannelControlGetTargetResponse>(
840            (channel,),
841            self.tx_id,
842            0x3602953dfbabe7a2,
843            fidl::encoding::DynamicFlags::empty(),
844        )
845    }
846}
847
848#[must_use = "FIDL methods require a response to be sent"]
849#[derive(Debug)]
850pub struct ChannelControlGetTargetListResponder {
851    control_handle: std::mem::ManuallyDrop<ChannelControlControlHandle>,
852    tx_id: u32,
853}
854
855/// Set the the channel to be shutdown (see [`ChannelControlControlHandle::shutdown`])
856/// if the responder is dropped without sending a response, so that the client
857/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
858impl std::ops::Drop for ChannelControlGetTargetListResponder {
859    fn drop(&mut self) {
860        self.control_handle.shutdown();
861        // Safety: drops once, never accessed again
862        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
863    }
864}
865
866impl fidl::endpoints::Responder for ChannelControlGetTargetListResponder {
867    type ControlHandle = ChannelControlControlHandle;
868
869    fn control_handle(&self) -> &ChannelControlControlHandle {
870        &self.control_handle
871    }
872
873    fn drop_without_shutdown(mut self) {
874        // Safety: drops once, never accessed again due to mem::forget
875        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
876        // Prevent Drop from running (which would shut down the channel)
877        std::mem::forget(self);
878    }
879}
880
881impl ChannelControlGetTargetListResponder {
882    /// Sends a response to the FIDL transaction.
883    ///
884    /// Sets the channel to shutdown if an error occurs.
885    pub fn send(self, mut channels: &[String]) -> Result<(), fidl::Error> {
886        let _result = self.send_raw(channels);
887        if _result.is_err() {
888            self.control_handle.shutdown();
889        }
890        self.drop_without_shutdown();
891        _result
892    }
893
894    /// Similar to "send" but does not shutdown the channel if an error occurs.
895    pub fn send_no_shutdown_on_err(self, mut channels: &[String]) -> Result<(), fidl::Error> {
896        let _result = self.send_raw(channels);
897        self.drop_without_shutdown();
898        _result
899    }
900
901    fn send_raw(&self, mut channels: &[String]) -> Result<(), fidl::Error> {
902        self.control_handle.inner.send::<ChannelControlGetTargetListResponse>(
903            (channels,),
904            self.tx_id,
905            0x727a95a911d8db11,
906            fidl::encoding::DynamicFlags::empty(),
907        )
908    }
909}
910
911mod internal {
912    use super::*;
913}
fidl_fuchsia_update_channelcontrol/fidl_fuchsia_update_channelcontrol.rs

fidl_fuchsia_update_channelcontrol/
fidl_fuchsia_update_channelcontrol.rs
