Enum PlayerStatusEvent 

pub enum PlayerStatusEvent {
    PositionUpdate {
        position: f64,
        duration: f64,
    },
    StateChanged {
        state: String,
        media_id: Option<String>,
    },
    MediaLoaded {
        duration: f64,
    },
    PlaybackEnded,
    Buffering {
        percent: u8,
    },
    Error {
        message: String,
        recoverable: bool,
    },
    VolumeChanged {
        volume: f32,
        muted: bool,
    },
    SleepTimerChanged {
        mode: SleepTimerMode,
        remaining_seconds: u32,
    },
    SleepTimerExpired,
    ShowNextEpisodePopup {
        current_episode: MediaItem,
        next_episode: MediaItem,
        countdown_seconds: u32,
        auto_advance: bool,
    },
    CountdownTick {
        remaining_seconds: u32,
    },
    QueueChanged {
        items: Vec<MediaItem>,
        current_index: Option<usize>,
        shuffle: bool,
        repeat: RepeatMode,
        has_next: bool,
        has_previous: bool,
    },
    SessionChanged {
        session: MediaSessionType,
    },
    SessionsUpdated {
        sessions: Vec<SessionInfo>,
    },
    PlaybackModeChanged {
        mode: String,
        session_id: Option<String>,
    },
    RemoteDisconnectRequested,
    ControlCommand {
        action: String,
        position: Option<f64>,
    },
    WebviewAudioLoad {
        url: String,
        media_id: Option<String>,
        position: f64,
        autoplay: bool,
    },
}

Events emitted by the player backend to the frontend via Tauri events.

These are distinct from PlayerEvent in state.rs, which handles internal state machine transitions.

TRACES: UR-005, UR-019, UR-023, UR-026 | DR-001, DR-028, DR-047

Variants

PositionUpdate

Playback position updated (emitted periodically during playback)

Fields

position: f64

Current position in seconds

duration: f64

Total duration in seconds

StateChanged

Player state changed

Fields

state: String

New state: “playing”, “paused”, “stopped”, “loading”, “idle”

media_id: Option<String>

ID of the current media item, if any

MediaLoaded

Media has finished loading and is ready to play

Fields

duration: f64

Total duration in seconds

PlaybackEnded

Playback has ended naturally (reached end of media)

Buffering

Buffering state changed

Fields

percent: u8

Buffering progress (0-100)

Error

An error occurred during playback

Fields

message: String

Error message

recoverable: bool

Whether the error is recoverable

VolumeChanged

Volume changed

Fields

volume: f32

New volume level (0.0-1.0)

muted: bool

Whether audio is muted

SleepTimerChanged

Sleep timer state changed

Fields

mode: SleepTimerMode

Sleep timer mode

remaining_seconds: u32

Remaining seconds (for time-based timer)

SleepTimerExpired

Time-based sleep timer expired: playback must stop. The backend stops its own (MPV/ExoPlayer) playback, but HTML5 video on Linux plays in the webview outside the backend’s control — the frontend pauses it on this event.

ShowNextEpisodePopup

Show next episode popup with countdown

Fields

current_episode: MediaItem

Current episode that just finished

next_episode: MediaItem

Next episode to play

countdown_seconds: u32

Countdown duration in seconds

auto_advance: bool

Whether to auto-advance when countdown reaches 0

CountdownTick

Countdown tick (emitted every second during autoplay countdown)

Fields

remaining_seconds: u32

Remaining seconds in countdown

QueueChanged

Queue changed (items added, removed, reordered, or playback mode changed)

Fields

items: Vec<MediaItem>

All items in the queue

current_index: Option<usize>

Current item index

shuffle: bool

Whether shuffle is enabled

repeat: RepeatMode

Current repeat mode

has_next: bool

Whether there’s a next track available

has_previous: bool

Whether there’s a previous track available

SessionChanged

Media session changed (activity context changed: Audio/Movie/TvShow/Idle)

Fields

session: MediaSessionType

Current session state

SessionsUpdated

Remote sessions updated (for cast/remote control UI)

Fields

sessions: Vec<SessionInfo>

All active controllable sessions from Jellyfin

PlaybackModeChanged

The authoritative playback mode changed in the Rust backend.

The Rust PlaybackModeManager is the single source of truth for which device playback commands route to (local vs a remote session). The frontend keeps a mirror store for the UI; without this event that mirror drifts out of sync (e.g. a mode transition happens inside a transfer or a local stop that the frontend never learns about), and controls then route to the wrong device — the classic “it keeps playing on the remote” bug. The frontend reconciles its store to this payload whenever it fires.

