android_media/

constants.rs

/// Audio sample rate enumeration
///
/// Defines standard sample rates supported by the Android audio system.
/// The sample rate is the number of audio samples captured per second, measured in Hz.
///
/// # Examples
///
/// ```no_run
/// use android_media::SampleRate;
/// let rate = SampleRate::Rate16000;
/// assert_eq!(rate.value(), 16000);
/// ```
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum SampleRate {
    /// 8000 Hz - commonly used for speech recognition
    Rate8000 = 8000,
    /// 16000 Hz - standard sample rate for voice applications
    Rate16000 = 16000,
    /// 22050 Hz - half of CD quality
    Rate22050 = 22050,
    /// 44100 Hz - CD audio standard sample rate
    Rate44100 = 44100,
    /// 48000 Hz - professional audio standard sample rate
    Rate48000 = 48000,
}

impl SampleRate {
    /// Get the integer value of the sample rate
    ///
    /// # Returns
    ///
    /// Returns the sample rate value in Hz (e.g., 16000, 44100, etc.)
    ///
    /// # Examples
    ///
    /// ```no_run
    /// use android_media::SampleRate;
    /// assert_eq!(SampleRate::Rate16000.value(), 16000);
    /// ```
    pub const fn value(&self) -> i32 {
        *self as i32
    }
}

/// Audio encoding format enumeration
///
/// Defines audio data encoding formats, i.e., how each audio sample is represented.
/// Different encoding formats correspond to different audio quality and storage requirements.
///
/// # Examples
///
/// ```no_run
/// use android_media::AudioEncoding;
/// let encoding = AudioEncoding::Pcm16bit;
/// assert_eq!(encoding.value(), 2);
/// assert_eq!(encoding.bytes_per_sample(), 2);
/// ```
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum AudioEncoding {
    /// 8-bit PCM encoding - 1 byte per sample
    Pcm8bit = 3,
    /// 16-bit PCM encoding - 2 bytes per sample, most commonly used
    Pcm16bit = 2,
    /// 32-bit float PCM encoding - 4 bytes per sample, provides higher dynamic range
    PcmFloat = 4,
}

impl AudioEncoding {
    /// Get the integer value of the encoding format
    ///
    /// # Returns
    ///
    /// Returns the encoding format identifier in the Android system
    ///
    /// # Examples
    ///
    /// ```no_run
    /// use android_media::AudioEncoding;
    /// assert_eq!(AudioEncoding::Pcm16bit.value(), 2);
    /// ```
    pub const fn value(&self) -> i32 {
        *self as i32
    }

    /// Get the number of bytes per sample
    ///
    /// # Returns
    ///
    /// Returns the number of bytes occupied by each audio sample in this encoding format
    ///
    /// # Examples
    ///
    /// ```no_run
    /// use android_media::AudioEncoding;
    /// assert_eq!(AudioEncoding::Pcm8bit.bytes_per_sample(), 1);
    /// assert_eq!(AudioEncoding::Pcm16bit.bytes_per_sample(), 2);
    /// assert_eq!(AudioEncoding::PcmFloat.bytes_per_sample(), 4);
    /// ```
    pub const fn bytes_per_sample(&self) -> i32 {
        match self {
            Self::Pcm8bit => 1,
            Self::Pcm16bit => 2,
            Self::PcmFloat => 4,
        }
    }
}

/// Audio channel configuration - Input (Microphone)
///
/// Defines channel configurations for audio input (recording), supporting mono and stereo.
/// Different channel configurations affect recording quality and storage space.
///
/// # Examples
///
/// ```no_run
/// use android_media::ChannelInConfig;
/// let config = ChannelInConfig::Mono;
/// assert_eq!(config.value(), 16);
/// assert_eq!(config.channel_count(), 1);
/// ```
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum ChannelInConfig {
    /// Mono recording - each sample point contains data from one channel
    Mono = 16,
    /// Stereo recording - each sample point contains data from left and right channels
    Stereo = 12,
}

impl ChannelInConfig {
    /// Get the integer value of the channel configuration
    ///
    /// # Returns
    ///
    /// Returns the channel configuration identifier in the Android system
    ///
    /// # Examples
    ///
    /// ```no_run
    /// use android_media::ChannelInConfig;
    /// assert_eq!(ChannelInConfig::Mono.value(), 16);
    /// ```
    pub const fn value(&self) -> i32 {
        *self as i32
    }

    /// Get the number of channels
    ///
    /// # Returns
    ///
    /// Returns the number of channels in this configuration (1 = mono, 2 = stereo)
    ///
    /// # Examples
    ///
    /// ```no_run
    /// use android_media::ChannelInConfig;
    /// assert_eq!(ChannelInConfig::Mono.channel_count(), 1);
    /// assert_eq!(ChannelInConfig::Stereo.channel_count(), 2);
    /// ```
    pub const fn channel_count(&self) -> i32 {
        match self {
            Self::Mono => 1,
            Self::Stereo => 2,
        }
    }
}

