Kordophone/kordophoned/src/main.rs

mod dbus;
mod daemon;

use std::future;
use log::LevelFilter;

use daemon::Daemon;
use daemon::signals::Signal;

use dbus::endpoint::Endpoint as DbusEndpoint;
use dbus::interface;
use dbus::server_impl::ServerImpl;

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();

    // Create the server implementation
    let server = ServerImpl::new(daemon.event_sender.clone());

    // Register DBus interfaces with endpoint
    let endpoint = DbusEndpoint::new(server);
    endpoint.register(
        interface::NAME,
        interface::OBJECT_PATH,
        |cr| {
            vec![
                interface::register_net_buzzert_kordophone_repository(cr),
                interface::register_net_buzzert_kordophone_settings(cr)
            ]
        }
    ).await;

    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::info!("Sending signal: ConversationsUpdated");
                    endpoint.send_signal(interface::OBJECT_PATH, DbusSignals::ConversationsUpdated{})
                        .unwrap_or_else(|_| {
                            log::error!("Failed to send signal");
                            0
                        });
                }
            }
        }
    });

    daemon.run().await;

    future::pending::<()>().await;
    unreachable!()
}