Driver: Add ability to clear all global event handlers.

Closes #32. This should make event handler cleanup considerably easier depending on use case.

src/driver/mod.rs

@@ -238,6 +238,12 @@ impl Driver {
         self.send(CoreMessage::AddEvent(EventData::new(event, action)));
     }
 
+    /// Removes all global event handlers from an audio context.
+    #[instrument(skip(self))]
+    pub fn remove_all_global_events(&mut self) {
+        self.send(CoreMessage::RemoveGlobalEvents);
+    }
+
     /// Sends a message to the inner tasks, restarting it if necessary.
     fn send(&mut self, status: CoreMessage) {
         // Restart thread if it errored.

src/driver/tasks/events.rs

@@ -43,6 +43,9 @@ pub(crate) async fn runner(_interconnect: Interconnect, evt_rx: Receiver<EventMe
 
                 global.fire_core_event(evt, ctx).await;
             },
+            Ok(RemoveGlobalEvents) => {
+                global.remove_handlers();
+            },
             Ok(AddTrack(store, state, handle)) => {
                 events.push(store);
                 states.push(state);

src/driver/tasks/message/core.rs

@@ -18,6 +18,7 @@ pub enum CoreMessage {
     AddTrack(Track),
     SetBitrate(Bitrate),
     AddEvent(EventData),
+    RemoveGlobalEvents,
     SetConfig(Config),
     Mute(bool),
     Reconnect,

src/driver/tasks/message/events.rs

@@ -12,6 +12,7 @@ pub enum EventMessage {
     AddGlobalEvent(EventData),
     AddTrackEvent(usize, EventData),
     FireCoreEvent(CoreContext),
+    RemoveGlobalEvents,
 
     AddTrack(EventStore, TrackState, TrackHandle),
     ChangeState(usize, TrackStateChange),

src/driver/tasks/mod.rs

@@ -109,6 +109,9 @@ async fn runner(mut config: Config, rx: Receiver<CoreMessage>, tx: Sender<CoreMe
             Ok(CoreMessage::AddEvent(evt)) => {
                 let _ = interconnect.events.send(EventMessage::AddGlobalEvent(evt));
             },
+            Ok(CoreMessage::RemoveGlobalEvents) => {
+                let _ = interconnect.events.send(EventMessage::RemoveGlobalEvents);
+            },
             Ok(CoreMessage::Mute(m)) => {
                 let _ = interconnect.mixer.send(MixerMessage::SetMute(m));
             },

src/events/store.rs

@@ -164,6 +164,10 @@ impl GlobalEvents {
         holder.push(index);
     }
 
+    pub(crate) fn remove_handlers(&mut self) {
+        self.store = EventStore::new();
+    }
+
     pub(crate) async fn tick(
         &mut self,
         events: &mut Vec<EventStore>,