Struct AudioConsumerSynchronousProxy

pub struct AudioConsumerSynchronousProxy { /* private fields */ }

Implementations

impl AudioConsumerSynchronousProxy

pub fn new(channel: Channel) -> Self

pub fn into_channel(self) -> Channel

pub fn wait_for_event( &self, deadline: MonotonicInstant, ) -> Result<AudioConsumerEvent, Error>

Waits until an event arrives and returns it. It is safe for other threads to make concurrent requests while waiting for an event.

pub fn create_stream_sink( &self, buffers: Vec<Vmo>, stream_type: &AudioStreamType, compression: Option<&Compression>, stream_sink_request: ServerEnd<StreamSinkMarker>, ) -> Result<(), Error>

Creates a StreamSink for the consumer with the indicated properties.

Multiple stream sinks may be acquired using this method, but they are intended to be used sequentially rather than concurrently. The first stream sink that’s created using this method is used as the sole source of packets incoming to the logical consumer until that stream sink is closed or the EndOfStream method is called on that sink. At that point, the second stream sink is used, and so on.

If an unsupported compression type is supplied, the stream_sink_request request will be closed with an epitaph value of ZX_ERR_INVALID_ARGS.

pub fn start( &self, flags: AudioConsumerStartFlags, reference_time: i64, media_time: i64, ) -> Result<(), Error>

Starts rendering as indicated by flags.

media_time indicates the packet timestamp that corresponds to reference_time. Typically, this is the timestamp of the first packet that will be rendered. If packets will be supplied with no timestamps, this value should be NO_TIMESTAMP. Passing a media_time value of NO_TIMESTAMP chooses the default media time, established as follows: 1. When starting for the first time, the default media time is the timestamp on the first packet sent to the stream sink. 2. When resuming after stop, the default media time is the media time at which the stream stopped.

reference_time is the monotonic system time at which rendering should be started. For supply-driven sources, this must be the time at which the first packet was (or will be) sent plus a lead time, which must be in the range indicated in the AudioConsumerStatus. For demand-driven sources, the client must ensure that the lead time requirement is met at the start time. Passing the default value of 0 for reference_time causes the consumer to choose a start time based on the availability of packets, the lead time requirements, and whether LOW_LATENCY has been specified.

The actual start time will be reflected in the updated status.

pub fn stop(&self) -> Result<(), Error>

Stops rendering as soon as possible after this method is called. The actual stop time will be reflected in the updated status.

pub fn set_rate(&self, rate: f32) -> Result<(), Error>

Requests to change the playback rate of the renderer. 1.0 means normal playback. Negative rates are not supported. The new rate will be reflected in the updated status. The default rate of any newly created StreamSink is 1.0.

pub fn bind_volume_control( &self, volume_control_request: ServerEnd<VolumeControlMarker>, ) -> Result<(), Error>

Binds to this AudioConsumer volume control for control and notifications.

pub fn watch_status( &self, ___deadline: MonotonicInstant, ) -> Result<AudioConsumerStatus, Error>

Gets the current status of the consumer using the long get pattern. The consumer responds to this method when the status changes - initially with respect to the initial status value and thereafter with respect to the previously-reported status value.

Trait Implementations

impl Debug for AudioConsumerSynchronousProxy

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl SynchronousProxy for AudioConsumerSynchronousProxy

type Proxy = AudioConsumerProxy

The async proxy for the same protocol.

type Protocol = AudioConsumerMarker

The protocol which this Proxy controls.

fn from_channel(inner: Channel) -> Self

Create a proxy over the given channel.

fn into_channel(self) -> Channel

Convert the proxy back into a channel.

fn as_channel(&self) -> &Channel

Get a reference to the proxy’s underlying channel.

fn is_closed(&self) -> Result<bool, Status>

Returns true if the proxy has received the PEER_CLOSED signal.