1#![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_power_battery_test_common::*;
11use futures::future::{self, MaybeDone, TryFutureExt};
12use zx_status;
13
14#[derive(Debug, Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Hash)]
15pub struct BatterySimulatorMarker;
16
17impl fidl::endpoints::ProtocolMarker for BatterySimulatorMarker {
18 type Proxy = BatterySimulatorProxy;
19 type RequestStream = BatterySimulatorRequestStream;
20 #[cfg(target_os = "fuchsia")]
21 type SynchronousProxy = BatterySimulatorSynchronousProxy;
22
23 const DEBUG_NAME: &'static str = "fuchsia.power.battery.test.BatterySimulator";
24}
25impl fidl::endpoints::DiscoverableProtocolMarker for BatterySimulatorMarker {}
26
27pub trait BatterySimulatorProxyInterface: Send + Sync {
28 type GetBatteryInfoResponseFut: std::future::Future<Output = Result<fidl_fuchsia_power_battery::BatteryInfo, fidl::Error>>
29 + Send;
30 fn r#get_battery_info(&self) -> Self::GetBatteryInfoResponseFut;
31 fn r#set_battery_status(
32 &self,
33 battery_status: fidl_fuchsia_power_battery::BatteryStatus,
34 ) -> Result<(), fidl::Error>;
35 fn r#set_charge_status(
36 &self,
37 charge_status: fidl_fuchsia_power_battery::ChargeStatus,
38 ) -> Result<(), fidl::Error>;
39 fn r#set_charge_source(
40 &self,
41 charge_source: fidl_fuchsia_power_battery::ChargeSource,
42 ) -> Result<(), fidl::Error>;
43 fn r#set_battery_percentage(&self, percent: f32) -> Result<(), fidl::Error>;
44 fn r#set_level_status(
45 &self,
46 level_status: fidl_fuchsia_power_battery::LevelStatus,
47 ) -> Result<(), fidl::Error>;
48 fn r#set_time_remaining(&self, duration: i64) -> Result<(), fidl::Error>;
49 fn r#disconnect_real_battery(&self) -> Result<(), fidl::Error>;
50 type IsSimulatingResponseFut: std::future::Future<Output = Result<bool, fidl::Error>> + Send;
51 fn r#is_simulating(&self) -> Self::IsSimulatingResponseFut;
52 fn r#reconnect_real_battery(&self) -> Result<(), fidl::Error>;
53 fn r#set_present_voltage_mv(&self, voltage: u32) -> Result<(), fidl::Error>;
54 fn r#set_remaining_capacity_uah(&self, capacity: u32) -> Result<(), fidl::Error>;
55 fn r#set_battery_spec(
56 &self,
57 spec: &fidl_fuchsia_power_battery::BatterySpec,
58 ) -> Result<(), fidl::Error>;
59}
60#[derive(Debug)]
61#[cfg(target_os = "fuchsia")]
62pub struct BatterySimulatorSynchronousProxy {
63 client: fidl::client::sync::Client,
64}
65
66#[cfg(target_os = "fuchsia")]
67impl fidl::endpoints::SynchronousProxy for BatterySimulatorSynchronousProxy {
68 type Proxy = BatterySimulatorProxy;
69 type Protocol = BatterySimulatorMarker;
70
71 fn from_channel(inner: fidl::Channel) -> Self {
72 Self::new(inner)
73 }
74
75 fn into_channel(self) -> fidl::Channel {
76 self.client.into_channel()
77 }
78
79 fn as_channel(&self) -> &fidl::Channel {
80 self.client.as_channel()
81 }
82}
83
84#[cfg(target_os = "fuchsia")]
85impl BatterySimulatorSynchronousProxy {
86 pub fn new(channel: fidl::Channel) -> Self {
87 let protocol_name = <BatterySimulatorMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME;
88 Self { client: fidl::client::sync::Client::new(channel, protocol_name) }
89 }
90
91 pub fn into_channel(self) -> fidl::Channel {
92 self.client.into_channel()
93 }
94
95 pub fn wait_for_event(
98 &self,
99 deadline: zx::MonotonicInstant,
100 ) -> Result<BatterySimulatorEvent, fidl::Error> {
101 BatterySimulatorEvent::decode(self.client.wait_for_event(deadline)?)
102 }
103
104 pub fn r#get_battery_info(
107 &self,
108 ___deadline: zx::MonotonicInstant,
109 ) -> Result<fidl_fuchsia_power_battery::BatteryInfo, fidl::Error> {
110 let _response = self.client.send_query::<
111 fidl::encoding::EmptyPayload,
112 BatterySimulatorControllerGetBatteryInfoResponse,
113 >(
114 (),
115 0x4a20d3731366aaf8,
116 fidl::encoding::DynamicFlags::empty(),
117 ___deadline,
118 )?;
119 Ok(_response.info)
120 }
121
122 pub fn r#set_battery_status(
125 &self,
126 mut battery_status: fidl_fuchsia_power_battery::BatteryStatus,
127 ) -> Result<(), fidl::Error> {
128 self.client.send::<BatterySimulatorControllerSetBatteryStatusRequest>(
129 (battery_status,),
130 0x2343eb65038c8b34,
131 fidl::encoding::DynamicFlags::empty(),
132 )
133 }
134
135 pub fn r#set_charge_status(
138 &self,
139 mut charge_status: fidl_fuchsia_power_battery::ChargeStatus,
140 ) -> Result<(), fidl::Error> {
141 self.client.send::<BatterySimulatorControllerSetChargeStatusRequest>(
142 (charge_status,),
143 0x79b2bf1a387acd85,
144 fidl::encoding::DynamicFlags::empty(),
145 )
146 }
147
148 pub fn r#set_charge_source(
151 &self,
152 mut charge_source: fidl_fuchsia_power_battery::ChargeSource,
153 ) -> Result<(), fidl::Error> {
154 self.client.send::<BatterySimulatorControllerSetChargeSourceRequest>(
155 (charge_source,),
156 0xb40433f42c33527,
157 fidl::encoding::DynamicFlags::empty(),
158 )
159 }
160
161 pub fn r#set_battery_percentage(&self, mut percent: f32) -> Result<(), fidl::Error> {
164 self.client.send::<BatterySimulatorControllerSetBatteryPercentageRequest>(
165 (percent,),
166 0x64a9d96eb7a45a9f,
167 fidl::encoding::DynamicFlags::empty(),
168 )
169 }
170
171 pub fn r#set_level_status(
174 &self,
175 mut level_status: fidl_fuchsia_power_battery::LevelStatus,
176 ) -> Result<(), fidl::Error> {
177 self.client.send::<BatterySimulatorControllerSetLevelStatusRequest>(
178 (level_status,),
179 0x577fc3314f7a48a4,
180 fidl::encoding::DynamicFlags::empty(),
181 )
182 }
183
184 pub fn r#set_time_remaining(&self, mut duration: i64) -> Result<(), fidl::Error> {
187 self.client.send::<BatterySimulatorControllerSetTimeRemainingRequest>(
188 (duration,),
189 0x7427251c9d2a794e,
190 fidl::encoding::DynamicFlags::empty(),
191 )
192 }
193
194 pub fn r#disconnect_real_battery(&self) -> Result<(), fidl::Error> {
196 self.client.send::<fidl::encoding::EmptyPayload>(
197 (),
198 0x75588eae6b9b67e3,
199 fidl::encoding::DynamicFlags::empty(),
200 )
201 }
202
203 pub fn r#is_simulating(&self, ___deadline: zx::MonotonicInstant) -> Result<bool, fidl::Error> {
205 let _response = self.client.send_query::<
206 fidl::encoding::EmptyPayload,
207 BatterySimulatorControllerIsSimulatingResponse,
208 >(
209 (),
210 0x4bf85cfe3476975d,
211 fidl::encoding::DynamicFlags::empty(),
212 ___deadline,
213 )?;
214 Ok(_response.simulation_state)
215 }
216
217 pub fn r#reconnect_real_battery(&self) -> Result<(), fidl::Error> {
220 self.client.send::<fidl::encoding::EmptyPayload>(
221 (),
222 0x18306690352d9dfa,
223 fidl::encoding::DynamicFlags::empty(),
224 )
225 }
226
227 pub fn r#set_present_voltage_mv(&self, mut voltage: u32) -> Result<(), fidl::Error> {
230 self.client.send::<BatterySimulatorControllerSetPresentVoltageMvRequest>(
231 (voltage,),
232 0x5462c9e9f947b8ce,
233 fidl::encoding::DynamicFlags::empty(),
234 )
235 }
236
237 pub fn r#set_remaining_capacity_uah(&self, mut capacity: u32) -> Result<(), fidl::Error> {
240 self.client.send::<BatterySimulatorControllerSetRemainingCapacityUahRequest>(
241 (capacity,),
242 0x38054049fe8c26ab,
243 fidl::encoding::DynamicFlags::empty(),
244 )
245 }
246
247 pub fn r#set_battery_spec(
249 &self,
250 mut spec: &fidl_fuchsia_power_battery::BatterySpec,
251 ) -> Result<(), fidl::Error> {
252 self.client.send::<BatterySimulatorControllerSetBatterySpecRequest>(
253 (spec,),
254 0x7324672546976583,
255 fidl::encoding::DynamicFlags::empty(),
256 )
257 }
258}
259
260#[derive(Debug, Clone)]
261pub struct BatterySimulatorProxy {
262 client: fidl::client::Client<fidl::encoding::DefaultFuchsiaResourceDialect>,
263}
264
265impl fidl::endpoints::Proxy for BatterySimulatorProxy {
266 type Protocol = BatterySimulatorMarker;
267
268 fn from_channel(inner: ::fidl::AsyncChannel) -> Self {
269 Self::new(inner)
270 }
271
272 fn into_channel(self) -> Result<::fidl::AsyncChannel, Self> {
273 self.client.into_channel().map_err(|client| Self { client })
274 }
275
276 fn as_channel(&self) -> &::fidl::AsyncChannel {
277 self.client.as_channel()
278 }
279}
280
281impl BatterySimulatorProxy {
282 pub fn new(channel: ::fidl::AsyncChannel) -> Self {
284 let protocol_name = <BatterySimulatorMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME;
285 Self { client: fidl::client::Client::new(channel, protocol_name) }
286 }
287
288 pub fn take_event_stream(&self) -> BatterySimulatorEventStream {
294 BatterySimulatorEventStream { event_receiver: self.client.take_event_receiver() }
295 }
296
297 pub fn r#get_battery_info(
300 &self,
301 ) -> fidl::client::QueryResponseFut<
302 fidl_fuchsia_power_battery::BatteryInfo,
303 fidl::encoding::DefaultFuchsiaResourceDialect,
304 > {
305 BatterySimulatorProxyInterface::r#get_battery_info(self)
306 }
307
308 pub fn r#set_battery_status(
311 &self,
312 mut battery_status: fidl_fuchsia_power_battery::BatteryStatus,
313 ) -> Result<(), fidl::Error> {
314 BatterySimulatorProxyInterface::r#set_battery_status(self, battery_status)
315 }
316
317 pub fn r#set_charge_status(
320 &self,
321 mut charge_status: fidl_fuchsia_power_battery::ChargeStatus,
322 ) -> Result<(), fidl::Error> {
323 BatterySimulatorProxyInterface::r#set_charge_status(self, charge_status)
324 }
325
326 pub fn r#set_charge_source(
329 &self,
330 mut charge_source: fidl_fuchsia_power_battery::ChargeSource,
331 ) -> Result<(), fidl::Error> {
332 BatterySimulatorProxyInterface::r#set_charge_source(self, charge_source)
333 }
334
335 pub fn r#set_battery_percentage(&self, mut percent: f32) -> Result<(), fidl::Error> {
338 BatterySimulatorProxyInterface::r#set_battery_percentage(self, percent)
339 }
340
341 pub fn r#set_level_status(
344 &self,
345 mut level_status: fidl_fuchsia_power_battery::LevelStatus,
346 ) -> Result<(), fidl::Error> {
347 BatterySimulatorProxyInterface::r#set_level_status(self, level_status)
348 }
349
350 pub fn r#set_time_remaining(&self, mut duration: i64) -> Result<(), fidl::Error> {
353 BatterySimulatorProxyInterface::r#set_time_remaining(self, duration)
354 }
355
356 pub fn r#disconnect_real_battery(&self) -> Result<(), fidl::Error> {
358 BatterySimulatorProxyInterface::r#disconnect_real_battery(self)
359 }
360
361 pub fn r#is_simulating(
363 &self,
364 ) -> fidl::client::QueryResponseFut<bool, fidl::encoding::DefaultFuchsiaResourceDialect> {
365 BatterySimulatorProxyInterface::r#is_simulating(self)
366 }
367
368 pub fn r#reconnect_real_battery(&self) -> Result<(), fidl::Error> {
371 BatterySimulatorProxyInterface::r#reconnect_real_battery(self)
372 }
373
374 pub fn r#set_present_voltage_mv(&self, mut voltage: u32) -> Result<(), fidl::Error> {
377 BatterySimulatorProxyInterface::r#set_present_voltage_mv(self, voltage)
378 }
379
380 pub fn r#set_remaining_capacity_uah(&self, mut capacity: u32) -> Result<(), fidl::Error> {
383 BatterySimulatorProxyInterface::r#set_remaining_capacity_uah(self, capacity)
384 }
385
386 pub fn r#set_battery_spec(
388 &self,
389 mut spec: &fidl_fuchsia_power_battery::BatterySpec,
390 ) -> Result<(), fidl::Error> {
391 BatterySimulatorProxyInterface::r#set_battery_spec(self, spec)
392 }
393}
394
395impl BatterySimulatorProxyInterface for BatterySimulatorProxy {
396 type GetBatteryInfoResponseFut = fidl::client::QueryResponseFut<
397 fidl_fuchsia_power_battery::BatteryInfo,
398 fidl::encoding::DefaultFuchsiaResourceDialect,
399 >;
400 fn r#get_battery_info(&self) -> Self::GetBatteryInfoResponseFut {
401 fn _decode(
402 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
403 ) -> Result<fidl_fuchsia_power_battery::BatteryInfo, fidl::Error> {
404 let _response = fidl::client::decode_transaction_body::<
405 BatterySimulatorControllerGetBatteryInfoResponse,
406 fidl::encoding::DefaultFuchsiaResourceDialect,
407 0x4a20d3731366aaf8,
408 >(_buf?)?;
409 Ok(_response.info)
410 }
411 self.client.send_query_and_decode::<
412 fidl::encoding::EmptyPayload,
413 fidl_fuchsia_power_battery::BatteryInfo,
414 >(
415 (),
416 0x4a20d3731366aaf8,
417 fidl::encoding::DynamicFlags::empty(),
418 _decode,
419 )
420 }
421
422 fn r#set_battery_status(
423 &self,
424 mut battery_status: fidl_fuchsia_power_battery::BatteryStatus,
425 ) -> Result<(), fidl::Error> {
426 self.client.send::<BatterySimulatorControllerSetBatteryStatusRequest>(
427 (battery_status,),
428 0x2343eb65038c8b34,
429 fidl::encoding::DynamicFlags::empty(),
430 )
431 }
432
433 fn r#set_charge_status(
434 &self,
435 mut charge_status: fidl_fuchsia_power_battery::ChargeStatus,
436 ) -> Result<(), fidl::Error> {
437 self.client.send::<BatterySimulatorControllerSetChargeStatusRequest>(
438 (charge_status,),
439 0x79b2bf1a387acd85,
440 fidl::encoding::DynamicFlags::empty(),
441 )
442 }
443
444 fn r#set_charge_source(
445 &self,
446 mut charge_source: fidl_fuchsia_power_battery::ChargeSource,
447 ) -> Result<(), fidl::Error> {
448 self.client.send::<BatterySimulatorControllerSetChargeSourceRequest>(
449 (charge_source,),
450 0xb40433f42c33527,
451 fidl::encoding::DynamicFlags::empty(),
452 )
453 }
454
455 fn r#set_battery_percentage(&self, mut percent: f32) -> Result<(), fidl::Error> {
456 self.client.send::<BatterySimulatorControllerSetBatteryPercentageRequest>(
457 (percent,),
458 0x64a9d96eb7a45a9f,
459 fidl::encoding::DynamicFlags::empty(),
460 )
461 }
462
463 fn r#set_level_status(
464 &self,
465 mut level_status: fidl_fuchsia_power_battery::LevelStatus,
466 ) -> Result<(), fidl::Error> {
467 self.client.send::<BatterySimulatorControllerSetLevelStatusRequest>(
468 (level_status,),
469 0x577fc3314f7a48a4,
470 fidl::encoding::DynamicFlags::empty(),
471 )
472 }
473
474 fn r#set_time_remaining(&self, mut duration: i64) -> Result<(), fidl::Error> {
475 self.client.send::<BatterySimulatorControllerSetTimeRemainingRequest>(
476 (duration,),
477 0x7427251c9d2a794e,
478 fidl::encoding::DynamicFlags::empty(),
479 )
480 }
481
482 fn r#disconnect_real_battery(&self) -> Result<(), fidl::Error> {
483 self.client.send::<fidl::encoding::EmptyPayload>(
484 (),
485 0x75588eae6b9b67e3,
486 fidl::encoding::DynamicFlags::empty(),
487 )
488 }
489
490 type IsSimulatingResponseFut =
491 fidl::client::QueryResponseFut<bool, fidl::encoding::DefaultFuchsiaResourceDialect>;
492 fn r#is_simulating(&self) -> Self::IsSimulatingResponseFut {
493 fn _decode(
494 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
495 ) -> Result<bool, fidl::Error> {
496 let _response = fidl::client::decode_transaction_body::<
497 BatterySimulatorControllerIsSimulatingResponse,
498 fidl::encoding::DefaultFuchsiaResourceDialect,
499 0x4bf85cfe3476975d,
500 >(_buf?)?;
501 Ok(_response.simulation_state)
502 }
503 self.client.send_query_and_decode::<fidl::encoding::EmptyPayload, bool>(
504 (),
505 0x4bf85cfe3476975d,
506 fidl::encoding::DynamicFlags::empty(),
507 _decode,
508 )
509 }
510
511 fn r#reconnect_real_battery(&self) -> Result<(), fidl::Error> {
512 self.client.send::<fidl::encoding::EmptyPayload>(
513 (),
514 0x18306690352d9dfa,
515 fidl::encoding::DynamicFlags::empty(),
516 )
517 }
518
519 fn r#set_present_voltage_mv(&self, mut voltage: u32) -> Result<(), fidl::Error> {
520 self.client.send::<BatterySimulatorControllerSetPresentVoltageMvRequest>(
521 (voltage,),
522 0x5462c9e9f947b8ce,
523 fidl::encoding::DynamicFlags::empty(),
524 )
525 }
526
527 fn r#set_remaining_capacity_uah(&self, mut capacity: u32) -> Result<(), fidl::Error> {
528 self.client.send::<BatterySimulatorControllerSetRemainingCapacityUahRequest>(
529 (capacity,),
530 0x38054049fe8c26ab,
531 fidl::encoding::DynamicFlags::empty(),
532 )
533 }
534
535 fn r#set_battery_spec(
536 &self,
537 mut spec: &fidl_fuchsia_power_battery::BatterySpec,
538 ) -> Result<(), fidl::Error> {
539 self.client.send::<BatterySimulatorControllerSetBatterySpecRequest>(
540 (spec,),
541 0x7324672546976583,
542 fidl::encoding::DynamicFlags::empty(),
543 )
544 }
545}
546
547pub struct BatterySimulatorEventStream {
548 event_receiver: fidl::client::EventReceiver<fidl::encoding::DefaultFuchsiaResourceDialect>,
549}
550
551impl std::marker::Unpin for BatterySimulatorEventStream {}
552
553impl futures::stream::FusedStream for BatterySimulatorEventStream {
554 fn is_terminated(&self) -> bool {
555 self.event_receiver.is_terminated()
556 }
557}
558
559impl futures::Stream for BatterySimulatorEventStream {
560 type Item = Result<BatterySimulatorEvent, fidl::Error>;
561
562 fn poll_next(
563 mut self: std::pin::Pin<&mut Self>,
564 cx: &mut std::task::Context<'_>,
565 ) -> std::task::Poll<Option<Self::Item>> {
566 match futures::ready!(futures::stream::StreamExt::poll_next_unpin(
567 &mut self.event_receiver,
568 cx
569 )?) {
570 Some(buf) => std::task::Poll::Ready(Some(BatterySimulatorEvent::decode(buf))),
571 None => std::task::Poll::Ready(None),
572 }
573 }
574}
575
576#[derive(Debug)]
577pub enum BatterySimulatorEvent {}
578
579impl BatterySimulatorEvent {
580 fn decode(
582 mut buf: <fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc,
583 ) -> Result<BatterySimulatorEvent, fidl::Error> {
584 let (bytes, _handles) = buf.split_mut();
585 let (tx_header, _body_bytes) = fidl::encoding::decode_transaction_header(bytes)?;
586 debug_assert_eq!(tx_header.tx_id, 0);
587 match tx_header.ordinal {
588 _ => Err(fidl::Error::UnknownOrdinal {
589 ordinal: tx_header.ordinal,
590 protocol_name:
591 <BatterySimulatorMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
592 }),
593 }
594 }
595}
596
597pub struct BatterySimulatorRequestStream {
599 inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
600 is_terminated: bool,
601}
602
603impl std::marker::Unpin for BatterySimulatorRequestStream {}
604
605impl futures::stream::FusedStream for BatterySimulatorRequestStream {
606 fn is_terminated(&self) -> bool {
607 self.is_terminated
608 }
609}
610
611impl fidl::endpoints::RequestStream for BatterySimulatorRequestStream {
612 type Protocol = BatterySimulatorMarker;
613 type ControlHandle = BatterySimulatorControlHandle;
614
615 fn from_channel(channel: ::fidl::AsyncChannel) -> Self {
616 Self { inner: std::sync::Arc::new(fidl::ServeInner::new(channel)), is_terminated: false }
617 }
618
619 fn control_handle(&self) -> Self::ControlHandle {
620 BatterySimulatorControlHandle { inner: self.inner.clone() }
621 }
622
623 fn into_inner(
624 self,
625 ) -> (::std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>, bool)
626 {
627 (self.inner, self.is_terminated)
628 }
629
630 fn from_inner(
631 inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
632 is_terminated: bool,
633 ) -> Self {
634 Self { inner, is_terminated }
635 }
636}
637
638impl futures::Stream for BatterySimulatorRequestStream {
639 type Item = Result<BatterySimulatorRequest, fidl::Error>;
640
641 fn poll_next(
642 mut self: std::pin::Pin<&mut Self>,
643 cx: &mut std::task::Context<'_>,
644 ) -> std::task::Poll<Option<Self::Item>> {
645 let this = &mut *self;
646 if this.inner.check_shutdown(cx) {
647 this.is_terminated = true;
648 return std::task::Poll::Ready(None);
649 }
650 if this.is_terminated {
651 panic!("polled BatterySimulatorRequestStream after completion");
652 }
653 fidl::encoding::with_tls_decode_buf::<_, fidl::encoding::DefaultFuchsiaResourceDialect>(
654 |bytes, handles| {
655 match this.inner.channel().read_etc(cx, bytes, handles) {
656 std::task::Poll::Ready(Ok(())) => {}
657 std::task::Poll::Pending => return std::task::Poll::Pending,
658 std::task::Poll::Ready(Err(zx_status::Status::PEER_CLOSED)) => {
659 this.is_terminated = true;
660 return std::task::Poll::Ready(None);
661 }
662 std::task::Poll::Ready(Err(e)) => {
663 return std::task::Poll::Ready(Some(Err(fidl::Error::ServerRequestRead(
664 e.into(),
665 ))))
666 }
667 }
668
669 let (header, _body_bytes) = fidl::encoding::decode_transaction_header(bytes)?;
671
672 std::task::Poll::Ready(Some(match header.ordinal {
673 0x4a20d3731366aaf8 => {
674 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
675 let mut req = fidl::new_empty!(
676 fidl::encoding::EmptyPayload,
677 fidl::encoding::DefaultFuchsiaResourceDialect
678 );
679 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
680 let control_handle =
681 BatterySimulatorControlHandle { inner: this.inner.clone() };
682 Ok(BatterySimulatorRequest::GetBatteryInfo {
683 responder: BatterySimulatorGetBatteryInfoResponder {
684 control_handle: std::mem::ManuallyDrop::new(control_handle),
685 tx_id: header.tx_id,
686 },
687 })
688 }
689 0x2343eb65038c8b34 => {
690 header.validate_request_tx_id(fidl::MethodType::OneWay)?;
691 let mut req = fidl::new_empty!(
692 BatterySimulatorControllerSetBatteryStatusRequest,
693 fidl::encoding::DefaultFuchsiaResourceDialect
694 );
695 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BatterySimulatorControllerSetBatteryStatusRequest>(&header, _body_bytes, handles, &mut req)?;
696 let control_handle =
697 BatterySimulatorControlHandle { inner: this.inner.clone() };
698 Ok(BatterySimulatorRequest::SetBatteryStatus {
699 battery_status: req.battery_status,
700
701 control_handle,
702 })
703 }
704 0x79b2bf1a387acd85 => {
705 header.validate_request_tx_id(fidl::MethodType::OneWay)?;
706 let mut req = fidl::new_empty!(
707 BatterySimulatorControllerSetChargeStatusRequest,
708 fidl::encoding::DefaultFuchsiaResourceDialect
709 );
710 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BatterySimulatorControllerSetChargeStatusRequest>(&header, _body_bytes, handles, &mut req)?;
711 let control_handle =
712 BatterySimulatorControlHandle { inner: this.inner.clone() };
713 Ok(BatterySimulatorRequest::SetChargeStatus {
714 charge_status: req.charge_status,
715
716 control_handle,
717 })
718 }
719 0xb40433f42c33527 => {
720 header.validate_request_tx_id(fidl::MethodType::OneWay)?;
721 let mut req = fidl::new_empty!(
722 BatterySimulatorControllerSetChargeSourceRequest,
723 fidl::encoding::DefaultFuchsiaResourceDialect
724 );
725 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BatterySimulatorControllerSetChargeSourceRequest>(&header, _body_bytes, handles, &mut req)?;
726 let control_handle =
727 BatterySimulatorControlHandle { inner: this.inner.clone() };
728 Ok(BatterySimulatorRequest::SetChargeSource {
729 charge_source: req.charge_source,
730
731 control_handle,
732 })
733 }
734 0x64a9d96eb7a45a9f => {
735 header.validate_request_tx_id(fidl::MethodType::OneWay)?;
736 let mut req = fidl::new_empty!(
737 BatterySimulatorControllerSetBatteryPercentageRequest,
738 fidl::encoding::DefaultFuchsiaResourceDialect
739 );
740 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BatterySimulatorControllerSetBatteryPercentageRequest>(&header, _body_bytes, handles, &mut req)?;
741 let control_handle =
742 BatterySimulatorControlHandle { inner: this.inner.clone() };
743 Ok(BatterySimulatorRequest::SetBatteryPercentage {
744 percent: req.percent,
745
746 control_handle,
747 })
748 }
749 0x577fc3314f7a48a4 => {
750 header.validate_request_tx_id(fidl::MethodType::OneWay)?;
751 let mut req = fidl::new_empty!(
752 BatterySimulatorControllerSetLevelStatusRequest,
753 fidl::encoding::DefaultFuchsiaResourceDialect
754 );
755 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BatterySimulatorControllerSetLevelStatusRequest>(&header, _body_bytes, handles, &mut req)?;
756 let control_handle =
757 BatterySimulatorControlHandle { inner: this.inner.clone() };
758 Ok(BatterySimulatorRequest::SetLevelStatus {
759 level_status: req.level_status,
760
761 control_handle,
762 })
763 }
764 0x7427251c9d2a794e => {
765 header.validate_request_tx_id(fidl::MethodType::OneWay)?;
766 let mut req = fidl::new_empty!(
767 BatterySimulatorControllerSetTimeRemainingRequest,
768 fidl::encoding::DefaultFuchsiaResourceDialect
769 );
770 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BatterySimulatorControllerSetTimeRemainingRequest>(&header, _body_bytes, handles, &mut req)?;
771 let control_handle =
772 BatterySimulatorControlHandle { inner: this.inner.clone() };
773 Ok(BatterySimulatorRequest::SetTimeRemaining {
774 duration: req.duration,
775
776 control_handle,
777 })
778 }
779 0x75588eae6b9b67e3 => {
780 header.validate_request_tx_id(fidl::MethodType::OneWay)?;
781 let mut req = fidl::new_empty!(
782 fidl::encoding::EmptyPayload,
783 fidl::encoding::DefaultFuchsiaResourceDialect
784 );
785 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
786 let control_handle =
787 BatterySimulatorControlHandle { inner: this.inner.clone() };
788 Ok(BatterySimulatorRequest::DisconnectRealBattery { control_handle })
789 }
790 0x4bf85cfe3476975d => {
791 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
792 let mut req = fidl::new_empty!(
793 fidl::encoding::EmptyPayload,
794 fidl::encoding::DefaultFuchsiaResourceDialect
795 );
796 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
797 let control_handle =
798 BatterySimulatorControlHandle { inner: this.inner.clone() };
799 Ok(BatterySimulatorRequest::IsSimulating {
800 responder: BatterySimulatorIsSimulatingResponder {
801 control_handle: std::mem::ManuallyDrop::new(control_handle),
802 tx_id: header.tx_id,
803 },
804 })
805 }
806 0x18306690352d9dfa => {
807 header.validate_request_tx_id(fidl::MethodType::OneWay)?;
808 let mut req = fidl::new_empty!(
809 fidl::encoding::EmptyPayload,
810 fidl::encoding::DefaultFuchsiaResourceDialect
811 );
812 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
813 let control_handle =
814 BatterySimulatorControlHandle { inner: this.inner.clone() };
815 Ok(BatterySimulatorRequest::ReconnectRealBattery { control_handle })
816 }
817 0x5462c9e9f947b8ce => {
818 header.validate_request_tx_id(fidl::MethodType::OneWay)?;
819 let mut req = fidl::new_empty!(
820 BatterySimulatorControllerSetPresentVoltageMvRequest,
821 fidl::encoding::DefaultFuchsiaResourceDialect
822 );
823 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BatterySimulatorControllerSetPresentVoltageMvRequest>(&header, _body_bytes, handles, &mut req)?;
824 let control_handle =
825 BatterySimulatorControlHandle { inner: this.inner.clone() };
826 Ok(BatterySimulatorRequest::SetPresentVoltageMv {
827 voltage: req.voltage,
828
829 control_handle,
830 })
831 }
832 0x38054049fe8c26ab => {
833 header.validate_request_tx_id(fidl::MethodType::OneWay)?;
834 let mut req = fidl::new_empty!(
835 BatterySimulatorControllerSetRemainingCapacityUahRequest,
836 fidl::encoding::DefaultFuchsiaResourceDialect
837 );
838 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BatterySimulatorControllerSetRemainingCapacityUahRequest>(&header, _body_bytes, handles, &mut req)?;
839 let control_handle =
840 BatterySimulatorControlHandle { inner: this.inner.clone() };
841 Ok(BatterySimulatorRequest::SetRemainingCapacityUah {
842 capacity: req.capacity,
843
844 control_handle,
845 })
846 }
847 0x7324672546976583 => {
848 header.validate_request_tx_id(fidl::MethodType::OneWay)?;
849 let mut req = fidl::new_empty!(
850 BatterySimulatorControllerSetBatterySpecRequest,
851 fidl::encoding::DefaultFuchsiaResourceDialect
852 );
853 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BatterySimulatorControllerSetBatterySpecRequest>(&header, _body_bytes, handles, &mut req)?;
854 let control_handle =
855 BatterySimulatorControlHandle { inner: this.inner.clone() };
856 Ok(BatterySimulatorRequest::SetBatterySpec {
857 spec: req.spec,
858
859 control_handle,
860 })
861 }
862 _ => Err(fidl::Error::UnknownOrdinal {
863 ordinal: header.ordinal,
864 protocol_name:
865 <BatterySimulatorMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
866 }),
867 }))
868 },
869 )
870 }
871}
872
873#[derive(Debug)]
875pub enum BatterySimulatorRequest {
876 GetBatteryInfo { responder: BatterySimulatorGetBatteryInfoResponder },
879 SetBatteryStatus {
882 battery_status: fidl_fuchsia_power_battery::BatteryStatus,
883 control_handle: BatterySimulatorControlHandle,
884 },
885 SetChargeStatus {
888 charge_status: fidl_fuchsia_power_battery::ChargeStatus,
889 control_handle: BatterySimulatorControlHandle,
890 },
891 SetChargeSource {
894 charge_source: fidl_fuchsia_power_battery::ChargeSource,
895 control_handle: BatterySimulatorControlHandle,
896 },
897 SetBatteryPercentage { percent: f32, control_handle: BatterySimulatorControlHandle },
900 SetLevelStatus {
903 level_status: fidl_fuchsia_power_battery::LevelStatus,
904 control_handle: BatterySimulatorControlHandle,
905 },
906 SetTimeRemaining { duration: i64, control_handle: BatterySimulatorControlHandle },
909 DisconnectRealBattery { control_handle: BatterySimulatorControlHandle },
911 IsSimulating { responder: BatterySimulatorIsSimulatingResponder },
913 ReconnectRealBattery { control_handle: BatterySimulatorControlHandle },
916 SetPresentVoltageMv { voltage: u32, control_handle: BatterySimulatorControlHandle },
919 SetRemainingCapacityUah { capacity: u32, control_handle: BatterySimulatorControlHandle },
922 SetBatterySpec {
924 spec: fidl_fuchsia_power_battery::BatterySpec,
925 control_handle: BatterySimulatorControlHandle,
926 },
927}
928
929impl BatterySimulatorRequest {
930 #[allow(irrefutable_let_patterns)]
931 pub fn into_get_battery_info(self) -> Option<(BatterySimulatorGetBatteryInfoResponder)> {
932 if let BatterySimulatorRequest::GetBatteryInfo { responder } = self {
933 Some((responder))
934 } else {
935 None
936 }
937 }
938
939 #[allow(irrefutable_let_patterns)]
940 pub fn into_set_battery_status(
941 self,
942 ) -> Option<(fidl_fuchsia_power_battery::BatteryStatus, BatterySimulatorControlHandle)> {
943 if let BatterySimulatorRequest::SetBatteryStatus { battery_status, control_handle } = self {
944 Some((battery_status, control_handle))
945 } else {
946 None
947 }
948 }
949
950 #[allow(irrefutable_let_patterns)]
951 pub fn into_set_charge_status(
952 self,
953 ) -> Option<(fidl_fuchsia_power_battery::ChargeStatus, BatterySimulatorControlHandle)> {
954 if let BatterySimulatorRequest::SetChargeStatus { charge_status, control_handle } = self {
955 Some((charge_status, control_handle))
956 } else {
957 None
958 }
959 }
960
961 #[allow(irrefutable_let_patterns)]
962 pub fn into_set_charge_source(
963 self,
964 ) -> Option<(fidl_fuchsia_power_battery::ChargeSource, BatterySimulatorControlHandle)> {
965 if let BatterySimulatorRequest::SetChargeSource { charge_source, control_handle } = self {
966 Some((charge_source, control_handle))
967 } else {
968 None
969 }
970 }
971
972 #[allow(irrefutable_let_patterns)]
973 pub fn into_set_battery_percentage(self) -> Option<(f32, BatterySimulatorControlHandle)> {
974 if let BatterySimulatorRequest::SetBatteryPercentage { percent, control_handle } = self {
975 Some((percent, control_handle))
976 } else {
977 None
978 }
979 }
980
981 #[allow(irrefutable_let_patterns)]
982 pub fn into_set_level_status(
983 self,
984 ) -> Option<(fidl_fuchsia_power_battery::LevelStatus, BatterySimulatorControlHandle)> {
985 if let BatterySimulatorRequest::SetLevelStatus { level_status, control_handle } = self {
986 Some((level_status, control_handle))
987 } else {
988 None
989 }
990 }
991
992 #[allow(irrefutable_let_patterns)]
993 pub fn into_set_time_remaining(self) -> Option<(i64, BatterySimulatorControlHandle)> {
994 if let BatterySimulatorRequest::SetTimeRemaining { duration, control_handle } = self {
995 Some((duration, control_handle))
996 } else {
997 None
998 }
999 }
1000
1001 #[allow(irrefutable_let_patterns)]
1002 pub fn into_disconnect_real_battery(self) -> Option<(BatterySimulatorControlHandle)> {
1003 if let BatterySimulatorRequest::DisconnectRealBattery { control_handle } = self {
1004 Some((control_handle))
1005 } else {
1006 None
1007 }
1008 }
1009
1010 #[allow(irrefutable_let_patterns)]
1011 pub fn into_is_simulating(self) -> Option<(BatterySimulatorIsSimulatingResponder)> {
1012 if let BatterySimulatorRequest::IsSimulating { responder } = self {
1013 Some((responder))
1014 } else {
1015 None
1016 }
1017 }
1018
1019 #[allow(irrefutable_let_patterns)]
1020 pub fn into_reconnect_real_battery(self) -> Option<(BatterySimulatorControlHandle)> {
1021 if let BatterySimulatorRequest::ReconnectRealBattery { control_handle } = self {
1022 Some((control_handle))
1023 } else {
1024 None
1025 }
1026 }
1027
1028 #[allow(irrefutable_let_patterns)]
1029 pub fn into_set_present_voltage_mv(self) -> Option<(u32, BatterySimulatorControlHandle)> {
1030 if let BatterySimulatorRequest::SetPresentVoltageMv { voltage, control_handle } = self {
1031 Some((voltage, control_handle))
1032 } else {
1033 None
1034 }
1035 }
1036
1037 #[allow(irrefutable_let_patterns)]
1038 pub fn into_set_remaining_capacity_uah(self) -> Option<(u32, BatterySimulatorControlHandle)> {
1039 if let BatterySimulatorRequest::SetRemainingCapacityUah { capacity, control_handle } = self
1040 {
1041 Some((capacity, control_handle))
1042 } else {
1043 None
1044 }
1045 }
1046
1047 #[allow(irrefutable_let_patterns)]
1048 pub fn into_set_battery_spec(
1049 self,
1050 ) -> Option<(fidl_fuchsia_power_battery::BatterySpec, BatterySimulatorControlHandle)> {
1051 if let BatterySimulatorRequest::SetBatterySpec { spec, control_handle } = self {
1052 Some((spec, control_handle))
1053 } else {
1054 None
1055 }
1056 }
1057
1058 pub fn method_name(&self) -> &'static str {
1060 match *self {
1061 BatterySimulatorRequest::GetBatteryInfo { .. } => "get_battery_info",
1062 BatterySimulatorRequest::SetBatteryStatus { .. } => "set_battery_status",
1063 BatterySimulatorRequest::SetChargeStatus { .. } => "set_charge_status",
1064 BatterySimulatorRequest::SetChargeSource { .. } => "set_charge_source",
1065 BatterySimulatorRequest::SetBatteryPercentage { .. } => "set_battery_percentage",
1066 BatterySimulatorRequest::SetLevelStatus { .. } => "set_level_status",
1067 BatterySimulatorRequest::SetTimeRemaining { .. } => "set_time_remaining",
1068 BatterySimulatorRequest::DisconnectRealBattery { .. } => "disconnect_real_battery",
1069 BatterySimulatorRequest::IsSimulating { .. } => "is_simulating",
1070 BatterySimulatorRequest::ReconnectRealBattery { .. } => "reconnect_real_battery",
1071 BatterySimulatorRequest::SetPresentVoltageMv { .. } => "set_present_voltage_mv",
1072 BatterySimulatorRequest::SetRemainingCapacityUah { .. } => "set_remaining_capacity_uah",
1073 BatterySimulatorRequest::SetBatterySpec { .. } => "set_battery_spec",
1074 }
1075 }
1076}
1077
1078#[derive(Debug, Clone)]
1079pub struct BatterySimulatorControlHandle {
1080 inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
1081}
1082
1083impl fidl::endpoints::ControlHandle for BatterySimulatorControlHandle {
1084 fn shutdown(&self) {
1085 self.inner.shutdown()
1086 }
1087 fn shutdown_with_epitaph(&self, status: zx_status::Status) {
1088 self.inner.shutdown_with_epitaph(status)
1089 }
1090
1091 fn is_closed(&self) -> bool {
1092 self.inner.channel().is_closed()
1093 }
1094 fn on_closed(&self) -> fidl::OnSignalsRef<'_> {
1095 self.inner.channel().on_closed()
1096 }
1097
1098 #[cfg(target_os = "fuchsia")]
1099 fn signal_peer(
1100 &self,
1101 clear_mask: zx::Signals,
1102 set_mask: zx::Signals,
1103 ) -> Result<(), zx_status::Status> {
1104 use fidl::Peered;
1105 self.inner.channel().signal_peer(clear_mask, set_mask)
1106 }
1107}
1108
1109impl BatterySimulatorControlHandle {}
1110
1111#[must_use = "FIDL methods require a response to be sent"]
1112#[derive(Debug)]
1113pub struct BatterySimulatorGetBatteryInfoResponder {
1114 control_handle: std::mem::ManuallyDrop<BatterySimulatorControlHandle>,
1115 tx_id: u32,
1116}
1117
1118impl std::ops::Drop for BatterySimulatorGetBatteryInfoResponder {
1122 fn drop(&mut self) {
1123 self.control_handle.shutdown();
1124 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
1126 }
1127}
1128
1129impl fidl::endpoints::Responder for BatterySimulatorGetBatteryInfoResponder {
1130 type ControlHandle = BatterySimulatorControlHandle;
1131
1132 fn control_handle(&self) -> &BatterySimulatorControlHandle {
1133 &self.control_handle
1134 }
1135
1136 fn drop_without_shutdown(mut self) {
1137 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
1139 std::mem::forget(self);
1141 }
1142}
1143
1144impl BatterySimulatorGetBatteryInfoResponder {
1145 pub fn send(
1149 self,
1150 mut info: &fidl_fuchsia_power_battery::BatteryInfo,
1151 ) -> Result<(), fidl::Error> {
1152 let _result = self.send_raw(info);
1153 if _result.is_err() {
1154 self.control_handle.shutdown();
1155 }
1156 self.drop_without_shutdown();
1157 _result
1158 }
1159
1160 pub fn send_no_shutdown_on_err(
1162 self,
1163 mut info: &fidl_fuchsia_power_battery::BatteryInfo,
1164 ) -> Result<(), fidl::Error> {
1165 let _result = self.send_raw(info);
1166 self.drop_without_shutdown();
1167 _result
1168 }
1169
1170 fn send_raw(
1171 &self,
1172 mut info: &fidl_fuchsia_power_battery::BatteryInfo,
1173 ) -> Result<(), fidl::Error> {
1174 self.control_handle.inner.send::<BatterySimulatorControllerGetBatteryInfoResponse>(
1175 (info,),
1176 self.tx_id,
1177 0x4a20d3731366aaf8,
1178 fidl::encoding::DynamicFlags::empty(),
1179 )
1180 }
1181}
1182
1183#[must_use = "FIDL methods require a response to be sent"]
1184#[derive(Debug)]
1185pub struct BatterySimulatorIsSimulatingResponder {
1186 control_handle: std::mem::ManuallyDrop<BatterySimulatorControlHandle>,
1187 tx_id: u32,
1188}
1189
1190impl std::ops::Drop for BatterySimulatorIsSimulatingResponder {
1194 fn drop(&mut self) {
1195 self.control_handle.shutdown();
1196 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
1198 }
1199}
1200
1201impl fidl::endpoints::Responder for BatterySimulatorIsSimulatingResponder {
1202 type ControlHandle = BatterySimulatorControlHandle;
1203
1204 fn control_handle(&self) -> &BatterySimulatorControlHandle {
1205 &self.control_handle
1206 }
1207
1208 fn drop_without_shutdown(mut self) {
1209 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
1211 std::mem::forget(self);
1213 }
1214}
1215
1216impl BatterySimulatorIsSimulatingResponder {
1217 pub fn send(self, mut simulation_state: bool) -> Result<(), fidl::Error> {
1221 let _result = self.send_raw(simulation_state);
1222 if _result.is_err() {
1223 self.control_handle.shutdown();
1224 }
1225 self.drop_without_shutdown();
1226 _result
1227 }
1228
1229 pub fn send_no_shutdown_on_err(self, mut simulation_state: bool) -> Result<(), fidl::Error> {
1231 let _result = self.send_raw(simulation_state);
1232 self.drop_without_shutdown();
1233 _result
1234 }
1235
1236 fn send_raw(&self, mut simulation_state: bool) -> Result<(), fidl::Error> {
1237 self.control_handle.inner.send::<BatterySimulatorControllerIsSimulatingResponse>(
1238 (simulation_state,),
1239 self.tx_id,
1240 0x4bf85cfe3476975d,
1241 fidl::encoding::DynamicFlags::empty(),
1242 )
1243 }
1244}
1245
1246#[derive(Debug, Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Hash)]
1247pub struct BatterySimulatorControllerMarker;
1248
1249impl fidl::endpoints::ProtocolMarker for BatterySimulatorControllerMarker {
1250 type Proxy = BatterySimulatorControllerProxy;
1251 type RequestStream = BatterySimulatorControllerRequestStream;
1252 #[cfg(target_os = "fuchsia")]
1253 type SynchronousProxy = BatterySimulatorControllerSynchronousProxy;
1254
1255 const DEBUG_NAME: &'static str = "(anonymous) BatterySimulatorController";
1256}
1257
1258pub trait BatterySimulatorControllerProxyInterface: Send + Sync {
1259 type GetBatteryInfoResponseFut: std::future::Future<Output = Result<fidl_fuchsia_power_battery::BatteryInfo, fidl::Error>>
1260 + Send;
1261 fn r#get_battery_info(&self) -> Self::GetBatteryInfoResponseFut;
1262 fn r#set_battery_status(
1263 &self,
1264 battery_status: fidl_fuchsia_power_battery::BatteryStatus,
1265 ) -> Result<(), fidl::Error>;
1266 fn r#set_charge_status(
1267 &self,
1268 charge_status: fidl_fuchsia_power_battery::ChargeStatus,
1269 ) -> Result<(), fidl::Error>;
1270 fn r#set_charge_source(
1271 &self,
1272 charge_source: fidl_fuchsia_power_battery::ChargeSource,
1273 ) -> Result<(), fidl::Error>;
1274 fn r#set_battery_percentage(&self, percent: f32) -> Result<(), fidl::Error>;
1275 fn r#set_level_status(
1276 &self,
1277 level_status: fidl_fuchsia_power_battery::LevelStatus,
1278 ) -> Result<(), fidl::Error>;
1279 fn r#set_time_remaining(&self, duration: i64) -> Result<(), fidl::Error>;
1280 fn r#disconnect_real_battery(&self) -> Result<(), fidl::Error>;
1281 type IsSimulatingResponseFut: std::future::Future<Output = Result<bool, fidl::Error>> + Send;
1282 fn r#is_simulating(&self) -> Self::IsSimulatingResponseFut;
1283 fn r#reconnect_real_battery(&self) -> Result<(), fidl::Error>;
1284 fn r#set_present_voltage_mv(&self, voltage: u32) -> Result<(), fidl::Error>;
1285 fn r#set_remaining_capacity_uah(&self, capacity: u32) -> Result<(), fidl::Error>;
1286 fn r#set_battery_spec(
1287 &self,
1288 spec: &fidl_fuchsia_power_battery::BatterySpec,
1289 ) -> Result<(), fidl::Error>;
1290}
1291#[derive(Debug)]
1292#[cfg(target_os = "fuchsia")]
1293pub struct BatterySimulatorControllerSynchronousProxy {
1294 client: fidl::client::sync::Client,
1295}
1296
1297#[cfg(target_os = "fuchsia")]
1298impl fidl::endpoints::SynchronousProxy for BatterySimulatorControllerSynchronousProxy {
1299 type Proxy = BatterySimulatorControllerProxy;
1300 type Protocol = BatterySimulatorControllerMarker;
1301
1302 fn from_channel(inner: fidl::Channel) -> Self {
1303 Self::new(inner)
1304 }
1305
1306 fn into_channel(self) -> fidl::Channel {
1307 self.client.into_channel()
1308 }
1309
1310 fn as_channel(&self) -> &fidl::Channel {
1311 self.client.as_channel()
1312 }
1313}
1314
1315#[cfg(target_os = "fuchsia")]
1316impl BatterySimulatorControllerSynchronousProxy {
1317 pub fn new(channel: fidl::Channel) -> Self {
1318 let protocol_name =
1319 <BatterySimulatorControllerMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME;
1320 Self { client: fidl::client::sync::Client::new(channel, protocol_name) }
1321 }
1322
1323 pub fn into_channel(self) -> fidl::Channel {
1324 self.client.into_channel()
1325 }
1326
1327 pub fn wait_for_event(
1330 &self,
1331 deadline: zx::MonotonicInstant,
1332 ) -> Result<BatterySimulatorControllerEvent, fidl::Error> {
1333 BatterySimulatorControllerEvent::decode(self.client.wait_for_event(deadline)?)
1334 }
1335
1336 pub fn r#get_battery_info(
1339 &self,
1340 ___deadline: zx::MonotonicInstant,
1341 ) -> Result<fidl_fuchsia_power_battery::BatteryInfo, fidl::Error> {
1342 let _response = self.client.send_query::<
1343 fidl::encoding::EmptyPayload,
1344 BatterySimulatorControllerGetBatteryInfoResponse,
1345 >(
1346 (),
1347 0x4a20d3731366aaf8,
1348 fidl::encoding::DynamicFlags::empty(),
1349 ___deadline,
1350 )?;
1351 Ok(_response.info)
1352 }
1353
1354 pub fn r#set_battery_status(
1357 &self,
1358 mut battery_status: fidl_fuchsia_power_battery::BatteryStatus,
1359 ) -> Result<(), fidl::Error> {
1360 self.client.send::<BatterySimulatorControllerSetBatteryStatusRequest>(
1361 (battery_status,),
1362 0x2343eb65038c8b34,
1363 fidl::encoding::DynamicFlags::empty(),
1364 )
1365 }
1366
1367 pub fn r#set_charge_status(
1370 &self,
1371 mut charge_status: fidl_fuchsia_power_battery::ChargeStatus,
1372 ) -> Result<(), fidl::Error> {
1373 self.client.send::<BatterySimulatorControllerSetChargeStatusRequest>(
1374 (charge_status,),
1375 0x79b2bf1a387acd85,
1376 fidl::encoding::DynamicFlags::empty(),
1377 )
1378 }
1379
1380 pub fn r#set_charge_source(
1383 &self,
1384 mut charge_source: fidl_fuchsia_power_battery::ChargeSource,
1385 ) -> Result<(), fidl::Error> {
1386 self.client.send::<BatterySimulatorControllerSetChargeSourceRequest>(
1387 (charge_source,),
1388 0xb40433f42c33527,
1389 fidl::encoding::DynamicFlags::empty(),
1390 )
1391 }
1392
1393 pub fn r#set_battery_percentage(&self, mut percent: f32) -> Result<(), fidl::Error> {
1396 self.client.send::<BatterySimulatorControllerSetBatteryPercentageRequest>(
1397 (percent,),
1398 0x64a9d96eb7a45a9f,
1399 fidl::encoding::DynamicFlags::empty(),
1400 )
1401 }
1402
1403 pub fn r#set_level_status(
1406 &self,
1407 mut level_status: fidl_fuchsia_power_battery::LevelStatus,
1408 ) -> Result<(), fidl::Error> {
1409 self.client.send::<BatterySimulatorControllerSetLevelStatusRequest>(
1410 (level_status,),
1411 0x577fc3314f7a48a4,
1412 fidl::encoding::DynamicFlags::empty(),
1413 )
1414 }
1415
1416 pub fn r#set_time_remaining(&self, mut duration: i64) -> Result<(), fidl::Error> {
1419 self.client.send::<BatterySimulatorControllerSetTimeRemainingRequest>(
1420 (duration,),
1421 0x7427251c9d2a794e,
1422 fidl::encoding::DynamicFlags::empty(),
1423 )
1424 }
1425
1426 pub fn r#disconnect_real_battery(&self) -> Result<(), fidl::Error> {
1428 self.client.send::<fidl::encoding::EmptyPayload>(
1429 (),
1430 0x75588eae6b9b67e3,
1431 fidl::encoding::DynamicFlags::empty(),
1432 )
1433 }
1434
1435 pub fn r#is_simulating(&self, ___deadline: zx::MonotonicInstant) -> Result<bool, fidl::Error> {
1437 let _response = self.client.send_query::<
1438 fidl::encoding::EmptyPayload,
1439 BatterySimulatorControllerIsSimulatingResponse,
1440 >(
1441 (),
1442 0x4bf85cfe3476975d,
1443 fidl::encoding::DynamicFlags::empty(),
1444 ___deadline,
1445 )?;
1446 Ok(_response.simulation_state)
1447 }
1448
1449 pub fn r#reconnect_real_battery(&self) -> Result<(), fidl::Error> {
1452 self.client.send::<fidl::encoding::EmptyPayload>(
1453 (),
1454 0x18306690352d9dfa,
1455 fidl::encoding::DynamicFlags::empty(),
1456 )
1457 }
1458
1459 pub fn r#set_present_voltage_mv(&self, mut voltage: u32) -> Result<(), fidl::Error> {
1462 self.client.send::<BatterySimulatorControllerSetPresentVoltageMvRequest>(
1463 (voltage,),
1464 0x5462c9e9f947b8ce,
1465 fidl::encoding::DynamicFlags::empty(),
1466 )
1467 }
1468
1469 pub fn r#set_remaining_capacity_uah(&self, mut capacity: u32) -> Result<(), fidl::Error> {
1472 self.client.send::<BatterySimulatorControllerSetRemainingCapacityUahRequest>(
1473 (capacity,),
1474 0x38054049fe8c26ab,
1475 fidl::encoding::DynamicFlags::empty(),
1476 )
1477 }
1478
1479 pub fn r#set_battery_spec(
1481 &self,
1482 mut spec: &fidl_fuchsia_power_battery::BatterySpec,
1483 ) -> Result<(), fidl::Error> {
1484 self.client.send::<BatterySimulatorControllerSetBatterySpecRequest>(
1485 (spec,),
1486 0x7324672546976583,
1487 fidl::encoding::DynamicFlags::empty(),
1488 )
1489 }
1490}
1491
1492#[derive(Debug, Clone)]
1493pub struct BatterySimulatorControllerProxy {
1494 client: fidl::client::Client<fidl::encoding::DefaultFuchsiaResourceDialect>,
1495}
1496
1497impl fidl::endpoints::Proxy for BatterySimulatorControllerProxy {
1498 type Protocol = BatterySimulatorControllerMarker;
1499
1500 fn from_channel(inner: ::fidl::AsyncChannel) -> Self {
1501 Self::new(inner)
1502 }
1503
1504 fn into_channel(self) -> Result<::fidl::AsyncChannel, Self> {
1505 self.client.into_channel().map_err(|client| Self { client })
1506 }
1507
1508 fn as_channel(&self) -> &::fidl::AsyncChannel {
1509 self.client.as_channel()
1510 }
1511}
1512
1513impl BatterySimulatorControllerProxy {
1514 pub fn new(channel: ::fidl::AsyncChannel) -> Self {
1516 let protocol_name =
1517 <BatterySimulatorControllerMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME;
1518 Self { client: fidl::client::Client::new(channel, protocol_name) }
1519 }
1520
1521 pub fn take_event_stream(&self) -> BatterySimulatorControllerEventStream {
1527 BatterySimulatorControllerEventStream { event_receiver: self.client.take_event_receiver() }
1528 }
1529
1530 pub fn r#get_battery_info(
1533 &self,
1534 ) -> fidl::client::QueryResponseFut<
1535 fidl_fuchsia_power_battery::BatteryInfo,
1536 fidl::encoding::DefaultFuchsiaResourceDialect,
1537 > {
1538 BatterySimulatorControllerProxyInterface::r#get_battery_info(self)
1539 }
1540
1541 pub fn r#set_battery_status(
1544 &self,
1545 mut battery_status: fidl_fuchsia_power_battery::BatteryStatus,
1546 ) -> Result<(), fidl::Error> {
1547 BatterySimulatorControllerProxyInterface::r#set_battery_status(self, battery_status)
1548 }
1549
1550 pub fn r#set_charge_status(
1553 &self,
1554 mut charge_status: fidl_fuchsia_power_battery::ChargeStatus,
1555 ) -> Result<(), fidl::Error> {
1556 BatterySimulatorControllerProxyInterface::r#set_charge_status(self, charge_status)
1557 }
1558
1559 pub fn r#set_charge_source(
1562 &self,
1563 mut charge_source: fidl_fuchsia_power_battery::ChargeSource,
1564 ) -> Result<(), fidl::Error> {
1565 BatterySimulatorControllerProxyInterface::r#set_charge_source(self, charge_source)
1566 }
1567
1568 pub fn r#set_battery_percentage(&self, mut percent: f32) -> Result<(), fidl::Error> {
1571 BatterySimulatorControllerProxyInterface::r#set_battery_percentage(self, percent)
1572 }
1573
1574 pub fn r#set_level_status(
1577 &self,
1578 mut level_status: fidl_fuchsia_power_battery::LevelStatus,
1579 ) -> Result<(), fidl::Error> {
1580 BatterySimulatorControllerProxyInterface::r#set_level_status(self, level_status)
1581 }
1582
1583 pub fn r#set_time_remaining(&self, mut duration: i64) -> Result<(), fidl::Error> {
1586 BatterySimulatorControllerProxyInterface::r#set_time_remaining(self, duration)
1587 }
1588
1589 pub fn r#disconnect_real_battery(&self) -> Result<(), fidl::Error> {
1591 BatterySimulatorControllerProxyInterface::r#disconnect_real_battery(self)
1592 }
1593
1594 pub fn r#is_simulating(
1596 &self,
1597 ) -> fidl::client::QueryResponseFut<bool, fidl::encoding::DefaultFuchsiaResourceDialect> {
1598 BatterySimulatorControllerProxyInterface::r#is_simulating(self)
1599 }
1600
1601 pub fn r#reconnect_real_battery(&self) -> Result<(), fidl::Error> {
1604 BatterySimulatorControllerProxyInterface::r#reconnect_real_battery(self)
1605 }
1606
1607 pub fn r#set_present_voltage_mv(&self, mut voltage: u32) -> Result<(), fidl::Error> {
1610 BatterySimulatorControllerProxyInterface::r#set_present_voltage_mv(self, voltage)
1611 }
1612
1613 pub fn r#set_remaining_capacity_uah(&self, mut capacity: u32) -> Result<(), fidl::Error> {
1616 BatterySimulatorControllerProxyInterface::r#set_remaining_capacity_uah(self, capacity)
1617 }
1618
1619 pub fn r#set_battery_spec(
1621 &self,
1622 mut spec: &fidl_fuchsia_power_battery::BatterySpec,
1623 ) -> Result<(), fidl::Error> {
1624 BatterySimulatorControllerProxyInterface::r#set_battery_spec(self, spec)
1625 }
1626}
1627
1628impl BatterySimulatorControllerProxyInterface for BatterySimulatorControllerProxy {
1629 type GetBatteryInfoResponseFut = fidl::client::QueryResponseFut<
1630 fidl_fuchsia_power_battery::BatteryInfo,
1631 fidl::encoding::DefaultFuchsiaResourceDialect,
1632 >;
1633 fn r#get_battery_info(&self) -> Self::GetBatteryInfoResponseFut {
1634 fn _decode(
1635 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
1636 ) -> Result<fidl_fuchsia_power_battery::BatteryInfo, fidl::Error> {
1637 let _response = fidl::client::decode_transaction_body::<
1638 BatterySimulatorControllerGetBatteryInfoResponse,
1639 fidl::encoding::DefaultFuchsiaResourceDialect,
1640 0x4a20d3731366aaf8,
1641 >(_buf?)?;
1642 Ok(_response.info)
1643 }
1644 self.client.send_query_and_decode::<
1645 fidl::encoding::EmptyPayload,
1646 fidl_fuchsia_power_battery::BatteryInfo,
1647 >(
1648 (),
1649 0x4a20d3731366aaf8,
1650 fidl::encoding::DynamicFlags::empty(),
1651 _decode,
1652 )
1653 }
1654
1655 fn r#set_battery_status(
1656 &self,
1657 mut battery_status: fidl_fuchsia_power_battery::BatteryStatus,
1658 ) -> Result<(), fidl::Error> {
1659 self.client.send::<BatterySimulatorControllerSetBatteryStatusRequest>(
1660 (battery_status,),
1661 0x2343eb65038c8b34,
1662 fidl::encoding::DynamicFlags::empty(),
1663 )
1664 }
1665
1666 fn r#set_charge_status(
1667 &self,
1668 mut charge_status: fidl_fuchsia_power_battery::ChargeStatus,
1669 ) -> Result<(), fidl::Error> {
1670 self.client.send::<BatterySimulatorControllerSetChargeStatusRequest>(
1671 (charge_status,),
1672 0x79b2bf1a387acd85,
1673 fidl::encoding::DynamicFlags::empty(),
1674 )
1675 }
1676
1677 fn r#set_charge_source(
1678 &self,
1679 mut charge_source: fidl_fuchsia_power_battery::ChargeSource,
1680 ) -> Result<(), fidl::Error> {
1681 self.client.send::<BatterySimulatorControllerSetChargeSourceRequest>(
1682 (charge_source,),
1683 0xb40433f42c33527,
1684 fidl::encoding::DynamicFlags::empty(),
1685 )
1686 }
1687
1688 fn r#set_battery_percentage(&self, mut percent: f32) -> Result<(), fidl::Error> {
1689 self.client.send::<BatterySimulatorControllerSetBatteryPercentageRequest>(
1690 (percent,),
1691 0x64a9d96eb7a45a9f,
1692 fidl::encoding::DynamicFlags::empty(),
1693 )
1694 }
1695
1696 fn r#set_level_status(
1697 &self,
1698 mut level_status: fidl_fuchsia_power_battery::LevelStatus,
1699 ) -> Result<(), fidl::Error> {
1700 self.client.send::<BatterySimulatorControllerSetLevelStatusRequest>(
1701 (level_status,),
1702 0x577fc3314f7a48a4,
1703 fidl::encoding::DynamicFlags::empty(),
1704 )
1705 }
1706
1707 fn r#set_time_remaining(&self, mut duration: i64) -> Result<(), fidl::Error> {
1708 self.client.send::<BatterySimulatorControllerSetTimeRemainingRequest>(
1709 (duration,),
1710 0x7427251c9d2a794e,
1711 fidl::encoding::DynamicFlags::empty(),
1712 )
1713 }
1714
1715 fn r#disconnect_real_battery(&self) -> Result<(), fidl::Error> {
1716 self.client.send::<fidl::encoding::EmptyPayload>(
1717 (),
1718 0x75588eae6b9b67e3,
1719 fidl::encoding::DynamicFlags::empty(),
1720 )
1721 }
1722
1723 type IsSimulatingResponseFut =
1724 fidl::client::QueryResponseFut<bool, fidl::encoding::DefaultFuchsiaResourceDialect>;
1725 fn r#is_simulating(&self) -> Self::IsSimulatingResponseFut {
1726 fn _decode(
1727 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
1728 ) -> Result<bool, fidl::Error> {
1729 let _response = fidl::client::decode_transaction_body::<
1730 BatterySimulatorControllerIsSimulatingResponse,
1731 fidl::encoding::DefaultFuchsiaResourceDialect,
1732 0x4bf85cfe3476975d,
1733 >(_buf?)?;
1734 Ok(_response.simulation_state)
1735 }
1736 self.client.send_query_and_decode::<fidl::encoding::EmptyPayload, bool>(
1737 (),
1738 0x4bf85cfe3476975d,
1739 fidl::encoding::DynamicFlags::empty(),
1740 _decode,
1741 )
1742 }
1743
1744 fn r#reconnect_real_battery(&self) -> Result<(), fidl::Error> {
1745 self.client.send::<fidl::encoding::EmptyPayload>(
1746 (),
1747 0x18306690352d9dfa,
1748 fidl::encoding::DynamicFlags::empty(),
1749 )
1750 }
1751
1752 fn r#set_present_voltage_mv(&self, mut voltage: u32) -> Result<(), fidl::Error> {
1753 self.client.send::<BatterySimulatorControllerSetPresentVoltageMvRequest>(
1754 (voltage,),
1755 0x5462c9e9f947b8ce,
1756 fidl::encoding::DynamicFlags::empty(),
1757 )
1758 }
1759
1760 fn r#set_remaining_capacity_uah(&self, mut capacity: u32) -> Result<(), fidl::Error> {
1761 self.client.send::<BatterySimulatorControllerSetRemainingCapacityUahRequest>(
1762 (capacity,),
1763 0x38054049fe8c26ab,
1764 fidl::encoding::DynamicFlags::empty(),
1765 )
1766 }
1767
1768 fn r#set_battery_spec(
1769 &self,
1770 mut spec: &fidl_fuchsia_power_battery::BatterySpec,
1771 ) -> Result<(), fidl::Error> {
1772 self.client.send::<BatterySimulatorControllerSetBatterySpecRequest>(
1773 (spec,),
1774 0x7324672546976583,
1775 fidl::encoding::DynamicFlags::empty(),
1776 )
1777 }
1778}
1779
1780pub struct BatterySimulatorControllerEventStream {
1781 event_receiver: fidl::client::EventReceiver<fidl::encoding::DefaultFuchsiaResourceDialect>,
1782}
1783
1784impl std::marker::Unpin for BatterySimulatorControllerEventStream {}
1785
1786impl futures::stream::FusedStream for BatterySimulatorControllerEventStream {
1787 fn is_terminated(&self) -> bool {
1788 self.event_receiver.is_terminated()
1789 }
1790}
1791
1792impl futures::Stream for BatterySimulatorControllerEventStream {
1793 type Item = Result<BatterySimulatorControllerEvent, fidl::Error>;
1794
1795 fn poll_next(
1796 mut self: std::pin::Pin<&mut Self>,
1797 cx: &mut std::task::Context<'_>,
1798 ) -> std::task::Poll<Option<Self::Item>> {
1799 match futures::ready!(futures::stream::StreamExt::poll_next_unpin(
1800 &mut self.event_receiver,
1801 cx
1802 )?) {
1803 Some(buf) => std::task::Poll::Ready(Some(BatterySimulatorControllerEvent::decode(buf))),
1804 None => std::task::Poll::Ready(None),
1805 }
1806 }
1807}
1808
1809#[derive(Debug)]
1810pub enum BatterySimulatorControllerEvent {}
1811
1812impl BatterySimulatorControllerEvent {
1813 fn decode(
1815 mut buf: <fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc,
1816 ) -> Result<BatterySimulatorControllerEvent, fidl::Error> {
1817 let (bytes, _handles) = buf.split_mut();
1818 let (tx_header, _body_bytes) = fidl::encoding::decode_transaction_header(bytes)?;
1819 debug_assert_eq!(tx_header.tx_id, 0);
1820 match tx_header.ordinal {
1821 _ => Err(fidl::Error::UnknownOrdinal {
1822 ordinal: tx_header.ordinal,
1823 protocol_name: <BatterySimulatorControllerMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
1824 })
1825 }
1826 }
1827}
1828
1829pub struct BatterySimulatorControllerRequestStream {
1831 inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
1832 is_terminated: bool,
1833}
1834
1835impl std::marker::Unpin for BatterySimulatorControllerRequestStream {}
1836
1837impl futures::stream::FusedStream for BatterySimulatorControllerRequestStream {
1838 fn is_terminated(&self) -> bool {
1839 self.is_terminated
1840 }
1841}
1842
1843impl fidl::endpoints::RequestStream for BatterySimulatorControllerRequestStream {
1844 type Protocol = BatterySimulatorControllerMarker;
1845 type ControlHandle = BatterySimulatorControllerControlHandle;
1846
1847 fn from_channel(channel: ::fidl::AsyncChannel) -> Self {
1848 Self { inner: std::sync::Arc::new(fidl::ServeInner::new(channel)), is_terminated: false }
1849 }
1850
1851 fn control_handle(&self) -> Self::ControlHandle {
1852 BatterySimulatorControllerControlHandle { inner: self.inner.clone() }
1853 }
1854
1855 fn into_inner(
1856 self,
1857 ) -> (::std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>, bool)
1858 {
1859 (self.inner, self.is_terminated)
1860 }
1861
1862 fn from_inner(
1863 inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
1864 is_terminated: bool,
1865 ) -> Self {
1866 Self { inner, is_terminated }
1867 }
1868}
1869
1870impl futures::Stream for BatterySimulatorControllerRequestStream {
1871 type Item = Result<BatterySimulatorControllerRequest, fidl::Error>;
1872
1873 fn poll_next(
1874 mut self: std::pin::Pin<&mut Self>,
1875 cx: &mut std::task::Context<'_>,
1876 ) -> std::task::Poll<Option<Self::Item>> {
1877 let this = &mut *self;
1878 if this.inner.check_shutdown(cx) {
1879 this.is_terminated = true;
1880 return std::task::Poll::Ready(None);
1881 }
1882 if this.is_terminated {
1883 panic!("polled BatterySimulatorControllerRequestStream after completion");
1884 }
1885 fidl::encoding::with_tls_decode_buf::<_, fidl::encoding::DefaultFuchsiaResourceDialect>(
1886 |bytes, handles| {
1887 match this.inner.channel().read_etc(cx, bytes, handles) {
1888 std::task::Poll::Ready(Ok(())) => {}
1889 std::task::Poll::Pending => return std::task::Poll::Pending,
1890 std::task::Poll::Ready(Err(zx_status::Status::PEER_CLOSED)) => {
1891 this.is_terminated = true;
1892 return std::task::Poll::Ready(None);
1893 }
1894 std::task::Poll::Ready(Err(e)) => {
1895 return std::task::Poll::Ready(Some(Err(fidl::Error::ServerRequestRead(
1896 e.into(),
1897 ))))
1898 }
1899 }
1900
1901 let (header, _body_bytes) = fidl::encoding::decode_transaction_header(bytes)?;
1903
1904 std::task::Poll::Ready(Some(match header.ordinal {
1905 0x4a20d3731366aaf8 => {
1906 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
1907 let mut req = fidl::new_empty!(fidl::encoding::EmptyPayload, fidl::encoding::DefaultFuchsiaResourceDialect);
1908 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
1909 let control_handle = BatterySimulatorControllerControlHandle {
1910 inner: this.inner.clone(),
1911 };
1912 Ok(BatterySimulatorControllerRequest::GetBatteryInfo {
1913 responder: BatterySimulatorControllerGetBatteryInfoResponder {
1914 control_handle: std::mem::ManuallyDrop::new(control_handle),
1915 tx_id: header.tx_id,
1916 },
1917 })
1918 }
1919 0x2343eb65038c8b34 => {
1920 header.validate_request_tx_id(fidl::MethodType::OneWay)?;
1921 let mut req = fidl::new_empty!(BatterySimulatorControllerSetBatteryStatusRequest, fidl::encoding::DefaultFuchsiaResourceDialect);
1922 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BatterySimulatorControllerSetBatteryStatusRequest>(&header, _body_bytes, handles, &mut req)?;
1923 let control_handle = BatterySimulatorControllerControlHandle {
1924 inner: this.inner.clone(),
1925 };
1926 Ok(BatterySimulatorControllerRequest::SetBatteryStatus {battery_status: req.battery_status,
1927
1928 control_handle,
1929 })
1930 }
1931 0x79b2bf1a387acd85 => {
1932 header.validate_request_tx_id(fidl::MethodType::OneWay)?;
1933 let mut req = fidl::new_empty!(BatterySimulatorControllerSetChargeStatusRequest, fidl::encoding::DefaultFuchsiaResourceDialect);
1934 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BatterySimulatorControllerSetChargeStatusRequest>(&header, _body_bytes, handles, &mut req)?;
1935 let control_handle = BatterySimulatorControllerControlHandle {
1936 inner: this.inner.clone(),
1937 };
1938 Ok(BatterySimulatorControllerRequest::SetChargeStatus {charge_status: req.charge_status,
1939
1940 control_handle,
1941 })
1942 }
1943 0xb40433f42c33527 => {
1944 header.validate_request_tx_id(fidl::MethodType::OneWay)?;
1945 let mut req = fidl::new_empty!(BatterySimulatorControllerSetChargeSourceRequest, fidl::encoding::DefaultFuchsiaResourceDialect);
1946 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BatterySimulatorControllerSetChargeSourceRequest>(&header, _body_bytes, handles, &mut req)?;
1947 let control_handle = BatterySimulatorControllerControlHandle {
1948 inner: this.inner.clone(),
1949 };
1950 Ok(BatterySimulatorControllerRequest::SetChargeSource {charge_source: req.charge_source,
1951
1952 control_handle,
1953 })
1954 }
1955 0x64a9d96eb7a45a9f => {
1956 header.validate_request_tx_id(fidl::MethodType::OneWay)?;
1957 let mut req = fidl::new_empty!(BatterySimulatorControllerSetBatteryPercentageRequest, fidl::encoding::DefaultFuchsiaResourceDialect);
1958 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BatterySimulatorControllerSetBatteryPercentageRequest>(&header, _body_bytes, handles, &mut req)?;
1959 let control_handle = BatterySimulatorControllerControlHandle {
1960 inner: this.inner.clone(),
1961 };
1962 Ok(BatterySimulatorControllerRequest::SetBatteryPercentage {percent: req.percent,
1963
1964 control_handle,
1965 })
1966 }
1967 0x577fc3314f7a48a4 => {
1968 header.validate_request_tx_id(fidl::MethodType::OneWay)?;
1969 let mut req = fidl::new_empty!(BatterySimulatorControllerSetLevelStatusRequest, fidl::encoding::DefaultFuchsiaResourceDialect);
1970 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BatterySimulatorControllerSetLevelStatusRequest>(&header, _body_bytes, handles, &mut req)?;
1971 let control_handle = BatterySimulatorControllerControlHandle {
1972 inner: this.inner.clone(),
1973 };
1974 Ok(BatterySimulatorControllerRequest::SetLevelStatus {level_status: req.level_status,
1975
1976 control_handle,
1977 })
1978 }
1979 0x7427251c9d2a794e => {
1980 header.validate_request_tx_id(fidl::MethodType::OneWay)?;
1981 let mut req = fidl::new_empty!(BatterySimulatorControllerSetTimeRemainingRequest, fidl::encoding::DefaultFuchsiaResourceDialect);
1982 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BatterySimulatorControllerSetTimeRemainingRequest>(&header, _body_bytes, handles, &mut req)?;
1983 let control_handle = BatterySimulatorControllerControlHandle {
1984 inner: this.inner.clone(),
1985 };
1986 Ok(BatterySimulatorControllerRequest::SetTimeRemaining {duration: req.duration,
1987
1988 control_handle,
1989 })
1990 }
1991 0x75588eae6b9b67e3 => {
1992 header.validate_request_tx_id(fidl::MethodType::OneWay)?;
1993 let mut req = fidl::new_empty!(fidl::encoding::EmptyPayload, fidl::encoding::DefaultFuchsiaResourceDialect);
1994 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
1995 let control_handle = BatterySimulatorControllerControlHandle {
1996 inner: this.inner.clone(),
1997 };
1998 Ok(BatterySimulatorControllerRequest::DisconnectRealBattery {
1999 control_handle,
2000 })
2001 }
2002 0x4bf85cfe3476975d => {
2003 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
2004 let mut req = fidl::new_empty!(fidl::encoding::EmptyPayload, fidl::encoding::DefaultFuchsiaResourceDialect);
2005 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
2006 let control_handle = BatterySimulatorControllerControlHandle {
2007 inner: this.inner.clone(),
2008 };
2009 Ok(BatterySimulatorControllerRequest::IsSimulating {
2010 responder: BatterySimulatorControllerIsSimulatingResponder {
2011 control_handle: std::mem::ManuallyDrop::new(control_handle),
2012 tx_id: header.tx_id,
2013 },
2014 })
2015 }
2016 0x18306690352d9dfa => {
2017 header.validate_request_tx_id(fidl::MethodType::OneWay)?;
2018 let mut req = fidl::new_empty!(fidl::encoding::EmptyPayload, fidl::encoding::DefaultFuchsiaResourceDialect);
2019 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
2020 let control_handle = BatterySimulatorControllerControlHandle {
2021 inner: this.inner.clone(),
2022 };
2023 Ok(BatterySimulatorControllerRequest::ReconnectRealBattery {
2024 control_handle,
2025 })
2026 }
2027 0x5462c9e9f947b8ce => {
2028 header.validate_request_tx_id(fidl::MethodType::OneWay)?;
2029 let mut req = fidl::new_empty!(BatterySimulatorControllerSetPresentVoltageMvRequest, fidl::encoding::DefaultFuchsiaResourceDialect);
2030 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BatterySimulatorControllerSetPresentVoltageMvRequest>(&header, _body_bytes, handles, &mut req)?;
2031 let control_handle = BatterySimulatorControllerControlHandle {
2032 inner: this.inner.clone(),
2033 };
2034 Ok(BatterySimulatorControllerRequest::SetPresentVoltageMv {voltage: req.voltage,
2035
2036 control_handle,
2037 })
2038 }
2039 0x38054049fe8c26ab => {
2040 header.validate_request_tx_id(fidl::MethodType::OneWay)?;
2041 let mut req = fidl::new_empty!(BatterySimulatorControllerSetRemainingCapacityUahRequest, fidl::encoding::DefaultFuchsiaResourceDialect);
2042 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BatterySimulatorControllerSetRemainingCapacityUahRequest>(&header, _body_bytes, handles, &mut req)?;
2043 let control_handle = BatterySimulatorControllerControlHandle {
2044 inner: this.inner.clone(),
2045 };
2046 Ok(BatterySimulatorControllerRequest::SetRemainingCapacityUah {capacity: req.capacity,
2047
2048 control_handle,
2049 })
2050 }
2051 0x7324672546976583 => {
2052 header.validate_request_tx_id(fidl::MethodType::OneWay)?;
2053 let mut req = fidl::new_empty!(BatterySimulatorControllerSetBatterySpecRequest, fidl::encoding::DefaultFuchsiaResourceDialect);
2054 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BatterySimulatorControllerSetBatterySpecRequest>(&header, _body_bytes, handles, &mut req)?;
2055 let control_handle = BatterySimulatorControllerControlHandle {
2056 inner: this.inner.clone(),
2057 };
2058 Ok(BatterySimulatorControllerRequest::SetBatterySpec {spec: req.spec,
2059
2060 control_handle,
2061 })
2062 }
2063 _ => Err(fidl::Error::UnknownOrdinal {
2064 ordinal: header.ordinal,
2065 protocol_name: <BatterySimulatorControllerMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
2066 }),
2067 }))
2068 },
2069 )
2070 }
2071}
2072
2073#[derive(Debug)]
2075pub enum BatterySimulatorControllerRequest {
2076 GetBatteryInfo { responder: BatterySimulatorControllerGetBatteryInfoResponder },
2079 SetBatteryStatus {
2082 battery_status: fidl_fuchsia_power_battery::BatteryStatus,
2083 control_handle: BatterySimulatorControllerControlHandle,
2084 },
2085 SetChargeStatus {
2088 charge_status: fidl_fuchsia_power_battery::ChargeStatus,
2089 control_handle: BatterySimulatorControllerControlHandle,
2090 },
2091 SetChargeSource {
2094 charge_source: fidl_fuchsia_power_battery::ChargeSource,
2095 control_handle: BatterySimulatorControllerControlHandle,
2096 },
2097 SetBatteryPercentage { percent: f32, control_handle: BatterySimulatorControllerControlHandle },
2100 SetLevelStatus {
2103 level_status: fidl_fuchsia_power_battery::LevelStatus,
2104 control_handle: BatterySimulatorControllerControlHandle,
2105 },
2106 SetTimeRemaining { duration: i64, control_handle: BatterySimulatorControllerControlHandle },
2109 DisconnectRealBattery { control_handle: BatterySimulatorControllerControlHandle },
2111 IsSimulating { responder: BatterySimulatorControllerIsSimulatingResponder },
2113 ReconnectRealBattery { control_handle: BatterySimulatorControllerControlHandle },
2116 SetPresentVoltageMv { voltage: u32, control_handle: BatterySimulatorControllerControlHandle },
2119 SetRemainingCapacityUah {
2122 capacity: u32,
2123 control_handle: BatterySimulatorControllerControlHandle,
2124 },
2125 SetBatterySpec {
2127 spec: fidl_fuchsia_power_battery::BatterySpec,
2128 control_handle: BatterySimulatorControllerControlHandle,
2129 },
2130}
2131
2132impl BatterySimulatorControllerRequest {
2133 #[allow(irrefutable_let_patterns)]
2134 pub fn into_get_battery_info(
2135 self,
2136 ) -> Option<(BatterySimulatorControllerGetBatteryInfoResponder)> {
2137 if let BatterySimulatorControllerRequest::GetBatteryInfo { responder } = self {
2138 Some((responder))
2139 } else {
2140 None
2141 }
2142 }
2143
2144 #[allow(irrefutable_let_patterns)]
2145 pub fn into_set_battery_status(
2146 self,
2147 ) -> Option<(fidl_fuchsia_power_battery::BatteryStatus, BatterySimulatorControllerControlHandle)>
2148 {
2149 if let BatterySimulatorControllerRequest::SetBatteryStatus {
2150 battery_status,
2151 control_handle,
2152 } = self
2153 {
2154 Some((battery_status, control_handle))
2155 } else {
2156 None
2157 }
2158 }
2159
2160 #[allow(irrefutable_let_patterns)]
2161 pub fn into_set_charge_status(
2162 self,
2163 ) -> Option<(fidl_fuchsia_power_battery::ChargeStatus, BatterySimulatorControllerControlHandle)>
2164 {
2165 if let BatterySimulatorControllerRequest::SetChargeStatus {
2166 charge_status,
2167 control_handle,
2168 } = self
2169 {
2170 Some((charge_status, control_handle))
2171 } else {
2172 None
2173 }
2174 }
2175
2176 #[allow(irrefutable_let_patterns)]
2177 pub fn into_set_charge_source(
2178 self,
2179 ) -> Option<(fidl_fuchsia_power_battery::ChargeSource, BatterySimulatorControllerControlHandle)>
2180 {
2181 if let BatterySimulatorControllerRequest::SetChargeSource {
2182 charge_source,
2183 control_handle,
2184 } = self
2185 {
2186 Some((charge_source, control_handle))
2187 } else {
2188 None
2189 }
2190 }
2191
2192 #[allow(irrefutable_let_patterns)]
2193 pub fn into_set_battery_percentage(
2194 self,
2195 ) -> Option<(f32, BatterySimulatorControllerControlHandle)> {
2196 if let BatterySimulatorControllerRequest::SetBatteryPercentage { percent, control_handle } =
2197 self
2198 {
2199 Some((percent, control_handle))
2200 } else {
2201 None
2202 }
2203 }
2204
2205 #[allow(irrefutable_let_patterns)]
2206 pub fn into_set_level_status(
2207 self,
2208 ) -> Option<(fidl_fuchsia_power_battery::LevelStatus, BatterySimulatorControllerControlHandle)>
2209 {
2210 if let BatterySimulatorControllerRequest::SetLevelStatus { level_status, control_handle } =
2211 self
2212 {
2213 Some((level_status, control_handle))
2214 } else {
2215 None
2216 }
2217 }
2218
2219 #[allow(irrefutable_let_patterns)]
2220 pub fn into_set_time_remaining(self) -> Option<(i64, BatterySimulatorControllerControlHandle)> {
2221 if let BatterySimulatorControllerRequest::SetTimeRemaining { duration, control_handle } =
2222 self
2223 {
2224 Some((duration, control_handle))
2225 } else {
2226 None
2227 }
2228 }
2229
2230 #[allow(irrefutable_let_patterns)]
2231 pub fn into_disconnect_real_battery(self) -> Option<(BatterySimulatorControllerControlHandle)> {
2232 if let BatterySimulatorControllerRequest::DisconnectRealBattery { control_handle } = self {
2233 Some((control_handle))
2234 } else {
2235 None
2236 }
2237 }
2238
2239 #[allow(irrefutable_let_patterns)]
2240 pub fn into_is_simulating(self) -> Option<(BatterySimulatorControllerIsSimulatingResponder)> {
2241 if let BatterySimulatorControllerRequest::IsSimulating { responder } = self {
2242 Some((responder))
2243 } else {
2244 None
2245 }
2246 }
2247
2248 #[allow(irrefutable_let_patterns)]
2249 pub fn into_reconnect_real_battery(self) -> Option<(BatterySimulatorControllerControlHandle)> {
2250 if let BatterySimulatorControllerRequest::ReconnectRealBattery { control_handle } = self {
2251 Some((control_handle))
2252 } else {
2253 None
2254 }
2255 }
2256
2257 #[allow(irrefutable_let_patterns)]
2258 pub fn into_set_present_voltage_mv(
2259 self,
2260 ) -> Option<(u32, BatterySimulatorControllerControlHandle)> {
2261 if let BatterySimulatorControllerRequest::SetPresentVoltageMv { voltage, control_handle } =
2262 self
2263 {
2264 Some((voltage, control_handle))
2265 } else {
2266 None
2267 }
2268 }
2269
2270 #[allow(irrefutable_let_patterns)]
2271 pub fn into_set_remaining_capacity_uah(
2272 self,
2273 ) -> Option<(u32, BatterySimulatorControllerControlHandle)> {
2274 if let BatterySimulatorControllerRequest::SetRemainingCapacityUah {
2275 capacity,
2276 control_handle,
2277 } = self
2278 {
2279 Some((capacity, control_handle))
2280 } else {
2281 None
2282 }
2283 }
2284
2285 #[allow(irrefutable_let_patterns)]
2286 pub fn into_set_battery_spec(
2287 self,
2288 ) -> Option<(fidl_fuchsia_power_battery::BatterySpec, BatterySimulatorControllerControlHandle)>
2289 {
2290 if let BatterySimulatorControllerRequest::SetBatterySpec { spec, control_handle } = self {
2291 Some((spec, control_handle))
2292 } else {
2293 None
2294 }
2295 }
2296
2297 pub fn method_name(&self) -> &'static str {
2299 match *self {
2300 BatterySimulatorControllerRequest::GetBatteryInfo { .. } => "get_battery_info",
2301 BatterySimulatorControllerRequest::SetBatteryStatus { .. } => "set_battery_status",
2302 BatterySimulatorControllerRequest::SetChargeStatus { .. } => "set_charge_status",
2303 BatterySimulatorControllerRequest::SetChargeSource { .. } => "set_charge_source",
2304 BatterySimulatorControllerRequest::SetBatteryPercentage { .. } => {
2305 "set_battery_percentage"
2306 }
2307 BatterySimulatorControllerRequest::SetLevelStatus { .. } => "set_level_status",
2308 BatterySimulatorControllerRequest::SetTimeRemaining { .. } => "set_time_remaining",
2309 BatterySimulatorControllerRequest::DisconnectRealBattery { .. } => {
2310 "disconnect_real_battery"
2311 }
2312 BatterySimulatorControllerRequest::IsSimulating { .. } => "is_simulating",
2313 BatterySimulatorControllerRequest::ReconnectRealBattery { .. } => {
2314 "reconnect_real_battery"
2315 }
2316 BatterySimulatorControllerRequest::SetPresentVoltageMv { .. } => {
2317 "set_present_voltage_mv"
2318 }
2319 BatterySimulatorControllerRequest::SetRemainingCapacityUah { .. } => {
2320 "set_remaining_capacity_uah"
2321 }
2322 BatterySimulatorControllerRequest::SetBatterySpec { .. } => "set_battery_spec",
2323 }
2324 }
2325}
2326
2327#[derive(Debug, Clone)]
2328pub struct BatterySimulatorControllerControlHandle {
2329 inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
2330}
2331
2332impl fidl::endpoints::ControlHandle for BatterySimulatorControllerControlHandle {
2333 fn shutdown(&self) {
2334 self.inner.shutdown()
2335 }
2336 fn shutdown_with_epitaph(&self, status: zx_status::Status) {
2337 self.inner.shutdown_with_epitaph(status)
2338 }
2339
2340 fn is_closed(&self) -> bool {
2341 self.inner.channel().is_closed()
2342 }
2343 fn on_closed(&self) -> fidl::OnSignalsRef<'_> {
2344 self.inner.channel().on_closed()
2345 }
2346
2347 #[cfg(target_os = "fuchsia")]
2348 fn signal_peer(
2349 &self,
2350 clear_mask: zx::Signals,
2351 set_mask: zx::Signals,
2352 ) -> Result<(), zx_status::Status> {
2353 use fidl::Peered;
2354 self.inner.channel().signal_peer(clear_mask, set_mask)
2355 }
2356}
2357
2358impl BatterySimulatorControllerControlHandle {}
2359
2360#[must_use = "FIDL methods require a response to be sent"]
2361#[derive(Debug)]
2362pub struct BatterySimulatorControllerGetBatteryInfoResponder {
2363 control_handle: std::mem::ManuallyDrop<BatterySimulatorControllerControlHandle>,
2364 tx_id: u32,
2365}
2366
2367impl std::ops::Drop for BatterySimulatorControllerGetBatteryInfoResponder {
2371 fn drop(&mut self) {
2372 self.control_handle.shutdown();
2373 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
2375 }
2376}
2377
2378impl fidl::endpoints::Responder for BatterySimulatorControllerGetBatteryInfoResponder {
2379 type ControlHandle = BatterySimulatorControllerControlHandle;
2380
2381 fn control_handle(&self) -> &BatterySimulatorControllerControlHandle {
2382 &self.control_handle
2383 }
2384
2385 fn drop_without_shutdown(mut self) {
2386 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
2388 std::mem::forget(self);
2390 }
2391}
2392
2393impl BatterySimulatorControllerGetBatteryInfoResponder {
2394 pub fn send(
2398 self,
2399 mut info: &fidl_fuchsia_power_battery::BatteryInfo,
2400 ) -> Result<(), fidl::Error> {
2401 let _result = self.send_raw(info);
2402 if _result.is_err() {
2403 self.control_handle.shutdown();
2404 }
2405 self.drop_without_shutdown();
2406 _result
2407 }
2408
2409 pub fn send_no_shutdown_on_err(
2411 self,
2412 mut info: &fidl_fuchsia_power_battery::BatteryInfo,
2413 ) -> Result<(), fidl::Error> {
2414 let _result = self.send_raw(info);
2415 self.drop_without_shutdown();
2416 _result
2417 }
2418
2419 fn send_raw(
2420 &self,
2421 mut info: &fidl_fuchsia_power_battery::BatteryInfo,
2422 ) -> Result<(), fidl::Error> {
2423 self.control_handle.inner.send::<BatterySimulatorControllerGetBatteryInfoResponse>(
2424 (info,),
2425 self.tx_id,
2426 0x4a20d3731366aaf8,
2427 fidl::encoding::DynamicFlags::empty(),
2428 )
2429 }
2430}
2431
2432#[must_use = "FIDL methods require a response to be sent"]
2433#[derive(Debug)]
2434pub struct BatterySimulatorControllerIsSimulatingResponder {
2435 control_handle: std::mem::ManuallyDrop<BatterySimulatorControllerControlHandle>,
2436 tx_id: u32,
2437}
2438
2439impl std::ops::Drop for BatterySimulatorControllerIsSimulatingResponder {
2443 fn drop(&mut self) {
2444 self.control_handle.shutdown();
2445 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
2447 }
2448}
2449
2450impl fidl::endpoints::Responder for BatterySimulatorControllerIsSimulatingResponder {
2451 type ControlHandle = BatterySimulatorControllerControlHandle;
2452
2453 fn control_handle(&self) -> &BatterySimulatorControllerControlHandle {
2454 &self.control_handle
2455 }
2456
2457 fn drop_without_shutdown(mut self) {
2458 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
2460 std::mem::forget(self);
2462 }
2463}
2464
2465impl BatterySimulatorControllerIsSimulatingResponder {
2466 pub fn send(self, mut simulation_state: bool) -> Result<(), fidl::Error> {
2470 let _result = self.send_raw(simulation_state);
2471 if _result.is_err() {
2472 self.control_handle.shutdown();
2473 }
2474 self.drop_without_shutdown();
2475 _result
2476 }
2477
2478 pub fn send_no_shutdown_on_err(self, mut simulation_state: bool) -> Result<(), fidl::Error> {
2480 let _result = self.send_raw(simulation_state);
2481 self.drop_without_shutdown();
2482 _result
2483 }
2484
2485 fn send_raw(&self, mut simulation_state: bool) -> Result<(), fidl::Error> {
2486 self.control_handle.inner.send::<BatterySimulatorControllerIsSimulatingResponse>(
2487 (simulation_state,),
2488 self.tx_id,
2489 0x4bf85cfe3476975d,
2490 fidl::encoding::DynamicFlags::empty(),
2491 )
2492 }
2493}
2494
2495mod internal {
2496 use super::*;
2497}