Replace tp-yell with tp-glib's Call1 API

22 files changed, 338 insertions, 396 deletions

diff --git a/.gitmodules b/.gitmodules
index d8ca620f7..f61abb4ef 100644
--- a/.gitmodules
+++ b/.gitmodules
@@ -1,6 +1,3 @@
 [submodule "lib/ext/wocky"]
 	path = lib/ext/wocky
 	url = git://anongit.freedesktop.org/wocky
-[submodule "lib/ext/telepathy-yell"]
-	path = lib/ext/telepathy-yell
-	url = git://anongit.freedesktop.org/telepathy/telepathy-yell
diff --git a/autogen.sh b/autogen.sh
index 27fa0501a..59c531ff9 100755
--- a/autogen.sh
+++ b/autogen.sh
@@ -30,7 +30,7 @@ done
 
 if test $enable_submodules = true; then
     # Fetch submodules if needed
-    if test ! -f lib/ext/wocky/autogen.sh -o ! -f lib/ext/telepathy-yell/autogen.sh; then
+    if test ! -f lib/ext/wocky/autogen.sh; then
         echo "+ Setting up submodules"
         git submodule init
     fi
@@ -40,11 +40,6 @@ if test $enable_submodules = true; then
     cd lib/ext/wocky
     sh autogen.sh --no-configure
     cd ../../..
-
-    # launch tp-yell's autogen.sh
-    cd lib/ext/telepathy-yell
-    sh autogen.sh --no-configure
-    cd ../../..
 fi
 
 # Honor NOCONFIGURE for compatibility with gnome-autogen.sh
diff --git a/configure.ac b/configure.ac
index 3e8d53812..e590706e0 100644
--- a/configure.ac
+++ b/configure.ac
@@ -309,8 +309,6 @@ AM_CONDITIONAL([WANT_TWISTED_TESTS], test false != "$TEST_PYTHON")
 # separate Wocky installation won't clash with them. This is a bit of a hack.
 # AX_CONFIG_DIR doesn't make it very easy to pass extra arguments to the
 # submodule's configure.
-#
-# Also do this for telepathy-yell.
 prev_ac_configure_args=$ac_configure_args
 ac_configure_args="$ac_configure_args --with-installed-headers=${wocky_install_headers_dir}"
 
@@ -331,16 +329,11 @@ prev_top_build_prefix=$ac_top_build_prefix
 AX_CONFIG_DIR([lib/ext/wocky])
 ac_top_build_prefix=$prev_top_build_prefix
 
-dnl tp-yell
-prev_top_build_prefix=$ac_top_build_prefix
-AX_CONFIG_DIR([lib/ext/telepathy-yell])
-ac_top_build_prefix=$prev_top_build_prefix
-
 ac_configure_args=$prev_ac_configure_args
 
 dnl Check if Android build
 AC_ARG_ENABLE(submodules,
-              AS_HELP_STRING([--disable-submodules],[Use system versions of Wocky and Telepathy-Yell, rather than submodules]),
+              AS_HELP_STRING([--disable-submodules],[Use system versions of Wocky, rather than submodules]),
               build_submodules=$enableval, build_submodules=yes )
 
 dnl Check for Wocky
@@ -353,14 +346,6 @@ PKG_CHECK_MODULES(WOCKY, wocky >= 0.0.0)
 AC_SUBST(WOCKY_CFLAGS)
 AC_SUBST(WOCKY_LIBS)
 
-dnl Check for tp-yell
-if test x$build_submodules = xyes; then
-    export PKG_CONFIG_PATH=$PKG_CONFIG_PATH:"$ac_top_build_prefix"lib/ext/telepathy-yell/telepathy-yell
-fi
-PKG_CHECK_MODULES(TP_YELL, telepathy-yell)
-AC_SUBST(TP_YELL_CFLAGS)
-AC_SUBST(TP_YELL_LIBS)
-
 AC_ARG_ENABLE(google-relay,
   AC_HELP_STRING([--disable-google-relay],
                  [disable Google Jingle relay support]),
diff --git a/lib/ext/Makefile.am b/lib/ext/Makefile.am
index ecb0d90fe..48e4e2d5e 100644
--- a/lib/ext/Makefile.am
+++ b/lib/ext/Makefile.am
@@ -1,23 +1,16 @@
 SUBDIRS =
-DIST_SUBDIRS = wocky telepathy-yell
+DIST_SUBDIRS = wocky
 
 all-local:
 	@cd wocky && $(MAKE)
-	@cd telepathy-yell && $(MAKE)
 
 clean-local:
 	if test -e wocky/Makefile ; then \
 		cd wocky && $(MAKE) clean ; \
 	fi
 
-	if test -e telepathy-yell/Makefile ; then \
-		cd telepathy-yell && $(MAKE) clean ; \
-	fi
-
 uninstall-local:
 	@cd wocky/wocky && $(MAKE) uninstall
-	@cd telepathy-yell/telepathy-yell && $(MAKE) uninstall
 
 install-data-local:
 	@cd wocky/wocky && $(MAKE) install
-	@cd telepathy-yell/telepathy-yell && $(MAKE) install
diff --git a/lib/ext/telepathy-yell b/lib/ext/telepathy-yell
deleted file mode 160000
-Subproject e119ea5c68389142ee328c694cdf08eaae4720f
diff --git a/src/Makefile.am b/src/Makefile.am
index b3d140e5e..1d520828a 100644
--- a/src/Makefile.am
+++ b/src/Makefile.am
@@ -213,7 +213,6 @@ libgabble_convenience_la_LIBADD = \
    $(top_builddir)/extensions/libgabble-extensions.la \
    $(top_builddir)/lib/gibber/libgibber.la \
    $(top_builddir)/lib/loudmouth/libloudmouth.la \
-   $(top_builddir)/lib/ext/telepathy-yell/telepathy-yell/libtelepathy-yell.la \
    $(ALL_LIBS)
 
 nodist_libgabble_convenience_la_SOURCES = \
@@ -240,7 +239,6 @@ telepathy_gabble_LDFLAGS = -export-dynamic
 noinst_LTLIBRARIES = libgabble-convenience.la
 
 AM_CFLAGS = $(ERROR_CFLAGS) -I$(top_srcdir) -I$(top_builddir) \
-	    @TP_YELL_CFLAGS@ \
 	    @DBUS_CFLAGS@ @GLIB_CFLAGS@ @WOCKY_CFLAGS@ \
 	    @TP_GLIB_CFLAGS@ \
 	    @SOUP_CFLAGS@ @NICE_CFLAGS@ @GMODULE_CFLAGS@ \
diff --git a/src/base-call-channel.c b/src/base-call-channel.c
index c2ab4ff4b..ea1881e26 100644
--- a/src/base-call-channel.c
+++ b/src/base-call-channel.c
@@ -35,11 +35,6 @@
 #include <telepathy-glib/base-connection.h>
 #include <telepathy-glib/gtypes.h>
 
-#include <telepathy-yell/enums.h>
-#include <telepathy-yell/gtypes.h>
-#include <telepathy-yell/interfaces.h>
-#include <telepathy-yell/svc-call.h>
-
 #include "util.h"
 #include "call-content.h"
 
@@ -51,10 +46,10 @@
 #include "debug.h"
 
 G_DEFINE_TYPE(GabbleBaseCallChannel, gabble_base_call_channel,
-  TPY_TYPE_BASE_CALL_CHANNEL);
+  TP_TYPE_BASE_CALL_CHANNEL);
 
 static void gabble_base_call_channel_hangup (
-    TpyBaseCallChannel *base,
+    TpBaseCallChannel *base,
     guint reason,
     const gchar *detailed_reason,
     const gchar *message);
