fidl_fuchsia_power_battery_test/
fidl_fuchsia_power_battery_test.rs

1// WARNING: This file is machine generated by fidlgen.
2
3#![warn(clippy::all)]
4#![allow(unused_parens, unused_mut, unused_imports, nonstandard_style)]
5
6use bitflags::bitflags;
7use fidl::client::QueryResponseFut;
8use fidl::encoding::{MessageBufFor, ProxyChannelBox, ResourceDialect};
9use fidl::endpoints::{ControlHandle as _, Responder as _};
10pub use fidl_fuchsia_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    /// Waits until an event arrives and returns it. It is safe for other
96    /// threads to make concurrent requests while waiting for an event.
97    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    /// Gets battery info. This should be called after
105    /// DisconnectRealBattery
106    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    /// Sets Battery Status. This should be called after
123    /// DisconnectRealBattery
124    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    /// Sets Charge Status. This should be called after
136    /// DisconnectRealBattery
137    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    /// Sets Charge Source. This should be called after
149    /// DisconnectRealBattery
150    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    /// Sets Battery Percentage. This should be called after
162    /// DisconnectRealBattery
163    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    /// Sets Level Status. This should be called after
172    /// DisconnectRealBattery
173    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    /// Sets Time Remaining to full charge / depletion
185    /// This should be called after DisconnectRealBattery
186    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    /// Disconnect the real battery connection
195    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    /// Gets Simulation State
204    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    /// Reconnect to the real battery
218    /// This should be called after DisconnectRealBattery
219    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    /// Sets Present Voltage in mV. This should be called after
228    /// DisconnectRealBattery
229    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    /// Sets Remaining Capacity Uah. This should be called after
238    /// DisconnectRealBattery
239    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    /// Sets the BatterySpec
248    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    /// Create a new Proxy for fuchsia.power.battery.test/BatterySimulator.
283    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    /// Get a Stream of events from the remote end of the protocol.
289    ///
290    /// # Panics
291    ///
292    /// Panics if the event stream was already taken.
293    pub fn take_event_stream(&self) -> BatterySimulatorEventStream {
294        BatterySimulatorEventStream { event_receiver: self.client.take_event_receiver() }
295    }
296
297    /// Gets battery info. This should be called after
298    /// DisconnectRealBattery
299    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    /// Sets Battery Status. This should be called after
309    /// DisconnectRealBattery
310    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    /// Sets Charge Status. This should be called after
318    /// DisconnectRealBattery
319    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    /// Sets Charge Source. This should be called after
327    /// DisconnectRealBattery
328    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    /// Sets Battery Percentage. This should be called after
336    /// DisconnectRealBattery
337    pub fn r#set_battery_percentage(&self, mut percent: f32) -> Result<(), fidl::Error> {
338        BatterySimulatorProxyInterface::r#set_battery_percentage(self, percent)
339    }
340
341    /// Sets Level Status. This should be called after
342    /// DisconnectRealBattery
343    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    /// Sets Time Remaining to full charge / depletion
351    /// This should be called after DisconnectRealBattery
352    pub fn r#set_time_remaining(&self, mut duration: i64) -> Result<(), fidl::Error> {
353        BatterySimulatorProxyInterface::r#set_time_remaining(self, duration)
354    }
355
356    /// Disconnect the real battery connection
357    pub fn r#disconnect_real_battery(&self) -> Result<(), fidl::Error> {
358        BatterySimulatorProxyInterface::r#disconnect_real_battery(self)
359    }
360
361    /// Gets Simulation State
362    pub fn r#is_simulating(
363        &self,
364    ) -> fidl::client::QueryResponseFut<bool, fidl::encoding::DefaultFuchsiaResourceDialect> {
365        BatterySimulatorProxyInterface::r#is_simulating(self)
366    }
367
368    /// Reconnect to the real battery
369    /// This should be called after DisconnectRealBattery
370    pub fn r#reconnect_real_battery(&self) -> Result<(), fidl::Error> {
371        BatterySimulatorProxyInterface::r#reconnect_real_battery(self)
372    }
373
374    /// Sets Present Voltage in mV. This should be called after
375    /// DisconnectRealBattery
376    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    /// Sets Remaining Capacity Uah. This should be called after
381    /// DisconnectRealBattery
382    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    /// Sets the BatterySpec
387    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    /// Decodes a message buffer as a [`BatterySimulatorEvent`].
581    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
597/// A Stream of incoming requests for fuchsia.power.battery.test/BatterySimulator.
598pub 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                // A message has been received from the channel
670                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/// Simulator interface for battery simulation
874#[derive(Debug)]
875pub enum BatterySimulatorRequest {
876    /// Gets battery info. This should be called after
877    /// DisconnectRealBattery
878    GetBatteryInfo { responder: BatterySimulatorGetBatteryInfoResponder },
879    /// Sets Battery Status. This should be called after
880    /// DisconnectRealBattery
881    SetBatteryStatus {
882        battery_status: fidl_fuchsia_power_battery::BatteryStatus,
883        control_handle: BatterySimulatorControlHandle,
884    },
885    /// Sets Charge Status. This should be called after
886    /// DisconnectRealBattery
887    SetChargeStatus {
888        charge_status: fidl_fuchsia_power_battery::ChargeStatus,
889        control_handle: BatterySimulatorControlHandle,
890    },
891    /// Sets Charge Source. This should be called after
892    /// DisconnectRealBattery
893    SetChargeSource {
894        charge_source: fidl_fuchsia_power_battery::ChargeSource,
895        control_handle: BatterySimulatorControlHandle,
896    },
897    /// Sets Battery Percentage. This should be called after
898    /// DisconnectRealBattery
899    SetBatteryPercentage { percent: f32, control_handle: BatterySimulatorControlHandle },
900    /// Sets Level Status. This should be called after
901    /// DisconnectRealBattery
902    SetLevelStatus {
903        level_status: fidl_fuchsia_power_battery::LevelStatus,
904        control_handle: BatterySimulatorControlHandle,
905    },
906    /// Sets Time Remaining to full charge / depletion
907    /// This should be called after DisconnectRealBattery
908    SetTimeRemaining { duration: i64, control_handle: BatterySimulatorControlHandle },
909    /// Disconnect the real battery connection
910    DisconnectRealBattery { control_handle: BatterySimulatorControlHandle },
911    /// Gets Simulation State
912    IsSimulating { responder: BatterySimulatorIsSimulatingResponder },
913    /// Reconnect to the real battery
914    /// This should be called after DisconnectRealBattery
915    ReconnectRealBattery { control_handle: BatterySimulatorControlHandle },
916    /// Sets Present Voltage in mV. This should be called after
917    /// DisconnectRealBattery
918    SetPresentVoltageMv { voltage: u32, control_handle: BatterySimulatorControlHandle },
919    /// Sets Remaining Capacity Uah. This should be called after
920    /// DisconnectRealBattery
921    SetRemainingCapacityUah { capacity: u32, control_handle: BatterySimulatorControlHandle },
922    /// Sets the BatterySpec
923    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    /// Name of the method defined in FIDL
1059    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
1118/// Set the the channel to be shutdown (see [`BatterySimulatorControlHandle::shutdown`])
1119/// if the responder is dropped without sending a response, so that the client
1120/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
1121impl std::ops::Drop for BatterySimulatorGetBatteryInfoResponder {
1122    fn drop(&mut self) {
1123        self.control_handle.shutdown();
1124        // Safety: drops once, never accessed again
1125        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        // Safety: drops once, never accessed again due to mem::forget
1138        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
1139        // Prevent Drop from running (which would shut down the channel)
1140        std::mem::forget(self);
1141    }
1142}
1143
1144impl BatterySimulatorGetBatteryInfoResponder {
1145    /// Sends a response to the FIDL transaction.
1146    ///
1147    /// Sets the channel to shutdown if an error occurs.
1148    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    /// Similar to "send" but does not shutdown the channel if an error occurs.
1161    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
1190/// Set the the channel to be shutdown (see [`BatterySimulatorControlHandle::shutdown`])
1191/// if the responder is dropped without sending a response, so that the client
1192/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
1193impl std::ops::Drop for BatterySimulatorIsSimulatingResponder {
1194    fn drop(&mut self) {
1195        self.control_handle.shutdown();
1196        // Safety: drops once, never accessed again
1197        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        // Safety: drops once, never accessed again due to mem::forget
1210        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
1211        // Prevent Drop from running (which would shut down the channel)
1212        std::mem::forget(self);
1213    }
1214}
1215
1216impl BatterySimulatorIsSimulatingResponder {
1217    /// Sends a response to the FIDL transaction.
1218    ///
1219    /// Sets the channel to shutdown if an error occurs.
1220    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    /// Similar to "send" but does not shutdown the channel if an error occurs.
1230    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    /// Waits until an event arrives and returns it. It is safe for other
1328    /// threads to make concurrent requests while waiting for an event.
1329    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    /// Gets battery info. This should be called after
1337    /// DisconnectRealBattery
1338    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    /// Sets Battery Status. This should be called after
1355    /// DisconnectRealBattery
1356    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    /// Sets Charge Status. This should be called after
1368    /// DisconnectRealBattery
1369    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    /// Sets Charge Source. This should be called after
1381    /// DisconnectRealBattery
1382    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    /// Sets Battery Percentage. This should be called after
1394    /// DisconnectRealBattery
1395    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    /// Sets Level Status. This should be called after
1404    /// DisconnectRealBattery
1405    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    /// Sets Time Remaining to full charge / depletion
1417    /// This should be called after DisconnectRealBattery
1418    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    /// Disconnect the real battery connection
1427    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    /// Gets Simulation State
1436    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    /// Reconnect to the real battery
1450    /// This should be called after DisconnectRealBattery
1451    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    /// Sets Present Voltage in mV. This should be called after
1460    /// DisconnectRealBattery
1461    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    /// Sets Remaining Capacity Uah. This should be called after
1470    /// DisconnectRealBattery
1471    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    /// Sets the BatterySpec
1480    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    /// Create a new Proxy for fuchsia.power.battery.test/BatterySimulatorController.
1515    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    /// Get a Stream of events from the remote end of the protocol.
1522    ///
1523    /// # Panics
1524    ///
1525    /// Panics if the event stream was already taken.
1526    pub fn take_event_stream(&self) -> BatterySimulatorControllerEventStream {
1527        BatterySimulatorControllerEventStream { event_receiver: self.client.take_event_receiver() }
1528    }
1529
1530    /// Gets battery info. This should be called after
1531    /// DisconnectRealBattery
1532    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    /// Sets Battery Status. This should be called after
1542    /// DisconnectRealBattery
1543    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    /// Sets Charge Status. This should be called after
1551    /// DisconnectRealBattery
1552    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    /// Sets Charge Source. This should be called after
1560    /// DisconnectRealBattery
1561    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    /// Sets Battery Percentage. This should be called after
1569    /// DisconnectRealBattery
1570    pub fn r#set_battery_percentage(&self, mut percent: f32) -> Result<(), fidl::Error> {
1571        BatterySimulatorControllerProxyInterface::r#set_battery_percentage(self, percent)
1572    }
1573
1574    /// Sets Level Status. This should be called after
1575    /// DisconnectRealBattery
1576    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    /// Sets Time Remaining to full charge / depletion
1584    /// This should be called after DisconnectRealBattery
1585    pub fn r#set_time_remaining(&self, mut duration: i64) -> Result<(), fidl::Error> {
1586        BatterySimulatorControllerProxyInterface::r#set_time_remaining(self, duration)
1587    }
1588
1589    /// Disconnect the real battery connection
1590    pub fn r#disconnect_real_battery(&self) -> Result<(), fidl::Error> {
1591        BatterySimulatorControllerProxyInterface::r#disconnect_real_battery(self)
1592    }
1593
1594    /// Gets Simulation State
1595    pub fn r#is_simulating(
1596        &self,
1597    ) -> fidl::client::QueryResponseFut<bool, fidl::encoding::DefaultFuchsiaResourceDialect> {
1598        BatterySimulatorControllerProxyInterface::r#is_simulating(self)
1599    }
1600
1601    /// Reconnect to the real battery
1602    /// This should be called after DisconnectRealBattery
1603    pub fn r#reconnect_real_battery(&self) -> Result<(), fidl::Error> {
1604        BatterySimulatorControllerProxyInterface::r#reconnect_real_battery(self)
1605    }
1606
1607    /// Sets Present Voltage in mV. This should be called after
1608    /// DisconnectRealBattery
1609    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    /// Sets Remaining Capacity Uah. This should be called after
1614    /// DisconnectRealBattery
1615    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    /// Sets the BatterySpec
1620    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    /// Decodes a message buffer as a [`BatterySimulatorControllerEvent`].
1814    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
1829/// A Stream of incoming requests for fuchsia.power.battery.test/BatterySimulatorController.
1830pub 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                // A message has been received from the channel
1902                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/// Controller interface to allow modification of battery state.
2074#[derive(Debug)]
2075pub enum BatterySimulatorControllerRequest {
2076    /// Gets battery info. This should be called after
2077    /// DisconnectRealBattery
2078    GetBatteryInfo { responder: BatterySimulatorControllerGetBatteryInfoResponder },
2079    /// Sets Battery Status. This should be called after
2080    /// DisconnectRealBattery
2081    SetBatteryStatus {
2082        battery_status: fidl_fuchsia_power_battery::BatteryStatus,
2083        control_handle: BatterySimulatorControllerControlHandle,
2084    },
2085    /// Sets Charge Status. This should be called after
2086    /// DisconnectRealBattery
2087    SetChargeStatus {
2088        charge_status: fidl_fuchsia_power_battery::ChargeStatus,
2089        control_handle: BatterySimulatorControllerControlHandle,
2090    },
2091    /// Sets Charge Source. This should be called after
2092    /// DisconnectRealBattery
2093    SetChargeSource {
2094        charge_source: fidl_fuchsia_power_battery::ChargeSource,
2095        control_handle: BatterySimulatorControllerControlHandle,
2096    },
2097    /// Sets Battery Percentage. This should be called after
2098    /// DisconnectRealBattery
2099    SetBatteryPercentage { percent: f32, control_handle: BatterySimulatorControllerControlHandle },
2100    /// Sets Level Status. This should be called after
2101    /// DisconnectRealBattery
2102    SetLevelStatus {
2103        level_status: fidl_fuchsia_power_battery::LevelStatus,
2104        control_handle: BatterySimulatorControllerControlHandle,
2105    },
2106    /// Sets Time Remaining to full charge / depletion
2107    /// This should be called after DisconnectRealBattery
2108    SetTimeRemaining { duration: i64, control_handle: BatterySimulatorControllerControlHandle },
2109    /// Disconnect the real battery connection
2110    DisconnectRealBattery { control_handle: BatterySimulatorControllerControlHandle },
2111    /// Gets Simulation State
2112    IsSimulating { responder: BatterySimulatorControllerIsSimulatingResponder },
2113    /// Reconnect to the real battery
2114    /// This should be called after DisconnectRealBattery
2115    ReconnectRealBattery { control_handle: BatterySimulatorControllerControlHandle },
2116    /// Sets Present Voltage in mV. This should be called after
2117    /// DisconnectRealBattery
2118    SetPresentVoltageMv { voltage: u32, control_handle: BatterySimulatorControllerControlHandle },
2119    /// Sets Remaining Capacity Uah. This should be called after
2120    /// DisconnectRealBattery
2121    SetRemainingCapacityUah {
2122        capacity: u32,
2123        control_handle: BatterySimulatorControllerControlHandle,
2124    },
2125    /// Sets the BatterySpec
2126    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    /// Name of the method defined in FIDL
2298    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
2367/// Set the the channel to be shutdown (see [`BatterySimulatorControllerControlHandle::shutdown`])
2368/// if the responder is dropped without sending a response, so that the client
2369/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
2370impl std::ops::Drop for BatterySimulatorControllerGetBatteryInfoResponder {
2371    fn drop(&mut self) {
2372        self.control_handle.shutdown();
2373        // Safety: drops once, never accessed again
2374        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        // Safety: drops once, never accessed again due to mem::forget
2387        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
2388        // Prevent Drop from running (which would shut down the channel)
2389        std::mem::forget(self);
2390    }
2391}
2392
2393impl BatterySimulatorControllerGetBatteryInfoResponder {
2394    /// Sends a response to the FIDL transaction.
2395    ///
2396    /// Sets the channel to shutdown if an error occurs.
2397    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    /// Similar to "send" but does not shutdown the channel if an error occurs.
2410    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
2439/// Set the the channel to be shutdown (see [`BatterySimulatorControllerControlHandle::shutdown`])
2440/// if the responder is dropped without sending a response, so that the client
2441/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
2442impl std::ops::Drop for BatterySimulatorControllerIsSimulatingResponder {
2443    fn drop(&mut self) {
2444        self.control_handle.shutdown();
2445        // Safety: drops once, never accessed again
2446        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        // Safety: drops once, never accessed again due to mem::forget
2459        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
2460        // Prevent Drop from running (which would shut down the channel)
2461        std::mem::forget(self);
2462    }
2463}
2464
2465impl BatterySimulatorControllerIsSimulatingResponder {
2466    /// Sends a response to the FIDL transaction.
2467    ///
2468    /// Sets the channel to shutdown if an error occurs.
2469    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    /// Similar to "send" but does not shutdown the channel if an error occurs.
2479    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}