Fields

mode: String

New mode: “local”, “remote”, or “idle”.

session_id: Option<String>

Session id when mode == "remote", otherwise None.

RemoteDisconnectRequested

The user asked to disconnect from the remote session and resume locally.

Emitted when the lockscreen Stop button is pressed while casting. The frontend owns the two-step remote->local transfer (it must reload the media item locally), so the native side only signals intent here.

ControlCommand

Backend-originated control command targeting the active frontend player adapter (the HTML5

Fields

action: String

One of: “play”, “pause”, “stop”, “seek”.

position: Option<f64>

Target position in seconds (only meaningful for “seek”).

WebviewAudioLoad

Ask the frontend webview <audio> element to load and play a stream.

Emitted by WebviewAudioBackend on platforms with no native audio backend (e.g. Windows): audio-only playback is rendered by an <audio> element in the webview, mirroring how all video already renders through the webview <video>. The element then reports its state/position back through the player_report_* commands, so the Rust controller stays the single source of truth. Subsequent play/pause/seek/stop reach the element via ControlCommand.

Fields

url: String

Stream URL for the <audio> element to play.

media_id: Option<String>

Jellyfin item id, used as the media_id when reporting state back.

position: f64

Resume position in seconds (0 = start from the beginning).

autoplay: bool

Whether to begin playing immediately after loading.

Trait Implementations

impl Clone for PlayerStatusEvent

fn clone(&self) -> PlayerStatusEvent

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for PlayerStatusEvent

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for PlayerStatusEvent

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Event for PlayerStatusEvent

const NAME: &'static str = "player-status-event"

The unique name for this event. Derived from the struct’s name via the Event derive macro.

fn listen<F, R, H>(handle: &H, handler: F) -> u32

where R: Runtime, H: Listener<R> + Manager<R>, F: Fn(TypedEvent<Self>) + Send + 'static, Self: DeserializeOwned,

Listen to an emitted event on this manager.

fn listen_any<F, R, H>(handle: &H, handler: F) -> u32

where R: Runtime, H: Listener<R> + Manager<R>, F: Fn(TypedEvent<Self>) + Send + 'static, Self: DeserializeOwned,

Listen to an emitted event to any target.

fn once<F, R, H>(handle: &H, handler: F) -> u32

where R: Runtime, H: Listener<R> + Manager<R>, F: FnOnce(TypedEvent<Self>) + Send + 'static, Self: DeserializeOwned,

Listen to an event on this manager only once.

fn once_any<F, R, H>(handle: &H, handler: F) -> u32

where R: Runtime, H: Listener<R> + Manager<R>, F: FnOnce(TypedEvent<Self>) + Send + 'static, Self: DeserializeOwned,

Listens once to an emitted event to any target .

fn emit<R, H>(&self, handle: &H) -> Result<(), Error>

where R: Runtime, H: Emitter<R> + Manager<R>, Self: Serialize + Clone,

Emits an event to all targets.

fn emit_to<R, H, I>(&self, handle: &H, target: I) -> Result<(), Error>

where R: Runtime, H: Emitter<R> + Manager<R>, I: Into<EventTarget>, Self: Serialize + Clone,

Emits an event to all targets matching the given target.

fn emit_filter<F, R, H>(&self, handle: &H, filter: F) -> Result<(), Error>

where R: Runtime, H: Emitter<R> + Manager<R>, F: Fn(&EventTarget) -> bool, Self: Serialize + Clone,

Emits an event to all targets based on the given filter.

impl NamedType for PlayerStatusEvent

fn sid() -> SpectaID

fn named_data_type( type_map: &mut TypeCollection, generics: &[DataType], ) -> NamedDataType

this is equivalent to [Type::inline] but returns a [NamedDataType] instead.

fn definition_named_data_type(type_map: &mut TypeCollection) -> NamedDataType

this is equivalent to [Type::definition] but returns a [NamedDataType] instead.

impl Serialize for PlayerStatusEvent

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Type for PlayerStatusEvent

fn inline(type_map: &mut TypeCollection, generics: Generics<'_>) -> DataType

Returns the definition of a type using the provided generics.

fn reference(type_map: &mut TypeCollection, generics: &[DataType]) -> Reference

Generates a datatype corresponding to a reference to this type, as determined by its category. Getting a reference to a type implies that it should belong in the type map (since it has to be referenced from somewhere), so the output of definition will be put into the type map.

impl Flatten for PlayerStatusEvent