Bind dbus_register vfunc

Author: swsnr

examples/gio_dbus_register_object/main.rs

@@ -82,13 +82,16 @@ mod imp {
     }
 
     impl SampleApplication {
-        fn register_object(&self, connection: &DBusConnection) {
+        fn register_object(
+            &self,
+            connection: &DBusConnection,
+        ) -> Result<gio::RegistrationId, glib::Error> {
             let example = gio::DBusNodeInfo::for_xml(EXAMPLE_XML)
                 .ok()
                 .and_then(|e| e.lookup_interface("com.github.gtk_rs.examples.HelloWorld"))
                 .expect("Example interface");
 
-            if let Ok(id) = connection
+            connection
                 .register_object("/com/github/gtk_rs/examples/HelloWorld", &example)
                 .typed_method_call::<HelloMethod>()
                 .invoke_and_return_future_local(|_, sender, call| {
@@ -110,12 +113,6 @@ mod imp {
                     }
                 })
                 .build()
-            {
-                println!("Registered object");
-                self.registration_id.replace(Some(id));
-            } else {
-                eprintln!("Could not register object");
-            }
         }
     }
 
@@ -131,10 +128,16 @@ mod imp {
     impl ObjectImpl for SampleApplication {}
 
     impl ApplicationImpl for SampleApplication {
-        fn startup(&self) {
-            self.parent_startup();
-            let connection = self.obj().dbus_connection().expect("connection");
-            self.register_object(&connection);
+        fn dbus_register(
+            &self,
+            connection: &DBusConnection,
+            object_path: &str,
+        ) -> Result<(), glib::Error> {
+            self.parent_dbus_register(connection, object_path)?;
+            self.registration_id
+                .replace(Some(self.register_object(connection)?));
+            println!("registered object on session bus");
+            Ok(())
         }
 
         fn shutdown(&self) {

gio/src/subclass/application.rs

@@ -2,10 +2,10 @@
 
 use std::{ffi::OsString, fmt, ops::Deref, ptr};
 
-use glib::{prelude::*, subclass::prelude::*, translate::*, ExitCode, VariantDict};
+use glib::{prelude::*, subclass::prelude::*, translate::*, Error, ExitCode, VariantDict};
 use libc::{c_char, c_int, c_void};
 
-use crate::{ffi, ActionGroup, ActionMap, Application};
+use crate::{ffi, ActionGroup, ActionMap, Application, DBusConnection};
 
 pub struct ArgumentList {
     pub(crate) ptr: *mut *mut *mut c_char,
@@ -110,6 +110,10 @@ pub trait ApplicationImpl:
     fn handle_local_options(&self, options: &VariantDict) -> ExitCode {
         self.parent_handle_local_options(options)
     }
+
+    fn dbus_register(&self, connection: &DBusConnection, object_path: &str) -> Result<(), Error> {
+        self.parent_dbus_register(connection, object_path)
+    }
 }
 
 pub trait ApplicationImplExt: ApplicationImpl {
@@ -266,6 +270,33 @@ pub trait ApplicationImplExt: ApplicationImpl {
             }
         }
     }
+
+    fn parent_dbus_register(
+        &self,
+        connection: &DBusConnection,
+        object_path: &str,
+    ) -> Result<(), glib::Error> {
+        unsafe {
+            let data = Self::type_data();
+            let parent_class = data.as_ref().parent_class() as *mut ffi::GApplicationClass;
+            let f = (*parent_class)
+                .dbus_register
+                .expect("No parent class implementation for \"dbus_register\"");
+            let mut err = ptr::null_mut();
+            let res = f(
+                self.obj().unsafe_cast_ref::<Application>().to_glib_none().0,
+                connection.to_glib_none().0,
+                object_path.to_glib_none().0,
+                &mut err,
+            );
+            if res == glib::ffi::GFALSE {
+                debug_assert!(!err.is_null());
+                Err(from_glib_full(err))
+            } else {
+                Ok(())
+            }
+        }
+    }
 }
 
 impl<T: ApplicationImpl> ApplicationImplExt for T {}
@@ -286,6 +317,7 @@ unsafe impl<T: ApplicationImpl> IsSubclassable<T> for Application {
         klass.shutdown = Some(application_shutdown::<T>);
         klass.startup = Some(application_startup::<T>);
         klass.handle_local_options = Some(application_handle_local_options::<T>);
+        klass.dbus_register = Some(application_dbus_register::<T>)
     }
 }
 
@@ -390,6 +422,29 @@ unsafe extern "C" fn application_handle_local_options<T: ApplicationImpl>(
     imp.handle_local_options(&from_glib_borrow(options)).into()
 }
 
+unsafe extern "C" fn application_dbus_register<T: ApplicationImpl>(
+    ptr: *mut ffi::GApplication,
+    connection: *mut ffi::GDBusConnection,
+    object_path: *const c_char,
+    error: *mut *mut glib::ffi::GError,
+) -> glib::ffi::gboolean {
+    let instance = &*(ptr as *mut T::Instance);
+    let imp = instance.imp();
+
+    match imp.dbus_register(
+        &from_glib_borrow(connection),
+        &glib::GString::from_glib_borrow(object_path),
+    ) {
+        Ok(()) => glib::ffi::GTRUE,
+        Err(e) => {
+            if !error.is_null() {
+                *error = e.into_glib_ptr();
+            }
+            glib::ffi::GFALSE
+        }
+    }
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;