Struct GeneralPlayer

pub struct GeneralPlayer {
    pub backend: Backend,
    pub playlist: Playlist,
    pub config: SharedServerSettings,
    pub current_track_updated: bool,
    pub mpris: Option<Mpris>,
    pub discord: Option<Rpc>,
    pub db: DataBase,
    pub db_podcast: Database,
    pub cmd_tx: PlayerCmdSender,
    pub stream_tx: StreamTX,
}

Fields

backend: Backend

playlist: Playlist

config: SharedServerSettings

current_track_updated: bool

mpris: Option<Mpris>

discord: Option<Rpc>

db: DataBase

db_podcast: Database

cmd_tx: PlayerCmdSender

stream_tx: StreamTX

Implementations

impl GeneralPlayer

pub fn mpris_handler(&mut self, e: MediaControlEvent)

pub fn mpris_handle_events(&mut self)

Handle Media-Controls events, if enabled to be used

pub fn mpris_update_progress(&mut self, progress: &PlayerProgress)

Update Media-Controls reported Position & Status, if enabled to be reporting

pub fn mpris_volume_update(&mut self)

Update Media-Controls reported volume, if enabled to be reporting

impl GeneralPlayer

pub fn new_backend( backend: BackendSelect, config: SharedServerSettings, cmd_tx: PlayerCmdSender, stream_tx: StreamTX, ) -> Result<Self>

Create a new GeneralPlayer, with the selected backend

Errors

• if connecting to the database fails
• if config path creation fails

pub fn new( config: SharedServerSettings, cmd_tx: PlayerCmdSender, stream_tx: StreamTX, ) -> Result<Self>

Create a new GeneralPlayer, with the [BackendSelect::Default] backend

Errors

• if connecting to the database fails
• if config path creation fails

pub fn reload_config(&mut self) -> Result<()>

Reload the config from file, on fail continue to use the old

Errors

• if Config could not be parsed

pub fn toggle_gapless(&mut self) -> bool

pub fn start_play(&mut self)

Requires that the function is called on a thread with a entered tokio runtime

Panics

if current_track_index in playlist is above u32

pub fn enqueue_next_from_playlist(&mut self)

pub fn next(&mut self)

Skip to the next track, if there is one

pub fn previous(&mut self)

Switch & Play the previous track in the playlist

pub fn toggle_pause(&mut self)

Resume playback if paused, pause playback if running

pub fn pause(&mut self)

Pause playback if running

pub fn play(&mut self)

Resume playback if paused

pub fn seek_relative(&mut self, forward: bool)

Panics

if the underlying “seek” returns a error (which current never happens)

pub fn player_save_last_position(&mut self)

pub fn player_restore_last_position(&mut self)

Trait Implementations

impl PlayerTrait for GeneralPlayer

fn pause(&mut self)

This function should not be used directly, use GeneralPlayer::pause

fn resume(&mut self)

This function should not be used directly, use GeneralPlayer::play

fn add_and_play<'life0, 'life1, 'async_trait>( &'life0 mut self, track: &'life1 Track, ) -> Pin<Box<dyn Future<Output = ()> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Add the given track, skip to it (if not already) and start playing

fn volume(&self) -> Volume

Get the currently set volume

fn add_volume(&mut self, volume: VolumeSigned) -> Volume

Add a relative amount to the current volume

fn set_volume(&mut self, volume: Volume) -> Volume

Set the volume to a specific amount.

fn is_paused(&self) -> bool

fn seek(&mut self, secs: i64) -> Result<()>

Seek relatively to the current time

fn seek_to(&mut self, position: Duration)

Seek to a absolute position

fn set_speed(&mut self, speed: Speed) -> Speed

Set the speed to a specific amount.

fn add_speed(&mut self, speed: SpeedSigned) -> Speed

Add a relative amount to the current speed

fn speed(&self) -> Speed

Get the currently set speed

fn stop(&mut self)

fn get_progress(&self) -> Option<PlayerProgress>

Get current track time position

fn gapless(&self) -> bool

fn set_gapless(&mut self, to: bool)

fn skip_one(&mut self)

fn position(&self) -> Option<PlayerTimeUnit>

Quickly access the position.

fn enqueue_next(&mut self, track: &Track)

Add the given URI to be played, but do not skip currently playing track

fn media_info(&self) -> MediaInfo

Get info of the current media