1#![warn(clippy::all)]
4#![allow(unused_parens, unused_mut, unused_imports, nonstandard_style)]
5
6use bitflags::bitflags;
7use fidl::encoding::{MessageBufFor, ProxyChannelBox, ResourceDialect};
8use futures::future::{self, MaybeDone, TryFutureExt};
9use zx_status;
10
11#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
12pub struct DisplayPowerSetDisplayPowerRequest {
13 pub power_on: bool,
14}
15
16impl fidl::Persistable for DisplayPowerSetDisplayPowerRequest {}
17
18#[derive(Clone, Debug, PartialEq)]
19pub struct InfoGetMetricsResponse {
20 pub info: Metrics,
21}
22
23impl fidl::Persistable for InfoGetMetricsResponse {}
24
25#[derive(Clone, Debug, Default, PartialEq)]
27pub struct Metrics {
28 pub extent_in_px: Option<fidl_fuchsia_math__common::SizeU>,
31 pub extent_in_mm: Option<fidl_fuchsia_math__common::SizeU>,
34 pub recommended_device_pixel_ratio: Option<fidl_fuchsia_math__common::VecF>,
40 pub maximum_refresh_rate_in_millihertz: Option<u32>,
43 #[doc(hidden)]
44 pub __source_breaking: fidl::marker::SourceBreaking,
45}
46
47impl fidl::Persistable for Metrics {}
48
49pub mod display_power_ordinals {
50 pub const SET_DISPLAY_POWER: u64 = 0x59f31b10e74ce66f;
51}
52
53pub mod info_ordinals {
54 pub const GET_METRICS: u64 = 0x6d631353834698be;
55}
56
57mod internal {
58 use super::*;
59
60 impl fidl::encoding::ValueTypeMarker for DisplayPowerSetDisplayPowerRequest {
61 type Borrowed<'a> = &'a Self;
62 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
63 value
64 }
65 }
66
67 unsafe impl fidl::encoding::TypeMarker for DisplayPowerSetDisplayPowerRequest {
68 type Owned = Self;
69
70 #[inline(always)]
71 fn inline_align(_context: fidl::encoding::Context) -> usize {
72 1
73 }
74
75 #[inline(always)]
76 fn inline_size(_context: fidl::encoding::Context) -> usize {
77 1
78 }
79 }
80
81 unsafe impl<D: fidl::encoding::ResourceDialect>
82 fidl::encoding::Encode<DisplayPowerSetDisplayPowerRequest, D>
83 for &DisplayPowerSetDisplayPowerRequest
84 {
85 #[inline]
86 unsafe fn encode(
87 self,
88 encoder: &mut fidl::encoding::Encoder<'_, D>,
89 offset: usize,
90 _depth: fidl::encoding::Depth,
91 ) -> fidl::Result<()> {
92 encoder.debug_check_bounds::<DisplayPowerSetDisplayPowerRequest>(offset);
93 fidl::encoding::Encode::<DisplayPowerSetDisplayPowerRequest, D>::encode(
95 (<bool as fidl::encoding::ValueTypeMarker>::borrow(&self.power_on),),
96 encoder,
97 offset,
98 _depth,
99 )
100 }
101 }
102 unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<bool, D>>
103 fidl::encoding::Encode<DisplayPowerSetDisplayPowerRequest, D> for (T0,)
104 {
105 #[inline]
106 unsafe fn encode(
107 self,
108 encoder: &mut fidl::encoding::Encoder<'_, D>,
109 offset: usize,
110 depth: fidl::encoding::Depth,
111 ) -> fidl::Result<()> {
112 encoder.debug_check_bounds::<DisplayPowerSetDisplayPowerRequest>(offset);
113 self.0.encode(encoder, offset + 0, depth)?;
117 Ok(())
118 }
119 }
120
121 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
122 for DisplayPowerSetDisplayPowerRequest
123 {
124 #[inline(always)]
125 fn new_empty() -> Self {
126 Self { power_on: fidl::new_empty!(bool, D) }
127 }
128
129 #[inline]
130 unsafe fn decode(
131 &mut self,
132 decoder: &mut fidl::encoding::Decoder<'_, D>,
133 offset: usize,
134 _depth: fidl::encoding::Depth,
135 ) -> fidl::Result<()> {
136 decoder.debug_check_bounds::<Self>(offset);
137 fidl::decode!(bool, D, &mut self.power_on, decoder, offset + 0, _depth)?;
139 Ok(())
140 }
141 }
142
143 impl fidl::encoding::ValueTypeMarker for InfoGetMetricsResponse {
144 type Borrowed<'a> = &'a Self;
145 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
146 value
147 }
148 }
149
150 unsafe impl fidl::encoding::TypeMarker for InfoGetMetricsResponse {
151 type Owned = Self;
152
153 #[inline(always)]
154 fn inline_align(_context: fidl::encoding::Context) -> usize {
155 8
156 }
157
158 #[inline(always)]
159 fn inline_size(_context: fidl::encoding::Context) -> usize {
160 16
161 }
162 }
163
164 unsafe impl<D: fidl::encoding::ResourceDialect>
165 fidl::encoding::Encode<InfoGetMetricsResponse, D> for &InfoGetMetricsResponse
166 {
167 #[inline]
168 unsafe fn encode(
169 self,
170 encoder: &mut fidl::encoding::Encoder<'_, D>,
171 offset: usize,
172 _depth: fidl::encoding::Depth,
173 ) -> fidl::Result<()> {
174 encoder.debug_check_bounds::<InfoGetMetricsResponse>(offset);
175 fidl::encoding::Encode::<InfoGetMetricsResponse, D>::encode(
177 (<Metrics as fidl::encoding::ValueTypeMarker>::borrow(&self.info),),
178 encoder,
179 offset,
180 _depth,
181 )
182 }
183 }
184 unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<Metrics, D>>
185 fidl::encoding::Encode<InfoGetMetricsResponse, D> for (T0,)
186 {
187 #[inline]
188 unsafe fn encode(
189 self,
190 encoder: &mut fidl::encoding::Encoder<'_, D>,
191 offset: usize,
192 depth: fidl::encoding::Depth,
193 ) -> fidl::Result<()> {
194 encoder.debug_check_bounds::<InfoGetMetricsResponse>(offset);
195 self.0.encode(encoder, offset + 0, depth)?;
199 Ok(())
200 }
201 }
202
203 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
204 for InfoGetMetricsResponse
205 {
206 #[inline(always)]
207 fn new_empty() -> Self {
208 Self { info: fidl::new_empty!(Metrics, D) }
209 }
210
211 #[inline]
212 unsafe fn decode(
213 &mut self,
214 decoder: &mut fidl::encoding::Decoder<'_, D>,
215 offset: usize,
216 _depth: fidl::encoding::Depth,
217 ) -> fidl::Result<()> {
218 decoder.debug_check_bounds::<Self>(offset);
219 fidl::decode!(Metrics, D, &mut self.info, decoder, offset + 0, _depth)?;
221 Ok(())
222 }
223 }
224
225 impl Metrics {
226 #[inline(always)]
227 fn max_ordinal_present(&self) -> u64 {
228 if let Some(_) = self.maximum_refresh_rate_in_millihertz {
229 return 4;
230 }
231 if let Some(_) = self.recommended_device_pixel_ratio {
232 return 3;
233 }
234 if let Some(_) = self.extent_in_mm {
235 return 2;
236 }
237 if let Some(_) = self.extent_in_px {
238 return 1;
239 }
240 0
241 }
242 }
243
244 impl fidl::encoding::ValueTypeMarker for Metrics {
245 type Borrowed<'a> = &'a Self;
246 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
247 value
248 }
249 }
250
251 unsafe impl fidl::encoding::TypeMarker for Metrics {
252 type Owned = Self;
253
254 #[inline(always)]
255 fn inline_align(_context: fidl::encoding::Context) -> usize {
256 8
257 }
258
259 #[inline(always)]
260 fn inline_size(_context: fidl::encoding::Context) -> usize {
261 16
262 }
263 }
264
265 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Metrics, D> for &Metrics {
266 unsafe fn encode(
267 self,
268 encoder: &mut fidl::encoding::Encoder<'_, D>,
269 offset: usize,
270 mut depth: fidl::encoding::Depth,
271 ) -> fidl::Result<()> {
272 encoder.debug_check_bounds::<Metrics>(offset);
273 let max_ordinal: u64 = self.max_ordinal_present();
275 encoder.write_num(max_ordinal, offset);
276 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
277 if max_ordinal == 0 {
279 return Ok(());
280 }
281 depth.increment()?;
282 let envelope_size = 8;
283 let bytes_len = max_ordinal as usize * envelope_size;
284 #[allow(unused_variables)]
285 let offset = encoder.out_of_line_offset(bytes_len);
286 let mut _prev_end_offset: usize = 0;
287 if 1 > max_ordinal {
288 return Ok(());
289 }
290
291 let cur_offset: usize = (1 - 1) * envelope_size;
294
295 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
297
298 fidl::encoding::encode_in_envelope_optional::<fidl_fuchsia_math__common::SizeU, D>(
303 self.extent_in_px.as_ref().map(
304 <fidl_fuchsia_math__common::SizeU as fidl::encoding::ValueTypeMarker>::borrow,
305 ),
306 encoder,
307 offset + cur_offset,
308 depth,
309 )?;
310
311 _prev_end_offset = cur_offset + envelope_size;
312 if 2 > max_ordinal {
313 return Ok(());
314 }
315
316 let cur_offset: usize = (2 - 1) * envelope_size;
319
320 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
322
323 fidl::encoding::encode_in_envelope_optional::<fidl_fuchsia_math__common::SizeU, D>(
328 self.extent_in_mm.as_ref().map(
329 <fidl_fuchsia_math__common::SizeU as fidl::encoding::ValueTypeMarker>::borrow,
330 ),
331 encoder,
332 offset + cur_offset,
333 depth,
334 )?;
335
336 _prev_end_offset = cur_offset + envelope_size;
337 if 3 > max_ordinal {
338 return Ok(());
339 }
340
341 let cur_offset: usize = (3 - 1) * envelope_size;
344
345 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
347
348 fidl::encoding::encode_in_envelope_optional::<fidl_fuchsia_math__common::VecF, D>(
353 self.recommended_device_pixel_ratio.as_ref().map(
354 <fidl_fuchsia_math__common::VecF as fidl::encoding::ValueTypeMarker>::borrow,
355 ),
356 encoder,
357 offset + cur_offset,
358 depth,
359 )?;
360
361 _prev_end_offset = cur_offset + envelope_size;
362 if 4 > max_ordinal {
363 return Ok(());
364 }
365
366 let cur_offset: usize = (4 - 1) * envelope_size;
369
370 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
372
373 fidl::encoding::encode_in_envelope_optional::<u32, D>(
378 self.maximum_refresh_rate_in_millihertz
379 .as_ref()
380 .map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
381 encoder,
382 offset + cur_offset,
383 depth,
384 )?;
385
386 _prev_end_offset = cur_offset + envelope_size;
387
388 Ok(())
389 }
390 }
391
392 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for Metrics {
393 #[inline(always)]
394 fn new_empty() -> Self {
395 Self::default()
396 }
397
398 unsafe fn decode(
399 &mut self,
400 decoder: &mut fidl::encoding::Decoder<'_, D>,
401 offset: usize,
402 mut depth: fidl::encoding::Depth,
403 ) -> fidl::Result<()> {
404 decoder.debug_check_bounds::<Self>(offset);
405 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
406 None => return Err(fidl::Error::NotNullable),
407 Some(len) => len,
408 };
409 if len == 0 {
411 return Ok(());
412 };
413 depth.increment()?;
414 let envelope_size = 8;
415 let bytes_len = len * envelope_size;
416 let offset = decoder.out_of_line_offset(bytes_len)?;
417 let mut _next_ordinal_to_read = 0;
419 let mut next_offset = offset;
420 let end_offset = offset + bytes_len;
421 _next_ordinal_to_read += 1;
422 if next_offset >= end_offset {
423 return Ok(());
424 }
425
426 while _next_ordinal_to_read < 1 {
428 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
429 _next_ordinal_to_read += 1;
430 next_offset += envelope_size;
431 }
432
433 let next_out_of_line = decoder.next_out_of_line();
434 let handles_before = decoder.remaining_handles();
435 if let Some((inlined, num_bytes, num_handles)) =
436 fidl::encoding::decode_envelope_header(decoder, next_offset)?
437 {
438 let member_inline_size =
439 <fidl_fuchsia_math__common::SizeU as fidl::encoding::TypeMarker>::inline_size(
440 decoder.context,
441 );
442 if inlined != (member_inline_size <= 4) {
443 return Err(fidl::Error::InvalidInlineBitInEnvelope);
444 }
445 let inner_offset;
446 let mut inner_depth = depth.clone();
447 if inlined {
448 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
449 inner_offset = next_offset;
450 } else {
451 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
452 inner_depth.increment()?;
453 }
454 let val_ref = self
455 .extent_in_px
456 .get_or_insert_with(|| fidl::new_empty!(fidl_fuchsia_math__common::SizeU, D));
457 fidl::decode!(
458 fidl_fuchsia_math__common::SizeU,
459 D,
460 val_ref,
461 decoder,
462 inner_offset,
463 inner_depth
464 )?;
465 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
466 {
467 return Err(fidl::Error::InvalidNumBytesInEnvelope);
468 }
469 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
470 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
471 }
472 }
473
474 next_offset += envelope_size;
475 _next_ordinal_to_read += 1;
476 if next_offset >= end_offset {
477 return Ok(());
478 }
479
480 while _next_ordinal_to_read < 2 {
482 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
483 _next_ordinal_to_read += 1;
484 next_offset += envelope_size;
485 }
486
487 let next_out_of_line = decoder.next_out_of_line();
488 let handles_before = decoder.remaining_handles();
489 if let Some((inlined, num_bytes, num_handles)) =
490 fidl::encoding::decode_envelope_header(decoder, next_offset)?
491 {
492 let member_inline_size =
493 <fidl_fuchsia_math__common::SizeU as fidl::encoding::TypeMarker>::inline_size(
494 decoder.context,
495 );
496 if inlined != (member_inline_size <= 4) {
497 return Err(fidl::Error::InvalidInlineBitInEnvelope);
498 }
499 let inner_offset;
500 let mut inner_depth = depth.clone();
501 if inlined {
502 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
503 inner_offset = next_offset;
504 } else {
505 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
506 inner_depth.increment()?;
507 }
508 let val_ref = self
509 .extent_in_mm
510 .get_or_insert_with(|| fidl::new_empty!(fidl_fuchsia_math__common::SizeU, D));
511 fidl::decode!(
512 fidl_fuchsia_math__common::SizeU,
513 D,
514 val_ref,
515 decoder,
516 inner_offset,
517 inner_depth
518 )?;
519 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
520 {
521 return Err(fidl::Error::InvalidNumBytesInEnvelope);
522 }
523 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
524 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
525 }
526 }
527
528 next_offset += envelope_size;
529 _next_ordinal_to_read += 1;
530 if next_offset >= end_offset {
531 return Ok(());
532 }
533
534 while _next_ordinal_to_read < 3 {
536 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
537 _next_ordinal_to_read += 1;
538 next_offset += envelope_size;
539 }
540
541 let next_out_of_line = decoder.next_out_of_line();
542 let handles_before = decoder.remaining_handles();
543 if let Some((inlined, num_bytes, num_handles)) =
544 fidl::encoding::decode_envelope_header(decoder, next_offset)?
545 {
546 let member_inline_size =
547 <fidl_fuchsia_math__common::VecF as fidl::encoding::TypeMarker>::inline_size(
548 decoder.context,
549 );
550 if inlined != (member_inline_size <= 4) {
551 return Err(fidl::Error::InvalidInlineBitInEnvelope);
552 }
553 let inner_offset;
554 let mut inner_depth = depth.clone();
555 if inlined {
556 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
557 inner_offset = next_offset;
558 } else {
559 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
560 inner_depth.increment()?;
561 }
562 let val_ref = self
563 .recommended_device_pixel_ratio
564 .get_or_insert_with(|| fidl::new_empty!(fidl_fuchsia_math__common::VecF, D));
565 fidl::decode!(
566 fidl_fuchsia_math__common::VecF,
567 D,
568 val_ref,
569 decoder,
570 inner_offset,
571 inner_depth
572 )?;
573 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
574 {
575 return Err(fidl::Error::InvalidNumBytesInEnvelope);
576 }
577 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
578 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
579 }
580 }
581
582 next_offset += envelope_size;
583 _next_ordinal_to_read += 1;
584 if next_offset >= end_offset {
585 return Ok(());
586 }
587
588 while _next_ordinal_to_read < 4 {
590 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
591 _next_ordinal_to_read += 1;
592 next_offset += envelope_size;
593 }
594
595 let next_out_of_line = decoder.next_out_of_line();
596 let handles_before = decoder.remaining_handles();
597 if let Some((inlined, num_bytes, num_handles)) =
598 fidl::encoding::decode_envelope_header(decoder, next_offset)?
599 {
600 let member_inline_size =
601 <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
602 if inlined != (member_inline_size <= 4) {
603 return Err(fidl::Error::InvalidInlineBitInEnvelope);
604 }
605 let inner_offset;
606 let mut inner_depth = depth.clone();
607 if inlined {
608 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
609 inner_offset = next_offset;
610 } else {
611 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
612 inner_depth.increment()?;
613 }
614 let val_ref = self
615 .maximum_refresh_rate_in_millihertz
616 .get_or_insert_with(|| fidl::new_empty!(u32, D));
617 fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
618 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
619 {
620 return Err(fidl::Error::InvalidNumBytesInEnvelope);
621 }
622 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
623 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
624 }
625 }
626
627 next_offset += envelope_size;
628
629 while next_offset < end_offset {
631 _next_ordinal_to_read += 1;
632 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
633 next_offset += envelope_size;
634 }
635
636 Ok(())
637 }
638 }
639}