Trait DeviceTrait

pub trait DeviceTrait {
    type SupportedInputConfigs: Iterator<Item = SupportedStreamConfigRange>;
    type SupportedOutputConfigs: Iterator<Item = SupportedStreamConfigRange>;
    type Stream: StreamTrait;

    // Required methods
    fn name(&self) -> Result<String, DeviceNameError>;
    fn supported_input_configs(
        &self,
    ) -> Result<Self::SupportedInputConfigs, SupportedStreamConfigsError>;
    fn supported_output_configs(
        &self,
    ) -> Result<Self::SupportedOutputConfigs, SupportedStreamConfigsError>;
    fn default_input_config(
        &self,
    ) -> Result<SupportedStreamConfig, DefaultStreamConfigError>;
    fn default_output_config(
        &self,
    ) -> Result<SupportedStreamConfig, DefaultStreamConfigError>;
    fn build_input_stream_raw<D, E>(
        &self,
        config: &StreamConfig,
        sample_format: SampleFormat,
        data_callback: D,
        error_callback: E,
        timeout: Option<Duration>,
    ) -> Result<Self::Stream, BuildStreamError>
       where D: FnMut(&Data, &InputCallbackInfo) + Send + 'static,
             E: FnMut(StreamError) + Send + 'static;
    fn build_output_stream_raw<D, E>(
        &self,
        config: &StreamConfig,
        sample_format: SampleFormat,
        data_callback: D,
        error_callback: E,
        timeout: Option<Duration>,
    ) -> Result<Self::Stream, BuildStreamError>
       where D: FnMut(&mut Data, &OutputCallbackInfo) + Send + 'static,
             E: FnMut(StreamError) + Send + 'static;

    // Provided methods
    fn build_input_stream<T, D, E>(
        &self,
        config: &StreamConfig,
        data_callback: D,
        error_callback: E,
        timeout: Option<Duration>,
    ) -> Result<Self::Stream, BuildStreamError>
       where T: SizedSample,
             D: FnMut(&[T], &InputCallbackInfo) + Send + 'static,
             E: FnMut(StreamError) + Send + 'static { ... }
    fn build_output_stream<T, D, E>(
        &self,
        config: &StreamConfig,
        data_callback: D,
        error_callback: E,
        timeout: Option<Duration>,
    ) -> Result<Self::Stream, BuildStreamError>
       where T: SizedSample,
             D: FnMut(&mut [T], &OutputCallbackInfo) + Send + 'static,
             E: FnMut(StreamError) + Send + 'static { ... }
}

A device that is capable of audio input and/or output.

Please note that Devices may become invalid if they get disconnected. Therefore, all the methods that involve a device return a Result allowing the user to handle this case.

Required Associated Types

type SupportedInputConfigs: Iterator<Item = SupportedStreamConfigRange>

The iterator type yielding supported input stream formats.

type SupportedOutputConfigs: Iterator<Item = SupportedStreamConfigRange>

The iterator type yielding supported output stream formats.

type Stream: StreamTrait

The stream type created by build_input_stream_raw and build_output_stream_raw.

Required Methods

fn name(&self) -> Result<String, DeviceNameError>

The human-readable name of the device.

fn supported_input_configs( &self, ) -> Result<Self::SupportedInputConfigs, SupportedStreamConfigsError>

An iterator yielding formats that are supported by the backend.

Can return an error if the device is no longer valid (e.g. it has been disconnected).

fn supported_output_configs( &self, ) -> Result<Self::SupportedOutputConfigs, SupportedStreamConfigsError>

An iterator yielding output stream formats that are supported by the device.

Can return an error if the device is no longer valid (e.g. it has been disconnected).

fn default_input_config( &self, ) -> Result<SupportedStreamConfig, DefaultStreamConfigError>

The default input stream format for the device.

fn default_output_config( &self, ) -> Result<SupportedStreamConfig, DefaultStreamConfigError>

The default output stream format for the device.

fn build_input_stream_raw<D, E>( &self, config: &StreamConfig, sample_format: SampleFormat, data_callback: D, error_callback: E, timeout: Option<Duration>, ) -> Result<Self::Stream, BuildStreamError>

where D: FnMut(&Data, &InputCallbackInfo) + Send + 'static, E: FnMut(StreamError) + Send + 'static,

Create a dynamically typed input stream.

fn build_output_stream_raw<D, E>( &self, config: &StreamConfig, sample_format: SampleFormat, data_callback: D, error_callback: E, timeout: Option<Duration>, ) -> Result<Self::Stream, BuildStreamError>

where D: FnMut(&mut Data, &OutputCallbackInfo) + Send + 'static, E: FnMut(StreamError) + Send + 'static,

Create a dynamically typed output stream.

Provided Methods

fn build_input_stream<T, D, E>( &self, config: &StreamConfig, data_callback: D, error_callback: E, timeout: Option<Duration>, ) -> Result<Self::Stream, BuildStreamError>

where T: SizedSample, D: FnMut(&[T], &InputCallbackInfo) + Send + 'static, E: FnMut(StreamError) + Send + 'static,

Create an input stream.

fn build_output_stream<T, D, E>( &self, config: &StreamConfig, data_callback: D, error_callback: E, timeout: Option<Duration>, ) -> Result<Self::Stream, BuildStreamError>

where T: SizedSample, D: FnMut(&mut [T], &OutputCallbackInfo) + Send + 'static, E: FnMut(StreamError) + Send + 'static,

Create an output stream.

Dyn Compatibility

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety", so this trait is not object safe.

Implementors

impl DeviceTrait for cpal::host::alsa::Device

type SupportedInputConfigs = IntoIter<SupportedStreamConfigRange>

type SupportedOutputConfigs = IntoIter<SupportedStreamConfigRange>

type Stream = Stream

impl DeviceTrait for rodio::Device

type SupportedInputConfigs = SupportedInputConfigs

type SupportedOutputConfigs = SupportedOutputConfigs

type Stream = Stream