songbird 0.6.0

An async Rust library for the Discord voice API.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139

use super::message::*;
use crate::{
    events::{EventStore, GlobalEvents, TrackEvent},
    tracks::{ReadyState, TrackHandle, TrackState},
};
use flume::Receiver;
use tracing::{debug, info, instrument, trace};

#[instrument(skip(evt_rx))]
pub(crate) async fn runner(evt_rx: Receiver<EventMessage>) {
    let mut global = GlobalEvents::default();

    let mut events: Vec<EventStore> = vec![];
    let mut states: Vec<TrackState> = vec![];
    let mut handles: Vec<TrackHandle> = vec![];

    while let Ok(msg) = evt_rx.recv_async().await {
        match msg {
            EventMessage::AddGlobalEvent(data) => {
                info!("Global event added.");
                global.add_event(data);
            },
            EventMessage::AddTrackEvent(i, data) => {
                info!("Adding event to track {}.", i);

                let event_store = events
                    .get_mut(i)
                    .expect("Event thread was given an illegal store index for AddTrackEvent.");
                let state = states
                    .get_mut(i)
                    .expect("Event thread was given an illegal state index for AddTrackEvent.");

                event_store.add_event(data, state.position);
            },
            EventMessage::FireCoreEvent(ctx) => {
                let ctx = ctx.to_user_context();
                let evt = ctx
                    .to_core_event()
                    .expect("Event thread was passed a non-core event in FireCoreEvent.");

                trace!("Firing core event {:?}.", evt);

                global.fire_core_event(evt, ctx).await;
            },
            EventMessage::RemoveGlobalEvents => {
                global.remove_handlers();
            },
            EventMessage::AddTrack(store, state, handle) => {
                events.push(store);
                states.push(state);
                handles.push(handle);

                info!("Event state for track {} added", events.len());
            },
            EventMessage::ChangeState(i, change) => {
                let max_states = states.len();
                debug!(
                    "Changing state for track {} of {}: {:?}",
                    i, max_states, change
                );

                let state = states
                    .get_mut(i)
                    .expect("Event thread was given an illegal state index for ChangeState.");

                match change {
                    TrackStateChange::Mode(mut mode) => {
                        std::mem::swap(&mut state.playing, &mut mode);
                        if state.playing != mode {
                            global.fire_track_event(state.playing.as_track_event(), i);
                            if let Some(other_evts) = state.playing.also_fired_track_events() {
                                for evt in other_evts {
                                    global.fire_track_event(evt, i);
                                }
                            }
                        }
                    },
                    TrackStateChange::Volume(vol) => {
                        state.volume = vol;
                    },
                    TrackStateChange::Position(pos) => {
                        // Currently, only Tick should fire time events.
                        state.position = pos;
                    },
                    TrackStateChange::Loops(loops, user_set) => {
                        state.loops = loops;
                        if !user_set {
                            global.fire_track_event(TrackEvent::Loop, i);
                        }
                    },
                    TrackStateChange::Total(new) => {
                        // Massive, unprecedented state changes.
                        *state = new;
                    },
                    TrackStateChange::Ready(ready_state) => {
                        state.ready = ready_state;

                        match ready_state {
                            ReadyState::Playable => {
                                global.fire_track_event(TrackEvent::Playable, i);
                            },
                            ReadyState::Preparing => {
                                global.fire_track_event(TrackEvent::Preparing, i);
                            },
                            ReadyState::Uninitialised => {},
                        }
                    },
                }
            },
            EventMessage::RemoveAllTracks => {
                info!("Event state for all tracks removed.");

                events.clear();
                states.clear();
                handles.clear();
            },
            EventMessage::Tick => {
                // NOTE: this should fire saved up blocks of state change evts.
                global.tick(&mut events, &mut states, &mut handles).await;

                let mut i = 0;
                while i < states.len() {
                    if states[i].playing.is_done() {
                        info!("Event state for track {} of {} removed.", i, events.len());

                        events.swap_remove(i);
                        states.swap_remove(i);
                        handles.swap_remove(i);
                    } else {
                        i += 1;
                    }
                }
            },
            EventMessage::Poison => break,
        }
    }

    trace!("Event thread exited.");
}