Enum LinkCommand 

pub enum LinkCommand {
    Play {
        track_ids: Vec<String>,
        start_at: u32,
        position_ms: u64,
        paused: bool,
        handoff: bool,
        mode: QueueMode,
    },
    Enqueue {
        track_ids: Vec<String>,
    },
    PlayNext {
        track_ids: Vec<String>,
    },
    Remove {
        track_ids: Vec<String>,
    },
    Clear,
    Sync {
        full: bool,
    },
    Evict {
        track_ids: Vec<String>,
    },
    JumpTo {
        track_id: String,
    },
    Seek {
        position_ms: u64,
    },
    Pause,
    Resume,
    Next,
    Previous,
    PlayItem {
        id: String,
    },
    RemoveItems {
        ids: Vec<String>,
    },
    MoveItems {
        ids: Vec<String>,
        target: String,
        after: bool,
    },
    Insert {
        track_ids: Vec<String>,
        after: String,
    },
    Undo,
    Redo,
    Shuffle {
        on: bool,
    },
    Repeat {
        mode: Repeat,
    },
    SleepTimer {
        timer: Option<SleepTimer>,
    },
    HandOff {
        to: String,
    },
    Devices {
        devices: Vec<LinkDevice>,
    },
    DeviceKeys {
        keys: Vec<LinkDeviceKey>,
    },
    Shares {
        grantees: Vec<String>,
        error: Option<String>,
        accounts: Vec<String>,
    },
    Shared {
        command: Box<LinkCommand>,
    },
    Forgotten {
        device: String,
    },
    HistoryChanged,
    DspProfilesChanged,
    SetOutput {
        output: OutputChoice,
    },
    RefreshOutputs,
    SetRendererVolume {
        volume: u8,
    },
    SetPreset {
        device: String,
        profile: Option<String>,
    },
    WatchLevels {
        on: bool,
    },
    Levels {
        from: String,
        f: Frame,
    },
    Acked {
        from: String,
        ack: u64,
        outcome: AckOutcome,
    },
}

What a server asks a linked client to do.

Variants

Play

Replace the queue with these tracks and play from start_at, position_ms into it — or load it there paused, when paused.

Fields

track_ids: Vec<String>

start_at: u32

position_ms: u64

paused: bool

handoff: bool

Sent by a device handing its music over. One that receives it while controlling another device takes control back: the music is here now, so this device is what the person is listening to. A plain play leaves control alone, so two devices can still control each other on purpose.

mode: QueueMode

Whether to reset the play mode, as a play from a play button does. Absent, the modes are kept.

Enqueue

Append these tracks to the queue.

Fields

track_ids: Vec<String>

PlayNext

Insert these tracks after the current one.

Fields

track_ids: Vec<String>

Remove

Take every queue entry for these tracks out of the queue.

Fields

track_ids: Vec<String>

Clear

Sync

Pull what the server has changed: library, favourites and playlists. The library is walked only if the server says it moved, unless full, which walks it regardless.

Fields

full: bool

Evict

Delete the downloaded copies of these tracks, so the next play fetches them again: for a copy that was cached while the server’s was bad.

Fields

track_ids: Vec<String>

JumpTo

Play this track: from where it sits in the queue, or slotted in after the current one when the queue does not hold it.

Fields

track_id: String

Seek

Fields

position_ms: u64

Pause

Resume

Next

Previous

PlayItem

Play this queue entry, by the id the device reported it under. Unlike JumpTo it names one entry of a track queued twice, and reaches a file only that device has.

Fields

id: String

RemoveItems

Fields

ids: Vec<String>

MoveItems

Move these queue entries before or after target, in the order given.

Fields

ids: Vec<String>

target: String

after: bool

Insert

Insert these tracks after the queue entry after.

Fields

track_ids: Vec<String>

after: String

Undo

Redo

Shuffle

Turn shuffle on or off. The queue keeps its order; shuffle picks which track yet to play this pass plays next.

Fields

on: bool

Repeat

What follows a track at its end: off, queue or one.

Fields

mode: Repeat

SleepTimer

Set the sleep timer, or with none cancel it.

Fields

timer: Option<SleepTimer>

HandOff

Send this device’s queue and playhead to the device to, as a play, and pause here. The device holding the queue does it, so taking music from another device and sending it there are one command.

Fields

to: String

Devices