@@ -152,8 +147,8 @@ gabble_base_call_channel_class_init (
   GObjectClass *object_class = G_OBJECT_CLASS (gabble_base_call_channel_class);
   TpBaseChannelClass *base_channel_class =
       TP_BASE_CHANNEL_CLASS (gabble_base_call_channel_class);
-  TpyBaseCallChannelClass *tpy_base_call_channel_class =
-      TPY_BASE_CALL_CHANNEL_CLASS (gabble_base_call_channel_class);
+  TpBaseCallChannelClass *tp_base_call_channel_class =
+      TP_BASE_CALL_CHANNEL_CLASS (gabble_base_call_channel_class);
   GParamSpec *param_spec;
 
   g_type_class_add_private (gabble_base_call_channel_class,
@@ -169,7 +164,7 @@ gabble_base_call_channel_class_init (
       gabble_base_call_channel_get_object_path_suffix;
   base_channel_class->close = gabble_base_call_channel_close;
 
-  tpy_base_call_channel_class->hangup = gabble_base_call_channel_hangup;
+  tp_base_call_channel_class->hangup = gabble_base_call_channel_hangup;
 
   param_spec = g_param_spec_string ("object-path-prefix", "Object path prefix",
       "prefix of the object path",
@@ -213,11 +208,11 @@ GabbleCallContent *
 gabble_base_call_channel_add_content (GabbleBaseCallChannel *self,
     const gchar *name,
     JingleMediaType mtype,
-    TpyCallContentDisposition disposition)
+    TpCallContentDisposition disposition)
 {
   TpBaseChannel *base = TP_BASE_CHANNEL (self);
   gchar *object_path;
-  TpyBaseCallContent *content;
+  TpBaseCallContent *content;
   gchar *escaped;
 
   /* FIXME could clash when other party in a one-to-one call creates a stream
@@ -238,7 +233,7 @@ gabble_base_call_channel_add_content (GabbleBaseCallChannel *self,
 
   g_free (object_path);
 
-  tpy_base_call_channel_add_content (TPY_BASE_CALL_CHANNEL (self),
+  tp_base_call_channel_add_content (TP_BASE_CALL_CHANNEL (self),
     content);
 
   return GABBLE_CALL_CONTENT (content);
@@ -246,14 +241,15 @@ gabble_base_call_channel_add_content (GabbleBaseCallChannel *self,
 
 static void
 call_member_flags_changed_cb (GabbleCallMember *member,
-  TpyCallMemberFlags flags,
+  TpCallMemberFlags flags,
   gpointer user_data)
 {
-  TpyBaseCallChannel *base = TPY_BASE_CALL_CHANNEL (user_data);
+  TpBaseCallChannel *base = TP_BASE_CALL_CHANNEL (user_data);
 
-  tpy_base_call_channel_update_member_flags (base,
+  tp_base_call_channel_update_member_flags (base,
     gabble_call_member_get_handle (member),
-    flags);
+    flags,
+    0, TP_CALL_STATE_CHANGE_REASON_PROGRESS_MADE, "", "");
 }
 
 GabbleCallMember *
@@ -281,9 +277,10 @@ gabble_base_call_channel_ensure_member_from_handle (
         NULL));
       g_hash_table_insert (priv->members, GUINT_TO_POINTER (handle), m);
 
-      tpy_base_call_channel_add_member (TPY_BASE_CALL_CHANNEL (self),
+      tp_base_call_channel_update_member_flags (TP_BASE_CALL_CHANNEL (self),
         gabble_call_member_get_handle (m),
-        gabble_call_member_get_flags (m));
+        gabble_call_member_get_flags (m),
+        0, TP_CALL_STATE_CHANGE_REASON_PROGRESS_MADE, "", "");
 
       gabble_signal_connect_weak (m, "flags-changed",
         G_CALLBACK (call_member_flags_changed_cb), G_OBJECT (self));
@@ -302,8 +299,9 @@ gabble_base_call_channel_remove_member (GabbleBaseCallChannel *self,
     GUINT_TO_POINTER (h))== member);
 
   gabble_call_member_shutdown (member);
-  tpy_base_call_channel_remove_member (TPY_BASE_CALL_CHANNEL (self),
-    gabble_call_member_get_handle (member));
+  tp_base_call_channel_remove_member (TP_BASE_CALL_CHANNEL (self),
+    gabble_call_member_get_handle (member),
+    0, TP_CALL_STATE_CHANGE_REASON_PROGRESS_MADE, "", "");
   g_hash_table_remove (self->priv->members, GUINT_TO_POINTER (h));
 }
 
@@ -319,7 +317,7 @@ gabble_base_call_channel_shutdown_all_members (GabbleBaseCallChannel *self)
 }
 
 static void
-gabble_base_call_channel_hangup (TpyBaseCallChannel *base,
+gabble_base_call_channel_hangup (TpBaseCallChannel *base,
     guint reason,
     const gchar *detailed_reason,
     const gchar *message)
diff --git a/src/base-call-channel.h b/src/base-call-channel.h
index 4dbc90ac1..a4708284f 100644
--- a/src/base-call-channel.h
+++ b/src/base-call-channel.h
@@ -23,10 +23,8 @@
 
 #include <glib-object.h>
 
-#include <telepathy-yell/enums.h>
-
 #include <telepathy-glib/base-channel.h>
-#include <telepathy-yell/base-call-channel.h>
+#include <telepathy-glib/base-call-channel.h>
 
 #include "jingle-content.h"
 #include "call-member.h"
@@ -39,11 +37,11 @@ typedef struct _GabbleBaseCallChannelPrivate GabbleBaseCallChannelPrivate;
 typedef struct _GabbleBaseCallChannelClass GabbleBaseCallChannelClass;
 
 struct _GabbleBaseCallChannelClass {
-    TpyBaseCallChannelClass parent_class;
+    TpBaseCallChannelClass parent_class;
 };
 
 struct _GabbleBaseCallChannel {
-    TpyBaseCallChannel parent;
+    TpBaseCallChannel parent;
 
     GabbleBaseCallChannelPrivate *priv;
 };
@@ -86,7 +84,7 @@ GabbleCallContent * gabble_base_call_channel_add_content (
     GabbleBaseCallChannel *self,
     const gchar *name,
     JingleMediaType mtype,
-    TpyCallContentDisposition disposition);
+    TpCallContentDisposition disposition);
 
 void gabble_base_call_channel_remove_content (GabbleBaseCallChannel *self,
     GabbleCallContent *content);
diff --git a/src/call-channel.c b/src/call-channel.c
index d8fc4f269..bd993f4fc 100644
--- a/src/call-channel.c
+++ b/src/call-channel.c
@@ -33,9 +33,6 @@
 #include <telepathy-glib/base-connection.h>
 #include <telepathy-glib/gtypes.h>
 
-#include <telepathy-yell/enums.h>
-#include <telepathy-yell/svc-call.h>
-
 #include "util.h"
 #include "call-channel.h"
 #include "call-content.h"
@@ -55,9 +52,9 @@ static void call_session_state_changed_cb (GabbleJingleSession *session,
 static void call_member_content_added_cb (GabbleCallMember *member,
     GabbleCallMemberContent *content, GabbleCallChannel *self);
 
-static void call_channel_accept (TpyBaseCallChannel *channel);
-static TpyBaseCallContent * call_channel_add_content (
-    TpyBaseCallChannel *base,
+static void call_channel_accept (TpBaseCallChannel *channel);
+static TpBaseCallContent * call_channel_add_content (
+    TpBaseCallChannel *base,
     const gchar *name,
     TpMediaStreamType type,
     GError **error);
@@ -90,7 +87,6 @@ gabble_call_channel_constructed (GObject *obj)
 {
   GabbleCallChannel *self = GABBLE_CALL_CHANNEL (obj);
   GabbleCallChannelPrivate *priv = self->priv;
-  TpyBaseCallChannel *tpy_base = TPY_BASE_CALL_CHANNEL (obj);
   GabbleBaseCallChannel *g_base = GABBLE_BASE_CALL_CHANNEL (obj);
   GabbleCallMember *member;
 
@@ -120,23 +116,9 @@ gabble_call_channel_constructed (GObject *obj)
           c = gabble_base_call_channel_add_content (g_base,
                 gabble_call_member_content_get_name (content),
                 gabble_call_member_content_get_media_type (content),
-                TPY_CALL_CONTENT_DISPOSITION_INITIAL);
+                TP_CALL_CONTENT_DISPOSITION_INITIAL);
 
           gabble_call_content_add_member_content (c, content);
-
-          switch (gabble_call_member_content_get_media_type (content))
-            {
-              case JINGLE_MEDIA_TYPE_AUDIO:
-                tpy_base->initial_audio = TRUE;
-                break;
-              case JINGLE_MEDIA_TYPE_VIDEO:
-                tpy_base->initial_video = TRUE;
-                break;
-              default:
-                DEBUG ("Unknown media type: %d",
-                  gabble_call_member_content_get_media_type (content));
-                break;
-            }
         }
     }
 
@@ -202,8 +184,8 @@ gabble_call_channel_class_init (
     GabbleCallChannelClass *gabble_call_channel_class)
 {
   GObjectClass *object_class = G_OBJECT_CLASS (gabble_call_channel_class);
-  TpyBaseCallChannelClass *tpy_base_call_class =
-      TPY_BASE_CALL_CHANNEL_CLASS (gabble_call_channel_class);
+  TpBaseCallChannelClass *tp_base_call_class =
+      TP_BASE_CALL_CHANNEL_CLASS (gabble_call_channel_class);
   TpBaseChannelClass *base_channel_class =
       TP_BASE_CHANNEL_CLASS (gabble_call_channel_class);
   GParamSpec *param_spec;
@@ -221,8 +203,8 @@ gabble_call_channel_class_init (
 
   base_channel_class->target_handle_type = TP_HANDLE_TYPE_CONTACT;
 
-  tpy_base_call_class->accept = call_channel_accept;
-  tpy_base_call_class->add_content = call_channel_add_content;
+  tp_base_call_class->accept = call_channel_accept;
+  tp_base_call_class->add_content = call_channel_add_content;
 
   param_spec = g_param_spec_object ("session", "GabbleJingleSession object",
       "Jingle session associated with this media channel object.",
@@ -259,23 +241,25 @@ call_session_state_changed_cb (GabbleJingleSession *session,
   GParamSpec *param,
   GabbleCallChannel *self)
 {
-  TpyBaseCallChannel *cbase = TPY_BASE_CALL_CHANNEL (self);
+  TpBaseCallChannel *cbase = TP_BASE_CALL_CHANNEL (self);
   JingleState state;
-  TpyCallState cstate;
+  TpCallState cstate;
 
-  cstate = tpy_base_call_channel_get_state (cbase);
+  cstate = tp_base_call_channel_get_state (cbase);
 
   g_object_get (session, "state", &state, NULL);
 
-  if (state == JINGLE_STATE_ACTIVE && cstate != TPY_CALL_STATE_ACCEPTED)
+  if (state == JINGLE_STATE_ACTIVE && cstate != TP_CALL_STATE_ACCEPTED)
     {
-      tpy_base_call_channel_set_state (cbase, TPY_CALL_STATE_ACCEPTED);
+      tp_base_call_channel_set_state (cbase, TP_CALL_STATE_ACCEPTED,
+          0, TP_CALL_STATE_CHANGE_REASON_PROGRESS_MADE, "", "");
       return;
     }
 
-  if (state == JINGLE_STATE_ENDED && cstate < TPY_CALL_STATE_ENDED)
+  if (state == JINGLE_STATE_ENDED && cstate < TP_CALL_STATE_ENDED)
     {
-      tpy_base_call_channel_set_state (cbase, TPY_CALL_STATE_ENDED);
+      tp_base_call_channel_set_state (cbase, TP_CALL_STATE_ENDED,
+          0, TP_CALL_STATE_CHANGE_REASON_PROGRESS_MADE, "", "");
       return;
     }
 }
@@ -289,7 +273,6 @@ call_member_content_added_cb (GabbleCallMember *member,
   GabbleBaseCallChannel *cbase = GABBLE_BASE_CALL_CHANNEL (self);
   GabbleJingleContent *jingle_content;
   GabbleCallContent *c;
-  TpyBaseCallContent *base_content;
 
   jingle_content = gabble_call_member_content_get_jingle_content (content);
 
@@ -300,13 +283,9 @@ call_member_content_added_cb (GabbleCallMember *member,
   c = gabble_base_call_channel_add_content (cbase,
       gabble_call_member_content_get_name (content),
       gabble_call_member_content_get_media_type (content),
-      TPY_CALL_CONTENT_DISPOSITION_NONE);
-  base_content = TPY_BASE_CALL_CONTENT (c);
+      TP_CALL_CONTENT_DISPOSITION_NONE);
 
   gabble_call_content_add_member_content (c, content);
-
-  tpy_svc_channel_type_call_emit_content_added (self,
-      tpy_base_call_content_get_object_path (base_content));
 }
 
 static gboolean
@@ -364,10 +343,10 @@ call_member_content_removed_cb (GabbleCallMember *member,
     GabbleCallMemberContent *mcontent,
     GabbleBaseCallChannel *self)
 {
-  TpyBaseCallChannel *cbase = TPY_BASE_CALL_CHANNEL (self);
+  TpBaseCallChannel *cbase = TP_BASE_CALL_CHANNEL (self);
   GList *l;
 
-  for (l = tpy_base_call_channel_get_contents (cbase);
+  for (l = tp_base_call_channel_get_contents (cbase);
       l != NULL; l = g_list_next (l))
     {
       GabbleCallContent *content = GABBLE_CALL_CONTENT (l->data);
@@ -375,8 +354,9 @@ call_member_content_removed_cb (GabbleCallMember *member,
 
       if (contents != NULL && contents->data == mcontent)
         {
-          tpy_base_call_channel_remove_content (cbase,
-            TPY_BASE_CALL_CONTENT (content));
+          tp_base_call_channel_remove_content (cbase,
+              TP_BASE_CALL_CONTENT (content),
+              0, TP_CALL_STATE_CHANGE_REASON_PROGRESS_MADE, "", "");
           break;
         }
     }
@@ -387,10 +367,11 @@ call_channel_continue_init (GabbleCallChannel *self,
     GSimpleAsyncResult *result)
 {
   GabbleCallChannelPrivate *priv = self->priv;
-  TpyBaseCallChannel *base = TPY_BASE_CALL_CHANNEL (self);
+  TpBaseCallChannel *base = TP_BASE_CALL_CHANNEL (self);
   TpBaseChannel *tp_base = TP_BASE_CHANNEL (self);
   GError *error = NULL;
-  gchar *initial_audio_name = NULL, *initial_video_name = NULL;
+  gboolean initial_audio, initial_video;
+  const gchar *initial_audio_name = NULL, *initial_video_name = NULL;
 
   if (priv->session == NULL)
     {
@@ -401,14 +382,14 @@ call_channel_continue_init (GabbleCallChannel *self,
           GABBLE_BASE_CALL_CHANNEL (self),
           tp_base_channel_get_target_handle (tp_base));
 
-      g_object_get (self,
-          "initial-audio-name", &initial_audio_name,
-          "initial-video-name", &initial_video_name,
-          NULL);
+      initial_audio = tp_base_call_channel_has_initial_audio (base,
+          &initial_audio_name);
+      initial_video = tp_base_call_channel_has_initial_video (base,
+          &initial_video_name);
 
       if (!gabble_call_member_start_session (member,
-          base->initial_audio ? initial_audio_name : NULL,
-          base->initial_video ? initial_video_name : NULL,
+          initial_audio ? initial_audio_name : NULL,
+          initial_video ? initial_video_name : NULL,
           &error))
        {
          g_simple_async_result_set_from_error (result, error);
@@ -432,7 +413,7 @@ call_channel_continue_init (GabbleCallChannel *self,
                 GABBLE_BASE_CALL_CHANNEL (self),
                 gabble_call_member_content_get_name (content),
                 gabble_call_member_content_get_media_type (content),
-                TPY_CALL_CONTENT_DISPOSITION_INITIAL);
+                TP_CALL_CONTENT_DISPOSITION_INITIAL);
 
           gabble_call_content_add_member_content (c, content);
         }
@@ -448,8 +429,6 @@ call_channel_continue_init (GabbleCallChannel *self,
 out:
   g_simple_async_result_complete_in_idle (result);
   g_object_unref (result);
-  g_free (initial_audio_name);
-  g_free (initial_video_name);
 }
 
 static void
@@ -557,14 +536,14 @@ async_initable_iface_init (GAsyncInitableIface *iface)
 }
 
 static void
-call_channel_accept (TpyBaseCallChannel *channel)
+call_channel_accept (TpBaseCallChannel *channel)
 {
   GabbleCallChannel *self = GABBLE_CALL_CHANNEL (channel);
   gabble_jingle_session_accept (self->priv->session);
 }
 
-static TpyBaseCallContent *
-call_channel_add_content (TpyBaseCallChannel *base,
+static TpBaseCallContent *
+call_channel_add_content (TpBaseCallChannel *base,
     const gchar *name,
     TpMediaStreamType type,
     GError **error)
@@ -581,9 +560,9 @@ call_channel_add_content (TpyBaseCallChannel *base,
       content = gabble_base_call_channel_add_content (
         GABBLE_BASE_CALL_CHANNEL (base),
         name, jingle_media_type_from_tp (type),
-        TPY_CALL_CONTENT_DISPOSITION_NONE);
+        TP_CALL_CONTENT_DISPOSITION_NONE);
       gabble_call_content_add_member_content (content, mcontent);
     }
 
-  return TPY_BASE_CALL_CONTENT (content);
+  return TP_BASE_CALL_CONTENT (content);
 }
diff --git a/src/call-content.c b/src/call-content.c
index c61fbcfac..423d75444 100644
--- a/src/call-content.c
+++ b/src/call-content.c
@@ -27,14 +27,6 @@
 #include <telepathy-glib/base-connection.h>
 #include <telepathy-glib/gtypes.h>
 
-#include <telepathy-yell/gtypes.h>
-#include <telepathy-yell/interfaces.h>
-#include <telepathy-yell/svc-call.h>
-
-#include <telepathy-yell/call-content-codec-offer.h>
-#include <telepathy-yell/base-call-content.h>
-#include <telepathy-yell/base-call-stream.h>
-
 #include "call-member.h"
 #include "call-content.h"
 #include "call-stream.h"
@@ -48,14 +40,15 @@
 
 #include "debug.h"
 
-static void call_content_deinit (TpyBaseCallContent *base);
-static void call_content_local_codecs_updated (
+static void call_content_deinit (TpBaseCallContent *base);
+static void call_content_local_media_description_updated (
     GabbleCallContent *self,
-    GPtrArray *local_codecs,
+    TpHandle contact,
+    GHashTable *properties,
     gpointer data);
 
 G_DEFINE_TYPE (GabbleCallContent, gabble_call_content,
-    TPY_TYPE_BASE_MEDIA_CALL_CONTENT);
+    TP_TYPE_BASE_MEDIA_CALL_CONTENT);
 
 /* private structure */
 struct _GabbleCallContentPrivate
@@ -76,8 +69,8 @@ gabble_call_content_init (GabbleCallContent *self)
 
   self->priv = priv;
 
-  g_signal_connect (self, "local_codecs_updated",
-    G_CALLBACK (call_content_local_codecs_updated), NULL);
+  g_signal_connect (self, "local-media-description-updated",
+    G_CALLBACK (call_content_local_media_description_updated), NULL);
 }
 
 static void gabble_call_content_dispose (GObject *object);
@@ -87,8 +80,8 @@ gabble_call_content_class_init (
     GabbleCallContentClass *gabble_call_content_class)
 {
   GObjectClass *object_class = G_OBJECT_CLASS (gabble_call_content_class);
-  TpyBaseCallContentClass *bcc_class =
-      TPY_BASE_CALL_CONTENT_CLASS (gabble_call_content_class);
+  TpBaseCallContentClass *bcc_class =
+      TP_BASE_CALL_CONTENT_CLASS (gabble_call_content_class);
 
   g_type_class_add_private (gabble_call_content_class,
       sizeof (GabbleCallContentPrivate));
@@ -115,7 +108,7 @@ gabble_call_content_dispose (GObject *object)
 }
 
 static void
-call_content_deinit (TpyBaseCallContent *base)
+call_content_deinit (TpBaseCallContent *base)
 {
   GabbleCallContent *self = GABBLE_CALL_CONTENT (base);
   GabbleCallContentPrivate *priv = self->priv;
@@ -133,84 +126,68 @@ call_content_deinit (TpyBaseCallContent *base)
       gabble_call_member_content_remove (c);
     }
 
-  TPY_BASE_CALL_CONTENT_CLASS (
+  TP_BASE_CALL_CONTENT_CLASS (
     gabble_call_content_parent_class)->deinit (base);
 }
 
-static GPtrArray *
-call_content_codec_list_to_array (GList *codecs)
-{
-  GPtrArray *arr;
-  GList *l;
-
-  arr = g_ptr_array_sized_new (g_list_length (codecs));
-  g_ptr_array_set_free_func (arr,
-    (GDestroyNotify) g_value_array_free);
-
-  for (l = codecs; l != NULL; l = g_list_next (l))
-    {
-      GValueArray *v;
-      JingleCodec *c = l->data;
-
-      g_assert (c->params != NULL);
-
-      v = tp_value_array_build (5,
-        G_TYPE_UINT, (guint) c->id,
-        G_TYPE_STRING, c->name,
-        G_TYPE_UINT, c->clockrate,
-        G_TYPE_UINT, c->channels,
-        DBUS_TYPE_G_STRING_STRING_HASHTABLE, c->params,
-        G_TYPE_INVALID);
-
-        g_ptr_array_add (arr, v);
-    }
-
-  return arr;
-}
-
 void
 gabble_call_content_new_offer (GabbleCallContent *self,
   GabbleCallMemberContent *content)
 {
   GabbleCallContentPrivate *priv = self->priv;
-  TpyBaseCallContent *base = TPY_BASE_CALL_CONTENT (self);
-  TpyCallContentCodecOffer *offer;
+  TpBaseCallContent *base = TP_BASE_CALL_CONTENT (self);
+  TpBaseConnection *conn = tp_base_call_content_get_connection (base);
+  TpCallContentMediaDescription *md;
   gchar *path;
   TpHandle handle = 0;
-  GPtrArray *codecs;
+
+  path = g_strdup_printf ("%s/Offer%d",
+      tp_base_call_content_get_object_path (base),
+      priv->offers++);
 
   if (content != NULL)
     {
       handle = gabble_call_member_get_handle (
         gabble_call_member_content_get_member (content));
-
-      codecs = call_content_codec_list_to_array (
-        gabble_call_member_content_get_remote_codecs (content));
     }
-  else
+
+  /* FIXME: no idea... */
+  md = tp_call_content_media_description_new (
+      tp_base_connection_get_dbus_daemon (conn), path, handle,
+      (content != NULL), (content == NULL));
+
+  if (content != NULL)
     {
-      codecs = g_ptr_array_new ();
-    }
+      GList *codecs, *l;
 
-  path = g_strdup_printf ("%s/Offer%d",
-      tpy_base_call_content_get_object_path (base),
-      priv->offers++);
+      codecs = gabble_call_member_content_get_remote_codecs (content);
+      for (l = codecs; l != NULL; l = g_list_next (l))
+        {
+          JingleCodec *c = l->data;
+
+          g_assert (c->params != NULL);
 
-  offer = tpy_call_content_codec_offer_new (path, handle, codecs);
-  tpy_base_media_call_content_add_offer (TPY_BASE_MEDIA_CALL_CONTENT (self),
-    offer);
+          tp_call_content_media_description_append_codec (md,
+              c->id, c->name, c->clockrate, c->channels,
+              FALSE, /* FIXME: updated?? */
+              c->params);
+        }
+    }
+
+  tp_base_media_call_content_offer_media_description_async (
+      TP_BASE_MEDIA_CALL_CONTENT (self), md, NULL, NULL);
 
-  g_ptr_array_unref (codecs);
+  g_object_unref (md);
   g_free (path);
 }
 
 JingleMediaType
 gabble_call_content_get_media_type (GabbleCallContent *self)
 {
-  TpyBaseCallContent *base = TPY_BASE_CALL_CONTENT (self);
+  TpBaseCallContent *base = TP_BASE_CALL_CONTENT (self);
 
   return jingle_media_type_from_tp (
-      tpy_base_call_content_get_media_type (base));
+      tp_base_call_content_get_media_type (base));
 }
 
 static void
@@ -244,7 +221,8 @@ codec_array_to_list (GPtrArray *codecs)
         g_value_get_string (va->values + 1),
         g_value_get_uint (va->values + 2),
         g_value_get_uint (va->values + 3),
-        g_value_get_boxed (va->values + 4));
+        /* g_value_get_boolean (va->values + 4), updated? */
+        g_value_get_boxed (va->values + 5));
 
         l = g_list_append (l, c);
     }
