Reimplemented TpsipMediaFactory as an implementation of TpChannelManager

TpsipMediaChannel changed to comply.

2 files changed, 394 insertions, 201 deletions

diff --git a/src/media-factory.c b/src/media-factory.c
index 203252e..8350ccb 100644
--- a/src/media-factory.c
+++ b/src/media-factory.c
@@ -1,6 +1,6 @@
 /*
  * media-factory.c - Media channel factory for SIP connection manager
- * Copyright (C) 2007 Collabora Ltd.
+ * Copyright (C) 2007-2008 Collabora Ltd.
  * Copyright (C) 2007-2008 Nokia Corporation
  *
  * This work is free software; you can redistribute it and/or
@@ -22,7 +22,8 @@
 
 #include <string.h>
 
-#include <telepathy-glib/svc-connection.h>
+#include <telepathy-glib/channel-manager.h>
+#include <telepathy-glib/dbus.h>
 #include <telepathy-glib/interfaces.h>
 
 #include "sip-connection.h"
@@ -33,12 +34,14 @@
 #define DEBUG_FLAG TPSIP_DEBUG_CONNECTION
 #include "debug.h"
 
-static void factory_iface_init (gpointer, gpointer);
+static void channel_manager_iface_init (gpointer, gpointer);
+static void tpsip_media_factory_constructed (GObject *object);
+static void tpsip_media_factory_close_all (TpsipMediaFactory *fac);
 
 G_DEFINE_TYPE_WITH_CODE (TpsipMediaFactory, tpsip_media_factory,
     G_TYPE_OBJECT,
-    G_IMPLEMENT_INTERFACE (TP_TYPE_CHANNEL_FACTORY_IFACE,
-      factory_iface_init))
+    G_IMPLEMENT_INTERFACE (TP_TYPE_CHANNEL_MANAGER,
+        channel_manager_iface_init))
 
 enum
 {
@@ -58,6 +61,9 @@ struct _TpsipMediaFactoryPrivate
   /* for unique channel object paths, currently always increments */
   guint channel_index;
 
+  gulong status_changed_id;
+  gulong invite_received_id;
+
   gchar *stun_server;
   guint16 stun_port;
 
@@ -88,17 +94,23 @@ tpsip_media_factory_dispose (GObject *object)
 
   priv->dispose_has_run = TRUE;
 
-  tp_channel_factory_iface_close_all (TP_CHANNEL_FACTORY_IFACE (object));
-
+  tpsip_media_factory_close_all (fac);
   g_assert (priv->channels == NULL);
 
-  g_free (priv->stun_server);
-
   if (G_OBJECT_CLASS (tpsip_media_factory_parent_class)->dispose)
     G_OBJECT_CLASS (tpsip_media_factory_parent_class)->dispose (object);
 }
 
 static void
