112 lines
3.4 KiB
Rust
112 lines
3.4 KiB
Rust
mod daemon;
|
|
mod dbus;
|
|
|
|
use log::LevelFilter;
|
|
use std::future;
|
|
|
|
use daemon::signals::Signal;
|
|
use daemon::Daemon;
|
|
|
|
use dbus::endpoint::DbusRegistry;
|
|
use dbus::interface;
|
|
use dbus::server_impl::ServerImpl;
|
|
use dbus_tokio::connection;
|
|
|
|
fn initialize_logging() {
|
|
// Weird: is this the best way to do this?
|
|
let log_level = std::env::var("RUST_LOG")
|
|
.map(|s| s.parse::<LevelFilter>().unwrap_or(LevelFilter::Info))
|
|
.unwrap_or(LevelFilter::Info);
|
|
|
|
env_logger::Builder::from_default_env()
|
|
.format_timestamp_secs()
|
|
.filter_level(log_level)
|
|
.init();
|
|
}
|
|
|
|
#[tokio::main]
|
|
async fn main() {
|
|
initialize_logging();
|
|
|
|
// Create the daemon
|
|
let mut daemon = Daemon::new()
|
|
.map_err(|e| {
|
|
log::error!("Failed to start daemon: {}", e);
|
|
std::process::exit(1);
|
|
})
|
|
.unwrap();
|
|
|
|
// Initialize dbus session connection
|
|
let (resource, connection) = connection::new_session_sync().unwrap();
|
|
|
|
// The resource is a task that should be spawned onto a tokio compatible
|
|
// reactor ASAP. If the resource ever finishes, you lost connection to D-Bus.
|
|
//
|
|
// To shut down the connection, both call _handle.abort() and drop the connection.
|
|
let _handle = tokio::spawn(async {
|
|
let err = resource.await;
|
|
panic!("Lost connection to D-Bus: {}", err);
|
|
});
|
|
|
|
// Acquire the name
|
|
connection
|
|
.request_name(interface::NAME, false, true, false)
|
|
.await
|
|
.expect("Unable to acquire dbus name");
|
|
|
|
// Create shared D-Bus registry
|
|
let dbus_registry = DbusRegistry::new(connection.clone());
|
|
|
|
// Create and register server implementation
|
|
let server = ServerImpl::new(daemon.event_sender.clone());
|
|
|
|
dbus_registry.register_object(
|
|
interface::OBJECT_PATH,
|
|
server,
|
|
|cr| vec![
|
|
interface::register_net_buzzert_kordophone_repository(cr),
|
|
interface::register_net_buzzert_kordophone_settings(cr),
|
|
]
|
|
);
|
|
|
|
let mut signal_receiver = daemon.obtain_signal_receiver();
|
|
tokio::spawn(async move {
|
|
use dbus::interface::signals as DbusSignals;
|
|
|
|
while let Some(signal) = signal_receiver.recv().await {
|
|
match signal {
|
|
Signal::ConversationsUpdated => {
|
|
log::debug!("Sending signal: ConversationsUpdated");
|
|
dbus_registry
|
|
.send_signal(interface::OBJECT_PATH, DbusSignals::ConversationsUpdated {})
|
|
.unwrap_or_else(|_| {
|
|
log::error!("Failed to send signal");
|
|
0
|
|
});
|
|
}
|
|
|
|
Signal::MessagesUpdated(conversation_id) => {
|
|
log::debug!(
|
|
"Sending signal: MessagesUpdated for conversation {}",
|
|
conversation_id
|
|
);
|
|
dbus_registry
|
|
.send_signal(
|
|
interface::OBJECT_PATH,
|
|
DbusSignals::MessagesUpdated { conversation_id },
|
|
)
|
|
.unwrap_or_else(|_| {
|
|
log::error!("Failed to send signal");
|
|
0
|
|
});
|
|
}
|
|
}
|
|
}
|
|
});
|
|
|
|
daemon.run().await;
|
|
|
|
future::pending::<()>().await;
|
|
unreachable!()
|
|
}
|