audrey/src/application.rs

mod imp {
    use crate::ui;
    use adw::prelude::*;
    use adw::subclass::prelude::*;
    use gtk::glib;

    #[derive(Default)]
    pub struct Application;

    #[glib::object_subclass]
    impl ObjectSubclass for Application {
        const NAME: &'static str = "AudreyApplication";
        type Type = super::Application;
        type ParentType = adw::Application;
    }

    impl ObjectImpl for Application {}

    impl ApplicationImpl for Application {
        fn activate(&self) {
            self.parent_activate();
            match self.obj().active_window() {
                None => {
                    let window = ui::Window::new(self.obj().as_ref());
                    window.present();

                    glib::spawn_future_local(async move {
                        let conn = zbus::connection::Builder::session()
                            .expect("could not connect to the session bus")
                            .internal_executor(false)
                            .build()
                            .await
                            .expect("could not build connection to the session bus");

                        // run this in glib's main loop
                        glib::spawn_future_local(glib::clone!(
                            #[strong]
                            conn,
                            async move {
                                loop {
                                    conn.executor().tick().await;
                                }
                            }
                        ));

                        crate::Mpris::setup(conn.object_server(), &window)
                            .await
                            .expect("could not serve mpris");
                        crate::mpris::Player::setup(conn.object_server(), &window.playbin())
                            .await
                            .expect("could not serve mpris player");

                        drop(window); // don't keep this alive

                        // always set up handlers before requesting service name
                        conn.request_name("org.mpris.MediaPlayer2.audrey")
                            .await
                            .expect("could not register name in session bus");
                    });
                }
                Some(win) => win.present(),
            }
        }
    }

    impl GtkApplicationImpl for Application {}

    impl AdwApplicationImpl for Application {}
}

use gtk::{gio, glib};

glib::wrapper! {
    pub struct Application(ObjectSubclass<imp::Application>)
        @extends adw::Application, gtk::Application, gio::Application,
        @implements gio::ActionGroup, gio::ActionMap;
}

impl Default for Application {
    fn default() -> Self {
        glib::Object::builder::<Application>()
            .property("application-id", crate::APP_ID)
            .property("flags", gio::ApplicationFlags::default())
            .build()
    }
}

impl Application {
    pub fn new() -> Self {
        Self::default()
    }
}