/// Audio channel configuration - Output (Player)
///
/// Defines channel configurations for audio output (playback), supporting mono and stereo.
///
/// # Examples
///
/// ```no_run
/// use android_media::ChannelOutConfig;
/// let config = ChannelOutConfig::Mono;
/// assert_eq!(config.value(), 4);
/// assert_eq!(config.channel_count(), 1);
/// ```
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum ChannelOutConfig {
    /// Mono playback - suitable for voice announcements, etc.
    Mono = 4,
    /// Stereo playback - suitable for music playback, etc.
    Stereo = 12,
}

impl ChannelOutConfig {
    /// Get the integer value of the channel configuration
    ///
    /// # Returns
    ///
    /// Returns the channel configuration identifier in the Android system
    ///
    /// # Examples
    ///
    /// ```no_run
    /// use android_media::ChannelOutConfig;
    /// assert_eq!(ChannelOutConfig::Mono.value(), 4);
    /// ```
    pub const fn value(&self) -> i32 {
        *self as i32
    }

    /// Get the number of channels
    ///
    /// # Returns
    ///
    /// Returns the number of channels in this configuration (1 = mono, 2 = stereo)
    ///
    /// # Examples
    ///
    /// ```no_run
    /// use android_media::ChannelOutConfig;
    /// assert_eq!(ChannelOutConfig::Mono.channel_count(), 1);
    /// assert_eq!(ChannelOutConfig::Stereo.channel_count(), 2);
    /// ```
    pub const fn channel_count(&self) -> i32 {
        match self {
            Self::Mono => 1,
            Self::Stereo => 2,
        }
    }
}

/// Audio source type
///
/// Defines various audio input sources supported by the Android audio system.
/// Different audio sources are suitable for different application scenarios.
///
/// # Examples
///
/// ```no_run
/// use android_media::AudioSource;
/// let source = AudioSource::Mic;
/// assert_eq!(source.value(), 1);
/// ```
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum AudioSource {
    /// Default audio source
    Default = 0,
    /// Main microphone - most commonly used recording source
    Mic = 1,
    /// Camera audio - used for video recording
    Camcorder = 5,
    /// Voice recognition - optimized for speech recognition scenarios with noise suppression
    VoiceRecognition = 6,
    /// Voice communication - optimized for call scenarios with echo cancellation
    VoiceCommunication = 7,
}

impl AudioSource {
    /// Get the integer value of the audio source
    ///
    /// # Returns
    ///
    /// Returns the audio source identifier in the Android system
    ///
    /// # Examples
    ///
    /// ```no_run
    /// use android_media::AudioSource;
    /// assert_eq!(AudioSource::Mic.value(), 1);
    /// ```
    pub const fn value(&self) -> i32 {
        *self as i32
    }
}

/// Audio recorder state
///
/// Defines the various states of the audio recorder.
///
/// # Examples
///
/// ```no_run
/// use android_media::RecorderState;
/// assert_eq!(RecorderState::Uninitialized.value(), 0);
/// assert_eq!(RecorderState::Initialized.value(), 1);
/// assert_eq!(RecorderState::Recording.value(), 3);
/// ```
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum RecorderState {
    /// Uninitialized state
    Uninitialized = 0,
    /// Initialized state, ready to start recording
    Initialized = 1,
    /// Recording state
    Recording = 3,
}

impl RecorderState {
    /// Get the integer value of the state
    ///
    /// # Returns
    ///
    /// Returns the state identifier in the Android system
    ///
    /// # Examples
    ///
    /// ```no_run
    /// use android_media::RecorderState;
    /// assert_eq!(RecorderState::Initialized.value(), 1);
    /// ```
    pub const fn value(&self) -> i32 {
        *self as i32
    }

    /// Get the state value after stopping
    ///
    /// In Android, after stopping recording, the recorder returns to the initialized state.
    ///
    /// # Returns
    ///
    /// Returns the value of the initialized state (1)
    ///
    /// # Examples
    ///
    /// ```no_run
    /// use android_media::RecorderState;
    /// assert_eq!(RecorderState::stopped(), 1);
    /// ```
    pub const fn stopped() -> i32 {
        Self::Initialized.value()
    }
}

/// Player mode
///
/// Defines the two playback modes of the audio player.
/// Different modes are suitable for different use cases.
///
/// # Examples
///
/// ```no_run
/// use android_media::PlayerMode;
/// let mode = PlayerMode::Stream;
/// assert_eq!(mode.value(), 1);
/// ```
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum PlayerMode {
    /// Static mode - suitable for playing short audio files
    ///
    /// In static mode, audio data is loaded into memory in one go before playback,
    /// suitable for playing shorter, fixed audio files (e.g., prompts, sound effects).
    Static = 0,
    /// Stream mode - suitable for playing long audio files or real-time audio streams
    ///
    /// In stream mode, audio data is written to the player in chunks, suitable for playing
    /// longer audio or real-time audio streams (e.g., music, real-time call audio).
    Stream = 1,
}

impl PlayerMode {
    /// Get the integer value of the playback mode
    ///
    /// # Returns
    ///
    /// Returns the playback mode identifier in the Android system
    ///
    /// # Examples
    ///
    /// ```no_run
    /// use android_media::PlayerMode;
    /// assert_eq!(PlayerMode::Stream.value(), 1);
    /// ```
    pub const fn value(&self) -> i32 {
        *self as i32
    }
}