use std::{
ffi::c_void,
ops::{BitAnd, BitAndAssign, BitOr, BitOrAssign},
ptr::NonNull,
sync::{Arc, Mutex},
};
use crate::{bridge, error::Result, ffi, network_services::NetworkService, PropertyList};
struct CallbackState {
callback: Box<dyn FnMut(PreferencesNotification) + Send>,
}
unsafe extern "C" fn preferences_callback(notification_type: u32, info: *mut c_void) {
if info.is_null() {
return;
}
let mutex = unsafe { &*info.cast::<Mutex<CallbackState>>() };
if let Ok(mut state) = mutex.lock() {
(state.callback)(PreferencesNotification::from_raw(notification_type));
}
}
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
pub struct PreferencesNotification(u32);
impl PreferencesNotification {
pub const COMMIT: Self = Self(1 << 0);
pub const APPLY: Self = Self(1 << 1);
pub const fn from_raw(raw: u32) -> Self {
Self(raw)
}
pub const fn raw_value(self) -> u32 {
self.0
}
pub const fn contains(self, other: Self) -> bool {
self.0 & other.0 == other.0
}
}
impl BitOr for PreferencesNotification {
type Output = Self;
fn bitor(self, rhs: Self) -> Self::Output {
Self(self.0 | rhs.0)
}
}
impl BitOrAssign for PreferencesNotification {
fn bitor_assign(&mut self, rhs: Self) {
self.0 |= rhs.0;
}
}
impl BitAnd for PreferencesNotification {
type Output = Self;
fn bitand(self, rhs: Self) -> Self::Output {
Self(self.0 & rhs.0)
}
}
impl BitAndAssign for PreferencesNotification {
fn bitand_assign(&mut self, rhs: Self) {
self.0 &= rhs.0;
}
}
#[derive(Clone)]
pub struct Preferences {
raw: bridge::OwnedHandle,
callback_state: Option<Arc<Mutex<CallbackState>>>,
}
impl std::fmt::Debug for Preferences {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.debug_struct("Preferences").finish_non_exhaustive()
}
}
impl Preferences {
pub fn type_id() -> u64 {
unsafe { ffi::preferences::sc_preferences_get_type_id() }
}
pub fn new(name: &str, prefs_id: Option<&str>) -> Result<Self> {
Self::create(name, prefs_id)
}
pub fn new_with_authorization(name: &str, prefs_id: Option<&str>) -> Result<Self> {
unsafe { Self::create_with_authorization(name, prefs_id, None) }
}
pub unsafe fn new_with_authorization_raw(
name: &str,
prefs_id: Option<&str>,
authorization: Option<NonNull<c_void>>,
) -> Result<Self> {
unsafe { Self::create_with_authorization(name, prefs_id, authorization) }
}
pub fn new_with_callback<F>(name: &str, prefs_id: Option<&str>, callback: F) -> Result<Self>
where
F: FnMut(PreferencesNotification) + Send + 'static,
{
let mut preferences = Self::new(name, prefs_id)?;
preferences.set_callback(callback)?;
Ok(preferences)
}
pub fn new_with_authorization_and_callback<F>(
name: &str,
prefs_id: Option<&str>,
callback: F,
) -> Result<Self>
where
F: FnMut(PreferencesNotification) + Send + 'static,
{
let mut preferences = Self::new_with_authorization(name, prefs_id)?;
preferences.set_callback(callback)?;
Ok(preferences)
}
pub unsafe fn new_with_authorization_raw_and_callback<F>(
name: &str,
prefs_id: Option<&str>,
authorization: Option<NonNull<c_void>>,
callback: F,
) -> Result<Self>
where
F: FnMut(PreferencesNotification) + Send + 'static,
{
let mut preferences =
unsafe { Self::create_with_authorization(name, prefs_id, authorization) }?;
preferences.set_callback(callback)?;
Ok(preferences)
}
fn create(name: &str, prefs_id: Option<&str>) -> Result<Self> {
let name = bridge::cstring(name, "sc_preferences_create")?;
let prefs_id = bridge::optional_cstring(prefs_id, "sc_preferences_create")?;
let raw = unsafe {
ffi::preferences::sc_preferences_create(
name.as_ptr(),
prefs_id
.as_ref()
.map_or(std::ptr::null(), |value| value.as_ptr()),
)
};
let raw = bridge::owned_handle_or_last("sc_preferences_create", raw)?;
Ok(Self {
raw,
callback_state: None,
})
}
unsafe fn create_with_authorization(
name: &str,
prefs_id: Option<&str>,
authorization: Option<NonNull<c_void>>,
) -> Result<Self> {
let name = bridge::cstring(name, "sc_preferences_create_with_authorization")?;
let prefs_id =
bridge::optional_cstring(prefs_id, "sc_preferences_create_with_authorization")?;
let raw = unsafe {
ffi::preferences::sc_preferences_create_with_authorization(
name.as_ptr(),
prefs_id
.as_ref()
.map_or(std::ptr::null(), |value| value.as_ptr()),
authorization.map_or(std::ptr::null_mut(), NonNull::as_ptr),
)
};
let raw = bridge::owned_handle_or_last("sc_preferences_create_with_authorization", raw)?;
Ok(Self {
raw,
callback_state: None,
})
}
pub fn set_callback<F>(&mut self, callback: F) -> Result<()>
where
F: FnMut(PreferencesNotification) + Send + 'static,
{
let state = Arc::new(Mutex::new(CallbackState {
callback: Box::new(callback),
}));
self.set_callback_state(Some(state))
}
pub fn clear_callback(&mut self) -> Result<()> {
self.set_callback_state(None)
}
fn set_callback_state(&mut self, callback: Option<Arc<Mutex<CallbackState>>>) -> Result<()> {
let ok = unsafe {
ffi::preferences::sc_preferences_set_callback(
self.raw.as_ptr(),
callback
.as_ref()
.map(|_| preferences_callback as unsafe extern "C" fn(u32, *mut c_void)),
callback.as_ref().map_or(std::ptr::null_mut(), |state| {
Arc::as_ptr(state).cast_mut().cast::<c_void>()
}),
)
};
bridge::bool_result("sc_preferences_set_callback", ok)?;
self.callback_state = callback;
Ok(())
}
pub fn schedule_with_run_loop_current(&self) -> Result<()> {
let ok = unsafe {
ffi::preferences::sc_preferences_schedule_with_run_loop_current(self.raw.as_ptr())
};
bridge::bool_result("sc_preferences_schedule_with_run_loop_current", ok)
}
pub fn unschedule_from_run_loop_current(&self) -> Result<()> {
let ok = unsafe {
ffi::preferences::sc_preferences_unschedule_from_run_loop_current(self.raw.as_ptr())
};
bridge::bool_result("sc_preferences_unschedule_from_run_loop_current", ok)
}
pub fn set_dispatch_queue_global(&self) -> Result<()> {
let ok = unsafe {
ffi::preferences::sc_preferences_set_dispatch_queue_global(self.raw.as_ptr())
};
bridge::bool_result("sc_preferences_set_dispatch_queue_global", ok)
}
pub fn clear_dispatch_queue(&self) -> Result<()> {
let ok =
unsafe { ffi::preferences::sc_preferences_clear_dispatch_queue(self.raw.as_ptr()) };
bridge::bool_result("sc_preferences_clear_dispatch_queue", ok)
}
pub fn lock(&self, wait: bool) -> Result<()> {
let ok =
unsafe { ffi::preferences::sc_preferences_lock(self.raw.as_ptr(), u8::from(wait)) };
bridge::bool_result("sc_preferences_lock", ok)
}
pub fn commit_changes(&self) -> Result<()> {
let ok = unsafe { ffi::preferences::sc_preferences_commit_changes(self.raw.as_ptr()) };
bridge::bool_result("sc_preferences_commit_changes", ok)
}
pub fn apply_changes(&self) -> Result<()> {
let ok = unsafe { ffi::preferences::sc_preferences_apply_changes(self.raw.as_ptr()) };
bridge::bool_result("sc_preferences_apply_changes", ok)
}
pub fn unlock(&self) -> Result<()> {
let ok = unsafe { ffi::preferences::sc_preferences_unlock(self.raw.as_ptr()) };
bridge::bool_result("sc_preferences_unlock", ok)
}
pub fn synchronize(&self) {
unsafe { ffi::preferences::sc_preferences_synchronize(self.raw.as_ptr()) };
}
pub fn signature(&self) -> Option<String> {
bridge::take_optional_string(unsafe {
ffi::preferences::sc_preferences_copy_signature(self.raw.as_ptr())
})
}
pub fn copy_key_list(&self) -> Vec<String> {
bridge::take_string_array(unsafe {
ffi::preferences::sc_preferences_copy_key_list(self.raw.as_ptr())
})
}
pub fn get_value(&self, key: &str) -> Result<Option<PropertyList>> {
let key = bridge::cstring(key, "sc_preferences_get_value")?;
let raw =
unsafe { ffi::preferences::sc_preferences_get_value(self.raw.as_ptr(), key.as_ptr()) };
Ok(unsafe { bridge::OwnedHandle::from_raw(raw) }.map(PropertyList::from_owned_handle))
}
pub fn add_value(&self, key: &str, value: &PropertyList) -> Result<()> {
let key = bridge::cstring(key, "sc_preferences_add_value")?;
let ok = unsafe {
ffi::preferences::sc_preferences_add_value(
self.raw.as_ptr(),
key.as_ptr(),
value.as_ptr(),
)
};
bridge::bool_result("sc_preferences_add_value", ok)
}
pub fn set_value(&self, key: &str, value: &PropertyList) -> Result<()> {
let key = bridge::cstring(key, "sc_preferences_set_value")?;
let ok = unsafe {
ffi::preferences::sc_preferences_set_value(
self.raw.as_ptr(),
key.as_ptr(),
value.as_ptr(),
)
};
bridge::bool_result("sc_preferences_set_value", ok)
}
pub fn remove_value(&self, key: &str) -> Result<()> {
let key = bridge::cstring(key, "sc_preferences_remove_value")?;
let ok = unsafe {
ffi::preferences::sc_preferences_remove_value(self.raw.as_ptr(), key.as_ptr())
};
bridge::bool_result("sc_preferences_remove_value", ok)
}
pub fn path_create_unique_child(&self, prefix: &str) -> Result<Option<String>> {
let prefix = bridge::cstring(prefix, "sc_preferences_path_create_unique_child")?;
Ok(bridge::take_optional_string(unsafe {
ffi::preferences::sc_preferences_path_create_unique_child(
self.raw.as_ptr(),
prefix.as_ptr(),
)
}))
}
pub fn path_get_value(&self, path: &str) -> Result<Option<PropertyList>> {
let path = bridge::cstring(path, "sc_preferences_path_get_value")?;
let raw = unsafe {
ffi::preferences::sc_preferences_path_get_value(self.raw.as_ptr(), path.as_ptr())
};
Ok(unsafe { bridge::OwnedHandle::from_raw(raw) }.map(PropertyList::from_owned_handle))
}
pub fn path_get_link(&self, path: &str) -> Result<Option<String>> {
let path = bridge::cstring(path, "sc_preferences_path_get_link")?;
Ok(bridge::take_optional_string(unsafe {
ffi::preferences::sc_preferences_path_get_link(self.raw.as_ptr(), path.as_ptr())
}))
}
pub fn path_set_value(&self, path: &str, value: &PropertyList) -> Result<()> {
let path = bridge::cstring(path, "sc_preferences_path_set_value")?;
let ok = unsafe {
ffi::preferences::sc_preferences_path_set_value(
self.raw.as_ptr(),
path.as_ptr(),
value.as_ptr(),
)
};
bridge::bool_result("sc_preferences_path_set_value", ok)
}
pub fn path_set_link(&self, path: &str, link: &str) -> Result<()> {
let path = bridge::cstring(path, "sc_preferences_path_set_link")?;
let link = bridge::cstring(link, "sc_preferences_path_set_link")?;
let ok = unsafe {
ffi::preferences::sc_preferences_path_set_link(
self.raw.as_ptr(),
path.as_ptr(),
link.as_ptr(),
)
};
bridge::bool_result("sc_preferences_path_set_link", ok)
}
pub fn path_remove_value(&self, path: &str) -> Result<()> {
let path = bridge::cstring(path, "sc_preferences_path_remove_value")?;
let ok = unsafe {
ffi::preferences::sc_preferences_path_remove_value(self.raw.as_ptr(), path.as_ptr())
};
bridge::bool_result("sc_preferences_path_remove_value", ok)
}
pub fn set_computer_name(&self, name: Option<&str>) -> Result<()> {
let name = bridge::optional_cstring(name, "sc_preferences_set_computer_name")?;
let ok = unsafe {
ffi::preferences::sc_preferences_set_computer_name(
self.raw.as_ptr(),
name.as_ref()
.map_or(std::ptr::null(), |value| value.as_ptr()),
)
};
bridge::bool_result("sc_preferences_set_computer_name", ok)
}
pub fn set_local_host_name(&self, name: Option<&str>) -> Result<()> {
let name = bridge::optional_cstring(name, "sc_preferences_set_local_host_name")?;
let ok = unsafe {
ffi::preferences::sc_preferences_set_local_host_name(
self.raw.as_ptr(),
name.as_ref()
.map_or(std::ptr::null(), |value| value.as_ptr()),
)
};
bridge::bool_result("sc_preferences_set_local_host_name", ok)
}
pub fn network_services(&self) -> Vec<NetworkService> {
NetworkService::copy_all(self)
}
pub(crate) fn as_ptr(&self) -> bridge::RawHandle {
self.raw.as_ptr()
}
}