fidl_fuchsia_ui_display_color/
fidl_fuchsia_ui_display_color.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_ui_display_color__common::*;
11use futures::future::{self, MaybeDone, TryFutureExt};
12use zx_status;
13
14#[derive(Debug, PartialEq)]
15pub struct ConverterSetValuesRequest {
16    pub properties: ConversionProperties,
17}
18
19impl fidl::Standalone<fidl::encoding::DefaultFuchsiaResourceDialect> for ConverterSetValuesRequest {}
20
21#[derive(Debug, Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Hash)]
22pub struct ConverterMarker;
23
24impl fidl::endpoints::ProtocolMarker for ConverterMarker {
25    type Proxy = ConverterProxy;
26    type RequestStream = ConverterRequestStream;
27    #[cfg(target_os = "fuchsia")]
28    type SynchronousProxy = ConverterSynchronousProxy;
29
30    const DEBUG_NAME: &'static str = "fuchsia.ui.display.color.Converter";
31}
32impl fidl::endpoints::DiscoverableProtocolMarker for ConverterMarker {}
33
34pub trait ConverterProxyInterface: Send + Sync {
35    type SetValuesResponseFut: std::future::Future<Output = Result<i32, fidl::Error>> + Send;
36    fn r#set_values(&self, properties: &ConversionProperties) -> Self::SetValuesResponseFut;
37    type SetMinimumRgbResponseFut: std::future::Future<Output = Result<bool, fidl::Error>> + Send;
38    fn r#set_minimum_rgb(&self, minimum_rgb: u8) -> Self::SetMinimumRgbResponseFut;
39}
40#[derive(Debug)]
41#[cfg(target_os = "fuchsia")]
42pub struct ConverterSynchronousProxy {
43    client: fidl::client::sync::Client,
44}
45
46#[cfg(target_os = "fuchsia")]
47impl fidl::endpoints::SynchronousProxy for ConverterSynchronousProxy {
48    type Proxy = ConverterProxy;
49    type Protocol = ConverterMarker;
50
51    fn from_channel(inner: fidl::Channel) -> Self {
52        Self::new(inner)
53    }
54
55    fn into_channel(self) -> fidl::Channel {
56        self.client.into_channel()
57    }
58
59    fn as_channel(&self) -> &fidl::Channel {
60        self.client.as_channel()
61    }
62}
63
64#[cfg(target_os = "fuchsia")]
65impl ConverterSynchronousProxy {
66    pub fn new(channel: fidl::Channel) -> Self {
67        let protocol_name = <ConverterMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME;
68        Self { client: fidl::client::sync::Client::new(channel, protocol_name) }
69    }
70
71    pub fn into_channel(self) -> fidl::Channel {
72        self.client.into_channel()
73    }
74
75    /// Waits until an event arrives and returns it. It is safe for other
76    /// threads to make concurrent requests while waiting for an event.
77    pub fn wait_for_event(
78        &self,
79        deadline: zx::MonotonicInstant,
80    ) -> Result<ConverterEvent, fidl::Error> {
81        ConverterEvent::decode(self.client.wait_for_event(deadline)?)
82    }
83
84    /// Modifies the color of final display output of rendered content. The sole parameter is a
85    /// table of |ConversionProperties|, which contains the parameters required to apply the
86    /// color conversion formula to the display. Please see |ConversionProperties| defined
87    /// above for more information.
88    ///
89    /// All parameters in the properties table must be normal 32-bit floating point values.
90    /// If any of the values do not meet this specification, the new color conversion values
91    /// will not be applied and a value of ZX_ERR_INVALID_ARGS will be returned. Otherwise,
92    /// the return value will be ZX_OK: https://en.wikipedia.org/wiki/Normal_number_%28computing%29.
93    /// Once a value of ZX_OK has been returned to the client, the color conversion values are ready
94    /// to be used in future render calls, including screenshots.
95    ///
96    /// Values in |ConversionProperties| may also be left blank. The default values for each member,
97    /// if left blank, are as follows:
98    ///     coefficients =
99    ///             [1, 0, 0,
100    ///              0, 1, 0,
101    ///              0, 0, 1]  (i.e. the identity matrix)
102    ///     preoffsets = [0,0,0]
103    ///     postoffsets = [0,0,0]
104    /// Thus, ColorConversion can be reset by passing in an empty table to this function.
105    ///
106    /// Hardware that support color conversion generally accept a limited range of coefficient
107    /// values. Coefficients in the range of [-2, 2] inclusive will be accepted by most
108    /// hardware. The hardware driver will clamp values that are outside its acceptable range.
109    ///
110    /// `preoffsets`, `postoffsets`: Clients are encouraged to produce color conversion values that
111    /// do not depend on pre and post offsets since some hardware do not have support for that.
112    /// For cases where pre and post offset values need to be used, the range should be limited to
113    /// (-1, 1).
114    pub fn r#set_values(
115        &self,
116        mut properties: &ConversionProperties,
117        ___deadline: zx::MonotonicInstant,
118    ) -> Result<i32, fidl::Error> {
119        let _response =
120            self.client.send_query::<ConverterSetValuesRequest, ConverterSetValuesResponse>(
121                (properties,),
122                0x64131a672b34af8d,
123                fidl::encoding::DynamicFlags::empty(),
124                ___deadline,
125            )?;
126        Ok(_response.res)
127    }
128
129    /// Submits a minimum value that all channels of all pixels rendered to the display
130    /// are clamped to. This can be used to mitigate the apparent effects of backlight
131    /// bleeding on certain devices in low-light environments.
132    ///
133    /// The valid range for a minimum value is [0, 255] (inclusive).  For a new
134    /// minimum value M, each color channel's range will be limited to [M, 255].
135    ///
136    /// Callers should wait for the acknowledgement to return before submitting another
137    /// call to this function. The minimum_rgb clamping can be removed simply by submitting
138    /// a value of 0.
139    ///
140    /// Not all hardware supports this feature. So this function returns |true|
141    /// if successfully applied and |false| if unsupported.
142    pub fn r#set_minimum_rgb(
143        &self,
144        mut minimum_rgb: u8,
145        ___deadline: zx::MonotonicInstant,
146    ) -> Result<bool, fidl::Error> {
147        let _response = self
148            .client
149            .send_query::<ConverterSetMinimumRgbRequest, ConverterSetMinimumRgbResponse>(
150                (minimum_rgb,),
151                0x45dd02bf82f653d1,
152                fidl::encoding::DynamicFlags::empty(),
153                ___deadline,
154            )?;
155        Ok(_response.supported)
156    }
157}
158
159#[cfg(target_os = "fuchsia")]
160impl From<ConverterSynchronousProxy> for zx::NullableHandle {
161    fn from(value: ConverterSynchronousProxy) -> Self {
162        value.into_channel().into()
163    }
164}
165
166#[cfg(target_os = "fuchsia")]
167impl From<fidl::Channel> for ConverterSynchronousProxy {
168    fn from(value: fidl::Channel) -> Self {
169        Self::new(value)
170    }
171}
172
173#[cfg(target_os = "fuchsia")]
174impl fidl::endpoints::FromClient for ConverterSynchronousProxy {
175    type Protocol = ConverterMarker;
176
177    fn from_client(value: fidl::endpoints::ClientEnd<ConverterMarker>) -> Self {
178        Self::new(value.into_channel())
179    }
180}
181
182#[derive(Debug, Clone)]
183pub struct ConverterProxy {
184    client: fidl::client::Client<fidl::encoding::DefaultFuchsiaResourceDialect>,
185}
186
187impl fidl::endpoints::Proxy for ConverterProxy {
188    type Protocol = ConverterMarker;
189
190    fn from_channel(inner: ::fidl::AsyncChannel) -> Self {
191        Self::new(inner)
192    }
193
194    fn into_channel(self) -> Result<::fidl::AsyncChannel, Self> {
195        self.client.into_channel().map_err(|client| Self { client })
196    }
197
198    fn as_channel(&self) -> &::fidl::AsyncChannel {
199        self.client.as_channel()
200    }
201}
202
203impl ConverterProxy {
204    /// Create a new Proxy for fuchsia.ui.display.color/Converter.
205    pub fn new(channel: ::fidl::AsyncChannel) -> Self {
206        let protocol_name = <ConverterMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME;
207        Self { client: fidl::client::Client::new(channel, protocol_name) }
208    }
209
210    /// Get a Stream of events from the remote end of the protocol.
211    ///
212    /// # Panics
213    ///
214    /// Panics if the event stream was already taken.
215    pub fn take_event_stream(&self) -> ConverterEventStream {
216        ConverterEventStream { event_receiver: self.client.take_event_receiver() }
217    }
218
219    /// Modifies the color of final display output of rendered content. The sole parameter is a
220    /// table of |ConversionProperties|, which contains the parameters required to apply the
221    /// color conversion formula to the display. Please see |ConversionProperties| defined
222    /// above for more information.
223    ///
224    /// All parameters in the properties table must be normal 32-bit floating point values.
225    /// If any of the values do not meet this specification, the new color conversion values
226    /// will not be applied and a value of ZX_ERR_INVALID_ARGS will be returned. Otherwise,
227    /// the return value will be ZX_OK: https://en.wikipedia.org/wiki/Normal_number_%28computing%29.
228    /// Once a value of ZX_OK has been returned to the client, the color conversion values are ready
229    /// to be used in future render calls, including screenshots.
230    ///
231    /// Values in |ConversionProperties| may also be left blank. The default values for each member,
232    /// if left blank, are as follows:
233    ///     coefficients =
234    ///             [1, 0, 0,
235    ///              0, 1, 0,
236    ///              0, 0, 1]  (i.e. the identity matrix)
237    ///     preoffsets = [0,0,0]
238    ///     postoffsets = [0,0,0]
239    /// Thus, ColorConversion can be reset by passing in an empty table to this function.
240    ///
241    /// Hardware that support color conversion generally accept a limited range of coefficient
242    /// values. Coefficients in the range of [-2, 2] inclusive will be accepted by most
243    /// hardware. The hardware driver will clamp values that are outside its acceptable range.
244    ///
245    /// `preoffsets`, `postoffsets`: Clients are encouraged to produce color conversion values that
246    /// do not depend on pre and post offsets since some hardware do not have support for that.
247    /// For cases where pre and post offset values need to be used, the range should be limited to
248    /// (-1, 1).
249    pub fn r#set_values(
250        &self,
251        mut properties: &ConversionProperties,
252    ) -> fidl::client::QueryResponseFut<i32, fidl::encoding::DefaultFuchsiaResourceDialect> {
253        ConverterProxyInterface::r#set_values(self, properties)
254    }
255
256    /// Submits a minimum value that all channels of all pixels rendered to the display
257    /// are clamped to. This can be used to mitigate the apparent effects of backlight
258    /// bleeding on certain devices in low-light environments.
259    ///
260    /// The valid range for a minimum value is [0, 255] (inclusive).  For a new
261    /// minimum value M, each color channel's range will be limited to [M, 255].
262    ///
263    /// Callers should wait for the acknowledgement to return before submitting another
264    /// call to this function. The minimum_rgb clamping can be removed simply by submitting
265    /// a value of 0.
266    ///
267    /// Not all hardware supports this feature. So this function returns |true|
268    /// if successfully applied and |false| if unsupported.
269    pub fn r#set_minimum_rgb(
270        &self,
271        mut minimum_rgb: u8,
272    ) -> fidl::client::QueryResponseFut<bool, fidl::encoding::DefaultFuchsiaResourceDialect> {
273        ConverterProxyInterface::r#set_minimum_rgb(self, minimum_rgb)
274    }
275}
276
277impl ConverterProxyInterface for ConverterProxy {
278    type SetValuesResponseFut =
279        fidl::client::QueryResponseFut<i32, fidl::encoding::DefaultFuchsiaResourceDialect>;
280    fn r#set_values(&self, mut properties: &ConversionProperties) -> Self::SetValuesResponseFut {
281        fn _decode(
282            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
283        ) -> Result<i32, fidl::Error> {
284            let _response = fidl::client::decode_transaction_body::<
285                ConverterSetValuesResponse,
286                fidl::encoding::DefaultFuchsiaResourceDialect,
287                0x64131a672b34af8d,
288            >(_buf?)?;
289            Ok(_response.res)
290        }
291        self.client.send_query_and_decode::<ConverterSetValuesRequest, i32>(
292            (properties,),
293            0x64131a672b34af8d,
294            fidl::encoding::DynamicFlags::empty(),
295            _decode,
296        )
297    }
298
299    type SetMinimumRgbResponseFut =
300        fidl::client::QueryResponseFut<bool, fidl::encoding::DefaultFuchsiaResourceDialect>;
301    fn r#set_minimum_rgb(&self, mut minimum_rgb: u8) -> Self::SetMinimumRgbResponseFut {
302        fn _decode(
303            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
304        ) -> Result<bool, fidl::Error> {
305            let _response = fidl::client::decode_transaction_body::<
306                ConverterSetMinimumRgbResponse,
307                fidl::encoding::DefaultFuchsiaResourceDialect,
308                0x45dd02bf82f653d1,
309            >(_buf?)?;
310            Ok(_response.supported)
311        }
312        self.client.send_query_and_decode::<ConverterSetMinimumRgbRequest, bool>(
313            (minimum_rgb,),
314            0x45dd02bf82f653d1,
315            fidl::encoding::DynamicFlags::empty(),
316            _decode,
317        )
318    }
319}
320
321pub struct ConverterEventStream {
322    event_receiver: fidl::client::EventReceiver<fidl::encoding::DefaultFuchsiaResourceDialect>,
323}
324
325impl std::marker::Unpin for ConverterEventStream {}
326
327impl futures::stream::FusedStream for ConverterEventStream {
328    fn is_terminated(&self) -> bool {
329        self.event_receiver.is_terminated()
330    }
331}
332
333impl futures::Stream for ConverterEventStream {
334    type Item = Result<ConverterEvent, fidl::Error>;
335
336    fn poll_next(
337        mut self: std::pin::Pin<&mut Self>,
338        cx: &mut std::task::Context<'_>,
339    ) -> std::task::Poll<Option<Self::Item>> {
340        match futures::ready!(futures::stream::StreamExt::poll_next_unpin(
341            &mut self.event_receiver,
342            cx
343        )?) {
344            Some(buf) => std::task::Poll::Ready(Some(ConverterEvent::decode(buf))),
345            None => std::task::Poll::Ready(None),
346        }
347    }
348}
349
350#[derive(Debug)]
351pub enum ConverterEvent {}
352
353impl ConverterEvent {
354    /// Decodes a message buffer as a [`ConverterEvent`].
355    fn decode(
356        mut buf: <fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc,
357    ) -> Result<ConverterEvent, fidl::Error> {
358        let (bytes, _handles) = buf.split_mut();
359        let (tx_header, _body_bytes) = fidl::encoding::decode_transaction_header(bytes)?;
360        debug_assert_eq!(tx_header.tx_id, 0);
361        match tx_header.ordinal {
362            _ => Err(fidl::Error::UnknownOrdinal {
363                ordinal: tx_header.ordinal,
364                protocol_name: <ConverterMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
365            }),
366        }
367    }
368}
369
370/// A Stream of incoming requests for fuchsia.ui.display.color/Converter.
371pub struct ConverterRequestStream {
372    inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
373    is_terminated: bool,
374}
375
376impl std::marker::Unpin for ConverterRequestStream {}
377
378impl futures::stream::FusedStream for ConverterRequestStream {
379    fn is_terminated(&self) -> bool {
380        self.is_terminated
381    }
382}
383
384impl fidl::endpoints::RequestStream for ConverterRequestStream {
385    type Protocol = ConverterMarker;
386    type ControlHandle = ConverterControlHandle;
387
388    fn from_channel(channel: ::fidl::AsyncChannel) -> Self {
389        Self { inner: std::sync::Arc::new(fidl::ServeInner::new(channel)), is_terminated: false }
390    }
391
392    fn control_handle(&self) -> Self::ControlHandle {
393        ConverterControlHandle { inner: self.inner.clone() }
394    }
395
396    fn into_inner(
397        self,
398    ) -> (::std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>, bool)
399    {
400        (self.inner, self.is_terminated)
401    }
402
403    fn from_inner(
404        inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
405        is_terminated: bool,
406    ) -> Self {
407        Self { inner, is_terminated }
408    }
409}
410
411impl futures::Stream for ConverterRequestStream {
412    type Item = Result<ConverterRequest, fidl::Error>;
413
414    fn poll_next(
415        mut self: std::pin::Pin<&mut Self>,
416        cx: &mut std::task::Context<'_>,
417    ) -> std::task::Poll<Option<Self::Item>> {
418        let this = &mut *self;
419        if this.inner.check_shutdown(cx) {
420            this.is_terminated = true;
421            return std::task::Poll::Ready(None);
422        }
423        if this.is_terminated {
424            panic!("polled ConverterRequestStream after completion");
425        }
426        fidl::encoding::with_tls_decode_buf::<_, fidl::encoding::DefaultFuchsiaResourceDialect>(
427            |bytes, handles| {
428                match this.inner.channel().read_etc(cx, bytes, handles) {
429                    std::task::Poll::Ready(Ok(())) => {}
430                    std::task::Poll::Pending => return std::task::Poll::Pending,
431                    std::task::Poll::Ready(Err(zx_status::Status::PEER_CLOSED)) => {
432                        this.is_terminated = true;
433                        return std::task::Poll::Ready(None);
434                    }
435                    std::task::Poll::Ready(Err(e)) => {
436                        return std::task::Poll::Ready(Some(Err(fidl::Error::ServerRequestRead(
437                            e.into(),
438                        ))));
439                    }
440                }
441
442                // A message has been received from the channel
443                let (header, _body_bytes) = fidl::encoding::decode_transaction_header(bytes)?;
444
445                std::task::Poll::Ready(Some(match header.ordinal {
446                    0x64131a672b34af8d => {
447                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
448                        let mut req = fidl::new_empty!(
449                            ConverterSetValuesRequest,
450                            fidl::encoding::DefaultFuchsiaResourceDialect
451                        );
452                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<ConverterSetValuesRequest>(&header, _body_bytes, handles, &mut req)?;
453                        let control_handle = ConverterControlHandle { inner: this.inner.clone() };
454                        Ok(ConverterRequest::SetValues {
455                            properties: req.properties,
456
457                            responder: ConverterSetValuesResponder {
458                                control_handle: std::mem::ManuallyDrop::new(control_handle),
459                                tx_id: header.tx_id,
460                            },
461                        })
462                    }
463                    0x45dd02bf82f653d1 => {
464                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
465                        let mut req = fidl::new_empty!(
466                            ConverterSetMinimumRgbRequest,
467                            fidl::encoding::DefaultFuchsiaResourceDialect
468                        );
469                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<ConverterSetMinimumRgbRequest>(&header, _body_bytes, handles, &mut req)?;
470                        let control_handle = ConverterControlHandle { inner: this.inner.clone() };
471                        Ok(ConverterRequest::SetMinimumRgb {
472                            minimum_rgb: req.minimum_rgb,
473
474                            responder: ConverterSetMinimumRgbResponder {
475                                control_handle: std::mem::ManuallyDrop::new(control_handle),
476                                tx_id: header.tx_id,
477                            },
478                        })
479                    }
480                    _ => Err(fidl::Error::UnknownOrdinal {
481                        ordinal: header.ordinal,
482                        protocol_name:
483                            <ConverterMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
484                    }),
485                }))
486            },
487        )
488    }
489}
490
491#[derive(Debug)]
492pub enum ConverterRequest {
493    /// Modifies the color of final display output of rendered content. The sole parameter is a
494    /// table of |ConversionProperties|, which contains the parameters required to apply the
495    /// color conversion formula to the display. Please see |ConversionProperties| defined
496    /// above for more information.
497    ///
498    /// All parameters in the properties table must be normal 32-bit floating point values.
499    /// If any of the values do not meet this specification, the new color conversion values
500    /// will not be applied and a value of ZX_ERR_INVALID_ARGS will be returned. Otherwise,
501    /// the return value will be ZX_OK: https://en.wikipedia.org/wiki/Normal_number_%28computing%29.
502    /// Once a value of ZX_OK has been returned to the client, the color conversion values are ready
503    /// to be used in future render calls, including screenshots.
504    ///
505    /// Values in |ConversionProperties| may also be left blank. The default values for each member,
506    /// if left blank, are as follows:
507    ///     coefficients =
508    ///             [1, 0, 0,
509    ///              0, 1, 0,
510    ///              0, 0, 1]  (i.e. the identity matrix)
511    ///     preoffsets = [0,0,0]
512    ///     postoffsets = [0,0,0]
513    /// Thus, ColorConversion can be reset by passing in an empty table to this function.
514    ///
515    /// Hardware that support color conversion generally accept a limited range of coefficient
516    /// values. Coefficients in the range of [-2, 2] inclusive will be accepted by most
517    /// hardware. The hardware driver will clamp values that are outside its acceptable range.
518    ///
519    /// `preoffsets`, `postoffsets`: Clients are encouraged to produce color conversion values that
520    /// do not depend on pre and post offsets since some hardware do not have support for that.
521    /// For cases where pre and post offset values need to be used, the range should be limited to
522    /// (-1, 1).
523    SetValues { properties: ConversionProperties, responder: ConverterSetValuesResponder },
524    /// Submits a minimum value that all channels of all pixels rendered to the display
525    /// are clamped to. This can be used to mitigate the apparent effects of backlight
526    /// bleeding on certain devices in low-light environments.
527    ///
528    /// The valid range for a minimum value is [0, 255] (inclusive).  For a new
529    /// minimum value M, each color channel's range will be limited to [M, 255].
530    ///
531    /// Callers should wait for the acknowledgement to return before submitting another
532    /// call to this function. The minimum_rgb clamping can be removed simply by submitting
533    /// a value of 0.
534    ///
535    /// Not all hardware supports this feature. So this function returns |true|
536    /// if successfully applied and |false| if unsupported.
537    SetMinimumRgb { minimum_rgb: u8, responder: ConverterSetMinimumRgbResponder },
538}
539
540impl ConverterRequest {
541    #[allow(irrefutable_let_patterns)]
542    pub fn into_set_values(self) -> Option<(ConversionProperties, ConverterSetValuesResponder)> {
543        if let ConverterRequest::SetValues { properties, responder } = self {
544            Some((properties, responder))
545        } else {
546            None
547        }
548    }
549
550    #[allow(irrefutable_let_patterns)]
551    pub fn into_set_minimum_rgb(self) -> Option<(u8, ConverterSetMinimumRgbResponder)> {
552        if let ConverterRequest::SetMinimumRgb { minimum_rgb, responder } = self {
553            Some((minimum_rgb, responder))
554        } else {
555            None
556        }
557    }
558
559    /// Name of the method defined in FIDL
560    pub fn method_name(&self) -> &'static str {
561        match *self {
562            ConverterRequest::SetValues { .. } => "set_values",
563            ConverterRequest::SetMinimumRgb { .. } => "set_minimum_rgb",
564        }
565    }
566}
567
568#[derive(Debug, Clone)]
569pub struct ConverterControlHandle {
570    inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
571}
572
573impl fidl::endpoints::ControlHandle for ConverterControlHandle {
574    fn shutdown(&self) {
575        self.inner.shutdown()
576    }
577
578    fn shutdown_with_epitaph(&self, status: zx_status::Status) {
579        self.inner.shutdown_with_epitaph(status)
580    }
581
582    fn is_closed(&self) -> bool {
583        self.inner.channel().is_closed()
584    }
585    fn on_closed(&self) -> fidl::OnSignalsRef<'_> {
586        self.inner.channel().on_closed()
587    }
588
589    #[cfg(target_os = "fuchsia")]
590    fn signal_peer(
591        &self,
592        clear_mask: zx::Signals,
593        set_mask: zx::Signals,
594    ) -> Result<(), zx_status::Status> {
595        use fidl::Peered;
596        self.inner.channel().signal_peer(clear_mask, set_mask)
597    }
598}
599
600impl ConverterControlHandle {}
601
602#[must_use = "FIDL methods require a response to be sent"]
603#[derive(Debug)]
604pub struct ConverterSetValuesResponder {
605    control_handle: std::mem::ManuallyDrop<ConverterControlHandle>,
606    tx_id: u32,
607}
608
609/// Set the the channel to be shutdown (see [`ConverterControlHandle::shutdown`])
610/// if the responder is dropped without sending a response, so that the client
611/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
612impl std::ops::Drop for ConverterSetValuesResponder {
613    fn drop(&mut self) {
614        self.control_handle.shutdown();
615        // Safety: drops once, never accessed again
616        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
617    }
618}
619
620impl fidl::endpoints::Responder for ConverterSetValuesResponder {
621    type ControlHandle = ConverterControlHandle;
622
623    fn control_handle(&self) -> &ConverterControlHandle {
624        &self.control_handle
625    }
626
627    fn drop_without_shutdown(mut self) {
628        // Safety: drops once, never accessed again due to mem::forget
629        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
630        // Prevent Drop from running (which would shut down the channel)
631        std::mem::forget(self);
632    }
633}
634
635impl ConverterSetValuesResponder {
636    /// Sends a response to the FIDL transaction.
637    ///
638    /// Sets the channel to shutdown if an error occurs.
639    pub fn send(self, mut res: i32) -> Result<(), fidl::Error> {
640        let _result = self.send_raw(res);
641        if _result.is_err() {
642            self.control_handle.shutdown();
643        }
644        self.drop_without_shutdown();
645        _result
646    }
647
648    /// Similar to "send" but does not shutdown the channel if an error occurs.
649    pub fn send_no_shutdown_on_err(self, mut res: i32) -> Result<(), fidl::Error> {
650        let _result = self.send_raw(res);
651        self.drop_without_shutdown();
652        _result
653    }
654
655    fn send_raw(&self, mut res: i32) -> Result<(), fidl::Error> {
656        self.control_handle.inner.send::<ConverterSetValuesResponse>(
657            (res,),
658            self.tx_id,
659            0x64131a672b34af8d,
660            fidl::encoding::DynamicFlags::empty(),
661        )
662    }
663}
664
665#[must_use = "FIDL methods require a response to be sent"]
666#[derive(Debug)]
667pub struct ConverterSetMinimumRgbResponder {
668    control_handle: std::mem::ManuallyDrop<ConverterControlHandle>,
669    tx_id: u32,
670}
671
672/// Set the the channel to be shutdown (see [`ConverterControlHandle::shutdown`])
673/// if the responder is dropped without sending a response, so that the client
674/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
675impl std::ops::Drop for ConverterSetMinimumRgbResponder {
676    fn drop(&mut self) {
677        self.control_handle.shutdown();
678        // Safety: drops once, never accessed again
679        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
680    }
681}
682
683impl fidl::endpoints::Responder for ConverterSetMinimumRgbResponder {
684    type ControlHandle = ConverterControlHandle;
685
686    fn control_handle(&self) -> &ConverterControlHandle {
687        &self.control_handle
688    }
689
690    fn drop_without_shutdown(mut self) {
691        // Safety: drops once, never accessed again due to mem::forget
692        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
693        // Prevent Drop from running (which would shut down the channel)
694        std::mem::forget(self);
695    }
696}
697
698impl ConverterSetMinimumRgbResponder {
699    /// Sends a response to the FIDL transaction.
700    ///
701    /// Sets the channel to shutdown if an error occurs.
702    pub fn send(self, mut supported: bool) -> Result<(), fidl::Error> {
703        let _result = self.send_raw(supported);
704        if _result.is_err() {
705            self.control_handle.shutdown();
706        }
707        self.drop_without_shutdown();
708        _result
709    }
710
711    /// Similar to "send" but does not shutdown the channel if an error occurs.
712    pub fn send_no_shutdown_on_err(self, mut supported: bool) -> Result<(), fidl::Error> {
713        let _result = self.send_raw(supported);
714        self.drop_without_shutdown();
715        _result
716    }
717
718    fn send_raw(&self, mut supported: bool) -> Result<(), fidl::Error> {
719        self.control_handle.inner.send::<ConverterSetMinimumRgbResponse>(
720            (supported,),
721            self.tx_id,
722            0x45dd02bf82f653d1,
723            fidl::encoding::DynamicFlags::empty(),
724        )
725    }
726}
727
728mod internal {
729    use super::*;
730
731    impl fidl::encoding::ResourceTypeMarker for ConverterSetValuesRequest {
732        type Borrowed<'a> = &'a mut Self;
733        fn take_or_borrow<'a>(
734            value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
735        ) -> Self::Borrowed<'a> {
736            value
737        }
738    }
739
740    unsafe impl fidl::encoding::TypeMarker for ConverterSetValuesRequest {
741        type Owned = Self;
742
743        #[inline(always)]
744        fn inline_align(_context: fidl::encoding::Context) -> usize {
745            8
746        }
747
748        #[inline(always)]
749        fn inline_size(_context: fidl::encoding::Context) -> usize {
750            16
751        }
752    }
753
754    unsafe impl
755        fidl::encoding::Encode<
756            ConverterSetValuesRequest,
757            fidl::encoding::DefaultFuchsiaResourceDialect,
758        > for &mut ConverterSetValuesRequest
759    {
760        #[inline]
761        unsafe fn encode(
762            self,
763            encoder: &mut fidl::encoding::Encoder<
764                '_,
765                fidl::encoding::DefaultFuchsiaResourceDialect,
766            >,
767            offset: usize,
768            _depth: fidl::encoding::Depth,
769        ) -> fidl::Result<()> {
770            encoder.debug_check_bounds::<ConverterSetValuesRequest>(offset);
771            // Delegate to tuple encoding.
772            fidl::encoding::Encode::<
773                ConverterSetValuesRequest,
774                fidl::encoding::DefaultFuchsiaResourceDialect,
775            >::encode(
776                (<ConversionProperties as fidl::encoding::ValueTypeMarker>::borrow(
777                    &self.properties,
778                ),),
779                encoder,
780                offset,
781                _depth,
782            )
783        }
784    }
785    unsafe impl<
786        T0: fidl::encoding::Encode<ConversionProperties, fidl::encoding::DefaultFuchsiaResourceDialect>,
787    >
788        fidl::encoding::Encode<
789            ConverterSetValuesRequest,
790            fidl::encoding::DefaultFuchsiaResourceDialect,
791        > for (T0,)
792    {
793        #[inline]
794        unsafe fn encode(
795            self,
796            encoder: &mut fidl::encoding::Encoder<
797                '_,
798                fidl::encoding::DefaultFuchsiaResourceDialect,
799            >,
800            offset: usize,
801            depth: fidl::encoding::Depth,
802        ) -> fidl::Result<()> {
803            encoder.debug_check_bounds::<ConverterSetValuesRequest>(offset);
804            // Zero out padding regions. There's no need to apply masks
805            // because the unmasked parts will be overwritten by fields.
806            // Write the fields.
807            self.0.encode(encoder, offset + 0, depth)?;
808            Ok(())
809        }
810    }
811
812    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
813        for ConverterSetValuesRequest
814    {
815        #[inline(always)]
816        fn new_empty() -> Self {
817            Self {
818                properties: fidl::new_empty!(
819                    ConversionProperties,
820                    fidl::encoding::DefaultFuchsiaResourceDialect
821                ),
822            }
823        }
824
825        #[inline]
826        unsafe fn decode(
827            &mut self,
828            decoder: &mut fidl::encoding::Decoder<
829                '_,
830                fidl::encoding::DefaultFuchsiaResourceDialect,
831            >,
832            offset: usize,
833            _depth: fidl::encoding::Depth,
834        ) -> fidl::Result<()> {
835            decoder.debug_check_bounds::<Self>(offset);
836            // Verify that padding bytes are zero.
837            fidl::decode!(
838                ConversionProperties,
839                fidl::encoding::DefaultFuchsiaResourceDialect,
840                &mut self.properties,
841                decoder,
842                offset + 0,
843                _depth
844            )?;
845            Ok(())
846        }
847    }
848}
fidl_fuchsia_ui_display_color/fidl_fuchsia_ui_display_color.rs

fidl_fuchsia_ui_display_color/
fidl_fuchsia_ui_display_color.rs
