fidl_fuchsia_ui_app/
fidl_fuchsia_ui_app.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_app_common::*;
11use futures::future::{self, MaybeDone, TryFutureExt};
12use zx_status;
13
14#[derive(Debug, PartialEq)]
15pub struct ViewProviderCreateView2Request {
16    pub args: CreateView2Args,
17}
18
19impl fidl::Standalone<fidl::encoding::DefaultFuchsiaResourceDialect>
20    for ViewProviderCreateView2Request
21{
22}
23
24#[derive(Debug, PartialEq)]
25pub struct ViewProviderCreateViewWithViewRefRequest {
26    pub token: fidl::EventPair,
27    pub view_ref_control: fidl_fuchsia_ui_views::ViewRefControl,
28    pub view_ref: fidl_fuchsia_ui_views::ViewRef,
29}
30
31impl fidl::Standalone<fidl::encoding::DefaultFuchsiaResourceDialect>
32    for ViewProviderCreateViewWithViewRefRequest
33{
34}
35
36#[derive(Debug, Default, PartialEq)]
37pub struct CreateView2Args {
38    /// Non-optional.  This token can be provided to Flatland to attach the client's child view
39    /// to the parent's viewport.
40    pub view_creation_token: Option<fidl_fuchsia_ui_views::ViewCreationToken>,
41    #[doc(hidden)]
42    pub __source_breaking: fidl::marker::SourceBreaking,
43}
44
45impl fidl::Standalone<fidl::encoding::DefaultFuchsiaResourceDialect> for CreateView2Args {}
46
47#[derive(Debug, Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Hash)]
48pub struct ViewProviderMarker;
49
50impl fidl::endpoints::ProtocolMarker for ViewProviderMarker {
51    type Proxy = ViewProviderProxy;
52    type RequestStream = ViewProviderRequestStream;
53    #[cfg(target_os = "fuchsia")]
54    type SynchronousProxy = ViewProviderSynchronousProxy;
55
56    const DEBUG_NAME: &'static str = "fuchsia.ui.app.ViewProvider";
57}
58impl fidl::endpoints::DiscoverableProtocolMarker for ViewProviderMarker {}
59
60pub trait ViewProviderProxyInterface: Send + Sync {
61    fn r#create_view_with_view_ref(
62        &self,
63        token: fidl::EventPair,
64        view_ref_control: fidl_fuchsia_ui_views::ViewRefControl,
65        view_ref: fidl_fuchsia_ui_views::ViewRef,
66    ) -> Result<(), fidl::Error>;
67    fn r#create_view2(&self, args: CreateView2Args) -> Result<(), fidl::Error>;
68}
69#[derive(Debug)]
70#[cfg(target_os = "fuchsia")]
71pub struct ViewProviderSynchronousProxy {
72    client: fidl::client::sync::Client,
73}
74
75#[cfg(target_os = "fuchsia")]
76impl fidl::endpoints::SynchronousProxy for ViewProviderSynchronousProxy {
77    type Proxy = ViewProviderProxy;
78    type Protocol = ViewProviderMarker;
79
80    fn from_channel(inner: fidl::Channel) -> Self {
81        Self::new(inner)
82    }
83
84    fn into_channel(self) -> fidl::Channel {
85        self.client.into_channel()
86    }
87
88    fn as_channel(&self) -> &fidl::Channel {
89        self.client.as_channel()
90    }
91}
92
93#[cfg(target_os = "fuchsia")]
94impl ViewProviderSynchronousProxy {
95    pub fn new(channel: fidl::Channel) -> Self {
96        let protocol_name = <ViewProviderMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME;
97        Self { client: fidl::client::sync::Client::new(channel, protocol_name) }
98    }
99
100    pub fn into_channel(self) -> fidl::Channel {
101        self.client.into_channel()
102    }
103
104    /// Waits until an event arrives and returns it. It is safe for other
105    /// threads to make concurrent requests while waiting for an event.
106    pub fn wait_for_event(
107        &self,
108        deadline: zx::MonotonicInstant,
109    ) -> Result<ViewProviderEvent, fidl::Error> {
110        ViewProviderEvent::decode(self.client.wait_for_event(deadline)?)
111    }
112
113    /// Creates a new View under the control of the ViewProvider.
114    ///
115    /// `token` is one half of the shared eventpair which will bind the new View
116    /// to its associated ViewHolder.  The ViewProvider will use `token` to
117    /// create its internal View representation.  The caller is expected to use
118    /// its half to create corresponding ViewHolder object.
119    ///
120    /// `view_ref_control` and `view_ref` are two typed handles to each half of the
121    /// same event pair. The `view_ref` can be cloned before passing it to this method,
122    /// which will allow clients to track the view (e.g., in a focus chain update).
123    ///
124    /// `view_ref_control` must not have the ZX_RIGHT_DUPLICATE set, or view creation
125    /// will fail.
126    pub fn r#create_view_with_view_ref(
127        &self,
128        mut token: fidl::EventPair,
129        mut view_ref_control: fidl_fuchsia_ui_views::ViewRefControl,
130        mut view_ref: fidl_fuchsia_ui_views::ViewRef,
131    ) -> Result<(), fidl::Error> {
132        self.client.send::<ViewProviderCreateViewWithViewRefRequest>(
133            (token, &mut view_ref_control, &mut view_ref),
134            0x586d23a5e4f69a86,
135            fidl::encoding::DynamicFlags::empty(),
136        )
137    }
138
139    /// Creates a new View under the control of the ViewProvider.
140    ///
141    /// The args are provided as a table, for forward compatibility.  See documentation on the
142    /// individual table fields.
143    pub fn r#create_view2(&self, mut args: CreateView2Args) -> Result<(), fidl::Error> {
144        self.client.send::<ViewProviderCreateView2Request>(
145            (&mut args,),
146            0x78b4a51b5e630482,
147            fidl::encoding::DynamicFlags::empty(),
148        )
149    }
150}
151
152#[derive(Debug, Clone)]
153pub struct ViewProviderProxy {
154    client: fidl::client::Client<fidl::encoding::DefaultFuchsiaResourceDialect>,
155}
156
157impl fidl::endpoints::Proxy for ViewProviderProxy {
158    type Protocol = ViewProviderMarker;
159
160    fn from_channel(inner: ::fidl::AsyncChannel) -> Self {
161        Self::new(inner)
162    }
163
164    fn into_channel(self) -> Result<::fidl::AsyncChannel, Self> {
165        self.client.into_channel().map_err(|client| Self { client })
166    }
167
168    fn as_channel(&self) -> &::fidl::AsyncChannel {
169        self.client.as_channel()
170    }
171}
172
173impl ViewProviderProxy {
174    /// Create a new Proxy for fuchsia.ui.app/ViewProvider.
175    pub fn new(channel: ::fidl::AsyncChannel) -> Self {
176        let protocol_name = <ViewProviderMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME;
177        Self { client: fidl::client::Client::new(channel, protocol_name) }
178    }
179
180    /// Get a Stream of events from the remote end of the protocol.
181    ///
182    /// # Panics
183    ///
184    /// Panics if the event stream was already taken.
185    pub fn take_event_stream(&self) -> ViewProviderEventStream {
186        ViewProviderEventStream { event_receiver: self.client.take_event_receiver() }
187    }
188
189    /// Creates a new View under the control of the ViewProvider.
190    ///
191    /// `token` is one half of the shared eventpair which will bind the new View
192    /// to its associated ViewHolder.  The ViewProvider will use `token` to
193    /// create its internal View representation.  The caller is expected to use
194    /// its half to create corresponding ViewHolder object.
195    ///
196    /// `view_ref_control` and `view_ref` are two typed handles to each half of the
197    /// same event pair. The `view_ref` can be cloned before passing it to this method,
198    /// which will allow clients to track the view (e.g., in a focus chain update).
199    ///
200    /// `view_ref_control` must not have the ZX_RIGHT_DUPLICATE set, or view creation
201    /// will fail.
202    pub fn r#create_view_with_view_ref(
203        &self,
204        mut token: fidl::EventPair,
205        mut view_ref_control: fidl_fuchsia_ui_views::ViewRefControl,
206        mut view_ref: fidl_fuchsia_ui_views::ViewRef,
207    ) -> Result<(), fidl::Error> {
208        ViewProviderProxyInterface::r#create_view_with_view_ref(
209            self,
210            token,
211            view_ref_control,
212            view_ref,
213        )
214    }
215
216    /// Creates a new View under the control of the ViewProvider.
217    ///
218    /// The args are provided as a table, for forward compatibility.  See documentation on the
219    /// individual table fields.
220    pub fn r#create_view2(&self, mut args: CreateView2Args) -> Result<(), fidl::Error> {
221        ViewProviderProxyInterface::r#create_view2(self, args)
222    }
223}
224
225impl ViewProviderProxyInterface for ViewProviderProxy {
226    fn r#create_view_with_view_ref(
227        &self,
228        mut token: fidl::EventPair,
229        mut view_ref_control: fidl_fuchsia_ui_views::ViewRefControl,
230        mut view_ref: fidl_fuchsia_ui_views::ViewRef,
231    ) -> Result<(), fidl::Error> {
232        self.client.send::<ViewProviderCreateViewWithViewRefRequest>(
233            (token, &mut view_ref_control, &mut view_ref),
234            0x586d23a5e4f69a86,
235            fidl::encoding::DynamicFlags::empty(),
236        )
237    }
238
239    fn r#create_view2(&self, mut args: CreateView2Args) -> Result<(), fidl::Error> {
240        self.client.send::<ViewProviderCreateView2Request>(
241            (&mut args,),
242            0x78b4a51b5e630482,
243            fidl::encoding::DynamicFlags::empty(),
244        )
245    }
246}
247
248pub struct ViewProviderEventStream {
249    event_receiver: fidl::client::EventReceiver<fidl::encoding::DefaultFuchsiaResourceDialect>,
250}
251
252impl std::marker::Unpin for ViewProviderEventStream {}
253
254impl futures::stream::FusedStream for ViewProviderEventStream {
255    fn is_terminated(&self) -> bool {
256        self.event_receiver.is_terminated()
257    }
258}
259
260impl futures::Stream for ViewProviderEventStream {
261    type Item = Result<ViewProviderEvent, fidl::Error>;
262
263    fn poll_next(
264        mut self: std::pin::Pin<&mut Self>,
265        cx: &mut std::task::Context<'_>,
266    ) -> std::task::Poll<Option<Self::Item>> {
267        match futures::ready!(futures::stream::StreamExt::poll_next_unpin(
268            &mut self.event_receiver,
269            cx
270        )?) {
271            Some(buf) => std::task::Poll::Ready(Some(ViewProviderEvent::decode(buf))),
272            None => std::task::Poll::Ready(None),
273        }
274    }
275}
276
277#[derive(Debug)]
278pub enum ViewProviderEvent {}
279
280impl ViewProviderEvent {
281    /// Decodes a message buffer as a [`ViewProviderEvent`].
282    fn decode(
283        mut buf: <fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc,
284    ) -> Result<ViewProviderEvent, fidl::Error> {
285        let (bytes, _handles) = buf.split_mut();
286        let (tx_header, _body_bytes) = fidl::encoding::decode_transaction_header(bytes)?;
287        debug_assert_eq!(tx_header.tx_id, 0);
288        match tx_header.ordinal {
289            _ => Err(fidl::Error::UnknownOrdinal {
290                ordinal: tx_header.ordinal,
291                protocol_name: <ViewProviderMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
292            }),
293        }
294    }
295}
296
297/// A Stream of incoming requests for fuchsia.ui.app/ViewProvider.
298pub struct ViewProviderRequestStream {
299    inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
300    is_terminated: bool,
301}
302
303impl std::marker::Unpin for ViewProviderRequestStream {}
304
305impl futures::stream::FusedStream for ViewProviderRequestStream {
306    fn is_terminated(&self) -> bool {
307        self.is_terminated
308    }
309}
310
311impl fidl::endpoints::RequestStream for ViewProviderRequestStream {
312    type Protocol = ViewProviderMarker;
313    type ControlHandle = ViewProviderControlHandle;
314
315    fn from_channel(channel: ::fidl::AsyncChannel) -> Self {
316        Self { inner: std::sync::Arc::new(fidl::ServeInner::new(channel)), is_terminated: false }
317    }
318
319    fn control_handle(&self) -> Self::ControlHandle {
320        ViewProviderControlHandle { inner: self.inner.clone() }
321    }
322
323    fn into_inner(
324        self,
325    ) -> (::std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>, bool)
326    {
327        (self.inner, self.is_terminated)
328    }
329
330    fn from_inner(
331        inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
332        is_terminated: bool,
333    ) -> Self {
334        Self { inner, is_terminated }
335    }
336}
337
338impl futures::Stream for ViewProviderRequestStream {
339    type Item = Result<ViewProviderRequest, fidl::Error>;
340
341    fn poll_next(
342        mut self: std::pin::Pin<&mut Self>,
343        cx: &mut std::task::Context<'_>,
344    ) -> std::task::Poll<Option<Self::Item>> {
345        let this = &mut *self;
346        if this.inner.check_shutdown(cx) {
347            this.is_terminated = true;
348            return std::task::Poll::Ready(None);
349        }
350        if this.is_terminated {
351            panic!("polled ViewProviderRequestStream after completion");
352        }
353        fidl::encoding::with_tls_decode_buf::<_, fidl::encoding::DefaultFuchsiaResourceDialect>(
354            |bytes, handles| {
355                match this.inner.channel().read_etc(cx, bytes, handles) {
356                    std::task::Poll::Ready(Ok(())) => {}
357                    std::task::Poll::Pending => return std::task::Poll::Pending,
358                    std::task::Poll::Ready(Err(zx_status::Status::PEER_CLOSED)) => {
359                        this.is_terminated = true;
360                        return std::task::Poll::Ready(None);
361                    }
362                    std::task::Poll::Ready(Err(e)) => {
363                        return std::task::Poll::Ready(Some(Err(fidl::Error::ServerRequestRead(
364                            e.into(),
365                        ))))
366                    }
367                }
368
369                // A message has been received from the channel
370                let (header, _body_bytes) = fidl::encoding::decode_transaction_header(bytes)?;
371
372                std::task::Poll::Ready(Some(match header.ordinal {
373                    0x586d23a5e4f69a86 => {
374                        header.validate_request_tx_id(fidl::MethodType::OneWay)?;
375                        let mut req = fidl::new_empty!(
376                            ViewProviderCreateViewWithViewRefRequest,
377                            fidl::encoding::DefaultFuchsiaResourceDialect
378                        );
379                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<ViewProviderCreateViewWithViewRefRequest>(&header, _body_bytes, handles, &mut req)?;
380                        let control_handle =
381                            ViewProviderControlHandle { inner: this.inner.clone() };
382                        Ok(ViewProviderRequest::CreateViewWithViewRef {
383                            token: req.token,
384                            view_ref_control: req.view_ref_control,
385                            view_ref: req.view_ref,
386
387                            control_handle,
388                        })
389                    }
390                    0x78b4a51b5e630482 => {
391                        header.validate_request_tx_id(fidl::MethodType::OneWay)?;
392                        let mut req = fidl::new_empty!(
393                            ViewProviderCreateView2Request,
394                            fidl::encoding::DefaultFuchsiaResourceDialect
395                        );
396                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<ViewProviderCreateView2Request>(&header, _body_bytes, handles, &mut req)?;
397                        let control_handle =
398                            ViewProviderControlHandle { inner: this.inner.clone() };
399                        Ok(ViewProviderRequest::CreateView2 { args: req.args, control_handle })
400                    }
401                    _ => Err(fidl::Error::UnknownOrdinal {
402                        ordinal: header.ordinal,
403                        protocol_name:
404                            <ViewProviderMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
405                    }),
406                }))
407            },
408        )
409    }
410}
411
412/// ViewProvider is the standard mechanism for two modules to each obtain half
413/// of a shared eventpair token.  The shared token is a capability allowing the
414/// modules to ask Scenic to create a ViewHolder/View pair.  The resulting
415/// View and ViewHolder are linked together until either one is destroyed.
416///
417/// Modules are free to use any other mechanism to agree upon the shared
418/// eventpair token, and use this to create the linked ViewHolder/View.
419/// ViewProvider is given for the convenience of clients that don't require
420/// a more complex implementation.
421#[derive(Debug)]
422pub enum ViewProviderRequest {
423    /// Creates a new View under the control of the ViewProvider.
424    ///
425    /// `token` is one half of the shared eventpair which will bind the new View
426    /// to its associated ViewHolder.  The ViewProvider will use `token` to
427    /// create its internal View representation.  The caller is expected to use
428    /// its half to create corresponding ViewHolder object.
429    ///
430    /// `view_ref_control` and `view_ref` are two typed handles to each half of the
431    /// same event pair. The `view_ref` can be cloned before passing it to this method,
432    /// which will allow clients to track the view (e.g., in a focus chain update).
433    ///
434    /// `view_ref_control` must not have the ZX_RIGHT_DUPLICATE set, or view creation
435    /// will fail.
436    CreateViewWithViewRef {
437        token: fidl::EventPair,
438        view_ref_control: fidl_fuchsia_ui_views::ViewRefControl,
439        view_ref: fidl_fuchsia_ui_views::ViewRef,
440        control_handle: ViewProviderControlHandle,
441    },
442    /// Creates a new View under the control of the ViewProvider.
443    ///
444    /// The args are provided as a table, for forward compatibility.  See documentation on the
445    /// individual table fields.
446    CreateView2 { args: CreateView2Args, control_handle: ViewProviderControlHandle },
447}
448
449impl ViewProviderRequest {
450    #[allow(irrefutable_let_patterns)]
451    pub fn into_create_view_with_view_ref(
452        self,
453    ) -> Option<(
454        fidl::EventPair,
455        fidl_fuchsia_ui_views::ViewRefControl,
456        fidl_fuchsia_ui_views::ViewRef,
457        ViewProviderControlHandle,
458    )> {
459        if let ViewProviderRequest::CreateViewWithViewRef {
460            token,
461            view_ref_control,
462            view_ref,
463            control_handle,
464        } = self
465        {
466            Some((token, view_ref_control, view_ref, control_handle))
467        } else {
468            None
469        }
470    }
471
472    #[allow(irrefutable_let_patterns)]
473    pub fn into_create_view2(self) -> Option<(CreateView2Args, ViewProviderControlHandle)> {
474        if let ViewProviderRequest::CreateView2 { args, control_handle } = self {
475            Some((args, control_handle))
476        } else {
477            None
478        }
479    }
480
481    /// Name of the method defined in FIDL
482    pub fn method_name(&self) -> &'static str {
483        match *self {
484            ViewProviderRequest::CreateViewWithViewRef { .. } => "create_view_with_view_ref",
485            ViewProviderRequest::CreateView2 { .. } => "create_view2",
486        }
487    }
488}
489
490#[derive(Debug, Clone)]
491pub struct ViewProviderControlHandle {
492    inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
493}
494
495impl fidl::endpoints::ControlHandle for ViewProviderControlHandle {
496    fn shutdown(&self) {
497        self.inner.shutdown()
498    }
499    fn shutdown_with_epitaph(&self, status: zx_status::Status) {
500        self.inner.shutdown_with_epitaph(status)
501    }
502
503    fn is_closed(&self) -> bool {
504        self.inner.channel().is_closed()
505    }
506    fn on_closed(&self) -> fidl::OnSignalsRef<'_> {
507        self.inner.channel().on_closed()
508    }
509
510    #[cfg(target_os = "fuchsia")]
511    fn signal_peer(
512        &self,
513        clear_mask: zx::Signals,
514        set_mask: zx::Signals,
515    ) -> Result<(), zx_status::Status> {
516        use fidl::Peered;
517        self.inner.channel().signal_peer(clear_mask, set_mask)
518    }
519}
520
521impl ViewProviderControlHandle {}
522
523mod internal {
524    use super::*;
525
526    impl fidl::encoding::ResourceTypeMarker for ViewProviderCreateView2Request {
527        type Borrowed<'a> = &'a mut Self;
528        fn take_or_borrow<'a>(
529            value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
530        ) -> Self::Borrowed<'a> {
531            value
532        }
533    }
534
535    unsafe impl fidl::encoding::TypeMarker for ViewProviderCreateView2Request {
536        type Owned = Self;
537
538        #[inline(always)]
539        fn inline_align(_context: fidl::encoding::Context) -> usize {
540            8
541        }
542
543        #[inline(always)]
544        fn inline_size(_context: fidl::encoding::Context) -> usize {
545            16
546        }
547    }
548
549    unsafe impl
550        fidl::encoding::Encode<
551            ViewProviderCreateView2Request,
552            fidl::encoding::DefaultFuchsiaResourceDialect,
553        > for &mut ViewProviderCreateView2Request
554    {
555        #[inline]
556        unsafe fn encode(
557            self,
558            encoder: &mut fidl::encoding::Encoder<
559                '_,
560                fidl::encoding::DefaultFuchsiaResourceDialect,
561            >,
562            offset: usize,
563            _depth: fidl::encoding::Depth,
564        ) -> fidl::Result<()> {
565            encoder.debug_check_bounds::<ViewProviderCreateView2Request>(offset);
566            // Delegate to tuple encoding.
567            fidl::encoding::Encode::<
568                ViewProviderCreateView2Request,
569                fidl::encoding::DefaultFuchsiaResourceDialect,
570            >::encode(
571                (<CreateView2Args as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
572                    &mut self.args,
573                ),),
574                encoder,
575                offset,
576                _depth,
577            )
578        }
579    }
580    unsafe impl<
581            T0: fidl::encoding::Encode<CreateView2Args, fidl::encoding::DefaultFuchsiaResourceDialect>,
582        >
583        fidl::encoding::Encode<
584            ViewProviderCreateView2Request,
585            fidl::encoding::DefaultFuchsiaResourceDialect,
586        > for (T0,)
587    {
588        #[inline]
589        unsafe fn encode(
590            self,
591            encoder: &mut fidl::encoding::Encoder<
592                '_,
593                fidl::encoding::DefaultFuchsiaResourceDialect,
594            >,
595            offset: usize,
596            depth: fidl::encoding::Depth,
597        ) -> fidl::Result<()> {
598            encoder.debug_check_bounds::<ViewProviderCreateView2Request>(offset);
599            // Zero out padding regions. There's no need to apply masks
600            // because the unmasked parts will be overwritten by fields.
601            // Write the fields.
602            self.0.encode(encoder, offset + 0, depth)?;
603            Ok(())
604        }
605    }
606
607    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
608        for ViewProviderCreateView2Request
609    {
610        #[inline(always)]
611        fn new_empty() -> Self {
612            Self {
613                args: fidl::new_empty!(
614                    CreateView2Args,
615                    fidl::encoding::DefaultFuchsiaResourceDialect
616                ),
617            }
618        }
619
620        #[inline]
621        unsafe fn decode(
622            &mut self,
623            decoder: &mut fidl::encoding::Decoder<
624                '_,
625                fidl::encoding::DefaultFuchsiaResourceDialect,
626            >,
627            offset: usize,
628            _depth: fidl::encoding::Depth,
629        ) -> fidl::Result<()> {
630            decoder.debug_check_bounds::<Self>(offset);
631            // Verify that padding bytes are zero.
632            fidl::decode!(
633                CreateView2Args,
634                fidl::encoding::DefaultFuchsiaResourceDialect,
635                &mut self.args,
636                decoder,
637                offset + 0,
638                _depth
639            )?;
640            Ok(())
641        }
642    }
643
644    impl fidl::encoding::ResourceTypeMarker for ViewProviderCreateViewWithViewRefRequest {
645        type Borrowed<'a> = &'a mut Self;
646        fn take_or_borrow<'a>(
647            value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
648        ) -> Self::Borrowed<'a> {
649            value
650        }
651    }
652
653    unsafe impl fidl::encoding::TypeMarker for ViewProviderCreateViewWithViewRefRequest {
654        type Owned = Self;
655
656        #[inline(always)]
657        fn inline_align(_context: fidl::encoding::Context) -> usize {
658            4
659        }
660
661        #[inline(always)]
662        fn inline_size(_context: fidl::encoding::Context) -> usize {
663            12
664        }
665    }
666
667    unsafe impl
668        fidl::encoding::Encode<
669            ViewProviderCreateViewWithViewRefRequest,
670            fidl::encoding::DefaultFuchsiaResourceDialect,
671        > for &mut ViewProviderCreateViewWithViewRefRequest
672    {
673        #[inline]
674        unsafe fn encode(
675            self,
676            encoder: &mut fidl::encoding::Encoder<
677                '_,
678                fidl::encoding::DefaultFuchsiaResourceDialect,
679            >,
680            offset: usize,
681            _depth: fidl::encoding::Depth,
682        ) -> fidl::Result<()> {
683            encoder.debug_check_bounds::<ViewProviderCreateViewWithViewRefRequest>(offset);
684            // Delegate to tuple encoding.
685            fidl::encoding::Encode::<ViewProviderCreateViewWithViewRefRequest, fidl::encoding::DefaultFuchsiaResourceDialect>::encode(
686                (
687                    <fidl::encoding::HandleType<fidl::EventPair, { fidl::ObjectType::EVENTPAIR.into_raw() }, 2147483648> as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.token),
688                    <fidl_fuchsia_ui_views::ViewRefControl as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.view_ref_control),
689                    <fidl_fuchsia_ui_views::ViewRef as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.view_ref),
690                ),
691                encoder, offset, _depth
692            )
693        }
694    }
695    unsafe impl<
696            T0: fidl::encoding::Encode<
697                fidl::encoding::HandleType<
698                    fidl::EventPair,
699                    { fidl::ObjectType::EVENTPAIR.into_raw() },
700                    2147483648,
701                >,
702                fidl::encoding::DefaultFuchsiaResourceDialect,
703            >,
704            T1: fidl::encoding::Encode<
705                fidl_fuchsia_ui_views::ViewRefControl,
706                fidl::encoding::DefaultFuchsiaResourceDialect,
707            >,
708            T2: fidl::encoding::Encode<
709                fidl_fuchsia_ui_views::ViewRef,
710                fidl::encoding::DefaultFuchsiaResourceDialect,
711            >,
712        >
713        fidl::encoding::Encode<
714            ViewProviderCreateViewWithViewRefRequest,
715            fidl::encoding::DefaultFuchsiaResourceDialect,
716        > for (T0, T1, T2)
717    {
718        #[inline]
719        unsafe fn encode(
720            self,
721            encoder: &mut fidl::encoding::Encoder<
722                '_,
723                fidl::encoding::DefaultFuchsiaResourceDialect,
724            >,
725            offset: usize,
726            depth: fidl::encoding::Depth,
727        ) -> fidl::Result<()> {
728            encoder.debug_check_bounds::<ViewProviderCreateViewWithViewRefRequest>(offset);
729            // Zero out padding regions. There's no need to apply masks
730            // because the unmasked parts will be overwritten by fields.
731            // Write the fields.
732            self.0.encode(encoder, offset + 0, depth)?;
733            self.1.encode(encoder, offset + 4, depth)?;
734            self.2.encode(encoder, offset + 8, depth)?;
735            Ok(())
736        }
737    }
738
739    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
740        for ViewProviderCreateViewWithViewRefRequest
741    {
742        #[inline(always)]
743        fn new_empty() -> Self {
744            Self {
745                token: fidl::new_empty!(fidl::encoding::HandleType<fidl::EventPair, { fidl::ObjectType::EVENTPAIR.into_raw() }, 2147483648>, fidl::encoding::DefaultFuchsiaResourceDialect),
746                view_ref_control: fidl::new_empty!(
747                    fidl_fuchsia_ui_views::ViewRefControl,
748                    fidl::encoding::DefaultFuchsiaResourceDialect
749                ),
750                view_ref: fidl::new_empty!(
751                    fidl_fuchsia_ui_views::ViewRef,
752                    fidl::encoding::DefaultFuchsiaResourceDialect
753                ),
754            }
755        }
756
757        #[inline]
758        unsafe fn decode(
759            &mut self,
760            decoder: &mut fidl::encoding::Decoder<
761                '_,
762                fidl::encoding::DefaultFuchsiaResourceDialect,
763            >,
764            offset: usize,
765            _depth: fidl::encoding::Depth,
766        ) -> fidl::Result<()> {
767            decoder.debug_check_bounds::<Self>(offset);
768            // Verify that padding bytes are zero.
769            fidl::decode!(fidl::encoding::HandleType<fidl::EventPair, { fidl::ObjectType::EVENTPAIR.into_raw() }, 2147483648>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.token, decoder, offset + 0, _depth)?;
770            fidl::decode!(
771                fidl_fuchsia_ui_views::ViewRefControl,
772                fidl::encoding::DefaultFuchsiaResourceDialect,
773                &mut self.view_ref_control,
774                decoder,
775                offset + 4,
776                _depth
777            )?;
778            fidl::decode!(
779                fidl_fuchsia_ui_views::ViewRef,
780                fidl::encoding::DefaultFuchsiaResourceDialect,
781                &mut self.view_ref,
782                decoder,
783                offset + 8,
784                _depth
785            )?;
786            Ok(())
787        }
788    }
789
790    impl CreateView2Args {
791        #[inline(always)]
792        fn max_ordinal_present(&self) -> u64 {
793            if let Some(_) = self.view_creation_token {
794                return 1;
795            }
796            0
797        }
798    }
799
800    impl fidl::encoding::ResourceTypeMarker for CreateView2Args {
801        type Borrowed<'a> = &'a mut Self;
802        fn take_or_borrow<'a>(
803            value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
804        ) -> Self::Borrowed<'a> {
805            value
806        }
807    }
808
809    unsafe impl fidl::encoding::TypeMarker for CreateView2Args {
810        type Owned = Self;
811
812        #[inline(always)]
813        fn inline_align(_context: fidl::encoding::Context) -> usize {
814            8
815        }
816
817        #[inline(always)]
818        fn inline_size(_context: fidl::encoding::Context) -> usize {
819            16
820        }
821    }
822
823    unsafe impl
824        fidl::encoding::Encode<CreateView2Args, fidl::encoding::DefaultFuchsiaResourceDialect>
825        for &mut CreateView2Args
826    {
827        unsafe fn encode(
828            self,
829            encoder: &mut fidl::encoding::Encoder<
830                '_,
831                fidl::encoding::DefaultFuchsiaResourceDialect,
832            >,
833            offset: usize,
834            mut depth: fidl::encoding::Depth,
835        ) -> fidl::Result<()> {
836            encoder.debug_check_bounds::<CreateView2Args>(offset);
837            // Vector header
838            let max_ordinal: u64 = self.max_ordinal_present();
839            encoder.write_num(max_ordinal, offset);
840            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
841            // Calling encoder.out_of_line_offset(0) is not allowed.
842            if max_ordinal == 0 {
843                return Ok(());
844            }
845            depth.increment()?;
846            let envelope_size = 8;
847            let bytes_len = max_ordinal as usize * envelope_size;
848            #[allow(unused_variables)]
849            let offset = encoder.out_of_line_offset(bytes_len);
850            let mut _prev_end_offset: usize = 0;
851            if 1 > max_ordinal {
852                return Ok(());
853            }
854
855            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
856            // are envelope_size bytes.
857            let cur_offset: usize = (1 - 1) * envelope_size;
858
859            // Zero reserved fields.
860            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
861
862            // Safety:
863            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
864            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
865            //   envelope_size bytes, there is always sufficient room.
866            fidl::encoding::encode_in_envelope_optional::<fidl_fuchsia_ui_views::ViewCreationToken, fidl::encoding::DefaultFuchsiaResourceDialect>(
867            self.view_creation_token.as_mut().map(<fidl_fuchsia_ui_views::ViewCreationToken as fidl::encoding::ResourceTypeMarker>::take_or_borrow),
868            encoder, offset + cur_offset, depth
869        )?;
870
871            _prev_end_offset = cur_offset + envelope_size;
872
873            Ok(())
874        }
875    }
876
877    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
878        for CreateView2Args
879    {
880        #[inline(always)]
881        fn new_empty() -> Self {
882            Self::default()
883        }
884
885        unsafe fn decode(
886            &mut self,
887            decoder: &mut fidl::encoding::Decoder<
888                '_,
889                fidl::encoding::DefaultFuchsiaResourceDialect,
890            >,
891            offset: usize,
892            mut depth: fidl::encoding::Depth,
893        ) -> fidl::Result<()> {
894            decoder.debug_check_bounds::<Self>(offset);
895            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
896                None => return Err(fidl::Error::NotNullable),
897                Some(len) => len,
898            };
899            // Calling decoder.out_of_line_offset(0) is not allowed.
900            if len == 0 {
901                return Ok(());
902            };
903            depth.increment()?;
904            let envelope_size = 8;
905            let bytes_len = len * envelope_size;
906            let offset = decoder.out_of_line_offset(bytes_len)?;
907            // Decode the envelope for each type.
908            let mut _next_ordinal_to_read = 0;
909            let mut next_offset = offset;
910            let end_offset = offset + bytes_len;
911            _next_ordinal_to_read += 1;
912            if next_offset >= end_offset {
913                return Ok(());
914            }
915
916            // Decode unknown envelopes for gaps in ordinals.
917            while _next_ordinal_to_read < 1 {
918                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
919                _next_ordinal_to_read += 1;
920                next_offset += envelope_size;
921            }
922
923            let next_out_of_line = decoder.next_out_of_line();
924            let handles_before = decoder.remaining_handles();
925            if let Some((inlined, num_bytes, num_handles)) =
926                fidl::encoding::decode_envelope_header(decoder, next_offset)?
927            {
928                let member_inline_size = <fidl_fuchsia_ui_views::ViewCreationToken as fidl::encoding::TypeMarker>::inline_size(decoder.context);
929                if inlined != (member_inline_size <= 4) {
930                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
931                }
932                let inner_offset;
933                let mut inner_depth = depth.clone();
934                if inlined {
935                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
936                    inner_offset = next_offset;
937                } else {
938                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
939                    inner_depth.increment()?;
940                }
941                let val_ref = self.view_creation_token.get_or_insert_with(|| {
942                    fidl::new_empty!(
943                        fidl_fuchsia_ui_views::ViewCreationToken,
944                        fidl::encoding::DefaultFuchsiaResourceDialect
945                    )
946                });
947                fidl::decode!(
948                    fidl_fuchsia_ui_views::ViewCreationToken,
949                    fidl::encoding::DefaultFuchsiaResourceDialect,
950                    val_ref,
951                    decoder,
952                    inner_offset,
953                    inner_depth
954                )?;
955                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
956                {
957                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
958                }
959                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
960                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
961                }
962            }
963
964            next_offset += envelope_size;
965
966            // Decode the remaining unknown envelopes.
967            while next_offset < end_offset {
968                _next_ordinal_to_read += 1;
969                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
970                next_offset += envelope_size;
971            }
972
973            Ok(())
974        }
975    }
976}