use std::sync::atomic::{AtomicU64, Ordering};
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Hash)]
pub enum AudioCategory {
#[default]
System,
Playback,
}
pub(crate) fn set_category(category: AudioCategory) {
#[cfg(target_os = "ios")]
ios::set_category(category);
#[cfg(not(target_os = "ios"))]
let _ = category;
}
#[cfg_attr(not(target_os = "ios"), allow(dead_code))]
pub(crate) fn resumes() -> u64 {
#[cfg(target_os = "ios")]
ios::listen();
RESUMES.load(Ordering::Acquire)
}
static RESUMES: AtomicU64 = AtomicU64::new(0);
#[cfg(target_os = "ios")]
mod ios {
use std::{ptr, sync::Once};
use objc2::{
msg_send,
rc::Retained,
runtime::{AnyObject, Bool},
};
use super::{AudioCategory, Ordering, RESUMES};
#[link(name = "AVFAudio", kind = "framework")]
unsafe extern "C" {
static AVAudioSessionCategoryPlayback: *const AnyObject;
static AVAudioSessionCategorySoloAmbient: *const AnyObject;
static AVAudioSessionInterruptionNotification: *const AnyObject;
static AVAudioSessionInterruptionTypeKey: *const AnyObject;
static AVAudioSessionInterruptionOptionKey: *const AnyObject;
}
const ENDED: usize = 0;
const SHOULD_RESUME: usize = 1;
fn session() -> Retained<AnyObject> {
unsafe { msg_send![objc2::class!(AVAudioSession), sharedInstance] }
}
pub(super) fn set_category(category: AudioCategory) {
unsafe {
let name = match category {
AudioCategory::System => AVAudioSessionCategorySoloAmbient,
AudioCategory::Playback => AVAudioSessionCategoryPlayback,
};
let set: Bool = msg_send![&*session(), setCategory: name, error: ptr::null_mut::<*mut AnyObject>()];
if !set.as_bool() {
tracing::warn!("lurq: iOS did not take the audio session's category {category:?}");
}
}
}
pub(super) fn listen() {
static ONCE: Once = Once::new();
ONCE.call_once(|| {
let ended = block2::RcBlock::new(|notification: *mut AnyObject| {
unsafe {
let Some(notification) = notification.as_ref() else {
return;
};
let info: Option<Retained<AnyObject>> = msg_send![notification, userInfo];
let Some(info) = info else {
return;
};
let number = |key: *const AnyObject| -> usize {
let value: Option<Retained<AnyObject>> = msg_send![&*info, objectForKey: key];
value.map_or(0, |value| msg_send![&*value, unsignedIntegerValue])
};
if number(AVAudioSessionInterruptionTypeKey) == ENDED
&& number(AVAudioSessionInterruptionOptionKey) & SHOULD_RESUME != 0
{
RESUMES.fetch_add(1, Ordering::AcqRel);
}
}
});
unsafe {
let center: Retained<AnyObject> = msg_send![objc2::class!(NSNotificationCenter), defaultCenter];
let token: Option<Retained<AnyObject>> = msg_send![
&*center,
addObserverForName: AVAudioSessionInterruptionNotification,
object: ptr::null::<AnyObject>(),
queue: ptr::null::<AnyObject>(),
usingBlock: &*ended
];
std::mem::forget(token);
}
});
}
}