The account’s other devices, as they are now. News rather than a command: sent whenever one of them changes, to links that asked for it.

Fields

devices: Vec<LinkDevice>

DeviceKeys

The public keys the account’s devices, and devices shared with it, prove themselves with on the local network (koanDeviceKeys). News, as Devices is: sent when a device that registered a key links, and whenever the account’s keys change. From the server alone, never from the network: it is what the network’s claims are checked against.

Fields

keys: Vec<LinkDeviceKey>

Shares

The accounts this device lets control it. News, as Devices is: sent when it links and whenever the list changes.

Fields

grantees: Vec<String>

error: Option<String>

Why the last request to share or stop sharing was refused.

accounts: Vec<String>

Every account on the server, to choose from.

Shared

command, sent by another account this device is shared with: run as that account’s request, from the playback set (allowed_playback).

Fields

command: Box<LinkCommand>

Forgotten

device was forgotten: drop it, however it was last heard of. News, as Devices is.

Fields

device: String

HistoryChanged

The account’s play history on the server moved: a play recorded or forgotten on one of its devices. The device reads what changed (remote::history::sync).

DspProfilesChanged

The account’s EQ profiles kept everywhere moved on the server: one changed or deleted on another of its devices. The device reads what changed (remote::dsp_sync::sync).

SetOutput

Play through this output from now on, carrying on from where the music is, as the device’s own output menu would.

Fields

output: OutputChoice

RefreshOutputs

List the outputs again, and publish them if they moved: a controller has opened its output menu. Cheap, and answered by the link state.

SetRendererVolume

The volume of the renderer the device plays to, 0–100.

Fields

volume: u8

SetPreset

Play the output device through the DSP profile profile, or untouched with None. A renderer is named by its UDN.

Fields

device: String

profile: Option<String>

WatchLevels

Send this device’s audio levels (LinkReport::Levels) while on: a controller has playing bars on screen. A device on the same network may ask; levels say no more than the now-playing it already sees.

Fields

on: bool

Levels

A frame of the levels of from, a device this one watches, relayed by the server. News, like Devices.

Fields

from: String

f: Frame

Acked

The device from answered the command this device sent it under ack: see remote::acks. Relayed by the server; news, like Levels.

Fields

from: String

ack: u64

outcome: AckOutcome

Implementations

impl LinkCommand

pub fn allowed_playback(&self) -> bool

What a device that is not this account’s may have it do: play, pause, skip and seek, change the queue, jump, set the volume and the sleep timer, choose the output and the preset, and move the music here or away. What it asks for runs as the asker’s request, never with this account’s powers: nothing here changes the library, the config beyond the output in use, or the account’s favourites, playlists or history, and a track it names that the library lacks is not synced for (see CommandSource). For a device shared with another account, and one on the local network under Full control.

pub fn from_the_network(&self, full: bool) -> Option<CommandSource>

How a command from a device on the local network runs here, if at all: with full control (this device’s setting) the playback set, as Nearby; without, a stranger’s narrower set, as Stranger.

pub fn relayable(&self) -> bool

Whether a client may have the server relay this to another device: the commands one device gives another. The server’s own news (the device list, the device keys, shares, forgettings, history) it alone originates; relayed, a forged copy would read as the server’s. Levels go only between live links, by their own route. Exhaustive, so a new variant is relayable only once someone decides it is.

pub fn live_only(&self) -> bool

Only worth saying to a device that is there to hear it: sent over a live route or not at all, never queued for an absent device and never a push to wake one.

pub fn allowed_nearby(&self) -> bool

Whether a device on the same network, which may belong to anyone, may send this under Playback only. Playback and the queue; nothing that touches the library or the files on disk.

Where the sound goes is not playback: an output switch reaches into the room, and a preset into the config. Those are the account’s own.

pub fn track_ids(&self) -> &[String]

The server’s ids for the tracks this command names, if any.

impl LinkCommand

pub fn track_ids_mut(&mut self) -> Vec<&mut String>

Every track id the command carries, for translating between the server’s row ids and the uids it publishes.

Trait Implementations

impl Clone for LinkCommand

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for LinkCommand

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for LinkCommand

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Eq for LinkCommand

impl From<LinkCommand> for Envelope

fn from(command: LinkCommand) -> Self

Converts to this type from the input type.

impl PartialEq for LinkCommand

fn eq(&self, other: &Self) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl Serialize for LinkCommand

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for LinkCommand