Merge pull request #409 from orottier/feature/on-state-change

Implement BaseAudioContext::onStateChange

Author: orottier

src/context/base.rs

@@ -6,6 +6,7 @@ use crate::context::{
     DESTINATION_NODE_ID,
 };
 use crate::decoding::MediaDecoder;
+use crate::events::{Event, EventHandler, EventType};
 use crate::node::{AudioNode, ChannelConfigOptions};
 use crate::param::AudioParamDescriptor;
 use crate::periodic_wave::{PeriodicWave, PeriodicWaveOptions};
@@ -301,6 +302,23 @@ pub trait BaseAudioContext {
         (param, proc_id)
     }
 
+    /// Register callback to run when the state of the AudioContext has changed
+    ///
+    /// Only a single event handler is active at any time. Calling this method multiple times will
+    /// override the previous event handler.
+    fn set_onstatechange<F: FnMut(Event) + Send + 'static>(&self, mut callback: F) {
+        let callback = move |_| {
+            callback(Event {
+                type_: "onstatechange",
+            })
+        };
+
+        self.base().set_event_handler(
+            EventType::StateChange,
+            EventHandler::Multiple(Box::new(callback)),
+        );
+    }
+
     #[cfg(test)]
     fn mock_registration(&self) -> AudioContextRegistration {
         AudioContextRegistration {

src/context/concrete_base.rs

@@ -338,7 +338,11 @@ impl ConcreteBaseAudioContext {
 
     /// Updates state of current context
     pub(super) fn set_state(&self, state: AudioContextState) {
-        self.inner.state.store(state as u8, Ordering::SeqCst);
+        let current_state = self.state();
+        if current_state != state {
+            self.inner.state.store(state as u8, Ordering::SeqCst);
+            let _ = self.send_event(EventDispatch::state_change());
+        }
     }
 
     /// The sample rate (in sample-frames per second) at which the `AudioContext` handles audio.

src/events.rs

@@ -15,10 +15,11 @@ pub struct Event {
     pub type_: &'static str,
 }
 
-#[derive(Hash, Eq, PartialEq)]
+#[derive(Hash, Eq, PartialEq, Debug)]
 pub(crate) enum EventType {
     Ended(AudioNodeId),
     SinkChange,
+    StateChange,
     RenderCapacity,
     ProcessorError(AudioNodeId),
     Diagnostics,
@@ -36,13 +37,15 @@ pub struct ErrorEvent {
     pub event: Event,
 }
 
+#[derive(Debug)]
 pub(crate) enum EventPayload {
     None,
     RenderCapacity(AudioRenderCapacityEvent),
     ProcessorError(ErrorEvent),
     Diagnostics(Vec<u8>),
 }
 
+#[derive(Debug)]
 pub(crate) struct EventDispatch {
     type_: EventType,
     payload: EventPayload,
@@ -63,6 +66,13 @@ impl EventDispatch {
         }
     }
 
+    pub fn state_change() -> Self {
+        EventDispatch {
+            type_: EventType::StateChange,
+            payload: EventPayload::None,
+        }
+    }
+
     pub fn render_capacity(value: AudioRenderCapacityEvent) -> Self {
         EventDispatch {
             type_: EventType::RenderCapacity,

tests/online.rs

@@ -8,7 +8,7 @@ use web_audio_api::context::{
 };
 use web_audio_api::node::AudioNode;
 
-use std::sync::atomic::{AtomicBool, Ordering};
+use std::sync::atomic::{AtomicBool, AtomicU32, Ordering};
 use web_audio_api::MAX_CHANNELS;
 
 fn require_send_sync_static<T: Send + Sync + 'static>(_: T) {}
@@ -87,6 +87,16 @@ fn test_none_sink_id() {
     let context = AudioContext::new(options);
     assert_eq!(context.sink_id(), "none");
 
+    // count the number of state changes
+    let state_changes = &*Box::leak(Box::new(AtomicU32::new(0)));
+    context.set_onstatechange(move |_| {
+        state_changes.fetch_add(1, Ordering::Relaxed);
+    });
+
+    // give event thread some time to pick up events
+    std::thread::sleep(std::time::Duration::from_millis(20));
+    assert_eq!(state_changes.load(Ordering::Relaxed), 1); // started
+
     // changing sink_id to 'none' again should make no changes
     let sink_stable = &*Box::leak(Box::new(AtomicBool::new(true)));
     context.set_onsinkchange(move |_| {
@@ -98,13 +108,24 @@ fn test_none_sink_id() {
     context.suspend_sync();
     assert_eq!(context.state(), AudioContextState::Suspended);
 
+    // give event thread some time to pick up events
+    std::thread::sleep(std::time::Duration::from_millis(20));
+    assert_eq!(state_changes.load(Ordering::Relaxed), 2); // suspended
+
     context.resume_sync();
     assert_eq!(context.state(), AudioContextState::Running);
 
+    // give event thread some time to pick up events
+    std::thread::sleep(std::time::Duration::from_millis(20));
+    assert_eq!(state_changes.load(Ordering::Relaxed), 3); // resumed
+
     context.close_sync();
     assert_eq!(context.state(), AudioContextState::Closed);
 
+    // give event thread some time to pick up events
+    std::thread::sleep(std::time::Duration::from_millis(20));
     assert!(sink_stable.load(Ordering::SeqCst));
+    assert_eq!(state_changes.load(Ordering::Relaxed), 4); // closed
 }
 
 #[test]