2005-02-11 Joe Shaw <joeshaw@novell.com>

	* mono/Connection.cs: The unpredictability of finalizers in mono
	prevents us from deterministically disconnecting the filters from
	the Service class's finalizer, so move tracking of filters and
	matches here.  Add API for that.

	* mono/Service.cs: Remove the code, add code which calls the
	methods now on the Connection class.

diff --git a/ChangeLog b/ChangeLog
index 1789aac..9903710 100644 (file)
--- a/ChangeLog
+++ b/ChangeLog
@@ -1,3 +1,13 @@
+2005-02-11  Joe Shaw  <joeshaw@novell.com>
+
+       * mono/Connection.cs: The unpredictability of finalizers in mono
+       prevents us from deterministically disconnecting the filters from
+       the Service class's finalizer, so move tracking of filters and
+       matches here.  Add API for that.
+
+       * mono/Service.cs: Remove the code, add code which calls the
+       methods now on the Connection class.
+
 2005-02-11  John (J5) Palmieri  <johnp@redhat.com>
 
        * python/dbus.py (class Sender): added to support dbus signals better

diff --git a/mono/Connection.cs b/mono/Connection.cs
index 2d98f64..699fee9 100644 (file)
--- a/mono/Connection.cs
+++ b/mono/Connection.cs
@@ -8,6 +8,10 @@ namespace DBus
   using System.IO;
   using System.Collections;
   
+  public delegate int DBusHandleMessageFunction (IntPtr rawConnection,
+                                                IntPtr rawMessage,
+                                                IntPtr userData);
+
   public class Connection 
   {
     /// <summary>
@@ -22,6 +26,9 @@ namespace DBus
     
     private int timeout = -1;
 
+    private ArrayList filters = new ArrayList (); // of DBusHandleMessageFunction
+    private ArrayList matches = new ArrayList (); // of string
+
     internal Connection(IntPtr rawConnection)
     {
       RawConnection = rawConnection;
@@ -56,6 +63,12 @@ namespace DBus
     {
       if (RawConnection != IntPtr.Zero) 
        {
+          foreach (DBusHandleMessageFunction func in this.filters)
+            RemoveFilter (func);
+
+          foreach (string match_rule in this.matches)
+            RemoveMatch (match_rule);
+
          dbus_connection_disconnect(rawConnection);
        }
       RawConnection = IntPtr.Zero; // free the native object
@@ -76,6 +89,38 @@ namespace DBus
       return new Connection(rawConnection);
     }
 
+    public void AddFilter (DBusHandleMessageFunction func)
+    {
+      if (!dbus_connection_add_filter (RawConnection,
+                                      func,
+                                      IntPtr.Zero,
+                                      IntPtr.Zero))
+        throw new OutOfMemoryException ();
+
+      this.filters.Add (func);
+    }
+
+    public void RemoveFilter (DBusHandleMessageFunction func)
+    {
+      dbus_connection_remove_filter (RawConnection, func, IntPtr.Zero);
+
+      this.filters.Remove (func);
+    }
+
+    public void AddMatch (string match_rule)
+    {
+      dbus_bus_add_match (RawConnection, match_rule, IntPtr.Zero);
+
+      this.matches.Add (match_rule);
+    }
+
+    public void RemoveMatch (string match_rule)
+    {
+      dbus_bus_remove_match (RawConnection, match_rule, IntPtr.Zero);
+
+      this.matches.Remove (match_rule);
+    }
+
     public string UniqueName
     {
       get
@@ -193,5 +238,26 @@ namespace DBus
 
     [DllImport ("dbus-1")]
     private extern static IntPtr dbus_bus_get_unique_name (IntPtr ptr);
+
+    [DllImport("dbus-1")]
+    private extern static bool dbus_connection_add_filter(IntPtr rawConnection,
+                                                         DBusHandleMessageFunction filter,
+                                                         IntPtr userData,
+                                                         IntPtr freeData);
+
+    [DllImport("dbus-1")]
+    private extern static void dbus_connection_remove_filter(IntPtr rawConnection,
+                                                            DBusHandleMessageFunction filter,
+                                                            IntPtr userData);
+
+    [DllImport("dbus-1")]
+    private extern static void dbus_bus_add_match(IntPtr rawConnection,
+                                                 string rule,
+                                                 IntPtr erro);
+
+    [DllImport("dbus-1")]
+    private extern static void dbus_bus_remove_match(IntPtr rawConnection,
+                                                    string rule,
+                                                    IntPtr erro);
   }
 }

diff --git a/mono/Service.cs b/mono/Service.cs
index b554796..4280c6b 100644 (file)
--- a/mono/Service.cs
+++ b/mono/Service.cs
@@ -14,9 +14,6 @@ namespace DBus
     private string name;
     private bool local = false;
     private Hashtable registeredHandlers = new Hashtable();
-    private delegate int DBusHandleMessageFunction(IntPtr rawConnection,
-                                                  IntPtr rawMessage,
-                                                  IntPtr userData);
     private DBusHandleMessageFunction filterCalled;
     public delegate void SignalCalledHandler(Signal signal);
     public event SignalCalledHandler SignalCalled;
@@ -50,12 +47,6 @@ namespace DBus
       this.local = true;
     }
 
-    ~Service ()
-    {
-      if (this.filterCalled != null)
-        RemoveFilter ();
-    }
-
     public static bool HasOwner(Connection connection, string name)
     {
       Error error = new Error();
@@ -116,23 +107,9 @@ namespace DBus
     {
       // Setup the filter function
       this.filterCalled = new DBusHandleMessageFunction(Service_FilterCalled);
-      if (!dbus_connection_add_filter(Connection.RawConnection,
-                                     this.filterCalled,
-                                     IntPtr.Zero,
-                                     IntPtr.Zero))
-       throw new OutOfMemoryException();
-
-      dbus_bus_add_match(connection.RawConnection, MatchRule, IntPtr.Zero);
-    }
-
-    private void RemoveFilter() 
-    {
-      dbus_connection_remove_filter (Connection.RawConnection,
-                                    this.filterCalled,
-                                    IntPtr.Zero);
-      this.filterCalled = null;
-
-      dbus_bus_remove_match (connection.RawConnection, MatchRule, IntPtr.Zero);
+      Connection.AddFilter (this.filterCalled);
+      // Add a match for signals. FIXME: Can we filter the service?
+      Connection.AddMatch ("type='signal'");
     }
 
     private int Service_FilterCalled(IntPtr rawConnection,
@@ -210,26 +187,5 @@ namespace DBus
                                                       string serviceName, 
                                                       ref Error error);    
 
-    [DllImport("dbus-1")]
-    private extern static bool dbus_connection_add_filter(IntPtr rawConnection,
-                                                         DBusHandleMessageFunction filter,
-                                                         IntPtr userData,
-                                                         IntPtr freeData);
-
-    [DllImport("dbus-1")]
-    private extern static void dbus_connection_remove_filter(IntPtr rawConnection,
-                                                            DBusHandleMessageFunction filter,
-                                                            IntPtr userData);
-
-    [DllImport("dbus-1")]
-    private extern static void dbus_bus_add_match(IntPtr rawConnection,
-                                                 string rule,
-                                                 IntPtr erro);
-
-    [DllImport("dbus-1")]
-    private extern static void dbus_bus_remove_match(IntPtr rawConnection,
-                                                    string rule,
-                                                    IntPtr erro);
-
   }
 }