fix(ios): resolve second review round on session interruption recovery

- Replace the playing/interrupted bool pair with a PlaybackState enum,
  so pause() during an interruption can't leave a stale flag that
  restarts the stream on the next interruption end.
- Narrow unsafe to the extern-static reads that actually need it.
- Drop the redundant field comment, tighten changelog wording.

Co-authored-by: Benoît Rouleau <benoit.rouleau@icloud.com>

Author: roderickvd

CHANGELOG.md

@@ -30,7 +30,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - **AudioWorklet**: Fix stale audio output when a data callback wrote a partial buffer.
 - **CoreAudio**: Default-output streams now report xrun status.
 - **CoreAudio**: Fix stale audio output when a data callback wrote a partial buffer.
-- **iOS**: Streams stopped by an audio session interruption now resume when it ends, instead of staying silent until rebuilt.
+- **iOS**: Streams now resume automatically when an audio session interruption ends.
 - **JACK**: Streams with more channels than physical system ports no longer fail to build.
 - **JACK**: Channel enumeration is no longer capped at the physical system port count.
 - **JACK**: `Device::id` no longer embeds the process ID, so `DeviceId` is now stable across application restarts.

src/host/coreaudio/ios/mod.rs

@@ -138,6 +138,39 @@ impl Device {
     }
 }
 