@@ -254,14 +232,17 @@ codec_array_to_list (GPtrArray *codecs)
 
 
 static void
-call_content_local_codecs_updated (GabbleCallContent *self,
-    GPtrArray *local_codecs,
+call_content_local_media_description_updated (GabbleCallContent *self,
+    TpHandle contact,
+    GHashTable *properties,
     gpointer data)
 {
   GList *l;
   JingleMediaDescription *md = jingle_media_description_new ();
 
-  md->codecs = codec_array_to_list (local_codecs);
+  md->codecs = codec_array_to_list (tp_asv_get_boxed (properties,
+          TP_PROP_CALL_CONTENT_MEDIA_DESCRIPTION_CODECS,
+          TP_ARRAY_TYPE_CODEC_LIST));
 
   for (l = self->priv->contents; l != NULL; l = g_list_next (l))
     {
@@ -280,35 +261,65 @@ call_content_local_codecs_updated (GabbleCallContent *self,
   jingle_media_description_free (md);
 }
 
+static TpStreamTransportType
+_jingle_to_tp_transport (JingleTransportType jt)
+{
+  switch (jt)
+  {
+    case JINGLE_TRANSPORT_GOOGLE_P2P:
+      return TP_STREAM_TRANSPORT_TYPE_GTALK_P2P;
+    case JINGLE_TRANSPORT_RAW_UDP:
+      return TP_STREAM_TRANSPORT_TYPE_RAW_UDP;
+    case JINGLE_TRANSPORT_ICE_UDP:
+      return TP_STREAM_TRANSPORT_TYPE_ICE;
+    default:
+      g_return_val_if_reached (G_MAXUINT);
+  }
+}
+
 static void
 call_content_setup_jingle (GabbleCallContent *self,
     GabbleCallMemberContent *mcontent)
 {
-  TpyBaseCallContent *base = TPY_BASE_CALL_CONTENT (self);
+  TpBaseCallContent *base = TP_BASE_CALL_CONTENT (self);
   GabbleJingleContent *jingle;
   GabbleCallStream *stream;
   gchar *path;
+  JingleTransportType transport;
   JingleMediaDescription *md;
+  GHashTable *tp_md;
+  TpHandle contact;
 
   jingle = gabble_call_member_content_get_jingle_content (mcontent);
 
   if (jingle == NULL)
     return;
 
+  transport = gabble_jingle_content_get_transport_type (jingle);
   path = g_strdup_printf ("%s/Stream%p",
-      tpy_base_call_content_get_object_path (base),
+      tp_base_call_content_get_object_path (base),
       jingle);
   stream = g_object_new (GABBLE_TYPE_CALL_STREAM,
       "object-path", path,
-      "connection", tpy_base_call_content_get_connection (base),
+      "connection", tp_base_call_content_get_connection (base),
       "jingle-content", jingle,
+      "transport", _jingle_to_tp_transport (transport),
       NULL);
   g_free (path);
 
   md = jingle_media_description_new ();
-  md->codecs = codec_array_to_list (
-      tpy_base_media_call_content_get_local_codecs (
-        TPY_BASE_MEDIA_CALL_CONTENT (self)));
+
+  /* FIXME: correct??? */
+  contact = gabble_call_member_get_handle (
+      gabble_call_member_content_get_member (mcontent));
+  tp_md = tp_base_media_call_content_get_local_media_description (
+      TP_BASE_MEDIA_CALL_CONTENT (self), contact);
+  if (tp_md != NULL)
+    {
+      md->codecs = codec_array_to_list (tp_asv_get_boxed (tp_md,
+          TP_PROP_CALL_CONTENT_MEDIA_DESCRIPTION_CODECS,
+          TP_ARRAY_TYPE_CODEC_LIST));
+    }
 
   if (md->codecs != NULL)
     jingle_media_rtp_set_local_media_description (
@@ -316,7 +327,7 @@ call_content_setup_jingle (GabbleCallContent *self,
   else
     jingle_media_description_free (md);
 
-  tpy_base_call_content_add_stream (base, TPY_BASE_CALL_STREAM (stream));
+  tp_base_call_content_add_stream (base, TP_BASE_CALL_STREAM (stream));
   g_object_unref (stream);
 }
 
@@ -334,7 +345,7 @@ member_content_removed_cb (GabbleCallMemberContent *mcontent,
 {
   GabbleCallContent *self = GABBLE_CALL_CONTENT (user_data);
   GabbleCallContentPrivate *priv = self->priv;
-  TpyBaseCallContent *base = TPY_BASE_CALL_CONTENT (self);
+  TpBaseCallContent *base = TP_BASE_CALL_CONTENT (self);
   GabbleJingleContent *content;
   GList *l;
 
@@ -342,7 +353,7 @@ member_content_removed_cb (GabbleCallMemberContent *mcontent,
 
   content = gabble_call_member_content_get_jingle_content (mcontent);
 
-  for (l = tpy_base_call_content_get_streams (base);
+  for (l = tp_base_call_content_get_streams (base);
        l != NULL;
        l = l->next)
     {
@@ -350,7 +361,8 @@ member_content_removed_cb (GabbleCallMemberContent *mcontent,
 
       if (content == gabble_call_stream_get_jingle_content (stream))
         {
-          tpy_base_call_content_remove_stream (base, l->data);
+          tp_base_call_content_remove_stream (base, l->data,
+              0, TP_CALL_STATE_CHANGE_REASON_PROGRESS_MADE, "", "");
           break;
         }
     }
diff --git a/src/call-content.h b/src/call-content.h
index 6507327df..ff3205f55 100644
--- a/src/call-content.h
+++ b/src/call-content.h
@@ -23,7 +23,7 @@
 
 #include <glib-object.h>
 
-#include <telepathy-yell/base-media-call-content.h>
+#include <telepathy-glib/base-media-call-content.h>
 
 #include "jingle-content.h"
 #include "call-member-content.h"
@@ -35,11 +35,11 @@ typedef struct _GabbleCallContentPrivate GabbleCallContentPrivate;
 typedef struct _GabbleCallContentClass GabbleCallContentClass;
 
 struct _GabbleCallContentClass {
-    TpyBaseMediaCallContentClass parent_class;
+    TpBaseMediaCallContentClass parent_class;
 };
 
 struct _GabbleCallContent {
-    TpyBaseMediaCallContent parent;
+    TpBaseMediaCallContent parent;
 
     GabbleCallContentPrivate *priv;
 };
diff --git a/src/call-member.c b/src/call-member.c
index 784aafee7..2765449a3 100644
--- a/src/call-member.c
+++ b/src/call-member.c
@@ -58,7 +58,7 @@ struct _GabbleCallMemberPrivate
   TpHandle target;
 
   GabbleBaseCallChannel *call;
-  TpyCallMemberFlags flags;
+  TpCallMemberFlags flags;
   GabbleJingleSession *session;
 
   GList *contents;
@@ -246,13 +246,13 @@ remote_state_changed_cb (GabbleJingleSession *session, gpointer user_data)
 {
   GabbleCallMember *self = GABBLE_CALL_MEMBER (user_data);
   GabbleCallMemberPrivate *priv = self->priv;
-  TpyCallMemberFlags newflags = 0;
+  TpCallMemberFlags newflags = 0;
 
   if (gabble_jingle_session_get_remote_ringing (session))
-    newflags |= TPY_CALL_MEMBER_FLAG_RINGING;
+    newflags |= TP_CALL_MEMBER_FLAG_RINGING;
 
   if (gabble_jingle_session_get_remote_hold (session))
-    newflags |= TPY_CALL_MEMBER_FLAG_HELD;
+    newflags |= TP_CALL_MEMBER_FLAG_HELD;
 
   if (priv->flags == newflags)
     return;
@@ -385,7 +385,7 @@ gabble_call_member_get_session (GabbleCallMember *self)
   return self->priv->session;
 }
 
-TpyCallMemberFlags
+TpCallMemberFlags
 gabble_call_member_get_flags (GabbleCallMember *self)
 {
   return self->priv->flags;
diff --git a/src/call-member.h b/src/call-member.h
index 755b6a7ce..8a0e2bbdf 100644
--- a/src/call-member.h
+++ b/src/call-member.h
@@ -25,8 +25,6 @@
 
 #include <telepathy-glib/handle.h>
 
-#include <telepathy-yell/enums.h>
-
 #include "types.h"
 #include "jingle-session.h"
 #include "call-member-content.h"
@@ -73,7 +71,7 @@ TpHandle gabble_call_member_get_handle (
 GabbleJingleSession *gabble_call_member_get_session (
     GabbleCallMember *self);
 
-TpyCallMemberFlags gabble_call_member_get_flags (
+TpCallMemberFlags gabble_call_member_get_flags (
   GabbleCallMember *self);
 
 GList *gabble_call_member_get_contents (GabbleCallMember *self);
diff --git a/src/call-muc-channel.c b/src/call-muc-channel.c
index f07088f21..d9ab2b9d6 100644
--- a/src/call-muc-channel.c
+++ b/src/call-muc-channel.c
@@ -24,9 +24,7 @@
 
 #include <telepathy-glib/dbus.h>
 #include <telepathy-glib/interfaces.h>
-
-#include <telepathy-yell/enums.h>
-#include <telepathy-yell/interfaces.h>
+#include <telepathy-glib/gtypes.h>
 
 #include <wocky/wocky-muc.h>
 #include "call-content.h"
@@ -42,14 +40,14 @@
 
 static void async_initable_iface_init (GAsyncInitableIface *iface);
 
-static void call_muc_channel_accept (TpyBaseCallChannel *channel);
-static TpyBaseCallContent * call_muc_channel_add_content (
-    TpyBaseCallChannel *base,
+static void call_muc_channel_accept (TpBaseCallChannel *channel);
+static TpBaseCallContent * call_muc_channel_add_content (
+    TpBaseCallChannel *base,
     const gchar *name,
     TpMediaStreamType type,
     GError **error);
 static void call_muc_channel_hangup (
-    TpyBaseCallChannel *base,
+    TpBaseCallChannel *base,
     guint reason,
     const gchar *detailed_reason,
     const gchar *message);
@@ -205,8 +203,8 @@ gabble_call_muc_channel_class_init (
     GabbleCallMucChannelClass *gabble_call_muc_channel_class)
 {
   GObjectClass *object_class = G_OBJECT_CLASS (gabble_call_muc_channel_class);
-  TpyBaseCallChannelClass *base_call_class =
-    TPY_BASE_CALL_CHANNEL_CLASS (gabble_call_muc_channel_class);
+  TpBaseCallChannelClass *base_call_class =
+    TP_BASE_CALL_CHANNEL_CLASS (gabble_call_muc_channel_class);
   TpBaseChannelClass *base_channel_class =
       TP_BASE_CHANNEL_CLASS (gabble_call_muc_channel_class);
   GParamSpec *param_spec;
@@ -279,12 +277,21 @@ call_muc_channel_got_codecs (GabbleCallMucChannel *self)
 {
   GList *l;
 
-  for (l = tpy_base_call_channel_get_contents (
-      TPY_BASE_CALL_CHANNEL (self)); l != NULL; l = g_list_next (l))
+  for (l = tp_base_call_channel_get_contents (
+      TP_BASE_CALL_CHANNEL (self)); l != NULL; l = g_list_next (l))
     {
-      TpyBaseMediaCallContent *content = TPY_BASE_MEDIA_CALL_CONTENT (l->data);
+      TpBaseMediaCallContent *content = TP_BASE_MEDIA_CALL_CONTENT (l->data);
+      GHashTable *tp_md;
+      GPtrArray *codecs;
 
-      if (tpy_base_media_call_content_get_local_codecs (content) == NULL)
+      /* FIXME: remote_contact==0 ??? */
+      tp_md = tp_base_media_call_content_get_local_media_description (content,
+          0);
+      codecs = tp_asv_get_boxed (tp_md,
+          TP_PROP_CALL_CONTENT_MEDIA_DESCRIPTION_CODECS,
+          TP_ARRAY_TYPE_CODEC_LIST);
+
+      if (codecs == NULL)
         return FALSE;
     }
 
@@ -334,8 +341,10 @@ call_muc_do_update (GabbleCallMucChannel *self)
 }
 
 static void
-call_muc_channel_content_local_codecs_updated (GabbleCallContent *content,
-    GPtrArray *local_codecs,
+call_muc_channel_content_local_media_description_updated (
+    GabbleCallContent *content,
+    TpHandle contact,
+    GHashTable *properties,
     gpointer user_data)
 {
   GabbleCallMucChannel *self = GABBLE_CALL_MUC_CHANNEL (user_data);
@@ -355,8 +364,9 @@ call_muc_channel_open_new_streams (GabbleCallMucChannel *self)
     {
       /* At the point where we opened the sessions we're accepted
          in the call */
-      tpy_base_call_channel_set_state (TPY_BASE_CALL_CHANNEL (self),
-          TPY_CALL_STATE_ACCEPTED);
+      tp_base_call_channel_set_state (TP_BASE_CALL_CHANNEL (self),
+          TP_CALL_STATE_ACCEPTED,
+          0, TP_CALL_STATE_CHANGE_REASON_PROGRESS_MADE, "", "");
     }
 
   priv->sessions_opened = TRUE;
@@ -385,8 +395,8 @@ call_muc_channel_setup_content (GabbleCallMucChannel *self,
 
   DEBUG ("Setting up content");
 
-  gabble_signal_connect_weak (content, "local-codecs-updated",
-    G_CALLBACK (call_muc_channel_content_local_codecs_updated),
+  gabble_signal_connect_weak (content, "local-media-description-updated",
+    G_CALLBACK (call_muc_channel_content_local_media_description_updated),
     G_OBJECT (self));
 
   if (priv->sessions_opened)
@@ -413,15 +423,15 @@ call_muc_channel_member_content_added_cb (GabbleCallMember *member,
 
   DEBUG ("New call member content: %s (type: %d)", name, mtype);
 
-  for (l = tpy_base_call_channel_get_contents (
-      TPY_BASE_CALL_CHANNEL (self)); l != NULL; l = g_list_next (l))
+  for (l = tp_base_call_channel_get_contents (
+      TP_BASE_CALL_CHANNEL (self)); l != NULL; l = g_list_next (l))
     {
       const char *cname;
       JingleMediaType cmtype;
 
       ccontent = GABBLE_CALL_CONTENT (l->data);
-      cname = tpy_base_call_content_get_name (
-          TPY_BASE_CALL_CONTENT (ccontent));
+      cname = tp_base_call_content_get_name (
+          TP_BASE_CALL_CONTENT (ccontent));
       cmtype = gabble_call_content_get_media_type (ccontent);
 
       if (!tp_strdiff (cname, name) && mtype == cmtype)
@@ -430,7 +440,7 @@ call_muc_channel_member_content_added_cb (GabbleCallMember *member,
 
   ccontent = gabble_base_call_channel_add_content (
       GABBLE_BASE_CALL_CHANNEL (self), name, mtype,
-      self->priv->initialized ? TPY_CALL_CONTENT_DISPOSITION_INITIAL : 0);
+      self->priv->initialized ? TP_CALL_CONTENT_DISPOSITION_INITIAL : 0);
   call_muc_channel_setup_content (self, ccontent);
 
 have_content:
@@ -516,13 +526,14 @@ call_muc_channel_send_new_state (GabbleCallMucChannel *self)
   g_object_unref (priv->muji);
   priv->muji = wocky_node_tree_new ("muji", NS_MUJI, '*', &m, NULL);
 
-  for (l = tpy_base_call_channel_get_contents (
-      TPY_BASE_CALL_CHANNEL (self)); l != NULL; l = g_list_next (l))
+  for (l = tp_base_call_channel_get_contents (
+      TP_BASE_CALL_CHANNEL (self)); l != NULL; l = g_list_next (l))
     {
       GabbleCallContent *content = GABBLE_CALL_CONTENT (l->data);
-      const gchar *name = tpy_base_call_content_get_name (
-          TPY_BASE_CALL_CONTENT (content));
+      const gchar *name = tp_base_call_content_get_name (
+          TP_BASE_CALL_CONTENT (content));
       WockyNode *description;
+      GHashTable *tp_md;
       GPtrArray *codecs;
       guint i;
       JingleMediaType mtype = gabble_call_content_get_media_type (content);
@@ -536,8 +547,12 @@ call_muc_channel_send_new_state (GabbleCallMucChannel *self)
         ')',
         NULL);
 
-      codecs = tpy_base_media_call_content_get_local_codecs (
-        TPY_BASE_MEDIA_CALL_CONTENT (content));
+      /* FIXME: remote_contact==0 ??? */
+      tp_md = tp_base_media_call_content_get_local_media_description (
+          TP_BASE_MEDIA_CALL_CONTENT (content), 0);
+      codecs = tp_asv_get_boxed (tp_md,
+          TP_PROP_CALL_CONTENT_MEDIA_DESCRIPTION_CODECS,
+          TP_ARRAY_TYPE_CODEC_LIST);
       for (i = 0; i < codecs->len; i++)
         {
           GValueArray *codec = g_ptr_array_index (codecs, i);
@@ -959,40 +974,38 @@ call_muc_channel_init_async (GAsyncInitable *initable,
 {
   GabbleCallMucChannel *self = GABBLE_CALL_MUC_CHANNEL (initable);
   GabbleCallMucChannelPrivate *priv = self->priv;
-  TpyBaseCallChannel *base = TPY_BASE_CALL_CHANNEL (self);
+  TpBaseCallChannel *base = TP_BASE_CALL_CHANNEL (self);
   GabbleCallContent *content;
   GSimpleAsyncResult *result;
-  gchar *initial_audio_name, *initial_video_name;
+  gboolean initial_audio, initial_video;
+  const gchar *initial_audio_name, *initial_video_name;
 
-  g_object_get (self,
-      "initial-audio-name", &initial_audio_name,
-      "initial-video-name", &initial_video_name,
-      NULL);
+  initial_audio = tp_base_call_channel_has_initial_audio (base,
+      &initial_audio_name);
+  initial_video = tp_base_call_channel_has_initial_video (base,
+      &initial_video_name);
 
   result = g_simple_async_result_new (G_OBJECT (initable),
       callback, user_data, NULL);
 
-  if (base->initial_audio)
+  if (initial_audio)
     {
       content = gabble_base_call_channel_add_content (
         GABBLE_BASE_CALL_CHANNEL (base),
         initial_audio_name, JINGLE_MEDIA_TYPE_AUDIO,
-        TPY_CALL_CONTENT_DISPOSITION_INITIAL);
+        TP_CALL_CONTENT_DISPOSITION_INITIAL);
       call_muc_channel_setup_content (self, content);
     }
 
-  if (base->initial_video)
+  if (initial_video)
     {
       content = gabble_base_call_channel_add_content (
         GABBLE_BASE_CALL_CHANNEL (base),
         initial_video_name, JINGLE_MEDIA_TYPE_VIDEO,
-        TPY_CALL_CONTENT_DISPOSITION_INITIAL);
+        TP_CALL_CONTENT_DISPOSITION_INITIAL);
       call_muc_channel_setup_content (self, content);
     }
 
-  g_free (initial_audio_name);
-  g_free (initial_video_name);
-
   if (_gabble_muc_channel_is_ready (priv->muc))
     {
       DEBUG ("Muc channel is ready to fly");
@@ -1047,14 +1060,14 @@ gabble_call_muc_channel_new_async (GabbleConnection *connection,
   if (request != NULL)
     {
       initial_audio = tp_asv_get_boolean (request,
-          TPY_PROP_CHANNEL_TYPE_CALL_INITIAL_AUDIO, NULL);
+          TP_PROP_CHANNEL_TYPE_CALL_INITIAL_AUDIO, NULL);
       initial_video = tp_asv_get_boolean (request,
-          TPY_PROP_CHANNEL_TYPE_CALL_INITIAL_VIDEO, NULL);
+          TP_PROP_CHANNEL_TYPE_CALL_INITIAL_VIDEO, NULL);
 
       initial_audio_name = tp_asv_get_string (request,
-          TPY_PROP_CHANNEL_TYPE_CALL_INITIAL_AUDIO_NAME);
+          TP_PROP_CHANNEL_TYPE_CALL_INITIAL_AUDIO_NAME);
       initial_video_name = tp_asv_get_string (request,
-          TPY_PROP_CHANNEL_TYPE_CALL_INITIAL_VIDEO_NAME);
+          TP_PROP_CHANNEL_TYPE_CALL_INITIAL_VIDEO_NAME);
     }
 
   g_async_initable_new_async (GABBLE_TYPE_CALL_MUC_CHANNEL,
@@ -1113,7 +1126,7 @@ gabble_call_muc_channel_incoming_session (GabbleCallMucChannel *self,
 }
 
 static void
-call_muc_channel_accept (TpyBaseCallChannel *channel)
+call_muc_channel_accept (TpBaseCallChannel *channel)
 {
   GabbleCallMucChannel *self = GABBLE_CALL_MUC_CHANNEL (channel);
 
@@ -1127,8 +1140,8 @@ call_muc_channel_accept (TpyBaseCallChannel *channel)
   call_muc_do_update (self);
 }
 
-static TpyBaseCallContent *
-call_muc_channel_add_content (TpyBaseCallChannel *base,
+static TpBaseCallContent *
+call_muc_channel_add_content (TpBaseCallChannel *base,
     const gchar *name,
     TpMediaStreamType type,
     GError **error)
@@ -1139,11 +1152,11 @@ call_muc_channel_add_content (TpyBaseCallChannel *base,
   content = gabble_base_call_channel_add_content (
         GABBLE_BASE_CALL_CHANNEL (base),
         name, jingle_media_type_from_tp (type),
-        TPY_CALL_CONTENT_DISPOSITION_NONE);
+        TP_CALL_CONTENT_DISPOSITION_NONE);
 
   call_muc_channel_setup_content (self, content);
 
-  return TPY_BASE_CALL_CONTENT (content);
+  return TP_BASE_CALL_CONTENT (content);
 }
 
 static void
@@ -1161,12 +1174,12 @@ call_muc_channel_leave (GabbleCallMucChannel *self)
 }
 
 static void
-call_muc_channel_hangup (TpyBaseCallChannel *base,
+call_muc_channel_hangup (TpBaseCallChannel *base,
     guint reason,
     const gchar *detailed_reason,
     const gchar *message)
 {
-  TpyBaseCallChannelClass *parent = TPY_BASE_CALL_CHANNEL_CLASS (
+  TpBaseCallChannelClass *parent = TP_BASE_CALL_CHANNEL_CLASS (
     gabble_call_muc_channel_parent_class);
   call_muc_channel_leave (GABBLE_CALL_MUC_CHANNEL (base));
 
diff --git a/src/call-stream.c b/src/call-stream.c
index 4c51ed8ea..2b55d9849 100644
--- a/src/call-stream.c
+++ b/src/call-stream.c
@@ -28,11 +28,6 @@
 #include <telepathy-glib/gtypes.h>
 #include <telepathy-glib/util.h>
 
-#include <telepathy-yell/enums.h>
-#include <telepathy-yell/gtypes.h>
-#include <telepathy-yell/interfaces.h>
-#include <telepathy-yell/call-stream-endpoint.h>
-
 #include "call-stream.h"
 #include "connection.h"
 #include "jingle-session.h"
@@ -45,15 +40,15 @@
 
 static void call_stream_update_member_states (GabbleCallStream *self);
 static GPtrArray *gabble_call_stream_add_candidates (
-    TpyBaseMediaCallStream *stream,
+    TpBaseMediaCallStream *stream,
     const GPtrArray *candidates,
     GError **error);
-static gboolean gabble_call_stream_set_sending (TpyBaseCallStream *stream,
+static gboolean gabble_call_stream_set_sending (TpBaseCallStream *stream,
     gboolean sending,
     GError **error);
 
 G_DEFINE_TYPE(GabbleCallStream, gabble_call_stream,
-    TPY_TYPE_BASE_MEDIA_CALL_STREAM)
+    TP_TYPE_BASE_MEDIA_CALL_STREAM)
 
 /* properties */
 enum
@@ -108,7 +103,7 @@ get_stun_servers (GabbleCallStream *self)
   gchar *stun_server;
   guint stun_port;
 
-  arr = g_ptr_array_sized_new (1);
+  arr = g_ptr_array_new_with_free_func ((GDestroyNotify) g_value_array_free);
 
   g_object_get (self->priv->content,
       "connection", &connection,
@@ -177,12 +172,12 @@ google_relay_session_cb (GPtrArray *relays,
                          gpointer user_data)
 {
   TpWeakRef *weak_ref = user_data;
-  TpyBaseMediaCallStream *stream = TPY_BASE_MEDIA_CALL_STREAM (
+  TpBaseMediaCallStream *stream = TP_BASE_MEDIA_CALL_STREAM (
       tp_weak_ref_dup_object (weak_ref));
 
   if (stream != NULL)
     {
-      tpy_base_media_call_stream_set_relay_info (stream, relays);
+      tp_base_media_call_stream_set_relay_info (stream, relays);
       g_object_unref (stream);
     }
 
@@ -217,8 +212,8 @@ jingle_factory_stun_server_changed_cb (GabbleJingleFactory *factory,
 {
   GPtrArray *stun_servers = get_stun_servers (self);
 
-  tpy_base_media_call_stream_set_stun_servers (
-    TPY_BASE_MEDIA_CALL_STREAM (self), stun_servers);
+  tp_base_media_call_stream_set_stun_servers (
+    TP_BASE_MEDIA_CALL_STREAM (self), stun_servers);
   g_ptr_array_unref (stun_servers);
 }
 
@@ -227,7 +222,7 @@ static void
 _new_candidates_cb (
     GabbleJingleContent *content,
     GList *candidates,
-    TpyCallStreamEndpoint *endpoint)
+    TpCallStreamEndpoint *endpoint)
 {
   GPtrArray *tp_candidates;
 
@@ -235,13 +230,13 @@ _new_candidates_cb (
     return;
 
   tp_candidates = gabble_call_candidates_to_array (candidates);
-  tpy_call_stream_endpoint_add_new_candidates (endpoint, tp_candidates);
-  g_boxed_free (TPY_ARRAY_TYPE_CANDIDATE_LIST, tp_candidates);
+  tp_call_stream_endpoint_add_new_candidates (endpoint, tp_candidates);
+  g_boxed_free (TP_ARRAY_TYPE_CANDIDATE_LIST, tp_candidates);
 }
 
 static void
 _stream_state_changed_cb (
-    TpyCallStreamEndpoint *endpoint,
+    TpCallStreamEndpoint *endpoint,
     GParamSpec *spec,
     GabbleJingleContent *content)
 {
@@ -252,41 +247,42 @@ _stream_state_changed_cb (
     state);
 }
 
-static TpyCallStreamEndpoint *
+static TpCallStreamEndpoint *
 _hook_up_endpoint (GabbleCallStream *self,
     const gchar *path,
     GabbleJingleContent *content)
 {
-  TpyBaseCallStream *base = (TpyBaseCallStream *) self;
-  TpBaseConnection *conn = tpy_base_call_stream_get_connection (base);
+  TpBaseCallStream *base = (TpBaseCallStream *) self;
+  TpBaseConnection *conn = tp_base_call_stream_get_connection (base);
   TpDBusDaemon *bus = tp_base_connection_get_dbus_daemon (conn);
-  TpyCallStreamEndpoint *endpoint;
-  TpyStreamTransportType type = 0;
+  TpCallStreamEndpoint *endpoint;
+  TpStreamTransportType type = 0;
   GPtrArray *tp_candidates;
   GList *candidates;
 
   switch (gabble_jingle_content_get_transport_type (content))
     {
     case JINGLE_TRANSPORT_GOOGLE_P2P:
-      type = TPY_STREAM_TRANSPORT_TYPE_GTALK_P2P;
+      type = TP_STREAM_TRANSPORT_TYPE_GTALK_P2P;
       break;
     case JINGLE_TRANSPORT_RAW_UDP:
-      type = TPY_STREAM_TRANSPORT_TYPE_RAW_UDP;
+      type = TP_STREAM_TRANSPORT_TYPE_RAW_UDP;
       break;
     case JINGLE_TRANSPORT_ICE_UDP:
-      type = TPY_STREAM_TRANSPORT_TYPE_ICE;
+      type = TP_STREAM_TRANSPORT_TYPE_ICE;
       break;
     case JINGLE_TRANSPORT_UNKNOWN:
     default:
       g_assert_not_reached ();
     }
 
-  endpoint = tpy_call_stream_endpoint_new (bus, path, type);
+  /* FIXME: ice??? */
+  endpoint = tp_call_stream_endpoint_new (bus, path, type, FALSE);
 
   candidates = gabble_jingle_content_get_remote_candidates (content);
   tp_candidates = gabble_call_candidates_to_array (candidates);
-  tpy_call_stream_endpoint_add_new_candidates (endpoint, tp_candidates);
-  g_boxed_free (TPY_ARRAY_TYPE_CANDIDATE_LIST, tp_candidates);
+  tp_call_stream_endpoint_add_new_candidates (endpoint, tp_candidates);
+  g_boxed_free (TP_ARRAY_TYPE_CANDIDATE_LIST, tp_candidates);
 
   tp_g_signal_connect_object (content, "new-candidates",
       G_CALLBACK (_new_candidates_cb), endpoint, 0);
@@ -297,31 +293,15 @@ _hook_up_endpoint (GabbleCallStream *self,
   return endpoint;
 }
 
-static TpyStreamTransportType
-_jingle_to_tp_transport (JingleTransportType jt)
-{
-  switch (jt)
-  {
-    case JINGLE_TRANSPORT_GOOGLE_P2P:
-      return TPY_STREAM_TRANSPORT_TYPE_GTALK_P2P;
-    case JINGLE_TRANSPORT_RAW_UDP:
-      return TPY_STREAM_TRANSPORT_TYPE_RAW_UDP;
-    case JINGLE_TRANSPORT_ICE_UDP:
-      return TPY_STREAM_TRANSPORT_TYPE_ICE;
-    default:
-      g_return_val_if_reached (G_MAXUINT);
-  }
-}
-
 static void
 gabble_call_stream_constructed (GObject *obj)
 {
   GabbleCallStream *self = GABBLE_CALL_STREAM (obj);
-  TpyBaseCallStream *base = (TpyBaseCallStream *) self;
-  TpyBaseMediaCallStream *media_base = (TpyBaseMediaCallStream *) self;
+  TpBaseCallStream *base = (TpBaseCallStream *) self;
+  TpBaseMediaCallStream *media_base = (TpBaseMediaCallStream *) self;
   GabbleCallStreamPrivate *priv = self->priv;
   GabbleConnection *conn;
-  TpyCallStreamEndpoint *endpoint;
+  TpCallStreamEndpoint *endpoint;
   gchar *path;
   JingleTransportType transport;
   GPtrArray *stun_servers;
@@ -329,20 +309,18 @@ gabble_call_stream_constructed (GObject *obj)
   if (G_OBJECT_CLASS (gabble_call_stream_parent_class)->constructed != NULL)
     G_OBJECT_CLASS (gabble_call_stream_parent_class)->constructed (obj);
 
-  conn = GABBLE_CONNECTION (tpy_base_call_stream_get_connection (base));
+  conn = GABBLE_CONNECTION (tp_base_call_stream_get_connection (base));
 
   /* Currently we'll only have one endpoint we know right away */
   path = g_strdup_printf ("%s/Endpoint",
-      tpy_base_call_stream_get_object_path (base));
+      tp_base_call_stream_get_object_path (base));
   endpoint = _hook_up_endpoint (self, path, priv->content);
-  tpy_base_media_call_stream_take_endpoint (media_base, endpoint);
+  tp_base_media_call_stream_add_endpoint (media_base, endpoint);
+  g_object_unref (endpoint);
   g_free (path);
 
   transport = gabble_jingle_content_get_transport_type (priv->content);
 
-  tpy_base_media_call_stream_set_transport (media_base,
-      _jingle_to_tp_transport (transport));
-
   if (transport == JINGLE_TRANSPORT_GOOGLE_P2P)
     {
       DEBUG ("Attempting to create Google relay session");
@@ -356,13 +334,13 @@ gabble_call_stream_constructed (GObject *obj)
   else
     {
       GPtrArray *relays = g_ptr_array_new ();
-      tpy_base_media_call_stream_set_relay_info (media_base, relays);
+      tp_base_media_call_stream_set_relay_info (media_base, relays);
       g_ptr_array_unref (relays);
     }
 
   stun_servers = get_stun_servers (self);
-  tpy_base_media_call_stream_set_stun_servers (
-    TPY_BASE_MEDIA_CALL_STREAM (self), stun_servers);
+  tp_base_media_call_stream_set_stun_servers (
+    TP_BASE_MEDIA_CALL_STREAM (self), stun_servers);
   g_ptr_array_unref (stun_servers);
 
   call_stream_update_member_states (GABBLE_CALL_STREAM (obj));
@@ -377,12 +355,12 @@ gabble_call_stream_constructed (GObject *obj)
 static void
 call_stream_update_member_states (GabbleCallStream *self)
 {
-  TpyBaseCallStream *base = TPY_BASE_CALL_STREAM (self);
+  TpBaseCallStream *base = TP_BASE_CALL_STREAM (self);
   GabbleCallStreamPrivate *priv = self->priv;
   gboolean created_by_us;
   JingleContentState state;
-  TpySendingState local_state = 0;
-  TpySendingState remote_state = 0;
+  TpSendingState local_state = 0;
+  TpSendingState remote_state = 0;
 
   g_object_get (priv->content, "state", &state, NULL);
 
@@ -396,22 +374,24 @@ call_stream_update_member_states (GabbleCallStream *self)
   if (gabble_jingle_content_sending (priv->content))
     {
       if (state == JINGLE_CONTENT_STATE_ACKNOWLEDGED)
-        local_state = TPY_SENDING_STATE_SENDING;
+        local_state = TP_SENDING_STATE_SENDING;
       else
-        local_state = TPY_SENDING_STATE_PENDING_SEND;
+        local_state = TP_SENDING_STATE_PENDING_SEND;
     }
 
   if (gabble_jingle_content_receiving (priv->content))
     {
       if (created_by_us && state != JINGLE_CONTENT_STATE_ACKNOWLEDGED)
-        remote_state = TPY_SENDING_STATE_PENDING_SEND;
+        remote_state = TP_SENDING_STATE_PENDING_SEND;
       else
-        remote_state = TPY_SENDING_STATE_SENDING;
+        remote_state = TP_SENDING_STATE_SENDING;
     }
 
-  tpy_base_call_stream_update_local_sending_state (base, local_state);
-  tpy_base_call_stream_remote_member_update_state (base,
-        priv->content->session->peer, remote_state);
+  tp_base_call_stream_update_local_sending_state (base, local_state,
+      0, TP_CALL_STATE_CHANGE_REASON_PROGRESS_MADE, "", "");
+  tp_base_call_stream_update_remote_sending_state (base,
+        priv->content->session->peer, remote_state,
+        0, TP_CALL_STATE_CHANGE_REASON_PROGRESS_MADE, "", "");
 }
 
 
@@ -419,10 +399,10 @@ static void
 gabble_call_stream_class_init (GabbleCallStreamClass *gabble_call_stream_class)
 {
   GObjectClass *object_class = G_OBJECT_CLASS (gabble_call_stream_class);
-  TpyBaseCallStreamClass *bcs_class =
-      TPY_BASE_CALL_STREAM_CLASS (gabble_call_stream_class);
-  TpyBaseMediaCallStreamClass *bmcs_class =
-      TPY_BASE_MEDIA_CALL_STREAM_CLASS (gabble_call_stream_class);
+  TpBaseCallStreamClass *bcs_class =
+      TP_BASE_CALL_STREAM_CLASS (gabble_call_stream_class);
+  TpBaseMediaCallStreamClass *bmcs_class =
+      TP_BASE_MEDIA_CALL_STREAM_CLASS (gabble_call_stream_class);
   GParamSpec *param_spec;
 
   g_type_class_add_private (gabble_call_stream_class,
@@ -470,7 +450,7 @@ gabble_call_stream_finalize (GObject *object)
 }
 
 static GPtrArray *
-gabble_call_stream_add_candidates (TpyBaseMediaCallStream *stream,
+gabble_call_stream_add_candidates (TpBaseMediaCallStream *stream,
     const GPtrArray *candidates,
     GError **error)
 {
@@ -517,11 +497,11 @@ gabble_call_stream_add_candidates (TpyBaseMediaCallStream *stream,
 
       username = tp_asv_get_string (info, "Username");
       if (username == NULL)
-        username = tpy_base_media_call_stream_get_username (stream);
+        username = tp_base_media_call_stream_get_username (stream);
 
       password = tp_asv_get_string (info, "Password");
       if (password == NULL)
-        password = tpy_base_media_call_stream_get_password (stream);
+        password = tp_base_media_call_stream_get_password (stream);
 
       foundation = tp_asv_get_string (info, "Foundation");
       if (foundation == NULL)
@@ -551,21 +531,23 @@ gabble_call_stream_add_candidates (TpyBaseMediaCallStream *stream,
         0);
 
       l = g_list_append (l, c);
-      g_ptr_array_add (accepted_candidates,
-          g_boxed_copy (TPY_STRUCT_TYPE_CANDIDATE, va));
+      g_ptr_array_add (accepted_candidates, va);
     }
 
   gabble_jingle_content_add_candidates (priv->content, l);
 
   if (accepted_candidates->len == 0 && candidates->len != 0)
-    g_set_error_literal (error, TP_ERRORS, TP_ERROR_INVALID_ARGUMENT,
-        "All candidates had the wrong Type");
+    {
+      g_set_error_literal (error, TP_ERRORS, TP_ERROR_INVALID_ARGUMENT,
+          "All candidates had the wrong Type");
+      tp_clear_pointer (&accepted_candidates, g_ptr_array_unref);
+    }
 
   return accepted_candidates;
 }
 
 static gboolean
-gabble_call_stream_set_sending (TpyBaseCallStream *stream,
+gabble_call_stream_set_sending (TpBaseCallStream *stream,
     gboolean sending,
     GError **error)
 {
diff --git a/src/call-stream.h b/src/call-stream.h
index 7d17e5184..e58d39f17 100644
--- a/src/call-stream.h
+++ b/src/call-stream.h
@@ -23,7 +23,7 @@
 
 #include <glib-object.h>
 
-#include <telepathy-yell/base-media-call-stream.h>
+#include <telepathy-glib/base-media-call-stream.h>
 #include "types.h"
 
 G_BEGIN_DECLS
@@ -33,11 +33,11 @@ typedef struct _GabbleCallStreamPrivate GabbleCallStreamPrivate;
 typedef struct _GabbleCallStreamClass GabbleCallStreamClass;
 
 struct _GabbleCallStreamClass {
-    TpyBaseMediaCallStreamClass parent_class;
+    TpBaseMediaCallStreamClass parent_class;
 };
 
 struct _GabbleCallStream {
-    TpyBaseMediaCallStream parent;
+    TpBaseMediaCallStream parent;
 
     GabbleCallStreamPrivate *priv;
 };
diff --git a/src/debug.c b/src/debug.c
index 24d2b1808..a7616f712 100644
--- a/src/debug.c
+++ b/src/debug.c
@@ -18,7 +18,6 @@
 #include <glib/gstdio.h>
 #include <telepathy-glib/debug.h>
 #include <telepathy-glib/debug-sender.h>
-#include <telepathy-yell/debug.h>
 
 static GabbleDebugFlags flags = 0;
 
@@ -63,7 +62,7 @@ void gabble_debug_set_flags_from_env ()
   flags_string = g_getenv ("GABBLE_DEBUG");
 
   tp_debug_set_flags (flags_string);
-  tpy_debug_set_flags (flags_string);
+  tp_debug_set_flags (flags_string);
 
   if (flags_string != NULL)
     {
diff --git a/src/google-relay.c b/src/google-relay.c
index d78f37e00..220e58d06 100644
--- a/src/google-relay.c
+++ b/src/google-relay.c
@@ -64,6 +64,7 @@ relay_session_data_new (guint requests_to_do,
   RelaySessionData *rsd = g_slice_new0 (RelaySessionData);
 
   rsd->relays = g_ptr_array_sized_new (requests_to_do);
+  g_ptr_array_set_free_func (rsd->relays, (GDestroyNotify) g_hash_table_unref);
   rsd->component = 1;
   rsd->requests_to_do = requests_to_do;
   rsd->callback = callback;
@@ -91,7 +92,6 @@ relay_session_data_destroy (gpointer p)
 {
   RelaySessionData *rsd = p;
 
-  g_ptr_array_foreach (rsd->relays, (GFunc) g_hash_table_unref, NULL);
   g_ptr_array_unref (rsd->relays);
 
   g_slice_free (RelaySessionData, rsd);
diff --git a/src/media-factory.c b/src/media-factory.c
index 4eb902c12..0eeca4b0c 100644
--- a/src/media-factory.c
+++ b/src/media-factory.c
@@ -30,8 +30,6 @@
 #include <telepathy-glib/dbus.h>
 #include <telepathy-glib/interfaces.h>
 
-#include <telepathy-yell/interfaces.h>
-
 #define DEBUG_FLAG GABBLE_DEBUG_MEDIA
 
 #include "gabble/caps-channel-manager.h"
@@ -399,6 +397,7 @@ new_call_channel (GabbleMediaFactory *self,
         initial_video_name != NULL ? initial_video_name : "video",
     "requested", request_token != NULL,
     "initiator-handle", initiator,
+    "mutable-contents", TRUE,
     NULL);
 
   g_free (object_path);
@@ -591,40 +590,40 @@ static const gchar * const both_allowed_immutable[] = {
 static const gchar * const call_channel_allowed_properties[] = {
     TP_IFACE_CHANNEL ".TargetHandle",
     TP_IFACE_CHANNEL ".TargetID",
-    TPY_IFACE_CHANNEL_TYPE_CALL ".InitialAudio",
-    TPY_IFACE_CHANNEL_TYPE_CALL ".InitialAudioName",
-    TPY_IFACE_CHANNEL_TYPE_CALL ".InitialVideo",
-    TPY_IFACE_CHANNEL_TYPE_CALL ".InitialVideoName",
-    TPY_IFACE_CHANNEL_TYPE_CALL ".MutableContents",
+    TP_IFACE_CHANNEL_TYPE_CALL ".InitialAudio",
+    TP_IFACE_CHANNEL_TYPE_CALL ".InitialAudioName",
+    TP_IFACE_CHANNEL_TYPE_CALL ".InitialVideo",
+    TP_IFACE_CHANNEL_TYPE_CALL ".InitialVideoName",
+    TP_IFACE_CHANNEL_TYPE_CALL ".MutableContents",
     NULL
 };
 
 static const gchar * const call_audio_allowed[] = {
-    TPY_IFACE_CHANNEL_TYPE_CALL ".InitialAudio",
-    TPY_IFACE_CHANNEL_TYPE_CALL ".InitialAudioName",
+    TP_IFACE_CHANNEL_TYPE_CALL ".InitialAudio",
+    TP_IFACE_CHANNEL_TYPE_CALL ".InitialAudioName",
     NULL
 };
 
 static const gchar * const call_video_allowed[] = {
-    TPY_IFACE_CHANNEL_TYPE_CALL ".InitialVideo",
-    TPY_IFACE_CHANNEL_TYPE_CALL ".InitialVideoName",
+    TP_IFACE_CHANNEL_TYPE_CALL ".InitialVideo",
+    TP_IFACE_CHANNEL_TYPE_CALL ".InitialVideoName",
     NULL
 };
 
 static const gchar * const call_both_allowed[] = {
-    TPY_IFACE_CHANNEL_TYPE_CALL ".InitialAudio",
-    TPY_IFACE_CHANNEL_TYPE_CALL ".InitialAudioName",
-    TPY_IFACE_CHANNEL_TYPE_CALL ".InitialVideo",
-    TPY_IFACE_CHANNEL_TYPE_CALL ".InitialVideoName",
-    TPY_IFACE_CHANNEL_TYPE_CALL ".MutableContents",
+    TP_IFACE_CHANNEL_TYPE_CALL ".InitialAudio",
+    TP_IFACE_CHANNEL_TYPE_CALL ".InitialAudioName",
+    TP_IFACE_CHANNEL_TYPE_CALL ".InitialVideo",
+    TP_IFACE_CHANNEL_TYPE_CALL ".InitialVideoName",
+    TP_IFACE_CHANNEL_TYPE_CALL ".MutableContents",
     NULL
 };
 
 static const gchar * const call_both_allowed_immutable[] = {
-    TPY_IFACE_CHANNEL_TYPE_CALL ".InitialAudio",
-    TPY_IFACE_CHANNEL_TYPE_CALL ".InitialAudioName",
-    TPY_IFACE_CHANNEL_TYPE_CALL ".InitialVideo",
-    TPY_IFACE_CHANNEL_TYPE_CALL ".InitialVideoName",
+    TP_IFACE_CHANNEL_TYPE_CALL ".InitialAudio",
+    TP_IFACE_CHANNEL_TYPE_CALL ".InitialAudioName",
+    TP_IFACE_CHANNEL_TYPE_CALL ".InitialVideo",
+    TP_IFACE_CHANNEL_TYPE_CALL ".InitialVideoName",
     NULL
 };
 
@@ -665,7 +664,7 @@ gabble_media_factory_call_channel_class (void)
 
   tp_asv_set_static_string (table,
       TP_IFACE_CHANNEL ".ChannelType",
-      TPY_IFACE_CHANNEL_TYPE_CALL);
+      TP_IFACE_CHANNEL_TYPE_CALL);
 
   return table;
 }
@@ -905,9 +904,9 @@ gabble_media_factory_create_call (TpChannelManager *manager,
     }
 
   initial_audio = tp_asv_get_boolean (request_properties,
-      TPY_IFACE_CHANNEL_TYPE_CALL ".InitialAudio", NULL);
+      TP_IFACE_CHANNEL_TYPE_CALL ".InitialAudio", NULL);
   initial_video = tp_asv_get_boolean (request_properties,
-      TPY_IFACE_CHANNEL_TYPE_CALL ".InitialVideo", NULL);
+      TP_IFACE_CHANNEL_TYPE_CALL ".InitialVideo", NULL);
 
   if (!initial_audio && !initial_video)
     {
@@ -922,9 +921,9 @@ gabble_media_factory_create_call (TpChannelManager *manager,
    */
 
   initial_audio_name = tp_asv_get_string (request_properties,
-    TPY_IFACE_CHANNEL_TYPE_CALL "InitialAudioName");
+    TP_IFACE_CHANNEL_TYPE_CALL "InitialAudioName");
   initial_video_name = tp_asv_get_string (request_properties,
-    TPY_IFACE_CHANNEL_TYPE_CALL "InitialVideoName");
+    TP_IFACE_CHANNEL_TYPE_CALL "InitialVideoName");
 
   new_call_channel (self, NULL, target,
     initial_audio, initial_audio_name,
@@ -957,7 +956,7 @@ gabble_media_factory_create_channel (TpChannelManager *manager,
 {
   if (!tp_strdiff (tp_asv_get_string (request_properties,
           TP_IFACE_CHANNEL ".ChannelType"),
-        TPY_IFACE_CHANNEL_TYPE_CALL))
+        TP_IFACE_CHANNEL_TYPE_CALL))
     return gabble_media_factory_create_call (manager, request_token,
       request_properties, METHOD_CREATE);
   else
@@ -973,7 +972,7 @@ gabble_media_factory_ensure_channel (TpChannelManager *manager,
 {
   if (!tp_strdiff (tp_asv_get_string (request_properties,
           TP_IFACE_CHANNEL ".ChannelType"),
-        TPY_IFACE_CHANNEL_TYPE_CALL))
+        TP_IFACE_CHANNEL_TYPE_CALL))
     return gabble_media_factory_create_call (manager, request_token,
         request_properties, METHOD_ENSURE);
   else
@@ -1221,15 +1220,15 @@ gabble_media_factory_represent_client (GabbleCapsChannelManager *manager,
       q_gtalk_p2p = g_quark_from_static_string (
           TP_IFACE_CHANNEL_INTERFACE_MEDIA_SIGNALLING "/gtalk-p2p");
       qc_gtalk_p2p = g_quark_from_static_string (
-          TPY_IFACE_CHANNEL_TYPE_CALL "/gtalk-p2p");
+          TP_IFACE_CHANNEL_TYPE_CALL "/gtalk-p2p");
       q_ice_udp = g_quark_from_static_string (
           TP_IFACE_CHANNEL_INTERFACE_MEDIA_SIGNALLING "/ice-udp");
       qc_ice_udp = g_quark_from_static_string (
-          TPY_IFACE_CHANNEL_TYPE_CALL "/ice-udp");
+          TP_IFACE_CHANNEL_TYPE_CALL "/ice-udp");
       q_h264 = g_quark_from_static_string (
           TP_IFACE_CHANNEL_INTERFACE_MEDIA_SIGNALLING "/video/h264");
       qc_h264 = g_quark_from_static_string (
-          TPY_IFACE_CHANNEL_TYPE_CALL "/video/h264");
+          TP_IFACE_CHANNEL_TYPE_CALL "/video/h264");
     }
 
   if (cap_tokens != NULL)
@@ -1275,7 +1274,7 @@ gabble_media_factory_represent_client (GabbleCapsChannelManager *manager,
             TP_IFACE_CHANNEL_TYPE_STREAMED_MEDIA)
           && tp_strdiff (tp_asv_get_string (filter,
               TP_IFACE_CHANNEL ".ChannelType"),
-            TPY_IFACE_CHANNEL_TYPE_CALL))
+            TP_IFACE_CHANNEL_TYPE_CALL))
         {
           /* not interesting to this channel manager */
           continue;
@@ -1286,7 +1285,7 @@ gabble_media_factory_represent_client (GabbleCapsChannelManager *manager,
        * incoming channels */
       if (!tp_strdiff (tp_asv_get_string (filter,
             TP_IFACE_CHANNEL ".ChannelType"),
-            TPY_IFACE_CHANNEL_TYPE_CALL))
+            TP_IFACE_CHANNEL_TYPE_CALL))
         {
           GabbleMediaFactory *self = GABBLE_MEDIA_FACTORY (manager);
           self->priv->use_call_channels = TRUE;
@@ -1307,13 +1306,13 @@ gabble_media_factory_represent_client (GabbleCapsChannelManager *manager,
       if (tp_asv_get_boolean (filter,
             TP_IFACE_CHANNEL_TYPE_STREAMED_MEDIA ".InitialAudio", NULL)
           || tp_asv_get_boolean (filter,
-            TPY_IFACE_CHANNEL_TYPE_CALL ".InitialAudio", NULL))
+            TP_IFACE_CHANNEL_TYPE_CALL ".InitialAudio", NULL))
         audio = TRUE;
 
       if (tp_asv_get_boolean (filter,
             TP_IFACE_CHANNEL_TYPE_STREAMED_MEDIA ".InitialVideo", NULL)
           || tp_asv_get_boolean (filter,
-            TPY_IFACE_CHANNEL_TYPE_CALL ".InitialVideo", NULL))
+            TP_IFACE_CHANNEL_TYPE_CALL ".InitialVideo", NULL))
         video = TRUE;
 
       /* If we've picked up all the capabilities we're ever going to, then
diff --git a/src/muc-factory.c b/src/muc-factory.c
index d55d20f40..58b5271e1 100644
--- a/src/muc-factory.c
+++ b/src/muc-factory.c
@@ -31,8 +31,6 @@
 #include <telepathy-glib/interfaces.h>
 #include <telepathy-glib/util.h>
 
-#include <telepathy-yell/interfaces.h>
-
 #define DEBUG_FLAG GABBLE_DEBUG_MUC
 
 #include "gabble/caps-channel-manager.h"
@@ -1167,7 +1165,7 @@ gabble_muc_factory_type_foreach_channel_class (GType type,
 
   /* Muc Channel.Type.Call */
   g_value_set_static_string (channel_type_value,
-      TPY_IFACE_CHANNEL_TYPE_CALL);
+      TP_IFACE_CHANNEL_TYPE_CALL);
   func (type, table,
       gabble_media_factory_call_channel_allowed_properties (),
       user_data);
@@ -1790,9 +1788,9 @@ handle_call_channel_request (GabbleMucFactory *self,
     return FALSE;
 
   initial_audio = tp_asv_get_boolean (request_properties,
-      TPY_PROP_CHANNEL_TYPE_CALL_INITIAL_AUDIO, NULL);
+      TP_PROP_CHANNEL_TYPE_CALL_INITIAL_AUDIO, NULL);
   initial_video = tp_asv_get_boolean (request_properties,
-      TPY_PROP_CHANNEL_TYPE_CALL_INITIAL_VIDEO, NULL);
+      TP_PROP_CHANNEL_TYPE_CALL_INITIAL_VIDEO, NULL);
 
   if (!initial_audio && !initial_video)
     {
@@ -1858,7 +1856,7 @@ static ChannelTypeHandler channel_type_handlers[] = {
     { TP_IFACE_CHANNEL_TYPE_TUBES, handle_tubes_channel_request },
     { TP_IFACE_CHANNEL_TYPE_STREAM_TUBE, handle_stream_tube_channel_request },
     { TP_IFACE_CHANNEL_TYPE_DBUS_TUBE, handle_dbus_tube_channel_request },
-    { TPY_IFACE_CHANNEL_TYPE_CALL, handle_call_channel_request },
+    { TP_IFACE_CHANNEL_TYPE_CALL, handle_call_channel_request },
     { NULL }
 };
 
diff --git a/src/util.c b/src/util.c
index 7bc0b83a7..d5d39163a 100644
--- a/src/util.c
+++ b/src/util.c
@@ -34,8 +34,6 @@
 #include <telepathy-glib/handle-repo-dynamic.h>
 #include <telepathy-glib/dbus.h>
 
-#include <telepathy-yell/gtypes.h>
-
 #define DEBUG_FLAG GABBLE_DEBUG_JID
 
 #include "base64.h"
@@ -1281,7 +1279,7 @@ gabble_call_candidates_to_array (GList *candidates)
             G_TYPE_UINT, cand->component,
             G_TYPE_STRING, cand->address,
             G_TYPE_UINT, cand->port,
-            TPY_HASH_TYPE_CANDIDATE_INFO, info,
+            TP_HASH_TYPE_CANDIDATE_INFO, info,
             G_TYPE_INVALID);
 
         g_ptr_array_add (arr, a);
diff --git a/tests/Makefile.am b/tests/Makefile.am
index a69bbb88d..2d2860e08 100644
--- a/tests/Makefile.am
+++ b/tests/Makefile.am
@@ -23,7 +23,7 @@ endif
 LDADD = $(top_builddir)/src/libgabble-convenience.la
 
 AM_CFLAGS = $(ERROR_CFLAGS) @DBUS_CFLAGS@ @GLIB_CFLAGS@ @WOCKY_CFLAGS@ \
-    @TP_GLIB_CFLAGS@ @TP_YELL_CFLAGS@ \
+    @TP_GLIB_CFLAGS@ \
     -I $(top_srcdir) -I $(top_builddir) \
     -I $(top_srcdir)/lib -I $(top_builddir)/lib