357 lines
15 KiB
Rust
357 lines
15 KiB
Rust
use std::{collections::HashMap, ffi::c_void};
|
|
|
|
use crate::{
|
|
as_c_string, bindings, helpers::fixed_c_str_to_string, ok_if_fail, success, Airport, Event,
|
|
Notification, Object, SimConnectError, Waypoint, NDB, VOR,
|
|
};
|
|
|
|
/// SimConnect SDK Client.
|
|
///
|
|
/// # Example
|
|
///
|
|
/// ```no_run
|
|
/// use simconnect_sdk::{Notification, SimConnect, SimConnectObject};
|
|
///
|
|
/// /// A data structure that will be used to receive data from SimConnect.
|
|
/// #[derive(Debug, Clone, SimConnectObject)]
|
|
/// #[simconnect(period = "second")]
|
|
/// struct GpsData {
|
|
/// #[simconnect(name = "PLANE LATITUDE", unit = "degrees")]
|
|
/// lat: f64,
|
|
/// #[simconnect(name = "PLANE LONGITUDE", unit = "degrees")]
|
|
/// lon: f64,
|
|
/// #[simconnect(name = "PLANE LONGITUDE", unit = "degrees")]
|
|
/// alt: f64,
|
|
/// }
|
|
///
|
|
/// fn main() -> Result<(), Box<dyn std::error::Error>> {
|
|
/// let client = SimConnect::new("Simple Program");
|
|
///
|
|
/// match client {
|
|
/// Ok(mut client) => {
|
|
/// let mut notifications_received = 0;
|
|
///
|
|
/// loop {
|
|
/// let notification = client.get_next_dispatch()?;
|
|
///
|
|
/// match notification {
|
|
/// Some(Notification::Open) => {
|
|
/// println!("Connection opened.");
|
|
///
|
|
/// // After the connection is successfully open, we register the struct
|
|
/// client.register_object::<GpsData>()?;
|
|
/// }
|
|
/// Some(Notification::Object(data)) => {
|
|
/// if let Ok(gps_data) = GpsData::try_from(&data) {
|
|
/// println!("{gps_data:?}");
|
|
///
|
|
/// notifications_received += 1;
|
|
///
|
|
/// // After we have received 10 notifications, we unregister the struct
|
|
/// if notifications_received > 10 {
|
|
/// client.unregister_object::<GpsData>()?;
|
|
/// println!("Subscription stopped.");
|
|
/// break;
|
|
/// }
|
|
/// }
|
|
/// }
|
|
/// _ => (),
|
|
/// }
|
|
///
|
|
/// // sleep for about a frame to reduce CPU usage
|
|
/// std::thread::sleep(std::time::Duration::from_millis(16));
|
|
/// }
|
|
/// }
|
|
/// Err(e) => {
|
|
/// println!("Error: {e:?}")
|
|
/// }
|
|
/// }
|
|
///
|
|
/// Ok(())
|
|
/// }
|
|
/// ```
|
|
#[derive(Debug)]
|
|
pub struct SimConnect {
|
|
pub(super) handle: std::ptr::NonNull<c_void>,
|
|
pub(super) next_request_id: u32,
|
|
pub(super) registered_objects: HashMap<String, u32>,
|
|
}
|
|
|
|
impl SimConnect {
|
|
/// Create a new SimConnect SDK client.
|
|
#[tracing::instrument(name = "SimConnect::new")]
|
|
pub fn new(name: &str) -> Result<Self, SimConnectError> {
|
|
let mut handle = std::ptr::null_mut();
|
|
|
|
success!(unsafe {
|
|
bindings::SimConnect_Open(
|
|
&mut handle,
|
|
as_c_string!(name),
|
|
std::ptr::null_mut(),
|
|
0,
|
|
std::ptr::null_mut(),
|
|
0,
|
|
)
|
|
});
|
|
|
|
Ok(Self {
|
|
handle: std::ptr::NonNull::new(handle).ok_or_else(|| {
|
|
SimConnectError::UnexpectedError(
|
|
"SimConnect_Open returned null pointer on success".to_string(),
|
|
)
|
|
})?,
|
|
next_request_id: 0,
|
|
registered_objects: HashMap::new(),
|
|
})
|
|
}
|
|
|
|
/// Receive the next SimConnect message.
|
|
///
|
|
/// # Remarks
|
|
/// This is a non-blocking function. If there are no messages to receive, it will return None immediately.
|
|
/// When called in a loop, it is recommended to use a short sleep time.
|
|
pub fn get_next_dispatch(&self) -> Result<Option<Notification>, SimConnectError> {
|
|
let mut data_buf: *mut bindings::SIMCONNECT_RECV = std::ptr::null_mut();
|
|
let mut size_buf: bindings::DWORD = 32;
|
|
let size_buf_pointer: *mut bindings::DWORD = &mut size_buf;
|
|
|
|
unsafe {
|
|
ok_if_fail!(
|
|
bindings::SimConnect_GetNextDispatch(
|
|
self.handle.as_ptr(),
|
|
&mut data_buf,
|
|
size_buf_pointer
|
|
),
|
|
None
|
|
);
|
|
};
|
|
|
|
let result = match unsafe { (*data_buf).dwID as i32 } {
|
|
bindings::SIMCONNECT_RECV_ID_SIMCONNECT_RECV_ID_OPEN => Some(Notification::Open),
|
|
bindings::SIMCONNECT_RECV_ID_SIMCONNECT_RECV_ID_QUIT => Some(Notification::Quit),
|
|
bindings::SIMCONNECT_RECV_ID_SIMCONNECT_RECV_ID_EVENT => {
|
|
let event = unsafe { *(data_buf as *const bindings::SIMCONNECT_RECV_EVENT) };
|
|
let event = Event::try_from(event.uEventID)
|
|
.map_err(|_| SimConnectError::SimConnectUnrecognizedEvent(event.uEventID))?;
|
|
Some(Notification::Event(event))
|
|
}
|
|
bindings::SIMCONNECT_RECV_ID_SIMCONNECT_RECV_ID_SIMOBJECT_DATA => {
|
|
let event: &bindings::SIMCONNECT_RECV_SIMOBJECT_DATA = unsafe {
|
|
std::mem::transmute_copy(
|
|
&(data_buf as *const bindings::SIMCONNECT_RECV_SIMOBJECT_DATA),
|
|
)
|
|
};
|
|
|
|
let type_name = self.get_type_name_by_request_id(event.dwDefineID);
|
|
|
|
match type_name {
|
|
Some(type_name) => {
|
|
let data = Object {
|
|
type_name,
|
|
data_addr: std::ptr::addr_of!(event.dwData),
|
|
};
|
|
|
|
Some(Notification::Object(data))
|
|
}
|
|
_ => None,
|
|
}
|
|
}
|
|
bindings::SIMCONNECT_RECV_ID_SIMCONNECT_RECV_ID_AIRPORT_LIST => {
|
|
let event: &bindings::SIMCONNECT_RECV_AIRPORT_LIST = unsafe {
|
|
std::mem::transmute_copy(
|
|
&(data_buf as *const bindings::SIMCONNECT_RECV_AIRPORT_LIST),
|
|
)
|
|
};
|
|
|
|
let data = (0..event._base.dwArraySize as usize)
|
|
.map(|i| {
|
|
// `rgData` is defined as a 1-element array, but it is actually a variable-length array.
|
|
let record = unsafe { event.rgData.get_unchecked(i) };
|
|
|
|
Airport {
|
|
icao: fixed_c_str_to_string(&record.Icao),
|
|
lat: record.Latitude,
|
|
lon: record.Longitude,
|
|
alt: record.Altitude,
|
|
}
|
|
})
|
|
.collect::<Vec<_>>();
|
|
|
|
Some(Notification::AirportList(data))
|
|
}
|
|
bindings::SIMCONNECT_RECV_ID_SIMCONNECT_RECV_ID_WAYPOINT_LIST => {
|
|
let event: &bindings::SIMCONNECT_RECV_WAYPOINT_LIST = unsafe {
|
|
std::mem::transmute_copy(
|
|
&(data_buf as *const bindings::SIMCONNECT_RECV_WAYPOINT_LIST),
|
|
)
|
|
};
|
|
|
|
let data = (0..event._base.dwArraySize as usize)
|
|
.map(|i| {
|
|
// `rgData` is defined as a 1-element array, but it is actually a variable-length array.
|
|
let record = unsafe { event.rgData.get_unchecked(i) };
|
|
|
|
Waypoint {
|
|
icao: fixed_c_str_to_string(&record._base.Icao),
|
|
lat: record._base.Latitude,
|
|
lon: record._base.Longitude,
|
|
alt: record._base.Altitude,
|
|
mag_var: record.fMagVar,
|
|
}
|
|
})
|
|
.collect::<Vec<_>>();
|
|
|
|
Some(Notification::WaypointList(data))
|
|
}
|
|
bindings::SIMCONNECT_RECV_ID_SIMCONNECT_RECV_ID_NDB_LIST => {
|
|
let event: &bindings::SIMCONNECT_RECV_NDB_LIST = unsafe {
|
|
std::mem::transmute_copy(
|
|
&(data_buf as *const bindings::SIMCONNECT_RECV_NDB_LIST),
|
|
)
|
|
};
|
|
|
|
let data = (0..event._base.dwArraySize as usize)
|
|
.map(|i| {
|
|
// `rgData` is defined as a 1-element array, but it is actually a variable-length array.
|
|
let record = unsafe { event.rgData.get_unchecked(i) };
|
|
|
|
NDB {
|
|
icao: fixed_c_str_to_string(&record._base._base.Icao),
|
|
lat: record._base._base.Latitude,
|
|
lon: record._base._base.Longitude,
|
|
alt: record._base._base.Altitude,
|
|
mag_var: record._base.fMagVar,
|
|
frequency: record.fFrequency,
|
|
}
|
|
})
|
|
.collect::<Vec<_>>();
|
|
|
|
Some(Notification::NdbList(data))
|
|
}
|
|
bindings::SIMCONNECT_RECV_ID_SIMCONNECT_RECV_ID_VOR_LIST => {
|
|
let event: &bindings::SIMCONNECT_RECV_VOR_LIST = unsafe {
|
|
std::mem::transmute_copy(
|
|
&(data_buf as *const bindings::SIMCONNECT_RECV_VOR_LIST),
|
|
)
|
|
};
|
|
|
|
let data = (0..event._base.dwArraySize as usize)
|
|
.map(|i| {
|
|
// `rgData` is defined as a 1-element array, but it is actually a variable-length array.
|
|
let record = unsafe { event.rgData.get_unchecked(i) };
|
|
|
|
let has_nav_signal = record.Flags
|
|
& bindings::SIMCONNECT_RECV_ID_VOR_LIST_HAS_NAV_SIGNAL
|
|
== bindings::SIMCONNECT_RECV_ID_VOR_LIST_HAS_NAV_SIGNAL;
|
|
let has_localizer = record.Flags
|
|
& bindings::SIMCONNECT_RECV_ID_VOR_LIST_HAS_LOCALIZER
|
|
== bindings::SIMCONNECT_RECV_ID_VOR_LIST_HAS_LOCALIZER;
|
|
let has_glide_slope = record.Flags
|
|
& bindings::SIMCONNECT_RECV_ID_VOR_LIST_HAS_GLIDE_SLOPE
|
|
== bindings::SIMCONNECT_RECV_ID_VOR_LIST_HAS_GLIDE_SLOPE;
|
|
let has_dme = record.Flags & bindings::SIMCONNECT_RECV_ID_VOR_LIST_HAS_DME
|
|
== bindings::SIMCONNECT_RECV_ID_VOR_LIST_HAS_DME;
|
|
|
|
VOR {
|
|
icao: fixed_c_str_to_string(&record._base._base._base.Icao),
|
|
lat: record._base._base._base.Latitude,
|
|
lon: record._base._base._base.Longitude,
|
|
alt: record._base._base._base.Altitude,
|
|
mag_var: record._base._base.fMagVar,
|
|
has_nav_signal,
|
|
has_localizer,
|
|
has_glide_slope,
|
|
has_dme,
|
|
localizer: if has_localizer {
|
|
Some(record.fLocalizer)
|
|
} else {
|
|
None
|
|
},
|
|
glide_lat: if has_nav_signal {
|
|
Some(record.GlideLat)
|
|
} else {
|
|
None
|
|
},
|
|
glide_lon: if has_nav_signal {
|
|
Some(record.GlideLon)
|
|
} else {
|
|
None
|
|
},
|
|
glide_alt: if has_nav_signal {
|
|
Some(record.GlideAlt)
|
|
} else {
|
|
None
|
|
},
|
|
glide_slope_angle: if has_glide_slope {
|
|
Some(record.fGlideSlopeAngle)
|
|
} else {
|
|
None
|
|
},
|
|
frequency: if has_dme {
|
|
Some(record._base.fFrequency)
|
|
} else {
|
|
None
|
|
},
|
|
}
|
|
})
|
|
.collect::<Vec<_>>();
|
|
|
|
Some(Notification::VorList(data))
|
|
}
|
|
bindings::SIMCONNECT_RECV_ID_SIMCONNECT_RECV_ID_EXCEPTION => {
|
|
let event = unsafe { *(data_buf as *const bindings::SIMCONNECT_RECV_EXCEPTION) };
|
|
Some(Notification::Exception(event.dwException))
|
|
}
|
|
bindings::SIMCONNECT_RECV_ID_SIMCONNECT_RECV_ID_NULL => None,
|
|
_ => panic!("Got unrecognized notification: {}", unsafe {
|
|
(*data_buf).dwID as i32
|
|
}),
|
|
};
|
|
|
|
Ok(result)
|
|
}
|
|
|
|
/// Register a Request ID in the internal state so that the user doesn't have to manually manage Request IDs.
|
|
#[tracing::instrument(name = "SimConnect::new_request_id")]
|
|
pub(super) fn new_request_id(&mut self, type_name: String) -> Result<u32, SimConnectError> {
|
|
if self.registered_objects.contains_key(&type_name) {
|
|
return Err(SimConnectError::ObjectAlreadyRegistered(type_name));
|
|
}
|
|
|
|
let mut request_id = self.next_request_id;
|
|
self.next_request_id += 1;
|
|
|
|
// when `next_request_id` overflows some ids might still be in use
|
|
// so we need to find the next available one
|
|
while self.registered_objects.values().any(|id| *id == request_id) {
|
|
request_id = self.next_request_id;
|
|
self.next_request_id += 1;
|
|
}
|
|
|
|
self.registered_objects.insert(type_name, request_id);
|
|
|
|
Ok(request_id)
|
|
}
|
|
|
|
/// Unregister a Request ID in the internal state so that the user doesn't have to manually manage Request IDs.
|
|
#[tracing::instrument(name = "SimConnect::unregister_request_id_by_type_name")]
|
|
pub(super) fn unregister_request_id_by_type_name(&mut self, type_name: &str) -> Option<u32> {
|
|
self.registered_objects.remove(type_name)
|
|
}
|
|
|
|
/// Get the Type Name of a Request ID.
|
|
#[tracing::instrument(name = "SimConnect::get_type_name_by_request_id")]
|
|
pub(super) fn get_type_name_by_request_id(&self, request_id: u32) -> Option<String> {
|
|
self.registered_objects
|
|
.iter()
|
|
.find(|(_, v)| **v == request_id)
|
|
.map(|(k, _)| k.clone())
|
|
}
|
|
}
|
|
|
|
impl Drop for SimConnect {
|
|
fn drop(&mut self) {
|
|
let _ = unsafe { bindings::SimConnect_Close(self.handle.as_ptr()) };
|
|
}
|
|
}
|