+tpsip_media_factory_finalize (GObject *object)
+{
+  TpsipMediaFactory *fac = TPSIP_MEDIA_FACTORY (object);
+  TpsipMediaFactoryPrivate *priv = TPSIP_MEDIA_FACTORY_GET_PRIVATE (fac);
+
+  g_free (priv->stun_server);
+}
+
+static void
 tpsip_media_factory_get_property (GObject *object,
                                guint property_id,
                                GValue *value,
@@ -157,9 +169,11 @@ tpsip_media_factory_class_init (TpsipMediaFactoryClass *klass)
 
   g_type_class_add_private (klass, sizeof (TpsipMediaFactoryPrivate));
 
+  object_class->constructed = tpsip_media_factory_constructed;
   object_class->get_property = tpsip_media_factory_get_property;
   object_class->set_property = tpsip_media_factory_set_property;
   object_class->dispose = tpsip_media_factory_dispose;
+  object_class->finalize = tpsip_media_factory_finalize;
 
   param_spec = g_param_spec_object ("connection", "TpsipConnection object",
       "SIP connection that owns this media channel factory",
@@ -182,68 +196,49 @@ tpsip_media_factory_class_init (TpsipMediaFactoryClass *klass)
 }
 
 static void
-tpsip_media_factory_close_one (gpointer data, gpointer user_data)
+tpsip_media_factory_close_all (TpsipMediaFactory *fac)
 {
-  tpsip_media_channel_close (TPSIP_MEDIA_CHANNEL(data));
-  g_object_unref (data);
-}
-
-static void
-tpsip_media_factory_close_all (TpChannelFactoryIface *iface)
-{
-  TpsipMediaFactory *fac = TPSIP_MEDIA_FACTORY (iface);
   TpsipMediaFactoryPrivate *priv = TPSIP_MEDIA_FACTORY_GET_PRIVATE (fac);
-  GPtrArray *channels;
 
-  channels = priv->channels;
-  priv->channels = NULL;
-  if (channels)
+  if (priv->status_changed_id != 0)
     {
-      g_ptr_array_foreach (channels, tpsip_media_factory_close_one, NULL);
-      g_ptr_array_free (channels, TRUE);
+      g_signal_handler_disconnect (priv->conn,
+          priv->status_changed_id);
+      priv->status_changed_id = 0;
     }
-}
-
-struct _ForeachData
-{
-  TpChannelFunc foreach;
-  gpointer user_data;
-};
-
-static void
-_foreach_slave (gpointer channel, gpointer user_data)
-{
-  struct _ForeachData *data = (struct _ForeachData *)user_data;
-  TpChannelIface *chan = TP_CHANNEL_IFACE (channel);
 
-  data->foreach (chan, data->user_data);
-}
+  if (priv->channels != NULL)
+    {
+      GPtrArray *channels;
+      guint i;
 
-static void
-tpsip_media_factory_foreach (TpChannelFactoryIface *iface,
-                          TpChannelFunc foreach,
-                          gpointer user_data)
-{
-  TpsipMediaFactory *fac = TPSIP_MEDIA_FACTORY (iface);
-  TpsipMediaFactoryPrivate *priv = TPSIP_MEDIA_FACTORY_GET_PRIVATE (fac);
+      channels = priv->channels;
+      priv->channels = NULL;
 
-  struct _ForeachData data = { foreach, user_data };
+      for (i = 0; i < channels->len; i++)
+        {
+          TpsipMediaChannel *chan = g_ptr_array_index (channels, i);
+          g_object_unref (chan);
+        }
 
-  g_ptr_array_foreach (priv->channels, _foreach_slave, &data);
+      g_ptr_array_free (channels, TRUE);
+    }
 }
 
 /**
- * channel_closed:
- *
+ * media_channel_closed_cb:
  * Signal callback for when a media channel is closed. Removes the references
  * that #TpsipMediaFactory holds to them.
  */
 static void
-channel_closed (TpsipMediaChannel *chan, gpointer user_data)
+media_channel_closed_cb (TpsipMediaChannel *chan, gpointer user_data)
 {
   TpsipMediaFactory *fac = TPSIP_MEDIA_FACTORY (user_data);
   TpsipMediaFactoryPrivate *priv = TPSIP_MEDIA_FACTORY_GET_PRIVATE (fac);
 
+  tp_channel_manager_emit_channel_closed_for_object (fac,
+      TP_EXPORTABLE_CHANNEL (chan));
+
   if (priv->channels)
     {
       g_ptr_array_remove_fast (priv->channels, chan);
@@ -257,12 +252,9 @@ channel_closed (TpsipMediaChannel *chan, gpointer user_data)
  * Creates a new empty TpsipMediaChannel.
  */
 static TpsipMediaChannel *
-tpsip_media_factory_new_channel (TpsipMediaFactory *fac,
-                                 gpointer request,
-                                 TpHandleType handle_type,
-                                 TpHandle handle,
-                                 TpHandle initiator,
-                                 GError **error)
+new_media_channel (TpsipMediaFactory *fac,
+                   TpHandle initiator,
+                   TpHandle maybe_peer)
 {
   TpsipMediaFactoryPrivate *priv;
   TpsipMediaChannel *chan = NULL;
@@ -275,29 +267,6 @@ tpsip_media_factory_new_channel (TpsipMediaFactory *fac,
   priv = TPSIP_MEDIA_FACTORY_GET_PRIVATE (fac);
   conn = (TpBaseConnection *)priv->conn;
 
-  switch (handle_type)
-    {
-    case TP_HANDLE_TYPE_CONTACT:
-      if (!tp_handle_is_valid (
-              tp_base_connection_get_handles (conn, TP_HANDLE_TYPE_CONTACT),
-              handle, error))
-        goto err;
-      break;
-    case TP_HANDLE_TYPE_NONE:
-      if (handle != 0)
-        {
-          g_set_error (error, TP_ERRORS, TP_ERROR_INVALID_ARGUMENT,
-              "TargetHandle must be zero or omitted if TargetHandleType is "
-              "NONE");
-          goto err;
-        }
-      break;
-    default:
-      g_set_error (error, TP_ERRORS, TP_ERROR_NOT_AVAILABLE,
-          "SIP media channels can not be created with this handle type");
-      goto err;
-    }
-
   object_path = g_strdup_printf ("%s/MediaChannel%u", conn->object_path,
       priv->channel_index++);
 
@@ -311,7 +280,7 @@ tpsip_media_factory_new_channel (TpsipMediaFactory *fac,
   chan = g_object_new (TPSIP_TYPE_MEDIA_CHANNEL,
                        "connection", priv->conn,
                        "object-path", object_path,
-                       "handle", handle,
+                       "handle", maybe_peer,
                        "initiator", initiator,
                        "nat-traversal", nat_traversal,
                        NULL);
@@ -325,86 +294,11 @@ tpsip_media_factory_new_channel (TpsipMediaFactory *fac,
         g_object_set ((GObject *) chan, "stun-port", priv->stun_port, NULL);
     }
 
-  if (handle_type == TP_HANDLE_TYPE_CONTACT && handle != initiator)
-    {
-      g_assert (initiator == conn->self_handle);
-
-      if (!_tpsip_media_channel_add_member ((GObject *) chan,
-               handle, "", error))
-        goto err;
-    }
-
-  g_signal_connect (chan, "closed", (GCallback) channel_closed, fac);
+  g_signal_connect (chan, "closed", G_CALLBACK (media_channel_closed_cb), fac);
 
   g_ptr_array_add (priv->channels, chan);
 
-  tp_channel_factory_iface_emit_new_channel (fac, (TpChannelIface *)chan,
-      request);
-
   return chan;
-
-err:
-  if (chan != NULL)
-    g_object_unref (chan);
-  return NULL;
-}
-
-static TpChannelFactoryRequestStatus
-tpsip_media_factory_request (TpChannelFactoryIface *iface,
-                             const gchar *chan_type,
-                             TpHandleType handle_type,
-                             TpHandle handle,
-                             gpointer request,
-                             TpChannelIface **ret,
-                             GError **error_ret)
-{
-  TpsipMediaFactory *fac = TPSIP_MEDIA_FACTORY (iface);
-  TpsipMediaFactoryPrivate *priv;
-  TpChannelIface *chan;
-  TpChannelFactoryRequestStatus status = TP_CHANNEL_FACTORY_REQUEST_STATUS_ERROR;
-  TpBaseConnection *base_conn;
-  GError *error = NULL;
-
-  if (strcmp (chan_type, TP_IFACE_CHANNEL_TYPE_STREAMED_MEDIA))
-    {
-      return TP_CHANNEL_FACTORY_REQUEST_STATUS_NOT_IMPLEMENTED;
-    }
-
-  priv = TPSIP_MEDIA_FACTORY_GET_PRIVATE (fac);
-  base_conn = (TpBaseConnection *)priv->conn;
-
-  chan = (TpChannelIface *) tpsip_media_factory_new_channel (fac,
-                                                             request,
-                                                             handle_type,
-                                                             handle,
-                                                             base_conn->self_handle,
-                                                             &error);
-  if (chan != NULL)
-    {
-      *ret = chan;
-      status = TP_CHANNEL_FACTORY_REQUEST_STATUS_CREATED;
-    }
-  else
-    {
-      g_assert (error != NULL);
-      switch (error->code)
-        {
-        case TP_ERROR_INVALID_HANDLE:
-        case TP_ERROR_INVALID_ARGUMENT:
-          status = TP_CHANNEL_FACTORY_REQUEST_STATUS_INVALID_HANDLE;
-          break;
-        case TP_ERROR_NOT_AVAILABLE:
-          status = TP_CHANNEL_FACTORY_REQUEST_STATUS_NOT_AVAILABLE;
-          break;
-        default:
-          status = TP_CHANNEL_FACTORY_REQUEST_STATUS_ERROR;
-        }
-      if (error_ret != NULL)
-        *error_ret = error;
-      else
-        g_error_free (error);
-    }
-  return status;
 }
 
 static gboolean
@@ -416,7 +310,6 @@ tpsip_nua_i_invite_cb (TpBaseConnection    *conn,
   TpsipMediaChannel *channel;
   TpHandleRepoIface *contact_repo;
   TpHandle handle;
-  GError *error = NULL;
 
   /* figure out a handle for the identity */
 
@@ -433,23 +326,9 @@ tpsip_nua_i_invite_cb (TpBaseConnection    *conn,
   DEBUG("Got incoming invite from <%s>",
         tp_handle_inspect (contact_repo, handle));
 
-  channel = tpsip_media_factory_new_channel (
-                fac,
-                NULL,
-                TP_HANDLE_TYPE_CONTACT,
-                handle,
-                handle,
-                &error);
-  if (channel)
-    {
-      tpsip_media_channel_receive_invite (channel, ev->nua_handle);
-    }
-  else
-    {
-      g_warning ("creation of SIP media channel failed: %s", error->message);
-      g_error_free (error);
-      nua_respond (ev->nua_handle, SIP_500_INTERNAL_SERVER_ERROR, TAG_END());
-    }
+  channel = new_media_channel (fac, handle, handle);
+
+  tpsip_media_channel_receive_invite (channel, ev->nua_handle);
 
   tp_handle_unref (contact_repo, handle);
 
@@ -457,38 +336,305 @@ tpsip_nua_i_invite_cb (TpBaseConnection    *conn,
 }
 
 static void
-tpsip_media_factory_connected (TpChannelFactoryIface *iface)
+connection_status_changed_cb (TpsipConnection *conn,
+                              guint status,
+                              guint reason,
+                              TpsipMediaFactory *self)
 {
-  TpsipMediaFactory *fac = TPSIP_MEDIA_FACTORY (iface);
-  TpsipMediaFactoryPrivate *priv = TPSIP_MEDIA_FACTORY_GET_PRIVATE (fac);
+  TpsipMediaFactoryPrivate *priv = TPSIP_MEDIA_FACTORY_GET_PRIVATE (self);
 
-  g_signal_connect (priv->conn,
-       "nua-event::nua_i_invite",
-       G_CALLBACK (tpsip_nua_i_invite_cb),
-       fac);
+  switch (status)
+    {
+    case TP_CONNECTION_STATUS_CONNECTED:
+
+      priv->invite_received_id = g_signal_connect (conn,
+          "nua-event::nua_i_invite",
+          G_CALLBACK (tpsip_nua_i_invite_cb), self);
+
+      break;
+    case TP_CONNECTION_STATUS_DISCONNECTED:
+
+      tpsip_media_factory_close_all (self);
+
+      g_signal_handler_disconnect (conn, priv->invite_received_id);
+      priv->invite_received_id = 0;
+
+      break;
+    default:
+      break;
+    }
 }
 
 static void
-tpsip_media_factory_disconnected (TpChannelFactoryIface *iface)
+tpsip_media_factory_constructed (GObject *object)
 {
-  TpsipMediaFactory *fac = TPSIP_MEDIA_FACTORY (iface);
+  TpsipMediaFactory *self = TPSIP_MEDIA_FACTORY (object);
+  TpsipMediaFactoryPrivate *priv = TPSIP_MEDIA_FACTORY_GET_PRIVATE (self);
+  GObjectClass *parent_object_class =
+      G_OBJECT_CLASS (tpsip_media_factory_parent_class);
+
+  if (parent_object_class->constructed != NULL)
+    parent_object_class->constructed (object);
+
+  priv->status_changed_id = g_signal_connect (priv->conn,
+      "status-changed", (GCallback) connection_status_changed_cb, object);
+}
+
+static void
+tpsip_media_factory_foreach_channel (TpChannelManager *manager,
+                                     TpExportableChannelFunc foreach,
+                                     gpointer user_data)
+{
+  TpsipMediaFactory *fac = TPSIP_MEDIA_FACTORY (manager);
   TpsipMediaFactoryPrivate *priv = TPSIP_MEDIA_FACTORY_GET_PRIVATE (fac);
+  guint i;
+
+  for (i = 0; i < priv->channels->len; i++)
+    {
+      TpExportableChannel *channel = TP_EXPORTABLE_CHANNEL (
+          g_ptr_array_index (priv->channels, i));
+
+      foreach (channel, user_data);
+    }
+}
+
+static const gchar * const media_channel_fixed_properties[] = {
+    TP_IFACE_CHANNEL ".ChannelType",
+    TP_IFACE_CHANNEL ".TargetHandleType",
+    NULL
+};
+
+static const gchar * const named_channel_allowed_properties[] = {
+    TP_IFACE_CHANNEL ".TargetHandle",
+    TP_IFACE_CHANNEL ".TargetID",
+    NULL
+};
+
+static const gchar * const anon_channel_allowed_properties[] = {
+    NULL
+};
+
+static void
+tpsip_media_factory_foreach_channel_class (TpChannelManager *manager,
+    TpChannelManagerChannelClassFunc func,
+    gpointer user_data)
+{
+  GHashTable *table = g_hash_table_new_full (g_str_hash, g_str_equal,
+      NULL, (GDestroyNotify) tp_g_value_slice_free);
+  GValue *value, *handle_type_value;
+
+  value = tp_g_value_slice_new (G_TYPE_STRING);
+  g_value_set_static_string (value, TP_IFACE_CHANNEL_TYPE_STREAMED_MEDIA);
+  g_hash_table_insert (table, TP_IFACE_CHANNEL ".ChannelType", value);
+
+  handle_type_value = tp_g_value_slice_new (G_TYPE_UINT);
+  /* no uint value yet - we'll change it for each channel class */
+  g_hash_table_insert (table, TP_IFACE_CHANNEL ".TargetHandleType",
+      handle_type_value);
+
+  g_value_set_uint (handle_type_value, TP_HANDLE_TYPE_NONE);
+  func (manager, table, anon_channel_allowed_properties, user_data);
+
+  g_value_set_uint (handle_type_value, TP_HANDLE_TYPE_CONTACT);
+  func (manager, table, named_channel_allowed_properties, user_data);
+
+  g_hash_table_destroy (table);
+}
+
+typedef enum
+{
+  METHOD_REQUEST,
+  METHOD_CREATE,
+  METHOD_ENSURE,
+} RequestMethod;
+
+static gboolean
+tpsip_media_factory_requestotron (TpChannelManager *manager,
+                                  gpointer request_token,
+                                  GHashTable *request_properties,
+                                  RequestMethod method)
+{
+  TpsipMediaFactory *self = TPSIP_MEDIA_FACTORY (manager);
+  TpsipMediaFactoryPrivate *priv = TPSIP_MEDIA_FACTORY_GET_PRIVATE (self);
+  TpBaseConnection *conn = (TpBaseConnection *) priv->conn;
+  TpHandleType handle_type;
+  TpHandle handle;
+  TpsipMediaChannel *channel = NULL;
+  GError *error = NULL;
+  GSList *request_tokens;
+  gboolean require_target_handle;
+  gboolean add_peer_to_remote_pending;
+
+  /* Supported modes of operation:
+   * - RequestChannel(None, 0):
+   *     channel is anonymous;
+   *     caller uses RequestStreams to set the peer and start the call.
+   * - RequestChannel(Contact, n) where n != 0:
+   *     channel has TargetHandle=n;
+   *     n is in remote pending;
+   *     call is started when caller calls RequestStreams.
+   * - CreateChannel({THT: Contact, TH: n}):
+   *     channel has TargetHandle=n
+   *     n is not in the group interface at all
+   *     call is started when caller calls RequestStreams.
+   * - EnsureChannel({THT: Contact, TH: n}):
+   *     look for a channel whose peer is n, and return that if found with
+   *       whatever properties and group membership it has;
+   *     otherwise the same as into CreateChannel
+   */
+  switch (method)
+    {
+    case METHOD_REQUEST:
+      require_target_handle = FALSE;
+      add_peer_to_remote_pending = TRUE;
+      break;
+    case METHOD_CREATE:
+    case METHOD_ENSURE:
+      require_target_handle = TRUE;
+      add_peer_to_remote_pending = FALSE;
+      break;
+    default:
+      g_assert_not_reached ();
+    }
+
+  if (tp_strdiff (tp_asv_get_string (request_properties,
+          TP_IFACE_CHANNEL ".ChannelType"),
+        TP_IFACE_CHANNEL_TYPE_STREAMED_MEDIA))
+    return FALSE;
+
+  handle_type = tp_asv_get_uint32 (request_properties,
+      TP_IFACE_CHANNEL ".TargetHandleType", NULL);
+
+  handle = tp_asv_get_uint32 (request_properties,
+      TP_IFACE_CHANNEL ".TargetHandle", NULL);
+
+  switch (handle_type)
+    {
+    case TP_HANDLE_TYPE_NONE:
+      if (handle != 0)
+        {
+          g_set_error (&error, TP_ERRORS, TP_ERROR_INVALID_ARGUMENT,
+              "TargetHandle must be zero or omitted if TargetHandleType is "
+              "NONE");
+          goto error;
+        }
+
+      if (require_target_handle)
+        {
+          g_set_error (&error, TP_ERRORS, TP_ERROR_NOT_IMPLEMENTED,
+              "A valid Contact handle must be provided when requesting a media "
+              "channel");
+          goto error;
+        }
+
+      if (tp_channel_manager_asv_has_unknown_properties (request_properties,
+              media_channel_fixed_properties, anon_channel_allowed_properties,
+              &error))
+        goto error;
 
-  g_signal_handlers_disconnect_by_func (priv->conn,
-       G_CALLBACK (tpsip_nua_i_invite_cb),
-       fac);
+      channel = new_media_channel (self, conn->self_handle, 0);
+      break;
+
+    case TP_HANDLE_TYPE_CONTACT:
+      if (!tp_handle_is_valid (
+            tp_base_connection_get_handles (conn, TP_HANDLE_TYPE_CONTACT),
+            handle, &error))
+        goto error;
+
+      if (tp_channel_manager_asv_has_unknown_properties (request_properties,
+              media_channel_fixed_properties, named_channel_allowed_properties,
+              &error))
+        goto error;
+
+      if (method == METHOD_ENSURE)
+        {
+          guint i;
+          TpHandle peer = 0;
+
+          for (i = 0; i < priv->channels->len; i++)
+            {
+              channel = g_ptr_array_index (priv->channels, i);
+              g_object_get (channel, "peer", &peer, NULL);
+
+              if (peer == handle)
+                {
+                  tp_channel_manager_emit_request_already_satisfied (self,
+                      request_token, TP_EXPORTABLE_CHANNEL (channel));
+                  return TRUE;
+                }
+            }
+        }
+
+      channel = new_media_channel (self, conn->self_handle, handle);
+
+      if (add_peer_to_remote_pending)
+        {
+          if (!_tpsip_media_channel_add_member ((GObject *) channel, handle,
+                "", &error))
+            {
+              tpsip_media_channel_close (channel);
+              goto error;
+            }
+        }
+
+      break;
+
+    default:
+      return FALSE;
+    }
+
+  g_assert (channel != NULL);
+
+  request_tokens = g_slist_prepend (NULL, request_token);
+  tp_channel_manager_emit_new_channel (self,
+      TP_EXPORTABLE_CHANNEL (channel), request_tokens);
+  g_slist_free (request_tokens);
+
+  return TRUE;
+
+error:
+  tp_channel_manager_emit_request_failed (self, request_token,
+      error->domain, error->code, error->message);
+  g_error_free (error);
+  return TRUE;
+}
+
+static gboolean
+tpsip_media_factory_request_channel (TpChannelManager *manager,
+                                     gpointer request_token,
+                                     GHashTable *request_properties)
+{
+  return tpsip_media_factory_requestotron (manager, request_token,
+      request_properties, METHOD_REQUEST);
+}
+
+static gboolean
+tpsip_media_factory_create_channel (TpChannelManager *manager,
+                                    gpointer request_token,
+                                    GHashTable *request_properties)
+{
+  return tpsip_media_factory_requestotron (manager, request_token,
+      request_properties, METHOD_CREATE);
+}
+
+static gboolean
+tpsip_media_factory_ensure_channel (TpChannelManager *manager,
+                                    gpointer request_token,
+                                    GHashTable *request_properties)
+{
+  return tpsip_media_factory_requestotron (manager, request_token,
+      request_properties, METHOD_ENSURE);
 }
 
 static void
-factory_iface_init (gpointer g_iface, gpointer iface_data)
+channel_manager_iface_init (gpointer g_iface,
+                            gpointer iface_data)
 {
-  TpChannelFactoryIfaceClass *klass = (TpChannelFactoryIfaceClass *) g_iface;
-
-#define IMPLEMENT(x) klass->x = tpsip_media_factory_##x
-  IMPLEMENT(close_all);
-  IMPLEMENT(foreach);
-  IMPLEMENT(request);
-  IMPLEMENT(connected);
-  IMPLEMENT(disconnected);
-#undef IMPLEMENT
+  TpChannelManagerIface *iface = g_iface;
+
+  iface->foreach_channel = tpsip_media_factory_foreach_channel;
+  iface->foreach_channel_class = tpsip_media_factory_foreach_channel_class;
+  iface->request_channel = tpsip_media_factory_request_channel;
+  iface->create_channel = tpsip_media_factory_create_channel;
+  iface->ensure_channel = tpsip_media_factory_ensure_channel;
 }
diff --git a/src/sip-media-channel.c b/src/sip-media-channel.c
index 57012f1..eb57ad5 100644
--- a/src/sip-media-channel.c
+++ b/src/sip-media-channel.c
@@ -31,9 +31,8 @@
 #include <telepathy-glib/channel-iface.h>
 #include <telepathy-glib/dbus.h>
 #include <telepathy-glib/errors.h>
-#include <telepathy-glib/gtypes.h>
+#include <telepathy-glib/exportable-channel.h>
 #include <telepathy-glib/interfaces.h>
-#include <telepathy-glib/intset.h>
 #include <telepathy-glib/svc-channel.h>
 
 #include <tpsip/event-target.h>
@@ -72,6 +71,7 @@ G_DEFINE_TYPE_WITH_CODE (TpsipMediaChannel, tpsip_media_channel,
       hold_iface_init);
     G_IMPLEMENT_INTERFACE (TP_TYPE_SVC_CHANNEL_TYPE_STREAMED_MEDIA,
       streamed_media_iface_init);
+    G_IMPLEMENT_INTERFACE (TP_TYPE_EXPORTABLE_CHANNEL, NULL);
     G_IMPLEMENT_INTERFACE (TP_TYPE_CHANNEL_IFACE, NULL));
 
 static const gchar *tpsip_media_channel_interfaces[] = {
@@ -95,8 +95,11 @@ enum
   PROP_TARGET_ID,
   PROP_INITIATOR,
   PROP_INITIATOR_ID,
+  PROP_PEER,
   PROP_REQUESTED,
   PROP_INTERFACES,
+  PROP_CHANNEL_DESTROYED,
+  PROP_CHANNEL_PROPERTIES,
   /* Telepathy properties (see below too) */
   PROP_NAT_TRAVERSAL,
   PROP_STUN_SERVER,
@@ -113,7 +116,7 @@ enum
   NUM_TP_PROPS
 };
 
-const TpPropertySignature media_channel_property_signatures[NUM_TP_PROPS] =
+static const TpPropertySignature media_channel_property_signatures[NUM_TP_PROPS] =
 {
     { "nat-traversal",          G_TYPE_STRING },
     { "stun-server",            G_TYPE_STRING },
@@ -277,6 +280,11 @@ tpsip_media_channel_class_init (TpsipMediaChannelClass *klass)
   g_object_class_override_property (object_class, PROP_CHANNEL_TYPE,
       "channel-type");
 
+  g_object_class_override_property (object_class, PROP_CHANNEL_DESTROYED,
+      "channel-destroyed");
+  g_object_class_override_property (object_class, PROP_CHANNEL_PROPERTIES,
+      "channel-properties");
+
   param_spec = g_param_spec_object ("connection", "TpsipConnection object",
       "SIP connection object that owns this SIP media channel object.",
       TPSIP_TYPE_CONNECTION,
@@ -376,8 +384,30 @@ tpsip_media_channel_get_property (GObject    *object,
           TP_HANDLE_TYPE_CONTACT : TP_HANDLE_TYPE_NONE);
       break;
     case PROP_TARGET_ID:
-      g_value_set_static_string (value, "");
+      if (priv->handle != 0)
+        {
+          TpHandleRepoIface *repo = tp_base_connection_get_handles (
+              base_conn, TP_HANDLE_TYPE_CONTACT);
+
+          g_value_set_string (value, tp_handle_inspect (repo, priv->initiator));
+        }
+      else
+        g_value_set_static_string (value, "");
       break;
+    case PROP_PEER:
+      {
+        TpHandle peer = 0;
+
+        if (priv->handle != 0)
+          peer = priv->handle;
+        else if (priv->session != NULL)
+          g_object_get (priv->session,
+              "peer", &peer,
+              NULL);
+
+        g_value_set_uint (value, peer);
+        break;
+      }
     case PROP_INITIATOR:
       g_value_set_uint (value, priv->initiator);
       break;
@@ -395,6 +425,21 @@ tpsip_media_channel_get_property (GObject    *object,
     case PROP_INTERFACES:
       g_value_set_static_boxed (value, tpsip_media_channel_interfaces);
       break;
+    case PROP_CHANNEL_DESTROYED:
+      g_value_set_boolean (value, priv->closed);
+      break;
+    case PROP_CHANNEL_PROPERTIES:
+      g_value_take_boxed (value,
+          tp_dbus_properties_mixin_make_properties_hash (object,
+              TP_IFACE_CHANNEL, "ChannelType",
+              TP_IFACE_CHANNEL, "TargetHandleType",
+              TP_IFACE_CHANNEL, "TargetHandle",
+              TP_IFACE_CHANNEL, "TargetID",
+              TP_IFACE_CHANNEL, "InitiatorHandle",
+              TP_IFACE_CHANNEL, "InitiatorID",
+              TP_IFACE_CHANNEL, "Requested",
+              NULL));
+      break;
     default:
       /* Some properties live in the mixin */
       {
@@ -445,6 +490,8 @@ tpsip_media_channel_set_property (GObject     *object,
       priv->object_path = g_value_dup_string (value);
       break;
     case PROP_HANDLE:
+      /* XXX: this property is defined as writable,
+       * but don't set it after construction, mmkay? */
       /* we don't ref it here because we don't necessarily have access to the
        * contact repo yet - instead we ref it in constructed. */
       priv->handle = g_value_get_uint (value);