+#[derive(Clone, Copy, Default, PartialEq, Eq)]
+enum PlaybackState {
+    #[default]
+    Stopped,
+    Playing,
+    Interrupted,
+}
+
+struct StreamInner {
+    state: PlaybackState,
+    audio_unit: AudioUnit,
+}
+
+impl StreamInner {
+    fn stop_for_interruption(&mut self) {
+        if self.state != PlaybackState::Playing {
+            return;
+        }
+        // The OS may have already stopped the unit; stop() is idempotent.
+        let _ = self.audio_unit.stop();
+        self.state = PlaybackState::Interrupted;
+    }
+
+    fn resume_after_interruption(&mut self) {
+        if self.state != PlaybackState::Interrupted {
+            return;
+        }
+        if self.audio_unit.start().is_ok() {
+            self.state = PlaybackState::Playing;
+        }
+    }
+}
+
 impl DeviceTrait for Device {
     type SupportedInputConfigs = SupportedInputConfigs;
     type SupportedOutputConfigs = SupportedOutputConfigs;
@@ -206,8 +239,7 @@ impl DeviceTrait for Device {
         )?;
 
         let inner = Arc::new(Mutex::new(StreamInner {
-            playing: false,
-            interrupted: false,
+            state: PlaybackState::default(),
             audio_unit,
         }));
         let session_manager = SessionEventManager::new(
@@ -266,8 +298,7 @@ impl DeviceTrait for Device {
         )?;
 
         let inner = Arc::new(Mutex::new(StreamInner {
-            playing: false,
-            interrupted: false,
+            state: PlaybackState::default(),
             audio_unit,
         }));
         let session_manager = SessionEventManager::new(
@@ -308,12 +339,12 @@ impl StreamTrait for Stream {
         let mut stream = self.inner.lock().map_err(|_| {
             Error::with_message(ErrorKind::StreamInvalidated, "Stream lock poisoned")
         })?;
-        if !stream.playing {
+        if stream.state != PlaybackState::Playing {
             stream
                 .audio_unit
                 .start()
                 .context("Failed to start audio unit")?;
-            stream.playing = true;
+            stream.state = PlaybackState::Playing;
         }
         Ok(())
     }
@@ -322,13 +353,13 @@ impl StreamTrait for Stream {
         let mut stream = self.inner.lock().map_err(|_| {
             Error::with_message(ErrorKind::StreamInvalidated, "Stream lock poisoned")
         })?;
-        if stream.playing {
+        if stream.state == PlaybackState::Playing {
             stream
                 .audio_unit
                 .stop()
                 .context("Failed to stop audio unit")?;
-            stream.playing = false;
         }
+        stream.state = PlaybackState::Stopped;
         Ok(())
     }
 
@@ -342,35 +373,6 @@ impl StreamTrait for Stream {
     }
 }
 
-struct StreamInner {
-    playing: bool,
-    /// Set while an interruption is what stopped the unit, so only those resume on its end.
-    interrupted: bool,
-    audio_unit: AudioUnit,
-}
-
-impl StreamInner {
-    /// The OS already stopped the unit; resync `playing` so a later `play` actually starts it.
-    fn stop_for_interruption(&mut self) {
-        if !self.playing {
-            return;
-        }
-        let _ = self.audio_unit.stop();
-        self.playing = false;
-        self.interrupted = true;
-    }
-
-    /// Only resumes what the interruption stopped; a stream the caller had paused stays paused.
-    fn resume_after_interruption(&mut self) {
-        if !std::mem::take(&mut self.interrupted) {
-            return;
-        }
-        if self.audio_unit.start().is_ok() {
-            self.playing = true;
-        }
-    }
-}
-
 fn create_audio_unit() -> Result<AudioUnit, coreaudio::Error> {
     AudioUnit::new_uninitialized(coreaudio::audio_unit::IOType::RemoteIO)
 }

src/host/coreaudio/ios/session_event_manager.rs

@@ -35,7 +35,7 @@ fn with_stream(stream: &Weak<Mutex<StreamInner>>, f: impl FnOnce(&mut StreamInne
 }
 
 /// Reads the number stored under `key` in a notification's `userInfo`.
-unsafe fn user_info_number(notification: &NSNotification, key: Option<&NSString>) -> Option<usize> {
+fn user_info_number(notification: &NSNotification, key: Option<&NSString>) -> Option<usize> {
     let user_info = notification.userInfo()?;
     let value = user_info.objectForKey(key?)?;
     Some(value.downcast::<NSNumber>().ok()?.unsignedIntegerValue())
@@ -45,10 +45,9 @@ unsafe fn user_info_number(notification: &NSNotification, key: Option<&NSString>
 /// input or output latency. `true` means an input stream.
 type LatencyRefresh = (Arc<AtomicUsize>, bool);
 
-unsafe fn route_change_error(notification: &NSNotification) -> Option<Error> {
-    let reason = AVAudioSessionRouteChangeReason(unsafe {
-        user_info_number(notification, AVAudioSessionRouteChangeReasonKey)?
-    });
+fn route_change_error(notification: &NSNotification) -> Option<Error> {
+    let key = unsafe { AVAudioSessionRouteChangeReasonKey };
+    let reason = AVAudioSessionRouteChangeReason(user_info_number(notification, key)?);
     match reason {
         AVAudioSessionRouteChangeReason::OldDeviceUnavailable => Some(Error::with_message(
             ErrorKind::DeviceChanged,
@@ -103,18 +102,17 @@ impl SessionEventManager {
                     return;
                 }
                 let notif = unsafe { notif.as_ref() };
-                let Some(kind) =
-                    (unsafe { user_info_number(notif, AVAudioSessionInterruptionTypeKey) })
-                else {
+                let interruption_type_key = unsafe { AVAudioSessionInterruptionTypeKey };
+                let Some(kind) = user_info_number(notif, interruption_type_key) else {
                     return;
                 };
                 if AVAudioSessionInterruptionType(kind) == AVAudioSessionInterruptionType::Began {
                     with_stream(&stream, StreamInner::stop_for_interruption);
                     return;
                 }
+                let interruption_option_key = unsafe { AVAudioSessionInterruptionOptionKey };
                 let options = AVAudioSessionInterruptionOptions(
-                    unsafe { user_info_number(notif, AVAudioSessionInterruptionOptionKey) }
-                        .unwrap_or(0),
+                    user_info_number(notif, interruption_option_key).unwrap_or(0),
                 );
                 if !options.contains(AVAudioSessionInterruptionOptions::ShouldResume) {
                     return;
@@ -147,7 +145,8 @@ impl SessionEventManager {
                         };
                         frames.store(depth, Ordering::Relaxed);
                     }
-                    if let Some(err) = unsafe { route_change_error(notif.as_ref()) } {
+                    let notif = unsafe { notif.as_ref() };
+                    if let Some(err) = route_change_error(notif) {
                         emit_error(&cb, err);
                     }
                 }