Merge branch 'async'

Upgrade to Delta v1.33.0
Despite the incremental version number, this is a backward-incompatible change, switching code to async. It does allow us to reduce the number of threads significantly, though.
2020-05-28 09:38:48 +01:00 · 2020-05-28 09:37:50 +01:00 · 2020-05-27 01:19:43 +01:00 · 2020-05-24 00:24:15 +01:00 · 2020-05-23 23:52:42 +01:00 · 2020-05-23 22:49:15 +01:00
155 changed files with 34146 additions and 0 deletions
--- a/.gitignore
+++ b/.gitignore
@@ -0,0 +1 @@
+/target
--- a/.rustfmt.toml
+++ b/.rustfmt.toml
@@ -0,0 +1 @@
+edition = "2018"
--- a/Cargo.lock
+++ b/Cargo.lock
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -0,0 +1,19 @@
+[package]
+name = "telepathy-padfoot"
+version = "0.1.0"
+authors = ["Nick Thomas <me@ur.gs>"]
+edition = "2018"
+license = "MIT"
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+[dependencies]
+anyhow = "1.0"
+async-std = "1.6"
+dbus = "0.8"
+deltachat = { git = "https://github.com/deltachat/deltachat-core-rust", tag="1.34.0" }
+directories = "2.0"
+rand = "0.7"
+
+[profile.release]
+lto = true
--- a/18
+++ b/18
@@ -0,0 +1,18 @@
+Copyright 2020 Nick Thomas <telepathy-delta@ur.gs>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of
+this software and associated documentation files (the "Software"), to deal in
+the Software without restriction, including without limitation the rights to
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+the Software, and to permit persons to whom the Software is furnished to do so,
+subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
--- a/README.md
+++ b/README.md
@@ -0,0 +1,207 @@
+# Telepathy for Delta Chat
+
+## Who
+
+Authored by [Nick Thomas](https://ur.gs) under the [MIT License](LICENSE).
+
+## What
+
+[Delta Chat](https://delta.chat) is IM over email.
+[Telepathy](https://telepathy.freedesktop.org) is a framework for abstracting
+over multiple IM protocols. This project glues the two together, allowing
+Telepathy clients to send/receive Delta messages.
+
+Telepathy CMs should have a name that is not the same as their protocol; so this
+CM is hereby named "padfoot".
+
+My first attempt was [purple-plugin-delta](https://code.ur.gs/lupine/purple-plugin-delta). This has some licensing issues (linking libpurple with OpenSSL)
+that will be resolved with OpenSSL v3.0.0. At least until then, I've lost
+interest in it; my efforts are going into this version instead.
+
+## When
+
+When it's ready.
+
+## Where
+
+Here's where we're at right now:
+
+- [x] Connect to DBUS
+- [x] Advertise enough properties / interfaces to become visible in Empathy
+- [x] Connect to deltachat-core-rust
+- [x] Set up an account via autoconfiguration
+- [x] Appear as online in Empathy
+- [x] Disconnect!
+- [ ] Set up an account manually
+- [~] Contacts handling
+- [x] Text messages
+- [ ] Multimedia messages
+- [~] Setup messages
+- [ ] Import/Export
+- [ ] Group chats
+- [ ] Geolocation messages
+
+## Why
+
+Mobile IM, mostly. Desktop IM, also. It's ideal for my pinephone, and lighter
+than the electron desktop client.
+
+At this point, I don't know Rust, I don't know DBUS, I don't know Telepathy, and
+I don't know Deltachat particularly well either. So this also functions as a
+learning exercise!
+
+## How
+
+### Compiling
+
+This project is written in Rust, so you'll need a rust compiler to build it.
+[Rustup](https://github.com/rust-lang/rustup) comes highly recommended.
+
+There is a [`rust-toolchain`](rust-toolchain) file that I try to keep synced
+with the version of rust that
+[`deltachat-core-rust`](https://github.com/deltachat/deltachat-core-rust)
+uses.
+
+
+Once you have a working rust compiler, just:
+
+```
+$ cargo build --release
+```
+
+to get a `telepathy-padfoot binary. Drop the release flag to make it build fast.
+
+
+### Cross-compiling amd64 -> i386
+
+If you need a 32-bit binary and you're on an am64 bit system, this seems to
+work, as long as you have 32-bit versions of `libdbus-1` and `libssl` installed.
+
+On Debian, the full sequence looks like:
+
+```
+$ dpkg --print-architecture
+amd64
+# dpkg --add-architecture i386
+$ dpkg --print-foreign-architectures
+i386
+# apt update
+# apt install libdbus-1-dev:i386 libssl-dev:i386
+$ rustup target install i686-unknown-linux-gnu
+$ PKG_CONFIG_ALLOW_CROSS=1 cargo build --target=i686-unknown-linux-gnu --release
+```
+
+This creates a 32-bit executable at `target/i686-unknown-linux-gnu/release/telepathy-padfoot`
+
+I don't have a 32-bit machine to test this on, but happy to take fixes for it.
+
+### Cross-compiling amd64 -> aarch64
+
+This is a handy thing to do for linux phones, most of which use telepathy. Rust
+is quite heavy to compile - it's a pain even on a pinebook pro, which is the
+same architecture. Setup on a Debian machine is quite simple:
+
+```
+$ dpkg --print-architecture
+amd64
+# dpkg --add-architecture arm64
+$ dpkg --print-foreign-architectures
+arm64
+# apt update
+# apt install libdbus-1-dev:arm64 libssl-dev:arm64 gcc-aarch64-linux-gnu
+$ rustup target install aarch64-unknown-linux-gnu
+$ RUSTFLAGS="-C linker=aarch64-linux-gnu-gcc" PKG_CONFIG_ALLOW_CROSS=1 cargo build --target=aarch64-unknown-linux-gnu --release
+```
+
+We have to specify the linker because of [this bug](https://github.com/rust-lang/cargo/issues/4133).
+
+Note that this doesn't create a static binary, so you'll need to match versions
+for the shared libraries that are on the phone. In theory we can create static
+binaries with musl, but openssl makes it hard. If you get it working, tell me
+how!
+
+UBTouch uses an ancient version of OpenSSL: 1.0.2g. KDE Neon does much better
+with 1.1.1, so is easier to compile against.
+
+An alternative approach to using multiarch (as above) is to use `debootstrap`
+(or a similar tool) to get a sysroot containing libraries of all the right
+versions. E.g. You can then add `-C link-args=--sysroot=/path/to/sysroot` to
+`RUSTFLAGS` to use those libraries. Ufff. I've not got this working yet either.
+
+...I'm compiling it directly on the phone. Not ideal. Add swap.
+
+Compiling directly on the phone, using KDE Neon, I can get Padfoot running at
+the same time as [Spacebar](https://invent.kde.org/plasma-mobile/spacebar),
+which is a Telepathy client. I can see that Padfoot is checked for protocols,
+but I don't see a way to start a connection with it yet. Next step for this is
+to get Spacebar built and running locally, for a better debugging experience.
+
+postmarketOS is more difficult. It's an `aarch64...musl` target. Rustup doesn't
+support this, and the `rustc` included in the repositories is stable, not
+nightly, so compiling directly on the phone is very difficult. Cross-compile is
+likely the way to go here, in the end, but I need to get one of the two tries
+above working first. Spacebar is available, but Empathy is not.
+
+Phosh uses Chatty, which is based on libpurple, so doesn't work with Padfoot.
+
+In the end, I tried Mobian. This is regular ordinary Debian Bullseye, plus a few
+Phosh packages. Installing Empathy and Padfoot together (Chatty is bundled but
+doesn't work), I have a working setup \o/ - although there are many warts, I can
+use Deltachat on Linux Mobile in at least one configuration.
+
+I'll probably keep Mobian for a while though, it's exactly what I want in a
+mobile phone. Yes, I am peculiar.
+
+### Installing
+
+There is a `share/` directory in this project that contains a bunch of files.
+They should be placed into `/usr/share`, following the same layout. Then put
+the binary into `/usr/lib/telepathy/telepathy-padfoot`.
+
+I should probably put this into the makefile.
+
+### Running
+
+D-Bus activation is not enabled yet, since it gets in the way of disaster-driven
+development. Just run the `telepathy-padfoot` binary as the same user that your
+chat client will be running as. It registers to the DBUS **session bus**, and
+will be picked up next time your chat client scans (which may need a restart).
+
+### Setup messages
+
+If you send an autocrypt setup message while a padfoot connection is up, it will
+notice it and open a channel asking you to reply with a message like:
+
+```
+IMEX: <id> nnnn-nnnn-nnnn-nnnn-nnnn-nnnn-nnnn-nnnn-nnnn
+```
+
+The ID is the delta-generated message ID, while the rest is the setup code. No
+whitespace!
+
+This bit is still extremely janky; it should instead be a magic channel type or
+action button of some kind. It is, however, functional.
+
+Delta wants us to enable the "Send copy to self" option in settings. That's
+exposed as "Bcc self" in the advanced options in Empathy. Once enabled, messages
+you send via Padfoot will appear in other clients. However, messages you send
+from other clients don't appear in Padfoot yet because it mostly ignores self
+messages as a dirty hack to avoid double-showing messages. Progess though.
+
+### Autogenerated telepathy DBUS bindings
+
+It makes use of the `dbus-codegen-rust` crate to convert the
+[telepathy interface specs](https://github.com/TelepathyIM/telepathy-spec) into
+the executable code in `src/telepathy`. This is checked in, but can be
+regenerated like so:
+
+```bash
+$ git submodule init telepathy-spec
+$ git submodule update telepathy-spec
+$ cargo install dbus-codegen
+$ ./scripts/dbus-codegen
+```
+
+`dbus-codegen-rust` doesn't seem to handle namespaced attributes properly, so
+we modify the XML files in `telepathy-spec`... with `sed`. The `tp:type`
+attribute is renamed to `tp:typehint`. This will be fixed in the next release.
--- a/about.hbs
+++ b/about.hbs
@@ -0,0 +1,70 @@
+<html>
+
+<head>
+    <style>
+        @media (prefers-color-scheme: dark) {
+            body {
+                background: #333;
+                color: white;
+            }
+            a {
+                color: skyblue;
+            }
+        }
+        .container {
+            font-family: sans-serif;
+            max-width: 800px;
+            margin: 0 auto;
+        }
+        .intro {
+            text-align: center;
+        }
+        .licenses-list {
+            list-style-type: none;
+            margin: 0;
+            padding: 0;
+        }
+        .license-used-by {
+            margin-top: -10px;
+        }
+        .license-text {
+            max-height: 200px;
+            overflow-y: scroll;
+            white-space: pre-wrap;
+        }
+    </style>
+</head>
+
+<body>
+    <main class="container">
+        <div class="intro">
+            <h1>Third Party Licenses</h1>
+            <p>This page lists the licenses of the projects used in telepathy-padfoot.</p>
+        </div>
+    
+        <h2>Overview of licenses:</h2>
+        <ul class="licenses-overview">
+            {{#each overview}}
+            <li><a href="#{{id}}">{{name}}</a> ({{count}})</li>
+            {{/each}}
+        </ul>
+
+        <h2>All license text:</h2>
+        <ul class="licenses-list">
+            {{#each licenses}}
+            <li class="license">
+                <h3 id="{{id}}">{{name}}</h3>
+                <h4>Used by:</h4>
+                <ul class="license-used-by">
+                    {{#each used_by}}
+                    <li><a href="{{#if crate.repository}} {{crate.repository}} {{else}} https://crates.io/crates/{{crate.name}} {{/if}}">{{crate.name}} {{crate.version}}</a></li>
+                    {{/each}}
+                </ul>
+                <pre class="license-text">{{text}}</pre>
+            </li>
+            {{/each}}
+        </ul>
+    </main>
+</body>
+
+</html>
--- a/about.toml
+++ b/about.toml
@@ -0,0 +1,11 @@
+accepted = [
+    "0BSD",
+    "Apache-2.0",
+    "BSD-2-Clause",
+    "BSD-3-Clause",
+    "ISC",
+    "CC0-1.0",
+    "MIT",
+    "MPL-2.0",
+    "Zlib"
+]
--- a/license.html
+++ b/license.html
--- a/1
+++ b/1
@@ -0,0 +1 @@
+nightly-2020-03-12
--- a/scripts/dbus-codegen
+++ b/scripts/dbus-codegen
@@ -0,0 +1,39 @@
+#!/bin/sh
+
+specs="telepathy-spec/spec"
+dest="src/telepathy"
+modfile="$dest.rs"
+
+#if [ -d "$dest" ]; then
+#	mv "$dest" "$dest.$$"
+#fi
+
+rm -f "$dest.rs"
+rm -rf "$dest"
+mkdir -p "$dest"
+
+echo "#![allow(unused)]" > "$modfile"
+
+for file in $(ls -a $specs/*.xml); do
+	sed -i 's/tp:type=/tp:typehint=/g' "$file"
+
+	name=$( \
+		echo $(basename "$file") | \
+		tr '[:upper:]' '[:lower:]' | \
+		tr '-' '_' | \
+		sed --expression 's/\.xml$//' \
+	)
+	out="$dest/$name.rs"
+
+	dbus-codegen-rust \
+		--file "$file" \
+		-i "org.freedesktop.Telepathy" \
+		-a AsRefClosure \
+		-o "$out"
+
+	rustfmt "$out"
+
+	echo "\n#[allow(clippy::all)]\nmod $name;\npub use self::$name::*;" >> "$modfile"
+done
+
+git -C telepathy-spec checkout -- .
--- a/share/dbus-1/services/org.freedesktop.Telepathy.ConnectionManager.padfoot.service
+++ b/share/dbus-1/services/org.freedesktop.Telepathy.ConnectionManager.padfoot.service
@@ -0,0 +1,4 @@
+[D-BUS Service]
+Name=org.freedesktop.Telepathy.ConnectionManager.padfoot
+Exec=/usr/lib/telepathy/telepathy-padfoot
+//SystemdService=telepathy-padfoot.service
--- a/share/icons/hicolor/scalable/apps/im-delta.svg
+++ b/share/icons/hicolor/scalable/apps/im-delta.svg
@@ -0,0 +1,167 @@
+<?xml version="1.0" encoding="UTF-8" standalone="no"?>
+<!-- Created with Inkscape (http://www.inkscape.org/) -->
+
+<svg
+   xmlns:dc="http://purl.org/dc/elements/1.1/"
+   xmlns:cc="http://creativecommons.org/ns#"
+   xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
+   xmlns:svg="http://www.w3.org/2000/svg"
+   xmlns="http://www.w3.org/2000/svg"
+   xmlns:xlink="http://www.w3.org/1999/xlink"
+   xmlns:sodipodi="http://sodipodi.sourceforge.net/DTD/sodipodi-0.dtd"
+   xmlns:inkscape="http://www.inkscape.org/namespaces/inkscape"
+   width="48px"
+   height="48px"
+   id="svg2985"
+   version="1.1"
+   inkscape:version="0.91 r13725"
+   sodipodi:docname="delta-v7-pathed.svg"
+   inkscape:export-filename="/home/bpetersen/projects/messenger-android/MessengerProj/src/main/res/drawable-xhdpi/ic_launcher.png"
+   inkscape:export-xdpi="183.83"
+   inkscape:export-ydpi="183.83">
+  <defs
+     id="defs2987">
+    <linearGradient
+       id="linearGradient4409">
+      <stop
+         style="stop-color:#f9f9f9;stop-opacity:1"
+         offset="0"
+         id="stop4411" />
+      <stop
+         style="stop-color:#cccccc;stop-opacity:0;"
+         offset="1"
+         id="stop4413" />
+    </linearGradient>
+    <linearGradient
+       id="linearGradient4399">
+      <stop
+         style="stop-color:#f9f9f9;stop-opacity:1;"
+         offset="0"
+         id="stop4401" />
+      <stop
+         style="stop-color:#f9f9f9;stop-opacity:0;"
+         offset="1"
+         id="stop4403" />
+    </linearGradient>
+    <linearGradient
+       id="linearGradient4375">
+      <stop
+         style="stop-color:#364e59;stop-opacity:1;"
+         offset="0"
+         id="stop4377" />
+      <stop
+         style="stop-color:#364e59;stop-opacity:0;"
+         offset="1"
+         id="stop4379" />
+    </linearGradient>
+    <linearGradient
+       id="linearGradient4367">
+      <stop
+         style="stop-color:#dc000f;stop-opacity:1;"
+         offset="0"
+         id="stop4369" />
+      <stop
+         style="stop-color:#00ff00;stop-opacity:0;"
+         offset="1"
+         id="stop4371" />
+    </linearGradient>
+    <linearGradient
+       id="linearGradient4359">
+      <stop
+         style="stop-color:#dc000f;stop-opacity:1;"
+         offset="0"
+         id="stop4361" />
+      <stop
+         style="stop-color:#000000;stop-opacity:0;"
+         offset="1"
+         id="stop4363" />
+    </linearGradient>
+    <linearGradient
+       inkscape:collect="always"
+       xlink:href="#linearGradient4375"
+       id="linearGradient4381"
+       x1="31.957268"
+       y1="29.751493"
+       x2="-45.041405"
+       y2="-18.591616"
+       gradientUnits="userSpaceOnUse"
+       gradientTransform="matrix(0.93766393,0,0,0.93766393,1.542566,1.7199693)" />
+    <linearGradient
+       inkscape:collect="always"
+       xlink:href="#linearGradient4409"
+       id="linearGradient4415"
+       x1="16.345125"
+       y1="3.8388948"
+       x2="36.001561"
+       y2="24.359164"
+       gradientUnits="userSpaceOnUse" />
+  </defs>
+  <sodipodi:namedview
+     id="base"
+     pagecolor="#ffffff"
+     bordercolor="#666666"
+     borderopacity="1.0"
+     inkscape:pageopacity="0.0"
+     inkscape:pageshadow="2"
+     inkscape:zoom="9.8994949"
+     inkscape:cx="1.9547978"
+     inkscape:cy="28.000232"
+     inkscape:current-layer="layer1"
+     showgrid="true"
+     inkscape:grid-bbox="true"
+     inkscape:document-units="px"
+     inkscape:snap-global="false"
+     inkscape:snap-bbox="true"
+     inkscape:bbox-nodes="true"
+     inkscape:bbox-paths="true"
+     inkscape:snap-bbox-edge-midpoints="true"
+     inkscape:window-width="1543"
+     inkscape:window-height="876"
+     inkscape:window-x="57"
+     inkscape:window-y="24"
+     inkscape:window-maximized="1" />
+  <metadata
+     id="metadata2990">
+    <rdf:RDF>
+      <cc:Work
+         rdf:about="">
+        <dc:format>image/svg+xml</dc:format>
+        <dc:type
+           rdf:resource="http://purl.org/dc/dcmitype/StillImage" />
+        <dc:title></dc:title>
+      </cc:Work>
+    </rdf:RDF>
+  </metadata>
+  <g
+     id="layer1"
+     inkscape:label="Layer 1"
+     inkscape:groupmode="layer">
+    <path
+       style="fill:#ffffff;fill-opacity:1;stroke:#000000;stroke-width:0.57405078;stroke-linejoin:round;stroke-miterlimit:4;stroke-dasharray:none;stroke-opacity:0.43921569"
+       d="m 24.015419,1.2870249 c -12.549421,0 -22.7283936,10.1789711 -22.7283936,22.7283931 0,12.549422 10.1789726,22.728395 22.7283936,22.728395 14.337742,-0.342877 9.614352,-4.702705 23.697556,0.969161 -7.545453,-13.001555 -1.082973,-13.32964 -0.969161,-23.697556 0,-12.549422 -10.178973,-22.7283931 -22.728395,-22.7283931 z"
+       id="path3769"
+       inkscape:connector-curvature="0"
+       sodipodi:nodetypes="sscccs" />
+    <path
+       inkscape:connector-curvature="0"
+       id="path3799"
+       d="M 23.982249,5.3106163 C 13.645822,5.4364005 5.2618355,13.92999 5.2618355,24.275753 c 0,10.345764 8.3839865,18.635301 18.7204135,18.509516 9.827724,-0.03951 7.516769,-5.489695 18.380082,-0.443187 -5.950849,-9.296115 0.201753,-10.533667 0.340336,-18.521947 0,-10.345766 -8.383989,-18.6353031 -18.720418,-18.5095187 z"
+       style="fill:url(#linearGradient4381);fill-opacity:1;stroke:none"
+       sodipodi:nodetypes="sscccs" />
+    <g
+       style="font-style:normal;font-weight:normal;font-size:40px;line-height:125%;font-family:Sans;letter-spacing:0px;word-spacing:0px;fill:#000000;fill-opacity:1;stroke:none"
+       id="text4383" />
+    <g
+       style="font-style:normal;font-weight:normal;font-size:40px;line-height:125%;font-family:Sans;letter-spacing:0px;word-spacing:0px;fill:#000000;fill-opacity:1;stroke:none"
+       id="text4421" />
+    <g
+       transform="scale(1.1122373,0.89908874)"
+       style="font-style:normal;font-weight:normal;font-size:42.10587311px;line-height:125%;font-family:Sans;letter-spacing:0px;word-spacing:0px;fill:#ffffff;fill-opacity:1;stroke:none"
+       id="text3797">
+      <path
+         d="m 21.688854,23.636251 q -1.027975,-1.151333 -2.857771,-2.754974 -2.014832,-1.768118 -2.713855,-2.775534 -0.699024,-1.027975 -0.699024,-2.240986 0,-1.809237 1.68588,-2.837212 1.68588,-1.048535 4.399735,-1.048535 2.713855,0 4.728687,0.925178 2.035391,0.925177 2.035391,2.549379 0,0.781261 -0.493428,1.295249 -0.493428,0.513987 -1.151333,0.513987 -0.945737,0 -2.220426,-1.418606 -1.295249,-1.439165 -2.199868,-2.014832 -0.884059,-0.596225 -2.07651,-0.596225 -1.521404,0 -2.50826,0.678463 -0.966297,0.678464 -0.966297,1.726999 0,0.986857 0.801821,1.850356 0.801821,0.863499 4.132461,3.145605 3.556795,2.446581 5.01652,3.824068 1.480285,1.377487 2.405462,3.3512 0.925178,1.973713 0.925178,4.17358 0,3.865188 -2.734414,6.825757 -2.713855,2.94001 -6.352888,2.94001 -3.310081,0 -5.592187,-2.364344 -2.282105,-2.364343 -2.282105,-6.311769 0,-3.803509 2.50826,-6.352888 2.528819,-2.549379 6.208971,-3.083926 z m 0.904619,0.945737 q -5.900579,0.966297 -5.900579,8.100447 0,3.680152 1.459725,5.715543 1.480285,2.035391 3.433438,2.035391 2.035391,0 3.3512,-1.953153 1.315808,-1.973713 1.315808,-5.324913 0,-4.852044 -3.659592,-8.573315 z"
+         style="font-family:'Times New Roman';-inkscape-font-specification:'Times New Roman';fill:#ffffff;fill-opacity:1"
+         id="path4161" />
+    </g>
+  </g>
+</svg>
--- a/share/telepathy/managers/padfoot.manager
+++ b/share/telepathy/managers/padfoot.manager
@@ -0,0 +1,26 @@
+[ConnectionManager]
+Interfaces=
+Name=padfoot
+BusName=org.freedesktop.Telepathy.ConnectionManager.padfoot
+ObjectPath=/org/freedesktop/Telepathy/ConnectionManager/padfoot
+
+[Protocol delta]
+param-account=s required
+param-password=s required secret
+param-bcc-self=b
+status-available=2 settable
+status-offline = 1 settable
+
+AuthenticationTypes=org.freedesktop.Telepathy.Channel.Type.ServerTLSConnection;
+ConnectionInterfaces=org.freedesktop.Telepathy.Connection.Interface.Avatars;org.freedesktop.Telepathy.Connection.Interface.Contacts;org.freedesktop.Telepathy.Connection.Interface.ContactList;org.freedesktop.Telepathy.Connection.Interface.Requests;org.freedesktop.Telepathy.Connection.Interface.SimplePresence;
+EnglishName=Delta Chat
+Icon=im-delta
+Interfaces=org.freedesktop.Telepathy.Protocol;org.freedesktop.Telepathy.Protocol.Interface.Presence;
+RequestableChannelClasses=text;
+VCardField=email
+
+[text]
+Interfaces=org.freedesktop.Telepathy.Channel.Interface.Messages;
+org.freedesktop.Telepathy.Channel.ChannelType s=org.freedesktop.Telepathy.Channel.Type.Text
+org.freedesktop.Telepathy.Channel.TargetHandleType u=1
+allowed=org.freedesktop.Telepathy.Channel.TargetHandle;org.freedesktop.Telepathy.Channel.TargetID;org.freedesktop.Telepathy.Channel.Interface.Messages;
--- a/src/main.rs
+++ b/src/main.rs
@@ -0,0 +1,82 @@
+mod padfoot;
+mod telepathy;
+
+use anyhow::{anyhow, Result};
+use dbus::{
+    blocking::{stdintf::org_freedesktop_dbus::RequestNameReply, LocalConnection},
+    channel::Sender,
+    tree::Factory,
+};
+use padfoot::{
+    ConnectionManager, Protocol, CM_BUS_NAME, CM_CONN_BUS_NAME, CM_OBJECT_PATH, CONN_BUS_NAME,
+    PROTO_BUS_NAME, PROTO_OBJECT_PATH,
+};
+use std::time::Duration;
+
+// TODO: move this to the ConnectionManager?
+fn run() -> Result<()> {
+    let (cm, msg_r) = ConnectionManager::new();
+    let cm_rc = std::rc::Rc::new(cm);
+
+    let proto = Protocol {};
+    let proto_rc = std::rc::Rc::new(proto);
+
+    let f = Factory::new_fn::<()>();
+    let mut tree = f.tree(());
+
+    let cm_iface = telepathy::connection_manager_server(&f, (), move |_| cm_rc.clone());
+
+    let proto_rc_1 = proto_rc.clone();
+    let proto_iface = telepathy::protocol_server(&f, (), move |_| proto_rc_1.clone());
+
+    let proto_presence_iface =
+        telepathy::protocol_interface_presence_server(&f, (), move |_| proto_rc.clone());
+
+    tree = tree.add(
+        f.object_path(CM_OBJECT_PATH, ())
+            .introspectable()
+            .add(cm_iface),
+    );
+    tree = tree.add(
+        f.object_path(PROTO_OBJECT_PATH, ())
+            .introspectable()
+            .add(proto_iface)
+            .add(proto_presence_iface),
+    );
+
+    tree = tree.add(f.object_path("/", ()).introspectable());
+
+    // Setup DBus connection
+    let mut c = LocalConnection::new_session()?;
+    tree.start_receive(&c);
+
+    for name in &[CM_BUS_NAME, PROTO_BUS_NAME, CM_CONN_BUS_NAME, CONN_BUS_NAME] {
+        let result = c.request_name(*name, false, false, true)?;
+        match result {
+            RequestNameReply::Exists => {
+                return Err(anyhow!("Another process is already registered on {}", name))
+            }
+            _ => println!("{} listening on {}", c.unique_name(), name), // All other responses we can get are a success
+        }
+    }
+
+    loop {
+        c.process(Duration::from_millis(100))?;
+
+        // Spend a bit of time sending any outgoing messages - signals, mostly
+        for msg in msg_r.try_iter().take(10) {
+            print!("Sending message...");
+            match c.send(msg) {
+                Err(e) => println!("error! {:?}", e),
+                _ => println!("OK!"),
+            }
+        }
+    }
+}
+
+fn main() {
+    if let Err(e) = run() {
+        println!("{}", e);
+        std::process::exit(1);
+    }
+}
--- a/src/padfoot.rs
+++ b/src/padfoot.rs
@@ -0,0 +1,17 @@
+mod channel;
+pub use self::channel::*;
+
+mod connection;
+pub use self::connection::*;
+
+mod connection_manager;
+pub use self::connection_manager::*;
+
+mod message;
+pub use self::message::*;
+
+mod protocol;
+pub use self::protocol::*;
+
+mod var_arg;
+pub use self::var_arg::*;
--- a/src/padfoot/channel.rs
+++ b/src/padfoot/channel.rs
@@ -0,0 +1,197 @@
+#[allow(clippy::module_inception)]
+mod channel;
+pub use channel::*;
+
+mod messages;
+pub use messages::*;
+
+mod type_text;
+pub use type_text::*;
+
+use crate::padfoot::{var_bool, var_str, var_str_vec, var_u32, DbusAction, VarArg};
+use crate::telepathy;
+
+use async_std::task::block_on;
+use deltachat as dc;
+
+use std::collections::HashMap;
+use std::sync::{mpsc, Arc};
+
+type Result<T> = std::result::Result<T, dbus::tree::MethodErr>;
+
+pub type HandleType = u32;
+
+#[allow(dead_code)]
+pub const HANDLE_TYPE_NONE: HandleType = 0;
+pub const HANDLE_TYPE_CONTACT: HandleType = 1;
+#[allow(dead_code)]
+pub const HANDLE_TYPE_ROOM: HandleType = 2;
+#[allow(dead_code)]
+pub const HANDLE_TYPE_LIST: HandleType = 3; // Deprecated
+#[allow(dead_code)]
+pub const HANDLE_TYPE_GROUP: HandleType = 4; // Deprecated
+
+// FIXME: I'm assuming that all channels will be of type text and 1-1 for now.
+#[derive(Debug)]
+pub struct Channel {
+    actq: mpsc::Sender<DbusAction>,
+    chat_id: dc::chat::ChatId,
+    ctx: Arc<dc::context::Context>,
+    initiator_handle: u32,
+    path: dbus::Path<'static>,
+    requested: bool,
+    target_handle: u32, // Who we're talking to
+}
+
+// "This SHOULD NOT include the channel type and channel interface itself"
+pub fn channel_interfaces() -> Vec<String> {
+    vec!["org.freedesktop.Telepathy.Channel.Interface.Messages".to_string()]
+}
+
+impl Channel {
+    pub fn new(
+        actq: mpsc::Sender<DbusAction>,
+        chat_id: dc::chat::ChatId,
+        ctx: Arc<dc::context::Context>,
+        initiator_handle: u32,
+        path: dbus::Path<'static>,
+        requested: bool,
+        target_handle: u32,
+    ) -> Self {
+        Channel {
+            actq,
+            chat_id,
+            ctx,
+            initiator_handle,
+            path,
+            requested,
+            target_handle,
+        }
+    }
+
+    // FIXME: we should be able to introspect this already???
+    pub fn chan_props(&self) -> HashMap<String, VarArg> {
+        let mut out = HashMap::<String, VarArg>::new();
+        out.insert(
+            "org.freedesktop.Telepathy.Channel.ChannelType".to_string(),
+            var_str(self.chan_type()),
+        );
+        out.insert(
+            "org.freedesktop.Telepathy.Channel.TargetHandleType".to_string(),
+            var_u32(self.handle_type()),
+        );
+        out.insert(
+            "org.freedesktop.Telepathy.Channel.InitiatorHandle".to_string(),
+            var_u32(self.initiator_handle),
+        );
+        out.insert(
+            "org.freedesktop.Telepathy.Channel.InitiatorID".to_string(),
+            var_str(self.initiator_contact().unwrap().get_addr().to_string()),
+        );
+        out.insert(
+            "org.freedesktop.Telepathy.Channel.TargetHandle".to_string(),
+            var_u32(self.target_handle),
+        );
+        out.insert(
+            "org.freedesktop.Telepathy.Channel.TargetID".to_string(),
+            var_str(self.target_contact().unwrap().get_addr().to_string()),
+        );
+        out.insert(
+            "org.freedesktop.Telepathy.Channel.Requested".to_string(),
+            var_bool(self.requested),
+        );
+        out.insert(
+            "org.freedesktop.Telepathy.Channel.Interfaces".to_string(),
+            var_str_vec(vec![
+                "org.freedesktop.Telepathy.Channel.Interface.Messages".to_string()
+            ]),
+        );
+
+        out
+    }
+
+    pub fn path(&self) -> dbus::Path<'static> {
+        self.path.clone()
+    }
+
+    pub fn chan_type(&self) -> String {
+        "org.freedesktop.Telepathy.Channel.Type.Text".to_string() // FIXME: this shouldn't be hardcoded
+    }
+
+    pub fn handle_type(&self) -> HandleType {
+        HANDLE_TYPE_CONTACT // FIXME: this shouldn't be hardcoded
+    }
+
+    pub fn handle(&self) -> u32 {
+        self.target_handle
+    }
+
+    pub fn target_contact(&self) -> Option<dc::contact::Contact> {
+        block_on(dc::contact::Contact::get_by_id(&self.ctx, self.handle())).ok()
+    }
+
+    pub fn initiator_contact(&self) -> Option<dc::contact::Contact> {
+        block_on(dc::contact::Contact::get_by_id(
+            &self.ctx,
+            self.initiator_handle,
+        ))
+        .ok() // FIXME: this will be wrong for outbound channels
+    }
+
+    pub fn requested(&self) -> bool {
+        self.requested
+    }
+
+    pub fn build_object_path(
+        channel: Arc<Channel>,
+    ) -> dbus::tree::ObjectPath<dbus::tree::MTFn, ()> {
+        let f = dbus::tree::Factory::new_fn::<()>();
+
+        let c_rc1 = channel.clone();
+        let chan_iface = telepathy::channel_server(&f, (), move |_| c_rc1.clone());
+
+        let c_rc2 = channel.clone();
+        let messages_iface =
+            telepathy::channel_interface_messages_server(&f, (), move |_| c_rc2.clone());
+
+        let c_rc3 = channel.clone();
+        let type_text_iface = telepathy::channel_type_text_server(&f, (), move |_| c_rc3.clone());
+
+        f.object_path(channel.path.clone(), ())
+            .introspectable()
+            .add(chan_iface)
+            .add(messages_iface)
+            .add(type_text_iface)
+    }
+
+    fn try_process_setupmsg(self: &Self, text: String) {
+        if !text.starts_with("IMEX: ") {
+            return;
+        };
+
+        // Expected form: "IMEX: <msg-id> <setupcode>
+        let mut iter = text.split_whitespace();
+        iter.next(); // Ignore the prefix
+
+        let msg_id = match iter.next() {
+            Some(txt) => match txt.parse::<u32>() {
+                Ok(id) => id,
+                _ => return,
+            },
+            _ => return,
+        };
+
+        let setup_code = match iter.next() {
+            Some(txt) => txt,
+            _ => return,
+        };
+
+        if let Err(e) = block_on(dc::imex::continue_key_transfer(
+            &self.ctx,
+            dc::message::MsgId::new(msg_id),
+            &setup_code,
+        )) {
+            println!("Failed to apply setup code {}: {}", msg_id, e);
+        }
+    }
+}
--- a/src/padfoot/channel/channel.rs
+++ b/src/padfoot/channel/channel.rs
@@ -0,0 +1,98 @@
+use crate::padfoot::DbusAction;
+use crate::telepathy;
+
+use dbus::tree::MethodErr;
+
+use super::{Channel, Result};
+
+impl AsRef<dyn telepathy::Channel + 'static> for std::sync::Arc<Channel> {
+    fn as_ref(&self) -> &(dyn telepathy::Channel + 'static) {
+        &**self
+    }
+}
+
+impl telepathy::Channel for Channel {
+    fn close(&self) -> Result<()> {
+        println!("Channel::close()");
+
+        self.actq
+            .send(DbusAction::CloseChannel(self.path()))
+            .unwrap();
+
+        Ok(())
+    }
+
+    // Deprecated
+    fn get_channel_type(&self) -> Result<String> {
+        self.channel_type()
+    }
+
+    fn channel_type(&self) -> Result<String> {
+        println!("Channel::channel_type()");
+
+        Ok(self.chan_type())
+    }
+
+    // Deprecated
+    fn get_handle(&self) -> Result<(u32, u32)> {
+        println!("Channel::get_handle()");
+
+        Ok((self.handle_type(), self.handle()))
+    }
+
+    // Deprecated
+    fn get_interfaces(&self) -> Result<Vec<String>> {
+        println!("Channel::get_interfaces()");
+
+        self.interfaces()
+    }
+
+    fn interfaces(&self) -> Result<Vec<String>> {
+        println!("Channel::interfaces()");
+        Ok(super::channel_interfaces())
+    }
+
+    fn target_handle(&self) -> Result<u32> {
+        println!("Channel::target_handle()");
+
+        Ok(self.handle())
+    }
+
+    fn target_id(&self) -> Result<String> {
+        println!("Channel::target_id()");
+
+        if let Some(contact) = self.target_contact() {
+            Ok(contact.get_addr().to_string())
+        } else {
+            Err(MethodErr::no_arg())
+        }
+    }
+
+    fn target_handle_type(&self) -> Result<u32> {
+        println!("Channel::target_handle_type()");
+
+        Ok(self.handle_type())
+    }
+
+    fn requested(&self) -> Result<bool> {
+        println!("Channel::requested()");
+
+        Ok(self.requested) // FIXME: channels initiated by ourselves *will* be requested
+    }
+
+    fn initiator_handle(&self) -> Result<u32> {
+        println!("Channel::initiator_handle()");
+
+        self.target_handle() // FIXME: Not the case for channels initiated by ourselves
+    }
+
+    fn initiator_id(&self) -> Result<String> {
+        println!("Channel::initiator_id()");
+
+        if let Some(contact) = self.initiator_contact() {
+            Ok(contact.get_addr().to_string())
+        } else {
+            Err(MethodErr::no_arg())
+        }
+    }
+}
--- a/src/padfoot/channel/messages.rs
+++ b/src/padfoot/channel/messages.rs
@@ -0,0 +1,139 @@
+use crate::padfoot::{convert_msg, DbusAction, VarArg};
+use crate::telepathy;
+
+use async_std::task::block_on;
+use dbus::message::SignalArgs;
+use dbus::tree::MethodErr;
+use dc::constants::Viewtype;
+use dc::message::{Message, MessageState};
+use deltachat as dc;
+use std::collections::HashMap;
+
+use super::{Channel, Result};
+
+impl AsRef<dyn telepathy::ChannelInterfaceMessages + 'static> for std::sync::Arc<Channel> {
+    fn as_ref(&self) -> &(dyn telepathy::ChannelInterfaceMessages + 'static) {
+        &**self
+    }
+}
+
+impl telepathy::ChannelInterfaceMessages for Channel {
+    fn send_message(&self, parts: Vec<HashMap<&str, VarArg>>, flags: u32) -> Result<String> {
+        println!("Channel::send_message({:?}, {})", parts, flags);
+
+        if parts.len() != 2 {
+            return Err(MethodErr::no_arg());
+        }
+        let _meta = &parts[0];
+        let content = &parts[1];
+
+        let content_type = content["content-type"].0.as_str().unwrap();
+
+        if content_type != "text/plain" {
+            println!("FIXME: can only send text/plain messages right now");
+            return Err(MethodErr::no_arg());
+        }
+
+        let text_opt = content["content"].0.as_str().map(|s| s.to_string());
+
+        let mut delta_msg = Message::new(Viewtype::Text); // FIXME: this won't always be plaintext
+        delta_msg.set_text(text_opt.clone());
+
+        if let Some(text) = text_opt.clone() {
+            self.try_process_setupmsg(text);
+        };
+
+        let ctx = &self.ctx;
+        let blobdir = ctx.get_blobdir();
+
+        let msg_id = match block_on(dc::chat::send_msg(&ctx, self.chat_id, &mut delta_msg)) {
+            Ok(msg_id) => msg_id,
+            Err(e) => {
+                println!("    Failed to send message: {}", e);
+                return Err(MethodErr::no_arg());
+            }
+        };
+
+        let token = format!("{}", msg_id.to_u32());
+        let dbus_parts = convert_msg(blobdir, &delta_msg).map_err(|_| MethodErr::no_arg())?;
+
+        let messages_sig = telepathy::ChannelInterfaceMessagesMessageSent {
+            content: dbus_parts,
+            flags: 0,
+            message_token: token.clone(),
+        }
+        .to_emit_message(&self.path());
+
+        let text_sig = telepathy::ChannelTypeTextSent {
+            timestamp: delta_msg.get_timestamp() as u32,
+            type_: 0,
+            text: text_opt.or_else(|| Some("".to_string())).unwrap(),
+        }
+        .to_emit_message(&self.path());
+
+        self.actq.send(DbusAction::Signal(messages_sig)).unwrap();
+        self.actq.send(DbusAction::Signal(text_sig)).unwrap();
+
+        Ok(token)
+    }
+
+    fn get_pending_message_content(
+        &self,
+        message_id: u32,
+        parts: Vec<u32>,
+    ) -> Result<HashMap<u32, VarArg>> {
+        println!(
+            "Channel::get_pending_message_content({}, {:?})",
+            message_id, parts
+        );
+        Err(MethodErr::no_arg())
+    }
+
+    fn supported_content_types(&self) -> Result<Vec<String>> {
+        println!("Channel::supported_content_types()");
+
+        Ok(vec!["*/*".to_string()])
+    }
+
+    fn message_types(&self) -> Result<Vec<u32>> {
+        println!("Channel::message_types()");
+
+        Ok(vec![0]) // Normal messages. FIXME: MDNs too
+    }
+
+    fn message_part_support_flags(&self) -> Result<u32> {
+        println!("Channel::message_part_support_flags()");
+
+        Ok(0) // FIXME: support multipart messages
+    }
+
+    // Return value is an array of array of message parts
+    fn pending_messages(&self) -> Result<Vec<Vec<HashMap<String, VarArg>>>> {
+        println!("Channel::pending_messages()");
+
+        let mut out = Vec::<Vec<HashMap<String, VarArg>>>::new();
+        let ctx = &self.ctx;
+        let blobdir = ctx.get_blobdir();
+
+        for msg_id in block_on(dc::chat::get_chat_msgs(ctx, self.chat_id, 0, None)) {
+            if let Ok(msg) = block_on(dc::message::Message::load_from_db(ctx, msg_id)) {
+                match msg.get_state() {
+                    MessageState::InFresh | MessageState::InNoticed => {
+                        println!("    A message: {:?}", msg);
+                        let parts = convert_msg(blobdir, &msg).map_err(|_| MethodErr::no_arg())?;
+                        out.push(parts);
+                    }
+                    _ => continue,
+                }
+            }
+        }
+
+        Ok(out) // FIXME: check for pending messages
+    }
+
+    fn delivery_reporting_support(&self) -> Result<u32> {
+        println!("Channel::delivery_reporting_support()");
+
+        Ok(0) // FIXME: MDNs
+    }
+}
--- a/src/padfoot/channel/type_text.rs
+++ b/src/padfoot/channel/type_text.rs
@@ -0,0 +1,74 @@
+use crate::padfoot::DbusAction;
+use crate::telepathy;
+use crate::telepathy::ChannelInterfaceMessages;
+
+use async_std::task::block_on;
+use dbus::message::SignalArgs;
+use dbus::tree::MethodErr;
+use dc::message::MsgId;
+use deltachat as dc;
+
+use super::{Channel, Result};
+
+impl AsRef<dyn telepathy::ChannelTypeText + 'static> for std::sync::Arc<Channel> {
+    fn as_ref(&self) -> &(dyn telepathy::ChannelTypeText + 'static) {
+        &**self
+    }
+}
+
+type PendingMessagesSpec = (
+    u32,    // numeric identifier
+    u32,    // Unix timestamp indicating when the message was received
+    u32,    // contact handle for the contact who sent the message
+    u32,    // message type, taken from ChannelTextMessageType
+    u32,    // bitwise-OR of the message flags from ChannelTextMessageFlags
+    String, // text of the message
+);
+
+// Most of these methods are deprecated, so should be implemented in terms of
+// the mandatory Messages interface.
+impl telepathy::ChannelTypeText for Channel {
+    // ids is a list of deltachat msg_ids
+    fn acknowledge_pending_messages(&self, ids: Vec<u32>) -> Result<()> {
+        println!("Channel::acknowledge_pending_messages({:?})", ids);
+
+        let mut msg_ids = Vec::<MsgId>::new();
+        for msg_id in &ids {
+            msg_ids.push(MsgId::new(*msg_id));
+        }
+
+        print!("    Marking messages as seen...");
+        let result = block_on(dc::message::markseen_msgs(&self.ctx, msg_ids));
+        if result {
+            println!("OK!");
+
+            // Emit a PendingMessagesRemoved signal only if all have been removed
+            let sig =
+                telepathy::ChannelInterfaceMessagesPendingMessagesRemoved { message_ids: ids }
+                    .to_emit_message(&self.path());
+
+            self.actq.send(DbusAction::Signal(sig)).unwrap();
+        } else {
+            println!("FAILED!");
+        }
+
+        Ok(())
+    }
+
+    fn get_message_types(&self) -> Result<Vec<u32>> {
+        println!("Channel::get_message_types()");
+
+        self.message_types()
+    }
+
+    fn list_pending_messages(&self, clear: bool) -> Result<Vec<PendingMessagesSpec>> {
+        println!("Channel::list_pending_messages({})", clear);
+
+        Err(MethodErr::no_arg())
+    }
+
+    fn send(&self, message_type: u32, text: &str) -> Result<()> {
+        println!("Channel::send({}, {})", message_type, text);
+        Err(MethodErr::no_arg())
+    }
+}
--- a/src/padfoot/connection.rs
+++ b/src/padfoot/connection.rs
@@ -0,0 +1,570 @@
+mod avatars;
+pub use self::avatars::*;
+
+#[allow(clippy::module_inception)]
+mod connection;
+pub use self::connection::*;
+
+mod contacts;
+pub use self::contacts::*;
+
+mod contact_list;
+pub use self::contact_list::*;
+
+mod escape;
+use self::escape::escape;
+
+mod requests;
+pub use self::requests::*;
+
+mod simple_presence;
+pub use self::simple_presence::*;
+
+use crate::padfoot::{convert_msg, Channel, VarArg};
+use crate::telepathy;
+
+use async_std::task::block_on;
+use dbus::blocking::{stdintf::org_freedesktop_dbus::RequestNameReply, LocalConnection};
+use dbus::channel::{MatchingReceiver, Sender};
+use dbus::message::SignalArgs;
+use dbus::tree::MethodErr;
+
+use dc::config::Config;
+use dc::context::Context;
+use dc::Event;
+use deltachat as dc;
+
+use std::collections::{HashMap, HashSet};
+use std::sync::{mpsc, Arc, Mutex, RwLock};
+use std::thread;
+use std::time::Duration;
+
+pub const CONN_BUS_NAME: &str = "org.freedesktop.Telepathy.Connection.padfoot.delta";
+pub const CONN_OBJECT_PATH: &str = "/org/freedesktop/Telepathy/Connection/padfoot/delta";
+
+// Only the main loop has access to the DBUS connection. Interacting with DBUS
+// outside of method return values requires one of these to be added to actq
+#[derive(Debug)]
+pub enum DbusAction {
+    Signal(dbus::Message), // Generic signal to send
+
+    NewChannel(Channel),               // Add this channel
+    CloseChannel(dbus::Path<'static>), // Close this channel
+
+    IncomingMessage(dc::chat::ChatId, dc::message::MsgId), // Look at this \o/
+    FreshMessages, // Hint that some messages need looking at
+}
+
+#[derive(Debug)]
+// A connection uses delta database IDs as handles, and email addresses as IDs
+pub struct Connection {
+    // Used for sending out messages
+    actq: mpsc::Sender<DbusAction>,
+    // actq: Arc<Mutex<VecDeque<DbusAction>>>,
+
+    // Channels we own
+    channels: Arc<RwLock<HashMap<dbus::Path<'static>, Arc<Channel>>>>,
+
+    // Owned by the CM. Remove ourselves from this when done
+    conns: Arc<Mutex<HashSet<dbus::Path<'static>>>>,
+
+    ctx: Arc<Context>, // Delta contexts are threadsafe
+    settings: ConnSettings,
+    state: Arc<RwLock<ConnState>>,
+}
+
+#[derive(Debug)]
+pub struct ConnSettings {
+    account: String,
+    password: String,
+    bcc_self: bool,
+    id: String,
+}
+
+impl ConnSettings {
+    pub fn from_params(params: HashMap<&str, VarArg>) -> Result<Self, MethodErr> {
+        let err = Err(MethodErr::no_arg());
+
+        let account = match params.get("account") {
+            Some(variant) => match variant.0.as_str() {
+                Some(str) => str.to_string(),
+                None => return err,
+            },
+            None => return err,
+        };
+
+        let id = escape(account.to_owned());
+
+        let password = match params.get("password") {
+            Some(variant) => match variant.0.as_str() {
+                Some(str) => str.to_string(),
+                None => return err,
+            },
+            None => return err,
+        };
+
+        let bcc_self = match params.get("bcc-self") {
+            Some(variant) => match variant.0.as_u64() {
+                Some(i) => i != 0,
+                None => {
+                    println!("0!");
+                    return err;
+                }
+            },
+            None => {
+                println!("1!");
+                false
+            }
+        };
+
+        Ok(Self {
+            account,
+            password,
+            bcc_self,
+            id,
+        })
+    }
+
+    pub fn id(&self) -> String {
+        self.id.to_owned()
+    }
+
+    pub fn bus(&self) -> String {
+        CONN_BUS_NAME.to_owned() + "." + &self.id
+    }
+
+    pub fn path(&self) -> dbus::Path<'static> {
+        dbus::Path::new(format!("{}/{}", CONN_OBJECT_PATH, &self.id)).expect("Valid path")
+    }
+}
+
+impl Connection {
+    pub fn new(
+        settings: ConnSettings,
+        conns: Arc<Mutex<HashSet<dbus::Path<'static>>>>,
+    ) -> Result<(Self, mpsc::Receiver<DbusAction>), MethodErr> {
+        let proj_dir = directories::ProjectDirs::from("gs", "ur", "telepathy-padfoot")
+            .ok_or_else(MethodErr::no_arg)?;
+
+        let mut dbfile = async_std::path::PathBuf::new();
+        dbfile.push(proj_dir.data_local_dir().to_str().unwrap());
+
+        dbfile.push(settings.id());
+        dbfile.push("db.sqlite3");
+
+        let (q_s, q_r) = mpsc::channel::<DbusAction>();
+        let id = settings.id();
+
+        let ctx = Arc::new(
+            block_on(Context::new("telepathy-padfoot".to_string(), dbfile)).map_err(|e| {
+                println!(
+                    "Connection<{}>::new(): couldn't get delta context: {}",
+                    settings.id(),
+                    e
+                );
+                MethodErr::no_arg() // FIXME: better error handling
+            })?,
+        );
+
+        let e_ctx = ctx.clone();
+        let e_queue = q_s.clone();
+        thread::spawn(move || {
+            let emitter = e_ctx.get_event_emitter();
+            while let Some(e) = emitter.recv_sync() {
+                match e {
+                    Event::Info(msg) => println!("Connection<{}>: INFO: {}", id, msg),
+                    Event::Warning(msg) => println!("Connection<{}>: WARN : {}", id, msg),
+                    Event::Error(msg)
+                    | Event::ErrorNetwork(msg)
+                    | Event::ErrorSelfNotInGroup(msg) => {
+                        println!("Connection<{}>: ERR : {}", id, msg)
+                    }
+                    Event::ConfigureProgress(progress) => {
+                        println!("Connection<{}>: Configuration progress: {}", id, progress)
+                    }
+                    Event::ImapConnected(msg) | Event::SmtpConnected(msg) => {
+                        println!("Connection<{}>: Network: {}", id, msg);
+                    }
+                    Event::MsgsChanged { chat_id, msg_id } => {
+                        println!(
+                            "Connection<{}>: Messages changed for {}: {}",
+                            id, chat_id, msg_id
+                        );
+                        e_queue
+                            .send(DbusAction::IncomingMessage(chat_id, msg_id))
+                            .unwrap();
+                    }
+                    Event::IncomingMsg { chat_id, msg_id } => {
+                        println!(
+                            "Connection<{}>: Incoming message for {}: {}",
+                            id, chat_id, msg_id
+                        );
+                        e_queue
+                            .send(DbusAction::IncomingMessage(chat_id, msg_id))
+                            .unwrap();
+                    }
+
+                    /* Unhandled messages:
+                        SmtpMessageSent(String),
+                        ImapMessageDeleted(String),
+                        ImapFolderEmptied(String),
+                        NewBlobFile(String),
+                        DeletedBlobFile(String),
+                        MsgDelivered
+                        MsgFailed
+                        MsgRead
+                        ChatModified(ChatId),
+                        ContactsChanged(Option<u32>),
+                        LocationChanged(Option<u32>),
+                        ImexProgress(usize),
+                        ImexFileWritten(PathBuf),
+                        SecurejoinInviterProgress
+                        SecurejoinJoinerProgress
+                    */
+                    Event::ImapMessageMoved(_) | Event::ImapMessageDeleted(_) => {}
+                    _ => println!("Connection<{}>: unhandled event received: {:?}", id, e),
+                };
+            }
+        });
+
+        block_on(ctx.set_config(Config::Addr, Some(&settings.account)))
+            .map_err(|_e| MethodErr::no_arg())?;
+        block_on(ctx.set_config(Config::MailPw, Some(&settings.password)))
+            .map_err(|_e| MethodErr::no_arg())?;
+
+        if settings.bcc_self {
+            block_on(ctx.set_config(Config::BccSelf, Some(&"1")))
+                .map_err(|_e| MethodErr::no_arg())?;
+        } else {
+            block_on(ctx.set_config(Config::BccSelf, Some(&"0")))
+                .map_err(|_e| MethodErr::no_arg())?;
+        }
+
+        if !block_on(ctx.is_configured()) {
+            block_on(ctx.configure()).unwrap();
+        };
+
+        Ok((
+            Connection {
+                actq: q_s,
+                channels: Arc::new(RwLock::new(
+                    HashMap::<dbus::Path<'static>, Arc<Channel>>::new(),
+                )),
+                conns,
+                ctx,
+                settings,
+                state: Arc::new(RwLock::new(ConnState::Initial)),
+            },
+            q_r,
+        ))
+    }
+
+    // This should be run inside its own thread. It will signal via the channel
+    // once the main loop is ready
+    //
+    // FIXME: running several +process+ loops sure is convenient, but it also
+    // seems inefficient...
+    pub fn run(
+        self,
+        done_signal: mpsc::Sender<Option<MethodErr>>,
+        queue_receiver: mpsc::Receiver<DbusAction>,
+    ) {
+        let id = self.id();
+        let bus = self.bus();
+        let path = self.path();
+
+        let conns = self.conns.clone();
+        let chans = self.channels.clone();
+        let actq = self.actq.clone();
+        let ctx = self.ctx.clone();
+        let state = self.state.clone();
+        let tree = self.build_tree();
+
+        // Setup DBus connection
+        let mut c = match LocalConnection::new_session() {
+            Ok(c) => c,
+            Err(e) => {
+                println!("Failed to establish DBUS session for {}: {}", bus, e);
+                return; // Leave early
+            }
+        };
+
+        let tc = tree.clone();
+        c.start_receive(
+            dbus::message::MatchRule::new_method_call(),
+            Box::new(move |msg, c| {
+                let tree = tc.lock().unwrap();
+                if let Some(replies) = tree.handle(&msg) {
+                    for r in replies {
+                        let _ = c.send(r);
+                    }
+                }
+                true
+            }),
+        );
+
+        match c.request_name(bus.clone(), false, false, true) {
+            Ok(RequestNameReply::Exists) => {
+                println!("Another process is already registered on {}", bus);
+                done_signal.send(Some(MethodErr::no_arg())).unwrap();
+                return;
+            }
+            Err(e) => {
+                println!("Failed to register {}: {}", bus, e);
+                done_signal.send(Some(MethodErr::no_arg())).unwrap();
+                return;
+            }
+            _ => {
+                // All other responses we can get are a success. We are now on
+                // the message bus, so the caller can proceed
+                println!("{} listening on {}", c.unique_name(), bus);
+                done_signal.send(None).unwrap();
+            }
+        };
+
+        // Set up delta jobs last in case registering to DBUS fails
+        // "Borrowed" from https://github.com/deltachat/deltachat-core-rust/blob/master/examples/simple.rs
+        while *state.read().unwrap() != ConnState::Disconnected {
+            if let Err(e) = c.process(Duration::from_millis(100)) {
+                println!("Error processing: {}", e);
+
+                break;
+            };
+
+            // Spend a bit of time sending any outgoing messages - signals, mostly
+            while let Some(act) = queue_receiver.try_recv().ok() {
+                match act {
+                    DbusAction::Signal(msg) => {
+                        print!("*** Connection<{}>: Sending signal: {:?}...", id, msg);
+
+                        match c.send(msg) {
+                            Err(e) => println!("error! {:?}", e), // FIXME: handle error better?
+                            _ => println!("OK!"),
+                        }
+                    }
+                    DbusAction::NewChannel(channel) => {
+                        let chan_type = channel.chan_type();
+                        let handle_type = channel.handle_type();
+                        let handle = channel.handle();
+                        let chan_path = channel.path().clone();
+                        let chan_props = channel.chan_props();
+                        let rc_channel = Arc::new(channel);
+
+                        println!("*** Creating channel {}", chan_path);
+
+                        Arc::clone(&chans)
+                            .write()
+                            .unwrap()
+                            .insert(chan_path.clone(), rc_channel.clone());
+
+                        let t2 = tree.clone();
+                        let op = Channel::build_object_path(rc_channel);
+
+                        t2.lock().unwrap().insert(op);
+
+                        let requests_sig = telepathy::ConnectionInterfaceRequestsNewChannels {
+                            channels: vec![(chan_path.clone(), chan_props)],
+                        };
+
+                        let legacy_sig = telepathy::ConnectionNewChannel {
+                            object_path: chan_path.clone(),
+                            channel_type: chan_type,
+                            handle_type, // contact. FIXME: support other channel types
+                            handle,      // id of other contact
+                            // TODO: initiator needs to be tracked
+                            suppress_handler: false, // We'll need to start passing this
+                        };
+
+                        actq.send(DbusAction::Signal(requests_sig.to_emit_message(&path)))
+                            .unwrap();
+                        actq.send(DbusAction::Signal(legacy_sig.to_emit_message(&path)))
+                            .unwrap();
+                    }
+                    DbusAction::CloseChannel(chan_path) => {
+                        println!("*** Closing channel {}", chan_path.clone());
+                        let _chan = Arc::clone(&chans).write().unwrap().remove(&chan_path);
+                        let t2 = tree.clone();
+                        t2.lock().unwrap().remove(&chan_path);
+
+                        let requests_sig = telepathy::ConnectionInterfaceRequestsChannelClosed {
+                            removed: chan_path.clone(),
+                        };
+
+                        let legacy_sig = telepathy::ChannelClosed {};
+
+                        actq.send(DbusAction::Signal(requests_sig.to_emit_message(&path)))
+                            .unwrap();
+                        actq.send(DbusAction::Signal(legacy_sig.to_emit_message(&chan_path)))
+                            .unwrap();
+                    }
+                    DbusAction::IncomingMessage(chat_id, msg_id) => {
+                        println!("*** Incoming message: {} {}", chat_id, msg_id);
+                        // TODO: check if we have a channel for the chat
+                        let chan_path = Connection::build_channel_path(path.clone(), chat_id);
+                        let c2 = Arc::clone(&chans);
+                        let chans = c2.read().unwrap();
+                        //let u_ctx = ctx.clone();
+                        let ctx = ctx.clone();
+                        let blobdir = ctx.get_blobdir();
+
+                        // Autocreate channel if it doesn't already exist
+                        // FIXME: unknown contacts need more care than this
+                        if !chans.contains_key(&chan_path) {
+                            print!("Channel for {} doesn't exist yet, creating it...", chat_id);
+
+                            let contacts = block_on(dc::chat::get_chat_contacts(&ctx, chat_id));
+                            if contacts.len() > 1 {
+                                println!("...{} contacts in chat, ignoring!", contacts.len());
+                                continue;
+                            }
+
+                            // FIXME: device-specific chat isn't really a self-chat
+                            let handle = contacts
+                                .first()
+                                .unwrap_or(&dc::constants::DC_CONTACT_ID_SELF);
+                            let chan = Channel::new(
+                                actq.clone(),
+                                chat_id,
+                                ctx.clone(),
+                                *handle, // initiator is the remote contact
+                                chan_path,
+                                false,   // FIXME: this needs to handle requested channels
+                                *handle, // target is always the other party
+                            );
+                            actq.send(DbusAction::NewChannel(chan)).unwrap();
+                            actq.send(act).unwrap();
+
+                            println!("OK");
+                            continue;
+                        }
+
+                        // Since the channel exists, emit new message signals
+                        print!("Message {} received for {}...", msg_id, chan_path);
+
+                        let msg = match block_on(dc::message::Message::load_from_db(&ctx, msg_id)) {
+                            Ok(m) => m,
+                            Err(e) => {
+                                println!("Can't load from database, skipping: {}", e);
+                                continue;
+                            }
+                        };
+
+                        // Ignore messages that are self-originated.
+                        // FIXME: special-case self-chats
+                        if msg.get_from_id() == dc::constants::DC_CONTACT_ID_SELF
+                            && !msg.is_setupmessage()
+                        {
+                            println!("from ourselves, skipping");
+                            continue;
+                        }
+
+                        let parts = convert_msg(blobdir, &msg);
+                        if parts.is_err() {
+                            println!("can't convert, skipping: {}", parts.unwrap_err());
+                            continue;
+                        }
+
+                        let sig = telepathy::ChannelInterfaceMessagesMessageReceived {
+                            message: parts.unwrap(),
+                        }
+                        .to_emit_message(&chan_path);
+
+                        actq.send(DbusAction::Signal(sig)).unwrap();
+
+                        // FIXME: We MUST also send a Text.Received signal
+
+                        println!("OK!");
+                    }
+
+                    DbusAction::FreshMessages => {
+                        println!("*** FRESH MESSAGES");
+                        let ctx = ctx.clone();
+
+                        for msg_id in block_on(dc::context::Context::get_fresh_msgs(&ctx)) {
+                            println!("    FRESH MESSAGE: {}", msg_id);
+                            match block_on(dc::message::Message::load_from_db(&ctx, msg_id)) {
+                                Ok(msg) => {
+                                    actq.send(DbusAction::IncomingMessage(
+                                        msg.get_chat_id(),
+                                        msg_id,
+                                    ))
+                                    .unwrap();
+                                }
+                                Err(e) => println!("Couldn't load fresh message {}: {}", msg_id, e),
+                            }
+                        }
+                    }
+                }
+            }
+        }
+
+        // TODO: join on threads started in connect!
+
+        let mut conns = conns.lock().expect("Mutex access");
+        conns.remove(&path);
+    }
+
+    pub fn id(&self) -> String {
+        self.settings.id.to_string()
+    }
+
+    pub fn bus(&self) -> String {
+        self.settings.bus()
+    }
+
+    pub fn path(&self) -> dbus::Path<'static> {
+        self.settings.path()
+    }
+
+    fn build_channel_path(
+        path: dbus::Path<'static>,
+        chat_id: dc::chat::ChatId,
+    ) -> dbus::strings::Path<'static> {
+        let path = format!("{}/{}", path, chat_id.to_u32());
+
+        dbus::strings::Path::new(path).expect("Must be valid")
+    }
+
+    fn build_tree(self) -> Arc<Mutex<dbus::tree::Tree<dbus::tree::MTFn, ()>>> {
+        let path = self.path();
+        let c_rc = std::rc::Rc::new(self);
+        let f = dbus::tree::Factory::new_fn::<()>();
+        let mut tree = f.tree(());
+
+        let c_rc1 = c_rc.clone();
+        let conn_iface = telepathy::connection_server(&f, (), move |_| c_rc1.clone());
+
+        let c_rc2 = c_rc.clone();
+        let avatars_iface =
+            telepathy::connection_interface_avatars_server(&f, (), move |_| c_rc2.clone());
+
+        let c_rc3 = c_rc.clone();
+        let contacts_iface =
+            telepathy::connection_interface_contacts_server(&f, (), move |_| c_rc3.clone());
+
+        let _c_rc4 = c_rc.clone();
+        let contact_list_iface =
+            telepathy::connection_interface_contact_list_server(&f, (), move |_| _c_rc4.clone());
+
+        let c_rc5 = c_rc.clone();
+        let requests_iface =
+            telepathy::connection_interface_requests_server(&f, (), move |_| c_rc5.clone());
+
+        let simple_presence_iface =
+            telepathy::connection_interface_simple_presence_server(&f, (), move |_| c_rc.clone());
+
+        tree = tree.add(
+            f.object_path(path, ())
+                .introspectable()
+                .add(conn_iface)
+                .add(avatars_iface)
+                .add(contacts_iface)
+                .add(contact_list_iface)
+                .add(requests_iface)
+                .add(simple_presence_iface),
+        );
+        tree = tree.add(f.object_path("/", ()).introspectable());
+
+        Arc::new(Mutex::new(tree))
+    }
+}
--- a/src/padfoot/connection/avatars.rs
+++ b/src/padfoot/connection/avatars.rs
@@ -0,0 +1,107 @@
+use crate::telepathy;
+
+use dbus::tree::MethodErr;
+use std::collections::HashMap;
+
+use super::Connection;
+
+impl AsRef<dyn telepathy::ConnectionInterfaceAvatars + 'static> for std::rc::Rc<Connection> {
+    fn as_ref(&self) -> &(dyn telepathy::ConnectionInterfaceAvatars + 'static) {
+        &**self
+    }
+}
+
+type AvatarRequirementSpec = (Vec<String>, u16, u16, u16, u16, u32);
+
+// TODO: come back and do this properly, I'm just putting it in for consistency
+impl telepathy::ConnectionInterfaceAvatars for Connection {
+    fn get_avatar_requirements(&self) -> Result<AvatarRequirementSpec, MethodErr> {
+        println!("Connection<{}>::get_avatar_requirements()", self.id());
+        Ok((vec![], 0, 0, 0, 0, 0))
+    }
+
+    fn get_avatar_tokens(&self, contacts: Vec<u32>) -> Result<Vec<String>, MethodErr> {
+        println!(
+            "Connection<{}>::get_avatar_tokens({:?})",
+            self.id(),
+            contacts
+        );
+        Ok(vec![])
+    }
+
+    fn get_known_avatar_tokens(
+        &self,
+        contacts: Vec<u32>,
+    ) -> Result<::std::collections::HashMap<u32, String>, MethodErr> {
+        println!(
+            "Connection<{}>::get_known_avatar_tokens({:?})",
+            self.id(),
+            contacts
+        );
+        Ok(HashMap::<u32, String>::new())
+    }
+
+    fn request_avatar(&self, contact: u32) -> Result<(Vec<u8>, String), MethodErr> {
+        println!("Connection<{}>::request_avatar({})", self.id(), contact);
+        Ok((vec![], "".to_string()))
+    }
+
+    fn request_avatars(&self, contacts: Vec<u32>) -> Result<(), MethodErr> {
+        println!("Connection<{}>::request_avatar({:?})", self.id(), contacts);
+        Ok(())
+    }
+
+    fn set_avatar(&self, _avatar: Vec<u8>, mimetype: &str) -> Result<String, MethodErr> {
+        println!(
+            "Connection<{}>::set_avatar((data), {:?})",
+            self.id(),
+            mimetype
+        );
+        Ok("".to_string())
+    }
+
+    fn clear_avatar(&self) -> Result<(), MethodErr> {
+        println!("Connection<{}>::clear_avatar()", self.id());
+        Ok(())
+    }
+
+    fn supported_avatar_mimetypes(&self) -> Result<Vec<String>, MethodErr> {
+        println!("Connection<{}>::supported_avatar_mimetypes()", self.id());
+        Ok(vec![])
+    }
+
+    fn minimum_avatar_height(&self) -> Result<u32, MethodErr> {
+        println!("Connection<{}>::minimum_avatar_height()", self.id());
+        Ok(0)
+    }
+
+    fn minimum_avatar_width(&self) -> Result<u32, MethodErr> {
+        println!("Connection<{}>::minimum_avatar_width()", self.id());
+        Ok(0)
+    }
+
+    fn recommended_avatar_height(&self) -> Result<u32, MethodErr> {
+        println!("Connection<{}>::recommended_avatar_height()", self.id());
+        Ok(0)
+    }
+
+    fn recommended_avatar_width(&self) -> Result<u32, MethodErr> {
+        println!("Connection<{}>::recommended_avatar_width()", self.id());
+        Ok(0)
+    }
+
+    fn maximum_avatar_height(&self) -> Result<u32, MethodErr> {
+        println!("Connection<{}>::maximum_avatar_height()", self.id());
+        Ok(0)
+    }
+
+    fn maximum_avatar_width(&self) -> Result<u32, MethodErr> {
+        println!("Connection<{}>::maximum_avatar_width()", self.id());
+        Ok(0)
+    }
+
+    fn maximum_avatar_bytes(&self) -> Result<u32, MethodErr> {
+        println!("Connection<{}>::maximum_avatar_bytes()", self.id());
+        Ok(0)
+    }
+}
--- a/src/padfoot/connection/connection.rs
+++ b/src/padfoot/connection/connection.rs
@@ -0,0 +1,354 @@
+use crate::telepathy;
+use crate::telepathy::{ConnectionInterfaceContacts, ConnectionInterfaceRequests}; // Non-deprecated channel methods
+
+use async_std::task::block_on;
+use dbus::message::SignalArgs;
+use dbus::tree::MethodErr;
+use dc::contact::Contact;
+use deltachat as dc;
+
+use std::collections::HashMap;
+use std::convert::TryInto;
+use std::thread;
+
+use super::{Connection, DbusAction};
+
+#[derive(Debug, PartialEq, Eq)]
+pub enum ConnState {
+    Initial,
+    Connected,
+    Disconnected,
+}
+
+type Result<T> = std::result::Result<T, dbus::tree::MethodErr>;
+
+// Deprecated channel information. Replaced by Requests.ChannelSpec
+type ChannelInfo = (
+    dbus::Path<'static>, // Object path
+    String,              // Channel type
+    u32,                 // Handle type
+    u32,                 // Handle
+);
+
+type ContactSubscription = (
+    u32,    // Subscribe state
+    u32,    // Publish state
+    String, // Publish-request message
+);
+
+pub fn connection_interfaces() -> Vec<String> {
+    vec![
+        "org.freedesktop.Telepathy.Connection".to_string(),
+        "org.freedesktop.Telepathy.Connection.Interface.Avatars".to_string(),
+        "org.freedesktop.Telepathy.Connection.Interface.Contacts".to_string(),
+        "org.freedesktop.Telepathy.Connection.Interface.ContactList".to_string(),
+        "org.freedesktop.Telepathy.Connection.Interface.Requests".to_string(),
+        "org.freedesktop.Telepathy.Connection.Interface.SimplePresence".to_string(),
+    ]
+}
+
+impl AsRef<dyn telepathy::Connection + 'static> for std::rc::Rc<Connection> {
+    fn as_ref(&self) -> &(dyn telepathy::Connection + 'static) {
+        &**self
+    }
+}
+
+impl telepathy::Connection for Connection {
+    // In connect(), we start the threads that drive the deltachat context
+    fn connect(&self) -> Result<()> {
+        println!("Connection<{}>::connect()", self.id());
+
+        let io_ctx = self.ctx.clone();
+        let io_id = self.id();
+        let _io_thread = thread::spawn(move || {
+            block_on(io_ctx.start_io());
+
+            println!("Connection<{}>::connect(): I/O thread exited", io_id);
+        });
+
+        // Just pretend to be connected all the time for now. Tracking IMAP+SMTP
+        // state is a pain
+        let state = self.state.clone();
+        let mut w = state.write().unwrap();
+        *w = ConnState::Connected;
+        let ctx = self.ctx.clone();
+
+        // Emit a StatusChanged signal for the benefit of others, but the caller
+        // learns from our RPC response
+        let connected_sig = telepathy::ConnectionStatusChanged {
+            status: 0, // Connected
+            reason: 1, // Requested
+        }
+        .to_emit_message(&self.path());
+
+        self.actq.send(DbusAction::Signal(connected_sig)).unwrap();
+        self.actq.send(DbusAction::FreshMessages).unwrap();
+
+        // If we can, emit signals on connect about the contact list
+        if let Ok(handles) = block_on(Contact::get_all(
+            &ctx,
+            (dc::constants::DC_GCL_ADD_SELF as usize)
+                .try_into()
+                .unwrap(),
+            None::<String>,
+        )) {
+            println!("    HANDLES: {:?}", handles);
+            let mut changes = HashMap::<u32, ContactSubscription>::new();
+            for handle in handles {
+                println!("    *** Handle: {}", handle);
+                changes.insert(handle, (4, 4, "".to_string())); // FIXME: hardcoded lies
+            }
+
+            // TODO: the old signal is deprecated. The new signal requires us to
+            // send identifiers with it, which is a bit of a lookup here.
+            // let cl_sig_new = telepathy::ConnectionInterfaceContactsChangedWithID {
+            // }.to_emit_message(&self.path());
+
+            let cl_sig_old = telepathy::ConnectionInterfaceContactListContactsChanged {
+                changes,
+                removals: Vec::new(),
+            }
+            .to_emit_message(&self.path());
+
+            // self.actq.send(DbusAction::Signal(cl_sig_new)).unwrap();
+            self.actq.send(DbusAction::Signal(cl_sig_old)).unwrap();
+        };
+
+        Ok(())
+    }
+
+    fn disconnect(&self) -> Result<()> {
+        println!("Connection<{}>::disconnect()", self.id());
+        block_on(self.ctx.stop_io());
+
+        let state = self.state.clone();
+        let mut w = state.write().unwrap();
+        *w = ConnState::Disconnected;
+
+        // FIXME: we need to signal to the CM that they should remove the
+        // connection from the active list
+
+        Ok(())
+    }
+
+    fn interfaces(&self) -> Result<Vec<String>> {
+        println!("Connection<{}>::interfaces()", self.id());
+
+        self.get_interfaces()
+    }
+
+    fn get_interfaces(&self) -> Result<Vec<String>> {
+        println!("Connection<{}>::get_interfaces()", self.id());
+
+        Ok(connection_interfaces())
+    }
+
+    fn get_protocol(&self) -> Result<String> {
+        println!("Connection<{}>::get_protocol()", self.id());
+
+        Ok(crate::padfoot::PROTO_NAME.to_string())
+    }
+
+    fn self_handle(&self) -> Result<u32> {
+        println!("Connection<{}>::self_handle()", self.id());
+
+        Ok(dc::constants::DC_CONTACT_ID_SELF)
+    }
+
+    // Deprecated in favour of the self_handle DBUS property
+    fn get_self_handle(&self) -> Result<u32> {
+        println!("Connection<{}>::get_self_handle()", self.id());
+
+        self.self_handle()
+    }
+
+    fn status(&self) -> Result<u32> {
+        println!("Connection<{}>::status()", self.id());
+
+        self.get_status()
+    }
+
+    fn get_status(&self) -> Result<u32> {
+        match *self.state.clone().read().unwrap() {
+            ConnState::Initial | ConnState::Disconnected => Ok(2),
+            ConnState::Connected => Ok(0),
+        }
+    }
+
+    fn hold_handles(&self, handle_type: u32, handles: Vec<u32>) -> Result<()> {
+        println!(
+            "Connection<{}>::hold_handles({}, {:?})",
+            self.id(),
+            handle_type,
+            handles
+        );
+
+        // Since HasImmortalHandles is true, this doesn't need to do anything
+        Ok(())
+    }
+
+    fn inspect_handles(&self, handle_type: u32, handles: Vec<u32>) -> Result<Vec<String>> {
+        println!(
+            "Connection<{}>::inspect_handles({}, {:?})",
+            self.id(),
+            handle_type,
+            handles
+        );
+        match handle_type {
+            crate::padfoot::HANDLE_TYPE_CONTACT => {
+                let mut out = Vec::<String>::new();
+                for (_handle, attrs) in self.get_contact_attributes(handles, vec![], true)? {
+                    if let Some(contact_id) =
+                        attrs.get("org.freedesktop.Telepathy.Connection/contact-id")
+                    {
+                        out.push(contact_id.0.as_str().unwrap().to_string());
+                    } else {
+                        return Err(MethodErr::no_arg()); // FIXME: should be InvalidHandle
+                    }
+                }
+                Ok(out)
+            }
+            _ => Err(MethodErr::no_arg()), // FIXME: should be NotImplemented?
+        }
+    }
+
+    // Deprecated in favour of Requests.Channels
+    fn list_channels(&self) -> Result<Vec<ChannelInfo>> {
+        println!("Connection<{}>::list_channels()", self.id());
+
+        let data = self.channels()?;
+        let mut out = Vec::<ChannelInfo>::new();
+
+        for (path, _props) in data {
+            // FIXME: pull correct details from the properties hash
+            out.push((
+                path,
+                "org.freedesktop.Telepathy.Channel.Type.Text".to_string(),
+                0,
+                0,
+            ))
+        }
+
+        Ok(out)
+    }
+
+    fn release_handles(&self, handle_type: u32, handles: Vec<u32>) -> Result<()> {
+        println!(
+            "Connection<{}>::release_handles({}, {:?})",
+            self.id(),
+            handle_type,
+            handles
+        );
+
+        // Since HasImmortalHandles is true, we don't need to do anything
+        Ok(())
+    }
+
+    // RequestChannel is deprecated in favour of the Requests interface.
+    fn request_channel(
+        &self,
+        channel_type: &str,
+        handle_type: u32,
+        handle: u32,
+        suppress_handler: bool,
+    ) -> Result<dbus::Path<'static>> {
+        println!(
+            "Connection<{}>::request_channel({}, {}, {}, {})",
+            self.id(),
+            channel_type,
+            handle_type,
+            handle,
+            suppress_handler
+        );
+
+        Err(MethodErr::no_arg()) // FIXME: should be NotImplemented?
+    }
+
+    fn request_handles(&self, handle_type: u32, identifiers: Vec<&str>) -> Result<Vec<u32>> {
+        println!(
+            "Connection<{}>::request_handles({}, {:?})",
+            self.id(),
+            handle_type,
+            identifiers
+        );
+
+        match handle_type {
+            crate::padfoot::HANDLE_TYPE_CONTACT => {
+                let ctx = &self.ctx;
+                let mut out = Vec::<u32>::new();
+
+                // Identifiers is a list of email addresses. These can be
+                // contact IDs, although we may have to create contacts to get
+                // the ID.
+                //
+                // FIXME: will it be faster to get all and filter?
+
+                for addr in identifiers {
+                    let id = block_on(Contact::lookup_id_by_addr(
+                        ctx,
+                        addr,
+                        dc::contact::Origin::Unknown,
+                    ));
+                    match id {
+                        0 => {
+                            // No contact exists for this address yet. Try to
+                            // add one so we can have an ID.
+                            match block_on(Contact::create(ctx, &addr, &addr)) {
+                                Ok(new_id) => out.push(new_id),
+                                Err(e) => {
+                                    println!("Failed to add contact {}: {}", addr, e);
+                                    return Err(MethodErr::no_arg());
+                                }
+                            }
+                        }
+                        _ => out.push(id),
+                    }
+                }
+
+                Ok(out)
+            }
+            _ => Err(MethodErr::no_arg()), // FIXME: should be NotImplemented?
+        }
+    }
+
+    fn add_client_interest(&self, tokens: Vec<&str>) -> Result<()> {
+        println!(
+            "Connection<{}>::add_client_interest({:?})",
+            self.id(),
+            tokens
+        );
+        Err(MethodErr::no_arg()) // FIXME: should be NotImplemented?
+    }
+
+    fn remove_client_interest(&self, tokens: Vec<&str>) -> Result<()> {
+        println!(
+            "Connection<{}>::remove_client_interest({:?})",
+            self.id(),
+            tokens
+        );
+        Err(MethodErr::no_arg()) // FIXME: should be NotImplemented?
+    }
+
+    fn self_id(&self) -> Result<String> {
+        println!("Connection<{}>::self_id()", self.id());
+
+        let contact = match block_on(dc::contact::Contact::get_by_id(
+            &self.ctx,
+            dc::constants::DC_CONTACT_ID_SELF,
+        )) {
+            Ok(c) => c,
+            Err(e) => {
+                println!("    err: {}", e);
+                return Err(MethodErr::no_arg());
+            }
+        };
+
+        Ok(contact.get_addr().to_string())
+    }
+
+    fn has_immortal_handles(&self) -> Result<bool> {
+        println!("Connection<{}>::has_immortal_handles()", self.id());
+
+        Ok(true)
+    }
+}
--- a/src/padfoot/connection/contact_list.rs
+++ b/src/padfoot/connection/contact_list.rs
@@ -0,0 +1,129 @@
+use crate::padfoot::VarArg;
+use crate::telepathy;
+
+use async_std::task::block_on;
+use dbus::tree::MethodErr;
+use dc::constants::DC_GCL_ADD_SELF;
+use dc::contact::Contact;
+use deltachat as dc;
+use std::collections::HashMap;
+use std::convert::TryInto;
+use telepathy::ConnectionInterfaceContacts; // for get_contact_attributes
+
+use super::Connection;
+
+impl AsRef<dyn telepathy::ConnectionInterfaceContactList + 'static> for std::rc::Rc<Connection> {
+    fn as_ref(&self) -> &(dyn telepathy::ConnectionInterfaceContactList + 'static) {
+        &**self
+    }
+}
+
+// FIXME: come back and do this properly later
+impl telepathy::ConnectionInterfaceContactList for Connection {
+    fn get_contact_list_attributes(
+        &self,
+        interfaces: Vec<&str>,
+        hold: bool,
+    ) -> Result<HashMap<u32, HashMap<String, VarArg>>, MethodErr> {
+        println!(
+            "Connection<{}>::get_contact_list_attributes({:?}, {})",
+            self.id(),
+            interfaces,
+            hold
+        );
+
+        let ids = match block_on(Contact::get_all(
+            &self.ctx,
+            DC_GCL_ADD_SELF.try_into().unwrap(),
+            None::<String>,
+        )) {
+            Ok(c) => c,
+            Err(e) => {
+                println!("    err: {}", e);
+                return Err(MethodErr::no_arg());
+            }
+        };
+
+        // FIXME: swap implementations so Contacts depends on ContactList?
+        self.get_contact_attributes(ids, vec![], true)
+    }
+
+    fn request_subscription(&self, contacts: Vec<u32>, message: &str) -> Result<(), MethodErr> {
+        println!(
+            "Connection<{}>::request_subscription({:?}, {})",
+            self.id(),
+            contacts,
+            message
+        );
+        Ok(())
+    }
+
+    fn authorize_publication(&self, contacts: Vec<u32>) -> Result<(), MethodErr> {
+        println!(
+            "Connection<{}>::authorize_publication({:?})",
+            self.id(),
+            contacts
+        );
+        Ok(())
+    }
+    fn remove_contacts(&self, contacts: Vec<u32>) -> Result<(), MethodErr> {
+        println!("Connection<{}>::remove_contacts({:?})", self.id(), contacts);
+
+        for contact_id in contacts {
+            // FIXME: don't ignore errors
+            if let Err(e) = block_on(Contact::delete(&self.ctx, contact_id)) {
+                println!("    Deleting contact {} failed: {}", contact_id, e);
+            }
+        }
+
+        // FIXME: signals MUST be emitted before this method returns
+        // FIXME: emitting signals at all would be great
+
+        Ok(())
+    }
+    fn unsubscribe(&self, contacts: Vec<u32>) -> Result<(), MethodErr> {
+        println!("Connection<{}>::unsubscribe({:?})", self.id(), contacts);
+        Ok(())
+    }
+
+    fn unpublish(&self, contacts: Vec<u32>) -> Result<(), MethodErr> {
+        println!("Connection<{}>::unpublish({:?})", self.id(), contacts);
+        Ok(())
+    }
+
+    fn download(&self) -> Result<(), MethodErr> {
+        println!("Connection<{}>::download()", self.id());
+
+        // This can be a no-op since we store the contacts list in delta's DB
+        Ok(())
+    }
+
+    fn contact_list_state(&self) -> Result<u32, MethodErr> {
+        println!("Connection<{}>::contact_list_state()", self.id());
+        Ok(3) // Success
+    }
+
+    fn contact_list_persists(&self) -> Result<bool, MethodErr> {
+        println!("Connection<{}>::contact_list_persists()", self.id());
+        Ok(true)
+    }
+
+    fn can_change_contact_list(&self) -> Result<bool, MethodErr> {
+        println!("Connection<{}>::can_change_contact_list()", self.id());
+        Ok(true)
+    }
+    fn request_uses_message(&self) -> Result<bool, MethodErr> {
+        println!("Connection<{}>::request_uses_message()", self.id());
+        Ok(false)
+    }
+
+    fn download_at_connection(&self) -> Result<bool, MethodErr> {
+        println!("Connection<{}>::download_at_connection()", self.id());
+
+        // TODO: https://telepathy.freedesktop.org/spec/Connection_Interface_Contact_List.html#Property:DownloadAtConnection
+        // Connections ... SHOULD provide a corresponding parameter named
+        // org.freedesktop.Telepathy.Connection.Interface.ContactList.DownloadAtConnection
+        // with the DBus_Property flag
+        Ok(true)
+    }
+}
--- a/src/padfoot/connection/contacts.rs
+++ b/src/padfoot/connection/contacts.rs
@@ -0,0 +1,108 @@
+use crate::padfoot::{var_str, var_u32, VarArg};
+use crate::telepathy;
+
+use async_std::task::block_on;
+use dbus::tree::MethodErr;
+use deltachat::contact::{Contact, Origin};
+use std::collections::HashMap;
+
+use super::Connection;
+
+impl AsRef<dyn telepathy::ConnectionInterfaceContacts + 'static> for std::rc::Rc<Connection> {
+    fn as_ref(&self) -> &(dyn telepathy::ConnectionInterfaceContacts + 'static) {
+        &**self
+    }
+}
+
+impl telepathy::ConnectionInterfaceContacts for Connection {
+    fn get_contact_attributes(
+        &self,
+        handles: Vec<u32>,
+        interfaces: Vec<&str>,
+        hold: bool,
+    ) -> Result<HashMap<u32, HashMap<String, VarArg>>, MethodErr> {
+        println!(
+            "Connection<{}>::get_contact_attributes({:?}, {:?}, {})",
+            self.id(),
+            handles,
+            interfaces,
+            hold
+        );
+
+        let mut out = HashMap::<u32, HashMap<String, VarArg>>::new();
+        for id in handles.iter() {
+            // FIXME: work out how to use get_all
+            let contact = match block_on(Contact::get_by_id(&self.ctx, *id)) {
+                Ok(c) => c,
+                Err(_e) => continue, // Invalid IDs are silently ignored
+            };
+
+            let mut props = HashMap::<String, VarArg>::new();
+            // This is mandatory
+            props.insert(
+                "org.freedesktop.Telepathy.Connection/contact-id".to_string(),
+                var_str(contact.get_addr().to_string()),
+            );
+
+            // The empty string means "no avatar"
+            props.insert(
+                "org.freedesktop.Telepathy.Connection.Interface.Avatars/token".to_string(),
+                var_str("".to_string()),
+            );
+
+            props.insert(
+                "org.freedesktop.Telepathy.Connection.Interface.ContactList/publish".to_string(),
+                var_u32(4), // YES (faking it for now)
+            );
+
+            props.insert(
+                "org.freedesktop.Telepathy.Connection.Interface.ContactList/subscribe".to_string(),
+                var_u32(4), // YES (faking it for now)
+            );
+
+            out.insert(*id, props);
+        }
+
+        Ok(out)
+    }
+
+    fn get_contact_by_id(
+        &self,
+        identifier: &str,
+        interfaces: Vec<&str>,
+    ) -> Result<(u32, HashMap<String, VarArg>), MethodErr> {
+        println!(
+            "Connection<{}>::get_contact_by_id({}, {:?})",
+            self.id(),
+            identifier,
+            interfaces
+        );
+
+        let id = block_on(Contact::lookup_id_by_addr(
+            &self.ctx,
+            identifier,
+            Origin::Unknown,
+        ));
+
+        if id == 0 {
+            return Err(MethodErr::no_arg()); // FIXME: should be InvalidHandle
+        };
+
+        let mut contacts = self.get_contact_attributes(vec![id], interfaces, true)?;
+        if let Some(contact) = contacts.remove(&id) {
+            Ok((id, contact))
+        } else {
+            Err(MethodErr::no_arg()) // FIXME: should be InvalidHandle
+        }
+    }
+
+    fn contact_attribute_interfaces(&self) -> Result<Vec<String>, MethodErr> {
+        println!("Connection<{}>::contact_attribute_interfaces()", self.id());
+
+        Ok(vec![
+            "org.freedesktop.Telepathy.Connection".to_string(),
+            "org.freedesktop.Telepathy.Connection.Interface.Avatars".to_string(),
+            "org.freedesktop.Telepathy.Connection.Interface.ContactList".to_string(),
+        ])
+    }
+}
--- a/src/padfoot/connection/escape.rs
+++ b/src/padfoot/connection/escape.rs
@@ -0,0 +1,52 @@
+fn escape_one(b: u8) -> String {
+    format!("_{:0<2x}", b)
+}
+
+// Some non-empty sequence of ASCII letters, digits and underscores
+pub fn escape(s: String) -> String {
+    // Special-case the empty string
+    if s.is_empty() {
+        return "_".to_string();
+    }
+
+    let bytes = s.into_bytes();
+    let mut iter = bytes.iter();
+    let mut out = String::new();
+
+    // Only alphanumeric in the first byte
+    let x = *iter.next().expect("Already checked len > 0");
+    let first = match x {
+        b'a'..=b'z' | b'A'..=b'Z' => unsafe { String::from_utf8_unchecked(vec![x]) },
+        _ => escape_one(x),
+    };
+
+    out.push_str(&first);
+
+    for x in iter {
+        let next = match x {
+            b'a'..=b'z' | b'A'..=b'Z' | b'0'..=b'9' => unsafe {
+                String::from_utf8_unchecked(vec![*x])
+            },
+            _ => escape_one(*x),
+        };
+
+        out.push_str(&next);
+    }
+
+    out
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_escape() {
+        assert_eq!(escape("".to_string()), "_");
+        assert_eq!(escape("foo".to_string()), "foo");
+        assert_eq!(escape("foo@bar".to_string()), "foo_40bar");
+        assert_eq!(escape("foo_bar".to_string()), "foo_5fbar");
+        assert_eq!(escape("foo__@__bar".to_string()), "foo_5f_5f_40_5f_5fbar");
+        assert_eq!(escape("1foo".to_string()), "_31foo");
+    }
+}
--- a/src/padfoot/connection/requests.rs
+++ b/src/padfoot/connection/requests.rs
@@ -0,0 +1,137 @@
+use crate::padfoot::{get_var_str, get_var_u32, requestables, Channel, DbusAction, VarArg};
+use crate::telepathy;
+
+use async_std::task::block_on;
+use dbus::tree::MethodErr;
+use dc::contact::Contact;
+use deltachat as dc;
+
+use std::collections::HashMap;
+
+use super::Connection;
+
+type ChannelSpec = (
+    dbus::Path<'static>,     // Object path on this connection
+    HashMap<String, VarArg>, // Map of channel property -> value
+);
+
+type RequestableChannelSpec = (HashMap<String, VarArg>, Vec<String>);
+
+type Result<T> = std::result::Result<T, MethodErr>;
+
+impl AsRef<dyn telepathy::ConnectionInterfaceRequests + 'static> for std::rc::Rc<Connection> {
+    fn as_ref(&self) -> &(dyn telepathy::ConnectionInterfaceRequests + 'static) {
+        &**self
+    }
+}
+
+impl telepathy::ConnectionInterfaceRequests for Connection {
+    fn create_channel(
+        &self,
+        request: HashMap<&str, VarArg>,
+    ) -> Result<(dbus::Path<'static>, HashMap<String, VarArg>)> {
+        println!("Connection<{}>::create_channel({:?})", self.id(), request);
+
+        Err(MethodErr::no_arg()) // FIXME: should be NotImplemented?
+    }
+
+    fn ensure_channel(
+        &self,
+        request: HashMap<&str, VarArg>,
+    ) -> Result<(bool, dbus::Path<'static>, HashMap<String, VarArg>)> {
+        let path = self.path().clone();
+        println!("Connection<{}>::ensure_channel({:?})", self.id(), request);
+
+        // Empathy sends this for the request:
+        //
+        // {
+        //   "org.freedesktop.Telepathy.Channel.TargetID": Variant("me@example.com"),
+        //   "org.freedesktop.Telepathy.Channel.TargetHandleType": Variant(1),
+        //   "org.freedesktop.Telepathy.Channel.ChannelType": Variant("org.freedesktop.Telepathy.Channel.Type.Text")
+        // }
+
+        // FIXME: life would be easier with TargetHandle
+        let target_id = request
+            .get("org.freedesktop.Telepathy.Channel.TargetID")
+            .map(|va| get_var_str(va))
+            .unwrap();
+
+        let target_handle_type = request
+            .get("org.freedesktop.Telepathy.Channel.TargetHandleType")
+            .map(|va| get_var_u32(va))
+            .unwrap();
+
+        let channel_type = request
+            .get("org.freedesktop.Telepathy.Channel.ChannelType")
+            .map(|va| get_var_str(va))
+            .unwrap();
+
+        // Text only
+        if channel_type != "org.freedesktop.Telepathy.Channel.Type.Text" {
+            println!("    Wrong channel type: {:?}", channel_type);
+            return Err(MethodErr::no_arg());
+        };
+
+        // IMs only
+        if target_handle_type != 1 {
+            println!("    Wrong target handle type: {:?}", target_handle_type);
+            return Err(MethodErr::no_arg());
+        };
+
+        let target_handle = block_on(Contact::lookup_id_by_addr(
+            &self.ctx,
+            target_id.clone(),
+            dc::contact::Origin::Unknown,
+        ));
+        if target_handle == 0 {
+            println!("Couldn't find target handle for {}", target_id);
+            return Err(MethodErr::no_arg());
+        };
+
+        let chat_id = dc::chat::ChatId::new(target_handle);
+        let channel_path = Connection::build_channel_path(path, chat_id);
+
+        // Return an existing channel if it already exists
+        let chans = self.channels.read().unwrap();
+        if let Some(channel) = chans.get(&channel_path) {
+            return Ok((false, channel_path, channel.chan_props()));
+        }
+
+        // Now we need to discover or create a chat id for the contact
+        let chat_id = block_on(dc::chat::create_by_contact_id(&self.ctx, target_handle)).unwrap();
+        let channel = Channel::new(
+            self.actq.clone(),
+            chat_id,
+            self.ctx.clone(),
+            dc::constants::DC_CONTACT_ID_SELF, // initiator is self in this case
+            channel_path.clone(),
+            true, // requested
+            target_handle,
+        );
+        let response = channel.chan_props(); // FIXME: fill with data about the channel
+
+        // Send signal
+        self.actq.send(DbusAction::NewChannel(channel)).unwrap();
+
+        Ok((true, channel_path, response))
+    }
+
+    fn channels(&self) -> Result<Vec<ChannelSpec>> {
+        println!("Connection<{}>::channels()", self.id());
+
+        let mut out = Vec::<ChannelSpec>::new();
+        for channel in self.channels.read().unwrap().values() {
+            out.push((
+                channel.path(),
+                HashMap::<String, VarArg>::new(), // FIXME: work out what props should be shown
+            ));
+        }
+
+        Ok(out)
+    }
+
+    fn requestable_channel_classes(&self) -> Result<Vec<RequestableChannelSpec>> {
+        println!("Connection<{}>::requestable_channel_classes()", self.id());
+        Ok(requestables())
+    }
+}
--- a/src/padfoot/connection/simple_presence.rs
+++ b/src/padfoot/connection/simple_presence.rs
@@ -0,0 +1,60 @@
+use crate::padfoot::{statuses, SimpleStatusSpec};
+use crate::telepathy;
+
+use dbus::tree::MethodErr;
+use std::collections::HashMap;
+
+use super::Connection;
+
+pub type SimplePresenceSpec = (
+    u32,    // connection presence type
+    String, // status
+    String, // status message
+);
+
+impl AsRef<dyn telepathy::ConnectionInterfaceSimplePresence + 'static> for std::rc::Rc<Connection> {
+    fn as_ref(&self) -> &(dyn telepathy::ConnectionInterfaceSimplePresence + 'static) {
+        &**self
+    }
+}
+
+impl telepathy::ConnectionInterfaceSimplePresence for Connection {
+    fn set_presence(&self, status: &str, status_message: &str) -> Result<(), MethodErr> {
+        println!(
+            "Connection<{}>::set_presence({}, {:?})",
+            self.id(),
+            status,
+            status_message
+        );
+
+        // FIXME: emit a presence changed signal
+
+        Ok(())
+    }
+
+    fn get_presences(
+        &self,
+        contacts: Vec<u32>,
+    ) -> Result<HashMap<u32, SimplePresenceSpec>, MethodErr> {
+        println!("Connection<{}>::get_presences({:?})", self.id(), contacts);
+
+        let mut out = HashMap::<u32, SimplePresenceSpec>::new();
+
+        for id in contacts {
+            out.insert(id, (2, "available".to_string(), "".to_string())); // Available
+        }
+
+        Ok(out)
+    }
+
+    fn statuses(&self) -> Result<HashMap<String, SimpleStatusSpec>, MethodErr> {
+        println!("Connection<{}>::statuses()", self.id());
+
+        Ok(statuses())
+    }
+
+    fn maximum_status_message_length(&self) -> Result<u32, MethodErr> {
+        println!("Connection<{}>::maximum_status_message_length()", self.id());
+        Ok(0)
+    }
+}
--- a/src/padfoot/connection_manager.rs
+++ b/src/padfoot/connection_manager.rs
@@ -0,0 +1,180 @@
+use crate::padfoot::{var_arg, var_str, var_str_vec, VarArg};
+use crate::telepathy;
+
+use dbus::message::SignalArgs;
+use dbus::tree::MethodErr;
+use std::collections::{HashMap, HashSet};
+use std::sync::{mpsc, Arc, Mutex};
+
+use super::{ConnSettings, Connection};
+
+pub const CM_BUS_NAME: &str = "org.freedesktop.Telepathy.ConnectionManager.padfoot";
+pub const CM_CONN_BUS_NAME: &str = "org.freedesktop.Telepathy.Connection.padfoot";
+pub const CM_OBJECT_PATH: &str = "/org/freedesktop/Telepathy/ConnectionManager/padfoot";
+
+#[derive(Debug)]
+pub struct ConnectionManager {
+    conns: Arc<Mutex<HashSet<dbus::Path<'static>>>>,
+    sender: mpsc::Sender<dbus::Message>,
+}
+
+impl AsRef<dyn telepathy::ConnectionManager + 'static> for std::rc::Rc<ConnectionManager> {
+    fn as_ref(&self) -> &(dyn telepathy::ConnectionManager + 'static) {
+        &**self
+    }
+}
+
+impl ConnectionManager {
+    pub fn new() -> (Self, mpsc::Receiver<dbus::Message>) {
+        let (msg_s, msg_r) = mpsc::channel::<dbus::Message>();
+
+        (
+            ConnectionManager {
+                conns: Arc::new(Mutex::new(HashSet::<dbus::Path<'static>>::new())),
+                sender: msg_s,
+            },
+            msg_r,
+        )
+    }
+
+    fn create_connection(
+        &self,
+        settings: ConnSettings,
+    ) -> Result<(String, dbus::Path<'static>), MethodErr> {
+        let bus = settings.bus();
+        let path = settings.path();
+
+        let mut conns = self.conns.lock().expect("Mutex access");
+
+        // We can't call connect() multiple times on the connection yet
+        if conns.contains(&path) {
+            return Err(MethodErr::no_arg());
+        }
+
+        // It would be nice to have a single main loop, but thread-per-conn is
+        // is easy enough for me to understand in Rust at the moment.
+        let conns_clone = self.conns.clone();
+        let (ok_s, ok_r) = mpsc::channel();
+        std::thread::spawn(move || {
+            let (conn, receiver) = Connection::new(settings, conns_clone).unwrap();
+            conn.run(ok_s, receiver);
+        });
+
+        // Emit a NewConnection signal for the benefit of others, but the caller
+        // learns from our RPC response
+        let sig = telepathy::ConnectionManagerNewConnection {
+            bus_name: bus.to_owned(),
+            object_path: path.clone(),
+            protocol: super::PROTO_NAME.to_string(),
+        };
+
+        // We must wait for the new name to appear on the bus, otherwise the
+        // client can race
+        if let Ok(opt) = ok_r.recv() {
+            if let Some(e) = opt {
+                return Err(e);
+            }
+
+        // Otherwise OK
+        } else {
+            return Err(MethodErr::no_arg());
+        }
+
+        conns.insert(path.clone());
+
+        let dbus_cm_path = dbus::strings::Path::new(CM_OBJECT_PATH.to_string())
+            .expect("Object path should meet DBUS requirements");
+
+        self.sender
+            .send(sig.to_emit_message(&dbus_cm_path))
+            .expect("send signal");
+
+        // The bus name *must* be org.freedesktop.Telepathy.Connection.padfoot.delta.<name>
+        Ok((bus, path))
+    }
+}
+
+impl telepathy::ConnectionManager for ConnectionManager {
+    fn get_parameters(&self, protocol: &str) -> Result<Vec<super::ParamSpec>, MethodErr> {
+        println!("CM::get_parameters({})", protocol);
+
+        match protocol {
+            super::PROTO_NAME => Ok(super::parameters()),
+            _ => Err(MethodErr::no_arg()), // FIXME: should be NotImplemented?
+        }
+    }
+
+    fn list_protocols(&self) -> Result<Vec<String>, MethodErr> {
+        println!("CM::list_protocols()");
+
+        Ok(vec![super::PROTO_NAME.to_string()])
+    }
+
+    fn request_connection(
+        &self,
+        protocol: &str,
+        params: HashMap<&str, VarArg>,
+    ) -> Result<(String, dbus::Path<'static>), MethodErr> {
+        println!("CM::request_connection({}, ...)", protocol);
+
+        match protocol {
+            super::PROTO_NAME => self.create_connection(super::ConnSettings::from_params(params)?),
+            _ => Err(MethodErr::no_arg()), // FIXME: should be NotImplemented?
+        }
+    }
+
+    fn protocols(&self) -> Result<HashMap<String, HashMap<String, VarArg>>, MethodErr> {
+        println!("CM::protocols()");
+
+        // FIXME: so much duplication. It would be good if we could get the
+        // properties from the Protocol instead
+        let mut out = HashMap::<String, HashMap<String, VarArg>>::new();
+        let mut props = HashMap::<String, VarArg>::new();
+
+        props.insert(
+            "org.freedesktop.Telepathy.Protocol.AuthenticationTypes".to_string(),
+            var_str_vec(vec![
+                "org.freedesktop.Telepathy.Channel.Type.ServerTLSConnection".to_string(),
+            ]),
+        );
+
+        props.insert(
+            "org.freedesktop.Telepathy.Protocol.ConnectionInterfaces".to_string(),
+            var_str_vec(super::connection_interfaces()),
+        );
+        props.insert(
+            "org.freedesktop.Telepathy.Protocol.EnglishName".to_string(),
+            var_str("Delta Chat".to_string()),
+        );
+        props.insert(
+            "org.freedesktop.Telepathy.Protocol.Icon".to_string(),
+            var_str("im-delta".to_string()),
+        );
+        props.insert(
+            "org.freedesktop.Telepathy.Protocol.Interfaces".to_string(),
+            var_str_vec(super::protocol_interfaces()),
+        );
+        props.insert(
+            "org.freedesktop.Telepathy.Protocol.Parameters".to_string(),
+            var_arg(Box::new(super::parameters())),
+        );
+        props.insert(
+            "org.freedesktop.Telepathy.Protocol.RequestableChannelClasses".to_string(),
+            var_arg(Box::new(super::requestables())),
+        );
+        props.insert(
+            "org.freedesktop.Telepathy.Protocol.VCardField".to_string(),
+            var_str("email".to_string()),
+        );
+
+        out.insert(super::PROTO_NAME.to_string(), props);
+
+        Ok(out)
+    }
+
+    fn interfaces(&self) -> Result<Vec<String>, MethodErr> {
+        println!("CM::interfaces()");
+
+        Ok(vec![])
+    }
+}
--- a/src/padfoot/message.rs
+++ b/src/padfoot/message.rs
@@ -0,0 +1,138 @@
+use crate::padfoot::{var_bytearray, var_i64, var_str, var_u32, VarArg};
+
+use async_std::path::{Path, PathBuf};
+use dc::constants::Viewtype as Vt;
+use dc::message::Message;
+use deltachat as dc;
+
+use std::collections::HashMap;
+
+type Part = HashMap<String, VarArg>;
+type Result<T> = std::result::Result<T, Box<dyn std::error::Error>>;
+
+// Turns a deltachat::message::Message into a Telepathy Message_Part_List
+pub fn convert_msg(blobdir: &Path, msg: &Message) -> Result<Vec<Part>> {
+    if msg.is_setupmessage() {
+        return Ok(convert_setupmessage(msg));
+    }
+
+    let mut parts = vec![make_props(msg)];
+
+    // TODO: Check. Can a deltachat message have multiple parts? Can an image
+    // viewtype have text as well?
+    let result = match msg.get_viewtype() {
+        Vt::Text => build_txt(msg),
+        Vt::Unknown => build_unknown(msg),
+        Vt::Audio | Vt::Voice => build_snd(msg),
+        Vt::Video => build_vid(msg),
+        _ => build_attachment(blobdir, msg),
+    };
+
+    result.map(|mut more| {
+        parts.append(&mut more);
+        parts
+    })
+}
+
+fn convert_setupmessage(msg: &Message) -> Vec<Part> {
+    let msg_id = msg.get_id();
+    vec![
+        make_props(msg),
+        make_plain(&format!("Setup message received. To apply it, reply with:\nIMEX: {} nnnn-nnnn-nnnn-nnnn-nnnn-nnnn-nnnn-nnnn-nnnn\nNo whitespace in the setup-code!", msg_id.to_u32())),
+    ]
+}
+
+fn make_props(msg: &Message) -> Part {
+    let msg_id = msg.get_id();
+    let mut out = HashMap::new();
+
+    out.insert(
+        "message-token".to_string(),
+        var_str(format!("{}", msg_id.to_u32())),
+    );
+    out.insert("message-sent".to_string(), var_i64(msg.get_timestamp()));
+    out.insert(
+        "message-received".to_string(),
+        var_i64(msg.get_received_timestamp()),
+    );
+    out.insert("message-sender".to_string(), var_u32(msg.get_from_id()));
+    // props.insert("message-sender-id", var_str()); // This doesn't need to be sent
+    // props.insert("sender-nickname", var_str()); // Can we get away without this one?
+    out.insert("message-type".to_string(), var_u32(0)); // normal
+
+    // These relate to superseded messages
+    // props.insert("supersedes", var_str());
+    // props.insert("original-message-sent", var_i64());
+    // props.insert("original-message-received", var_i64());
+
+    out.insert("pending-message-id".to_string(), var_u32(msg_id.to_u32()));
+
+    // Don't need these
+    // props.insert("interface", var_str());
+    // props.insert("scrollback", var_vool());
+    // props.insert("silent", var_bool());
+    // props.insert("rescued", var_bool());
+
+    out
+}
+
+fn make_plain(text: &str) -> Part {
+    make_content("text/plain", None, var_str(text.to_string()))
+}
+
+fn make_content(type_: &str, id: Option<&str>, content: VarArg) -> Part {
+    let mut out = HashMap::new();
+
+    out.insert("content-type".to_string(), var_str(type_.to_string()));
+    out.insert("content".to_string(), content);
+
+    id.map(|txt| out.insert("identifier".to_string(), var_str(txt.to_string())));
+
+    out
+}
+
+fn build_snd(_msg: &Message) -> Result<Vec<Part>> {
+    Ok(vec![make_plain("(a sound file was received)")])
+}
+
+fn build_txt(msg: &Message) -> Result<Vec<Part>> {
+    Ok(vec![make_plain(
+        &msg.get_text().unwrap_or_else(|| "".to_string()),
+    )])
+}
+
+fn build_unknown(_msg: &Message) -> Result<Vec<Part>> {
+    Ok(vec![make_plain("(a message of unknown type was received)")])
+}
+
+fn build_vid(_msg: &Message) -> Result<Vec<Part>> {
+    Ok(vec![make_plain("(a video was received)")])
+}
+
+// The message contains a file. Detect the content-type and construct a part
+// containing the data in full.
+fn build_attachment(blobdir: &Path, msg: &Message) -> Result<Vec<Part>> {
+    let mime = msg
+        .get_filemime()
+        .unwrap_or_else(|| "application/octet-stream".to_string());
+    let filename = msg.get_filename().ok_or("Failed to get filename")?;
+
+    let path: PathBuf = [blobdir, &Path::new(&filename)].iter().collect();
+
+    let data =
+        std::fs::read(&path).map_err(|e| format!("Failed to read file {:?}: {}", path, e))?;
+
+    println!("MIME type for attachment: {}", mime);
+
+    let html = make_content(
+        "text/html",
+        None,
+        var_str("<img src=\"cid:picture\" />".to_string()),
+    );
+
+    let txt = make_plain("(an image was sent but cannot be displayed)");
+
+    let blob = make_content(&mime, Some("picture"), var_bytearray(data));
+
+    Ok(vec![html, txt, blob])
+}
--- a/src/padfoot/protocol.rs
+++ b/src/padfoot/protocol.rs
@@ -0,0 +1,183 @@
+use crate::padfoot::{var_bool, var_str, var_u32, VarArg};
+use crate::telepathy;
+
+use dbus::tree::MethodErr;
+use deltachat as dc;
+use std::collections::HashMap;
+
+use super::ConnSettings;
+
+pub const PROTO_OBJECT_PATH: &str = "/org/freedesktop/Telepathy/ConnectionManager/padfoot/delta";
+pub const PROTO_BUS_NAME: &str = "org.freedesktop.Telepathy.ConnectionManager.padfoot.delta";
+pub const PROTO_NAME: &str = "delta";
+
+#[derive(Debug)]
+pub struct Protocol {}
+
+pub type ParamSpec = (
+    String, // Name
+    u32,    // Flags (Conn_Mgr_Param_Flags)
+    String, // Signature
+    VarArg, // Default value
+);
+
+// Requestable_Channel_Class
+pub type RequestableChannelSpec = (
+    HashMap<String, VarArg>, // Fixed properties
+    Vec<String>,             // Allowed properties
+);
+
+// FIXME: these should come from codegen
+//const FLAG_NONE: u32 = 0;
+const FLAG_REQUIRED: u32 = 1;
+//const FLAG_REGISTER: u32 = 2;
+//const FLAG_HAS_DEFAULT: u32 = 4;
+const FLAG_SECRET: u32 = 8;
+//const FLAG_DBUS_PROP: u32 = 16;
+
+pub fn parameters() -> Vec<ParamSpec> {
+    vec![
+        (
+            "account".to_string(),
+            FLAG_REQUIRED,
+            "s".to_string(),
+            var_str("".to_string()),
+        ),
+        (
+            "password".to_string(),
+            FLAG_REQUIRED | FLAG_SECRET,
+            "s".to_string(),
+            var_str("".to_string()),
+        ),
+        ("bcc-self".to_string(), 0, "b".to_string(), var_bool(false)),
+    ]
+}
+
+pub fn protocol_interfaces() -> Vec<String> {
+    vec![
+        "org.freedesktop.Telepathy.Protocol".to_string(),
+        "org.freedesktop.Telepathy.Protocol.Interface.Presence".to_string(),
+    ]
+}
+
+pub fn requestables() -> Vec<RequestableChannelSpec> {
+    let mut rf = HashMap::<String, VarArg>::new();
+
+    rf.insert(
+        "org.freedesktop.Telepathy.Channel.ChannelType".to_string(),
+        var_str("org.freedesktop.Telepathy.Channel.Type.Text".to_string()),
+    );
+
+    rf.insert(
+        "org.freedesktop.Telepathy.Channel.TargetHandleType".to_string(),
+        var_u32(1),
+    );
+
+    let ra = vec![
+        "org.freedesktop.Telepathy.Channel.TargetHandle".to_string(),
+        "org.freedesktop.Telepathy.Channel.TargetID".to_string(),
+    ];
+
+    vec![(rf, ra)]
+}
+
+impl AsRef<dyn telepathy::Protocol + 'static> for std::rc::Rc<Protocol> {
+    fn as_ref(&self) -> &(dyn telepathy::Protocol + 'static) {
+        &**self
+    }
+}
+
+impl telepathy::Protocol for Protocol {
+    fn identify_account(&self, params: HashMap<&str, VarArg>) -> Result<String, MethodErr> {
+        println!("Protocol::identify_account(...)");
+
+        let settings = ConnSettings::from_params(params)?;
+
+        Ok(settings.id())
+    }
+
+    fn normalize_contact(&self, contact_id: &str) -> Result<String, MethodErr> {
+        println!("Protocol::normalize_contact({})", contact_id);
+
+        Ok(dc::contact::addr_normalize(contact_id).to_string())
+    }
+
+    fn interfaces(&self) -> Result<Vec<String>, MethodErr> {
+        println!("Protocol::interfaces()");
+
+        Ok(protocol_interfaces())
+    }
+
+    fn parameters(&self) -> Result<Vec<ParamSpec>, MethodErr> {
+        println!("Protocol::parameters()");
+
+        Ok(parameters())
+    }
+
+    fn connection_interfaces(&self) -> Result<Vec<String>, MethodErr> {
+        println!("Protocol::connection_interfaces()");
+
+        Ok(super::connection_interfaces())
+    }
+
+    fn requestable_channel_classes(&self) -> Result<Vec<RequestableChannelSpec>, MethodErr> {
+        println!("Protocol::requestable_channel_classes()");
+
+        Ok(requestables())
+    }
+
+    fn vcard_field(&self) -> Result<String, MethodErr> {
+        println!("Protocol::vcard_field()");
+
+        Ok("email".to_string())
+    }
+
+    fn english_name(&self) -> Result<String, MethodErr> {
+        println!("Protocol::english_name()");
+
+        Ok("Delta Chat".to_string())
+    }
+
+    fn icon(&self) -> Result<String, MethodErr> {
+        println!("Protocol::icon()");
+
+        Ok("im-delta".to_string())
+    }
+
+    fn authentication_types(&self) -> Result<Vec<String>, MethodErr> {
+        println!("Protocol::authentication_types()");
+
+        Ok(vec![
+            "org.freedesktop.Telepathy.Channel.Type.ServerTLSConnection".to_string(),
+        ])
+    }
+}
+
+pub type SimpleStatusSpec = (
+    u32,  // connection presence type
+    bool, // may set on self?
+    bool, // can have message?
+);
+
+pub fn statuses() -> HashMap<String, SimpleStatusSpec> {
+    let mut out = HashMap::<String, SimpleStatusSpec>::new();
+
+    out.insert("available".to_string(), (2, true, false));
+    out.insert("offline".to_string(), (1, true, false));
+
+    out
+}
+
+impl AsRef<dyn telepathy::ProtocolInterfacePresence + 'static> for std::rc::Rc<Protocol> {
+    fn as_ref(&self) -> &(dyn telepathy::ProtocolInterfacePresence + 'static) {
+        &**self
+    }
+}
+
+impl telepathy::ProtocolInterfacePresence for Protocol {
+    fn statuses(&self) -> Result<HashMap<String, SimpleStatusSpec>, MethodErr> {
+        println!("Protocol::presences()");
+
+        Ok(statuses())
+    }
+}
--- a/src/padfoot/var_arg.rs
+++ b/src/padfoot/var_arg.rs
@@ -0,0 +1,41 @@
+use dbus::arg::{RefArg, Variant};
+
+use std::convert::TryInto;
+
+pub type VarArg = Variant<Box<dyn RefArg + 'static>>;
+
+pub fn var_arg(item: Box<dyn RefArg + 'static>) -> VarArg {
+    Variant(item)
+}
+
+pub fn var_str(item: String) -> VarArg {
+    var_arg(Box::new(item))
+}
+
+pub fn var_str_vec(item: Vec<String>) -> VarArg {
+    var_arg(Box::new(item))
+}
+
+pub fn var_bool(item: bool) -> VarArg {
+    var_arg(Box::new(item))
+}
+
+pub fn var_bytearray(item: std::vec::Vec<u8>) -> VarArg {
+    var_arg(Box::new(item))
+}
+
+pub fn var_u32(item: u32) -> VarArg {
+    var_arg(Box::new(item))
+}
+
+pub fn var_i64(item: i64) -> VarArg {
+    var_arg(Box::new(item))
+}
+
+pub fn get_var_str(from: &VarArg) -> String {
+    from.0.as_str().unwrap().to_string()
+}
+
+pub fn get_var_u32(from: &VarArg) -> u32 {
+    from.0.as_u64().unwrap().try_into().unwrap()
+}
--- a/src/telepathy.rs
+++ b/src/telepathy.rs
@@ -0,0 +1,485 @@
+#![allow(unused)]
+
+#[allow(clippy::all)]
+mod account_interface_addressing;
+pub use self::account_interface_addressing::*;
+
+#[allow(clippy::all)]
+mod account_interface_avatar;
+pub use self::account_interface_avatar::*;
+
+#[allow(clippy::all)]
+mod account_interface_external_password_storage;
+pub use self::account_interface_external_password_storage::*;
+
+#[allow(clippy::all)]
+mod account_interface_hidden;
+pub use self::account_interface_hidden::*;
+
+#[allow(clippy::all)]
+mod account_interface_storage;
+pub use self::account_interface_storage::*;
+
+#[allow(clippy::all)]
+mod account_manager_interface_hidden;
+pub use self::account_manager_interface_hidden::*;
+
+#[allow(clippy::all)]
+mod account_manager;
+pub use self::account_manager::*;
+
+#[allow(clippy::all)]
+mod account;
+pub use self::account::*;
+
+#[allow(clippy::all)]
+mod all;
+pub use self::all::*;
+
+#[allow(clippy::all)]
+mod authentication_tls_certificate;
+pub use self::authentication_tls_certificate::*;
+
+#[allow(clippy::all)]
+mod call_content_interface_audio_control;
+pub use self::call_content_interface_audio_control::*;
+
+#[allow(clippy::all)]
+mod call_content_interface_dtmf;
+pub use self::call_content_interface_dtmf::*;
+
+#[allow(clippy::all)]
+mod call_content_interface_media;
+pub use self::call_content_interface_media::*;
+
+#[allow(clippy::all)]
+mod call_content_interface_video_control;
+pub use self::call_content_interface_video_control::*;
+
+#[allow(clippy::all)]
+mod call_content_media_description_interface_rtcp_extended_reports;
+pub use self::call_content_media_description_interface_rtcp_extended_reports::*;
+
+#[allow(clippy::all)]
+mod call_content_media_description_interface_rtcp_feedback;
+pub use self::call_content_media_description_interface_rtcp_feedback::*;
+
+#[allow(clippy::all)]
+mod call_content_media_description_interface_rtp_header_extensions;
+pub use self::call_content_media_description_interface_rtp_header_extensions::*;
+
+#[allow(clippy::all)]
+mod call_content_media_description;
+pub use self::call_content_media_description::*;
+
+#[allow(clippy::all)]
+mod call_content;
+pub use self::call_content::*;
+
+#[allow(clippy::all)]
+mod call_interface_mute;
+pub use self::call_interface_mute::*;
+
+#[allow(clippy::all)]
+mod call_stream_endpoint;
+pub use self::call_stream_endpoint::*;
+
+#[allow(clippy::all)]
+mod call_stream_interface_media;
+pub use self::call_stream_interface_media::*;
+
+#[allow(clippy::all)]
+mod call_stream;
+pub use self::call_stream::*;
+
+#[allow(clippy::all)]
+mod channel_bundle;
+pub use self::channel_bundle::*;
+
+#[allow(clippy::all)]
+mod channel_dispatcher_interface_messages1;
+pub use self::channel_dispatcher_interface_messages1::*;
+
+#[allow(clippy::all)]
+mod channel_dispatcher_interface_operation_list;
+pub use self::channel_dispatcher_interface_operation_list::*;
+
+#[allow(clippy::all)]
+mod channel_dispatcher;
+pub use self::channel_dispatcher::*;
+
+#[allow(clippy::all)]
+mod channel_dispatch_operation;
+pub use self::channel_dispatch_operation::*;
+
+#[allow(clippy::all)]
+mod channel_future;
+pub use self::channel_future::*;
+
+#[allow(clippy::all)]
+mod channel_handler;
+pub use self::channel_handler::*;
+
+#[allow(clippy::all)]
+mod channel_interface_addressing;
+pub use self::channel_interface_addressing::*;
+
+#[allow(clippy::all)]
+mod channel_interface_anonymity;
+pub use self::channel_interface_anonymity::*;
+
+#[allow(clippy::all)]
+mod channel_interface_call_state;
+pub use self::channel_interface_call_state::*;
+
+#[allow(clippy::all)]
+mod channel_interface_captcha_authentication;
+pub use self::channel_interface_captcha_authentication::*;
+
+#[allow(clippy::all)]
+mod channel_interface_chat_state;
+pub use self::channel_interface_chat_state::*;
+
+#[allow(clippy::all)]
+mod channel_interface_conference;
+pub use self::channel_interface_conference::*;
+
+#[allow(clippy::all)]
+mod channel_interface_credentials_storage;
+pub use self::channel_interface_credentials_storage::*;
+
+#[allow(clippy::all)]
+mod channel_interface_destroyable;
+pub use self::channel_interface_destroyable::*;
+
+#[allow(clippy::all)]
+mod channel_interface_dtmf;
+pub use self::channel_interface_dtmf::*;
+
+#[allow(clippy::all)]
+mod channel_interface_file_transfer_metadata;
+pub use self::channel_interface_file_transfer_metadata::*;
+
+#[allow(clippy::all)]
+mod channel_interface_group;
+pub use self::channel_interface_group::*;
+
+#[allow(clippy::all)]
+mod channel_interface_hold;
+pub use self::channel_interface_hold::*;
+
+#[allow(clippy::all)]
+mod channel_interface_html;
+pub use self::channel_interface_html::*;
+
+#[allow(clippy::all)]
+mod channel_interface_media_signalling;
+pub use self::channel_interface_media_signalling::*;
+
+#[allow(clippy::all)]
+mod channel_interface_mergeable_conference;
+pub use self::channel_interface_mergeable_conference::*;
+
+#[allow(clippy::all)]
+mod channel_interface_messages;
+pub use self::channel_interface_messages::*;
+
+#[allow(clippy::all)]
+mod channel_interface_password;
+pub use self::channel_interface_password::*;
+
+#[allow(clippy::all)]
+mod channel_interface_picture;
+pub use self::channel_interface_picture::*;
+
+#[allow(clippy::all)]
+mod channel_interface_room_config;
+pub use self::channel_interface_room_config::*;
+
+#[allow(clippy::all)]
+mod channel_interface_room;
+pub use self::channel_interface_room::*;
+
+#[allow(clippy::all)]
+mod channel_interface_sasl_authentication;
+pub use self::channel_interface_sasl_authentication::*;
+
+#[allow(clippy::all)]
+mod channel_interface_securable;
+pub use self::channel_interface_securable::*;
+
+#[allow(clippy::all)]
+mod channel_interface_service_point;
+pub use self::channel_interface_service_point::*;
+
+#[allow(clippy::all)]
+mod channel_interface_sms;
+pub use self::channel_interface_sms::*;
+
+#[allow(clippy::all)]
+mod channel_interface_splittable;
+pub use self::channel_interface_splittable::*;
+
+#[allow(clippy::all)]
+mod channel_interface_subject;
+pub use self::channel_interface_subject::*;
+
+#[allow(clippy::all)]
+mod channel_interface_transfer;
+pub use self::channel_interface_transfer::*;
+
+#[allow(clippy::all)]
+mod channel_interface_tube;
+pub use self::channel_interface_tube::*;
+
+#[allow(clippy::all)]
+mod channel_request;
+pub use self::channel_request::*;
+
+#[allow(clippy::all)]
+mod channel_type_call;
+pub use self::channel_type_call::*;
+
+#[allow(clippy::all)]
+mod channel_type_contact_list;
+pub use self::channel_type_contact_list::*;
+
+#[allow(clippy::all)]
+mod channel_type_contact_search;
+pub use self::channel_type_contact_search::*;
+
+#[allow(clippy::all)]
+mod channel_type_dbus_tube;
+pub use self::channel_type_dbus_tube::*;
+
+#[allow(clippy::all)]
+mod channel_type_file_transfer;
+pub use self::channel_type_file_transfer::*;
+
+#[allow(clippy::all)]
+mod channel_type_room_list;
+pub use self::channel_type_room_list::*;
+
+#[allow(clippy::all)]
+mod channel_type_server_authentication;
+pub use self::channel_type_server_authentication::*;
+
+#[allow(clippy::all)]
+mod channel_type_server_tls_connection;
+pub use self::channel_type_server_tls_connection::*;
+
+#[allow(clippy::all)]
+mod channel_type_streamed_media;
+pub use self::channel_type_streamed_media::*;
+
+#[allow(clippy::all)]
+mod channel_type_stream_tube;
+pub use self::channel_type_stream_tube::*;
+
+#[allow(clippy::all)]
+mod channel_type_text;
+pub use self::channel_type_text::*;
+
+#[allow(clippy::all)]
+mod channel_type_tubes;
+pub use self::channel_type_tubes::*;
+
+#[allow(clippy::all)]
+mod channel;
+pub use self::channel::*;
+
+#[allow(clippy::all)]
+mod client_approver;
+pub use self::client_approver::*;
+
+#[allow(clippy::all)]
+mod client_handler_future;
+pub use self::client_handler_future::*;
+
+#[allow(clippy::all)]
+mod client_handler;
+pub use self::client_handler::*;
+
+#[allow(clippy::all)]
+mod client_interface_requests;
+pub use self::client_interface_requests::*;
+
+#[allow(clippy::all)]
+mod client_observer;
+pub use self::client_observer::*;
+
+#[allow(clippy::all)]
+mod client;
+pub use self::client::*;
+
+#[allow(clippy::all)]
+mod connection_interface_addressing;
+pub use self::connection_interface_addressing::*;
+
+#[allow(clippy::all)]
+mod connection_interface_aliasing;
+pub use self::connection_interface_aliasing::*;
+
+#[allow(clippy::all)]
+mod connection_interface_anonymity;
+pub use self::connection_interface_anonymity::*;
+
+#[allow(clippy::all)]
+mod connection_interface_avatars;
+pub use self::connection_interface_avatars::*;
+
+#[allow(clippy::all)]
+mod connection_interface_balance;
+pub use self::connection_interface_balance::*;
+
+#[allow(clippy::all)]
+mod connection_interface_capabilities;
+pub use self::connection_interface_capabilities::*;
+
+#[allow(clippy::all)]
+mod connection_interface_cellular;
+pub use self::connection_interface_cellular::*;
+
+#[allow(clippy::all)]
+mod connection_interface_client_types;
+pub use self::connection_interface_client_types::*;
+
+#[allow(clippy::all)]
+mod connection_interface_communication_policy;
+pub use self::connection_interface_communication_policy::*;
+
+#[allow(clippy::all)]
+mod connection_interface_contact_blocking;
+pub use self::connection_interface_contact_blocking::*;
+
+#[allow(clippy::all)]
+mod connection_interface_contact_capabilities;
+pub use self::connection_interface_contact_capabilities::*;
+
+#[allow(clippy::all)]
+mod connection_interface_contact_groups;
+pub use self::connection_interface_contact_groups::*;
+
+#[allow(clippy::all)]
+mod connection_interface_contact_info;
+pub use self::connection_interface_contact_info::*;
+
+#[allow(clippy::all)]
+mod connection_interface_contact_list;
+pub use self::connection_interface_contact_list::*;
+
+#[allow(clippy::all)]
+mod connection_interface_contacts;
+pub use self::connection_interface_contacts::*;
+
+#[allow(clippy::all)]
+mod connection_interface_forwarding;
+pub use self::connection_interface_forwarding::*;
+
+#[allow(clippy::all)]
+mod connection_interface_irc_command1;
+pub use self::connection_interface_irc_command1::*;
+
+#[allow(clippy::all)]
+mod connection_interface_keepalive;
+pub use self::connection_interface_keepalive::*;
+
+#[allow(clippy::all)]
+mod connection_interface_location;
+pub use self::connection_interface_location::*;
+
+#[allow(clippy::all)]
+mod connection_interface_mail_notification;
+pub use self::connection_interface_mail_notification::*;
+
+#[allow(clippy::all)]
+mod connection_interface_power_saving;
+pub use self::connection_interface_power_saving::*;
+
+#[allow(clippy::all)]
+mod connection_interface_presence;
+pub use self::connection_interface_presence::*;
+
+#[allow(clippy::all)]
+mod connection_interface_privacy;
+pub use self::connection_interface_privacy::*;
+
+#[allow(clippy::all)]
+mod connection_interface_renaming;
+pub use self::connection_interface_renaming::*;
+
+#[allow(clippy::all)]
+mod connection_interface_requests;
+pub use self::connection_interface_requests::*;
+
+#[allow(clippy::all)]
+mod connection_interface_resources;
+pub use self::connection_interface_resources::*;
+
+#[allow(clippy::all)]
+mod connection_interface_service_point;
+pub use self::connection_interface_service_point::*;
+
+#[allow(clippy::all)]
+mod connection_interface_sidecars1;
+pub use self::connection_interface_sidecars1::*;
+
+#[allow(clippy::all)]
+mod connection_interface_simple_presence;
+pub use self::connection_interface_simple_presence::*;
+
+#[allow(clippy::all)]
+mod connection_manager_interface_account_storage;
+pub use self::connection_manager_interface_account_storage::*;
+
+#[allow(clippy::all)]
+mod connection_manager;
+pub use self::connection_manager::*;
+
+#[allow(clippy::all)]
+mod connection;
+pub use self::connection::*;
+
+#[allow(clippy::all)]
+mod debug;
+pub use self::debug::*;
+
+#[allow(clippy::all)]
+mod errors;
+pub use self::errors::*;
+
+#[allow(clippy::all)]
+mod generic_types;
+pub use self::generic_types::*;
+
+#[allow(clippy::all)]
+mod media_session_handler;
+pub use self::media_session_handler::*;
+
+#[allow(clippy::all)]
+mod media_stream_handler;
+pub use self::media_stream_handler::*;
+
+#[allow(clippy::all)]
+mod properties_interface;
+pub use self::properties_interface::*;
+
+#[allow(clippy::all)]
+mod protocol_interface_addressing;
+pub use self::protocol_interface_addressing::*;
+
+#[allow(clippy::all)]
+mod protocol_interface_avatars;
+pub use self::protocol_interface_avatars::*;
+
+#[allow(clippy::all)]
+mod protocol_interface_presence;
+pub use self::protocol_interface_presence::*;
+
+#[allow(clippy::all)]
+mod protocol;
+pub use self::protocol::*;
+
+#[allow(clippy::all)]
+mod template;
+pub use self::template::*;
--- a/src/telepathy/account.rs
+++ b/src/telepathy/account.rs
@@ -0,0 +1,492 @@
+// This code was autogenerated with `dbus-codegen-rust --file telepathy-spec/spec/Account.xml -i org.freedesktop.Telepathy -a AsRefClosure -o src/telepathy/account.rs`, see https://github.com/diwic/dbus-rs
+use dbus;
+use dbus::arg;
+use dbus::tree;
+
+pub trait Account {
+    fn remove(&self) -> Result<(), tree::MethodErr>;
+    fn update_parameters(
+        &self,
+        set: ::std::collections::HashMap<&str, arg::Variant<Box<dyn arg::RefArg>>>,
+        unset: Vec<&str>,
+    ) -> Result<Vec<String>, tree::MethodErr>;
+    fn reconnect(&self) -> Result<(), tree::MethodErr>;
+    fn interfaces(&self) -> Result<Vec<String>, tree::MethodErr>;
+    fn display_name(&self) -> Result<String, tree::MethodErr>;
+    fn set_display_name(&self, value: String) -> Result<(), tree::MethodErr>;
+    fn icon(&self) -> Result<String, tree::MethodErr>;
+    fn set_icon(&self, value: String) -> Result<(), tree::MethodErr>;
+    fn valid(&self) -> Result<bool, tree::MethodErr>;
+    fn enabled(&self) -> Result<bool, tree::MethodErr>;
+    fn set_enabled(&self, value: bool) -> Result<(), tree::MethodErr>;
+    fn nickname(&self) -> Result<String, tree::MethodErr>;
+    fn set_nickname(&self, value: String) -> Result<(), tree::MethodErr>;
+    fn service(&self) -> Result<String, tree::MethodErr>;
+    fn set_service(&self, value: String) -> Result<(), tree::MethodErr>;
+    fn parameters(
+        &self,
+    ) -> Result<
+        ::std::collections::HashMap<String, arg::Variant<Box<dyn arg::RefArg + 'static>>>,
+        tree::MethodErr,
+    >;
+    fn automatic_presence(&self) -> Result<(u32, String, String), tree::MethodErr>;
+    fn set_automatic_presence(&self, value: (u32, String, String)) -> Result<(), tree::MethodErr>;
+    fn connect_automatically(&self) -> Result<bool, tree::MethodErr>;
+    fn set_connect_automatically(&self, value: bool) -> Result<(), tree::MethodErr>;
+    fn connection(&self) -> Result<dbus::Path<'static>, tree::MethodErr>;
+    fn connection_status(&self) -> Result<u32, tree::MethodErr>;
+    fn connection_status_reason(&self) -> Result<u32, tree::MethodErr>;
+    fn connection_error(&self) -> Result<String, tree::MethodErr>;
+    fn connection_error_details(
+        &self,
+    ) -> Result<
+        ::std::collections::HashMap<String, arg::Variant<Box<dyn arg::RefArg + 'static>>>,
+        tree::MethodErr,
+    >;
+    fn current_presence(&self) -> Result<(u32, String, String), tree::MethodErr>;
+    fn requested_presence(&self) -> Result<(u32, String, String), tree::MethodErr>;
+    fn set_requested_presence(&self, value: (u32, String, String)) -> Result<(), tree::MethodErr>;
+    fn changing_presence(&self) -> Result<bool, tree::MethodErr>;
+    fn normalized_name(&self) -> Result<String, tree::MethodErr>;
+    fn has_been_online(&self) -> Result<bool, tree::MethodErr>;
+    fn supersedes(&self) -> Result<Vec<dbus::Path<'static>>, tree::MethodErr>;
+    fn set_supersedes(&self, value: Vec<dbus::Path<'static>>) -> Result<(), tree::MethodErr>;
+}
+
+pub fn account_server<F, T, D>(
+    factory: &tree::Factory<tree::MTFn<D>, D>,
+    data: D::Interface,
+    f: F,
+) -> tree::Interface<tree::MTFn<D>, D>
+where
+    D: tree::DataType,
+    D::Method: Default,
+    D::Property: Default,
+    D::Signal: Default,
+    T: AsRef<dyn Account>,
+    F: 'static + Fn(&tree::MethodInfo<tree::MTFn<D>, D>) -> T,
+{
+    let i = factory.interface("org.freedesktop.Telepathy.Account", data);
+    let f = ::std::sync::Arc::new(f);
+    let fclone = f.clone();
+    let h = move |minfo: &tree::MethodInfo<tree::MTFn<D>, D>| {
+        let dd = fclone(minfo);
+        let d = dd.as_ref();
+        d.remove()?;
+        let rm = minfo.msg.method_return();
+        Ok(vec![rm])
+    };
+    let m = factory.method("Remove", Default::default(), h);
+    let i = i.add_m(m);
+
+    let fclone = f.clone();
+    let h = move |minfo: &tree::MethodInfo<tree::MTFn<D>, D>| {
+        let mut i = minfo.msg.iter_init();
+        let set: ::std::collections::HashMap<&str, arg::Variant<Box<dyn arg::RefArg>>> =
+            i.read()?;
+        let unset: Vec<&str> = i.read()?;
+        let dd = fclone(minfo);
+        let d = dd.as_ref();
+        let reconnect_required = d.update_parameters(set, unset)?;
+        let rm = minfo.msg.method_return();
+        let rm = rm.append1(reconnect_required);
+        Ok(vec![rm])
+    };
+    let m = factory.method("UpdateParameters", Default::default(), h);
+    let m = m.in_arg(("Set", "a{sv}"));
+    let m = m.in_arg(("Unset", "as"));
+    let m = m.out_arg(("Reconnect_Required", "as"));
+    let i = i.add_m(m);
+
+    let fclone = f.clone();
+    let h = move |minfo: &tree::MethodInfo<tree::MTFn<D>, D>| {
+        let dd = fclone(minfo);
+        let d = dd.as_ref();
+        d.reconnect()?;
+        let rm = minfo.msg.method_return();
+        Ok(vec![rm])
+    };
+    let m = factory.method("Reconnect", Default::default(), h);
+    let i = i.add_m(m);
+
+    let p = factory.property::<Vec<&str>, _>("Interfaces", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let dd = fclone(&minfo);
+        let d = dd.as_ref();
+        a.append(d.interfaces()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+
+    let p = factory.property::<&str, _>("DisplayName", Default::default());
+    let p = p.access(tree::Access::ReadWrite);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let dd = fclone(&minfo);
+        let d = dd.as_ref();
+        a.append(d.display_name()?);
+        Ok(())
+    });
+    let fclone = f.clone();
+    let p = p.on_set(move |iter, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let dd = fclone(&minfo);
+        let d = dd.as_ref();
+        d.set_display_name(iter.read()?)?;
+        Ok(())
+    });
+    let i = i.add_p(p);
+
+    let p = factory.property::<&str, _>("Icon", Default::default());
+    let p = p.access(tree::Access::ReadWrite);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let dd = fclone(&minfo);
+        let d = dd.as_ref();
+        a.append(d.icon()?);
+        Ok(())
+    });
+    let fclone = f.clone();
+    let p = p.on_set(move |iter, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let dd = fclone(&minfo);
+        let d = dd.as_ref();
+        d.set_icon(iter.read()?)?;
+        Ok(())
+    });
+    let i = i.add_p(p);
+
+    let p = factory.property::<bool, _>("Valid", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let dd = fclone(&minfo);
+        let d = dd.as_ref();
+        a.append(d.valid()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+
+    let p = factory.property::<bool, _>("Enabled", Default::default());
+    let p = p.access(tree::Access::ReadWrite);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let dd = fclone(&minfo);
+        let d = dd.as_ref();
+        a.append(d.enabled()?);
+        Ok(())
+    });
+    let fclone = f.clone();
+    let p = p.on_set(move |iter, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let dd = fclone(&minfo);
+        let d = dd.as_ref();
+        d.set_enabled(iter.read()?)?;
+        Ok(())
+    });
+    let i = i.add_p(p);
+
+    let p = factory.property::<&str, _>("Nickname", Default::default());
+    let p = p.access(tree::Access::ReadWrite);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let dd = fclone(&minfo);
+        let d = dd.as_ref();
+        a.append(d.nickname()?);
+        Ok(())
+    });
+    let fclone = f.clone();
+    let p = p.on_set(move |iter, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let dd = fclone(&minfo);
+        let d = dd.as_ref();
+        d.set_nickname(iter.read()?)?;
+        Ok(())
+    });
+    let i = i.add_p(p);
+
+    let p = factory.property::<&str, _>("Service", Default::default());
+    let p = p.access(tree::Access::ReadWrite);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let dd = fclone(&minfo);
+        let d = dd.as_ref();
+        a.append(d.service()?);
+        Ok(())
+    });
+    let fclone = f.clone();
+    let p = p.on_set(move |iter, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let dd = fclone(&minfo);
+        let d = dd.as_ref();
+        d.set_service(iter.read()?)?;
+        Ok(())
+    });
+    let i = i.add_p(p);
+
+    let p = factory
+        .property::<::std::collections::HashMap<&str, arg::Variant<Box<dyn arg::RefArg>>>, _>(
+            "Parameters",
+            Default::default(),
+        );
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let dd = fclone(&minfo);
+        let d = dd.as_ref();
+        a.append(d.parameters()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+
+    let p = factory.property::<(u32, &str, &str), _>("AutomaticPresence", Default::default());
+    let p = p.access(tree::Access::ReadWrite);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let dd = fclone(&minfo);
+        let d = dd.as_ref();
+        a.append(d.automatic_presence()?);
+        Ok(())
+    });
+    let fclone = f.clone();
+    let p = p.on_set(move |iter, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let dd = fclone(&minfo);
+        let d = dd.as_ref();
+        d.set_automatic_presence(iter.read()?)?;
+        Ok(())
+    });
+    let i = i.add_p(p);
+
+    let p = factory.property::<bool, _>("ConnectAutomatically", Default::default());
+    let p = p.access(tree::Access::ReadWrite);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let dd = fclone(&minfo);
+        let d = dd.as_ref();
+        a.append(d.connect_automatically()?);
+        Ok(())
+    });
+    let fclone = f.clone();
+    let p = p.on_set(move |iter, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let dd = fclone(&minfo);
+        let d = dd.as_ref();
+        d.set_connect_automatically(iter.read()?)?;
+        Ok(())
+    });
+    let i = i.add_p(p);
+
+    let p = factory.property::<dbus::Path, _>("Connection", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let dd = fclone(&minfo);
+        let d = dd.as_ref();
+        a.append(d.connection()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+
+    let p = factory.property::<u32, _>("ConnectionStatus", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let dd = fclone(&minfo);
+        let d = dd.as_ref();
+        a.append(d.connection_status()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+
+    let p = factory.property::<u32, _>("ConnectionStatusReason", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let dd = fclone(&minfo);
+        let d = dd.as_ref();
+        a.append(d.connection_status_reason()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+
+    let p = factory.property::<&str, _>("ConnectionError", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let dd = fclone(&minfo);
+        let d = dd.as_ref();
+        a.append(d.connection_error()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+
+    let p = factory
+        .property::<::std::collections::HashMap<&str, arg::Variant<Box<dyn arg::RefArg>>>, _>(
+            "ConnectionErrorDetails",
+            Default::default(),
+        );
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let dd = fclone(&minfo);
+        let d = dd.as_ref();
+        a.append(d.connection_error_details()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+
+    let p = factory.property::<(u32, &str, &str), _>("CurrentPresence", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let dd = fclone(&minfo);
+        let d = dd.as_ref();
+        a.append(d.current_presence()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+
+    let p = factory.property::<(u32, &str, &str), _>("RequestedPresence", Default::default());
+    let p = p.access(tree::Access::ReadWrite);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let dd = fclone(&minfo);
+        let d = dd.as_ref();
+        a.append(d.requested_presence()?);
+        Ok(())
+    });
+    let fclone = f.clone();
+    let p = p.on_set(move |iter, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let dd = fclone(&minfo);
+        let d = dd.as_ref();
+        d.set_requested_presence(iter.read()?)?;
+        Ok(())
+    });
+    let i = i.add_p(p);
+
+    let p = factory.property::<bool, _>("ChangingPresence", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let dd = fclone(&minfo);
+        let d = dd.as_ref();
+        a.append(d.changing_presence()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+
+    let p = factory.property::<&str, _>("NormalizedName", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let dd = fclone(&minfo);
+        let d = dd.as_ref();
+        a.append(d.normalized_name()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+
+    let p = factory.property::<bool, _>("HasBeenOnline", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let dd = fclone(&minfo);
+        let d = dd.as_ref();
+        a.append(d.has_been_online()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+
+    let p = factory.property::<Vec<dbus::Path>, _>("Supersedes", Default::default());
+    let p = p.access(tree::Access::ReadWrite);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let dd = fclone(&minfo);
+        let d = dd.as_ref();
+        a.append(d.supersedes()?);
+        Ok(())
+    });
+    let fclone = f.clone();
+    let p = p.on_set(move |iter, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let dd = fclone(&minfo);
+        let d = dd.as_ref();
+        d.set_supersedes(iter.read()?)?;
+        Ok(())
+    });
+    let i = i.add_p(p);
+    let s = factory.signal("Removed", Default::default());
+    let i = i.add_s(s);
+    let s = factory.signal("AccountPropertyChanged", Default::default());
+    let s = s.arg(("Properties", "a{sv}"));
+    let i = i.add_s(s);
+    i
+}
+
+#[derive(Debug)]
+pub struct AccountRemoved {}
+
+impl arg::AppendAll for AccountRemoved {
+    fn append(&self, _: &mut arg::IterAppend) {}
+}
+
+impl arg::ReadAll for AccountRemoved {
+    fn read(_: &mut arg::Iter) -> Result<Self, arg::TypeMismatchError> {
+        Ok(AccountRemoved {})
+    }
+}
+
+impl dbus::message::SignalArgs for AccountRemoved {
+    const NAME: &'static str = "Removed";
+    const INTERFACE: &'static str = "org.freedesktop.Telepathy.Account";
+}
+
+#[derive(Debug)]
+pub struct AccountAccountPropertyChanged {
+    pub properties:
+        ::std::collections::HashMap<String, arg::Variant<Box<dyn arg::RefArg + 'static>>>,
+}
+
+impl arg::AppendAll for AccountAccountPropertyChanged {
+    fn append(&self, i: &mut arg::IterAppend) {
+        arg::RefArg::append(&self.properties, i);
+    }
+}
+
+impl arg::ReadAll for AccountAccountPropertyChanged {
+    fn read(i: &mut arg::Iter) -> Result<Self, arg::TypeMismatchError> {
+        Ok(AccountAccountPropertyChanged {
+            properties: i.read()?,
+        })
+    }
+}
+
+impl dbus::message::SignalArgs for AccountAccountPropertyChanged {
+    const NAME: &'static str = "AccountPropertyChanged";
+    const INTERFACE: &'static str = "org.freedesktop.Telepathy.Account";
+}
--- a/src/telepathy/account_interface_addressing.rs
+++ b/src/telepathy/account_interface_addressing.rs
@@ -0,0 +1,60 @@
+// This code was autogenerated with `dbus-codegen-rust --file telepathy-spec/spec/Account_Interface_Addressing.xml -i org.freedesktop.Telepathy -a AsRefClosure -o src/telepathy/account_interface_addressing.rs`, see https://github.com/diwic/dbus-rs
+use dbus;
+use dbus::arg;
+use dbus::tree;
+
+pub trait AccountInterfaceAddressing {
+    fn set_urischeme_association(
+        &self,
+        urischeme: &str,
+        association: bool,
+    ) -> Result<(), tree::MethodErr>;
+    fn urischemes(&self) -> Result<Vec<String>, tree::MethodErr>;
+}
+
+pub fn account_interface_addressing_server<F, T, D>(
+    factory: &tree::Factory<tree::MTFn<D>, D>,
+    data: D::Interface,
+    f: F,
+) -> tree::Interface<tree::MTFn<D>, D>
+where
+    D: tree::DataType,
+    D::Method: Default,
+    D::Property: Default,
+    T: AsRef<dyn AccountInterfaceAddressing>,
+    F: 'static + Fn(&tree::MethodInfo<tree::MTFn<D>, D>) -> T,
+{
+    let i = factory.interface(
+        "org.freedesktop.Telepathy.Account.Interface.Addressing",
+        data,
+    );
+    let f = ::std::sync::Arc::new(f);
+    let fclone = f.clone();
+    let h = move |minfo: &tree::MethodInfo<tree::MTFn<D>, D>| {
+        let mut i = minfo.msg.iter_init();
+        let urischeme: &str = i.read()?;
+        let association: bool = i.read()?;
+        let dd = fclone(minfo);
+        let d = dd.as_ref();
+        d.set_urischeme_association(urischeme, association)?;
+        let rm = minfo.msg.method_return();
+        Ok(vec![rm])
+    };
+    let m = factory.method("SetURISchemeAssociation", Default::default(), h);
+    let m = m.in_arg(("URI_Scheme", "s"));
+    let m = m.in_arg(("Association", "b"));
+    let i = i.add_m(m);
+
+    let p = factory.property::<Vec<&str>, _>("URISchemes", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let dd = fclone(&minfo);
+        let d = dd.as_ref();
+        a.append(d.urischemes()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+    i
+}
--- a/src/telepathy/account_interface_avatar.rs
+++ b/src/telepathy/account_interface_avatar.rs
@@ -0,0 +1,66 @@
+// This code was autogenerated with `dbus-codegen-rust --file telepathy-spec/spec/Account_Interface_Avatar.xml -i org.freedesktop.Telepathy -a AsRefClosure -o src/telepathy/account_interface_avatar.rs`, see https://github.com/diwic/dbus-rs
+use dbus;
+use dbus::arg;
+use dbus::tree;
+
+pub trait AccountInterfaceAvatar {
+    fn avatar(&self) -> Result<(Vec<u8>, String), tree::MethodErr>;
+    fn set_avatar(&self, value: (Vec<u8>, String)) -> Result<(), tree::MethodErr>;
+}
+
+pub fn account_interface_avatar_server<F, T, D>(
+    factory: &tree::Factory<tree::MTFn<D>, D>,
+    data: D::Interface,
+    f: F,
+) -> tree::Interface<tree::MTFn<D>, D>
+where
+    D: tree::DataType,
+    D::Method: Default,
+    D::Property: Default,
+    D::Signal: Default,
+    T: AsRef<dyn AccountInterfaceAvatar>,
+    F: 'static + Fn(&tree::MethodInfo<tree::MTFn<D>, D>) -> T,
+{
+    let i = factory.interface("org.freedesktop.Telepathy.Account.Interface.Avatar", data);
+    let f = ::std::sync::Arc::new(f);
+    let p = factory.property::<(Vec<u8>, &str), _>("Avatar", Default::default());
+    let p = p.access(tree::Access::ReadWrite);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let dd = fclone(&minfo);
+        let d = dd.as_ref();
+        a.append(d.avatar()?);
+        Ok(())
+    });
+    let fclone = f.clone();
+    let p = p.on_set(move |iter, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let dd = fclone(&minfo);
+        let d = dd.as_ref();
+        d.set_avatar(iter.read()?)?;
+        Ok(())
+    });
+    let i = i.add_p(p);
+    let s = factory.signal("AvatarChanged", Default::default());
+    let i = i.add_s(s);
+    i
+}
+
+#[derive(Debug)]
+pub struct AccountInterfaceAvatarAvatarChanged {}
+
+impl arg::AppendAll for AccountInterfaceAvatarAvatarChanged {
+    fn append(&self, _: &mut arg::IterAppend) {}
+}
+
+impl arg::ReadAll for AccountInterfaceAvatarAvatarChanged {
+    fn read(_: &mut arg::Iter) -> Result<Self, arg::TypeMismatchError> {
+        Ok(AccountInterfaceAvatarAvatarChanged {})
+    }
+}
+
+impl dbus::message::SignalArgs for AccountInterfaceAvatarAvatarChanged {
+    const NAME: &'static str = "AvatarChanged";
+    const INTERFACE: &'static str = "org.freedesktop.Telepathy.Account.Interface.Avatar";
+}
--- a/src/telepathy/account_interface_external_password_storage.rs
+++ b/src/telepathy/account_interface_external_password_storage.rs
@@ -0,0 +1,51 @@
+// This code was autogenerated with `dbus-codegen-rust --file telepathy-spec/spec/Account_Interface_External_Password_Storage.xml -i org.freedesktop.Telepathy -a AsRefClosure -o src/telepathy/account_interface_external_password_storage.rs`, see https://github.com/diwic/dbus-rs
+use dbus;
+use dbus::arg;
+use dbus::tree;
+
+pub trait AccountInterfaceExternalPasswordStorageDRAFT {
+    fn forget_password(&self) -> Result<(), tree::MethodErr>;
+    fn password_saved(&self) -> Result<bool, tree::MethodErr>;
+}
+
+pub fn account_interface_external_password_storage_draft_server<F, T, D>(
+    factory: &tree::Factory<tree::MTFn<D>, D>,
+    data: D::Interface,
+    f: F,
+) -> tree::Interface<tree::MTFn<D>, D>
+where
+    D: tree::DataType,
+    D::Method: Default,
+    D::Property: Default,
+    T: AsRef<dyn AccountInterfaceExternalPasswordStorageDRAFT>,
+    F: 'static + Fn(&tree::MethodInfo<tree::MTFn<D>, D>) -> T,
+{
+    let i = factory.interface(
+        "org.freedesktop.Telepathy.Account.Interface.ExternalPasswordStorage.DRAFT",
+        data,
+    );
+    let f = ::std::sync::Arc::new(f);
+    let fclone = f.clone();
+    let h = move |minfo: &tree::MethodInfo<tree::MTFn<D>, D>| {
+        let dd = fclone(minfo);
+        let d = dd.as_ref();
+        d.forget_password()?;
+        let rm = minfo.msg.method_return();
+        Ok(vec![rm])
+    };
+    let m = factory.method("ForgetPassword", Default::default(), h);
+    let i = i.add_m(m);
+
+    let p = factory.property::<bool, _>("PasswordSaved", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let dd = fclone(&minfo);
+        let d = dd.as_ref();
+        a.append(d.password_saved()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+    i
+}
--- a/src/telepathy/account_interface_hidden.rs
+++ b/src/telepathy/account_interface_hidden.rs
@@ -0,0 +1,39 @@
+// This code was autogenerated with `dbus-codegen-rust --file telepathy-spec/spec/Account_Interface_Hidden.xml -i org.freedesktop.Telepathy -a AsRefClosure -o src/telepathy/account_interface_hidden.rs`, see https://github.com/diwic/dbus-rs
+use dbus;
+use dbus::arg;
+use dbus::tree;
+
+pub trait AccountInterfaceHiddenDRAFT1 {
+    fn hidden(&self) -> Result<bool, tree::MethodErr>;
+}
+
+pub fn account_interface_hidden_draft1_server<F, T, D>(
+    factory: &tree::Factory<tree::MTFn<D>, D>,
+    data: D::Interface,
+    f: F,
+) -> tree::Interface<tree::MTFn<D>, D>
+where
+    D: tree::DataType,
+    D::Method: Default,
+    D::Property: Default,
+    T: AsRef<dyn AccountInterfaceHiddenDRAFT1>,
+    F: 'static + Fn(&tree::MethodInfo<tree::MTFn<D>, D>) -> T,
+{
+    let i = factory.interface(
+        "org.freedesktop.Telepathy.Account.Interface.Hidden.DRAFT1",
+        data,
+    );
+    let f = ::std::sync::Arc::new(f);
+    let p = factory.property::<bool, _>("Hidden", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let dd = fclone(&minfo);
+        let d = dd.as_ref();
+        a.append(d.hidden()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+    i
+}
--- a/src/telepathy/account_interface_storage.rs
+++ b/src/telepathy/account_interface_storage.rs
@@ -0,0 +1,87 @@
+// This code was autogenerated with `dbus-codegen-rust --file telepathy-spec/spec/Account_Interface_Storage.xml -i org.freedesktop.Telepathy -a AsRefClosure -o src/telepathy/account_interface_storage.rs`, see https://github.com/diwic/dbus-rs
+use dbus;
+use dbus::arg;
+use dbus::tree;
+
+pub trait AccountInterfaceStorage {
+    fn storage_provider(&self) -> Result<String, tree::MethodErr>;
+    fn storage_identifier(
+        &self,
+    ) -> Result<arg::Variant<Box<dyn arg::RefArg + 'static>>, tree::MethodErr>;
+    fn storage_specific_information(
+        &self,
+    ) -> Result<
+        ::std::collections::HashMap<String, arg::Variant<Box<dyn arg::RefArg + 'static>>>,
+        tree::MethodErr,
+    >;
+    fn storage_restrictions(&self) -> Result<u32, tree::MethodErr>;
+}
+
+pub fn account_interface_storage_server<F, T, D>(
+    factory: &tree::Factory<tree::MTFn<D>, D>,
+    data: D::Interface,
+    f: F,
+) -> tree::Interface<tree::MTFn<D>, D>
+where
+    D: tree::DataType,
+    D::Method: Default,
+    D::Property: Default,
+    T: AsRef<dyn AccountInterfaceStorage>,
+    F: 'static + Fn(&tree::MethodInfo<tree::MTFn<D>, D>) -> T,
+{
+    let i = factory.interface("org.freedesktop.Telepathy.Account.Interface.Storage", data);
+    let f = ::std::sync::Arc::new(f);
+    let p = factory.property::<&str, _>("StorageProvider", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let dd = fclone(&minfo);
+        let d = dd.as_ref();
+        a.append(d.storage_provider()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+
+    let p = factory
+        .property::<arg::Variant<Box<dyn arg::RefArg>>, _>("StorageIdentifier", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let dd = fclone(&minfo);
+        let d = dd.as_ref();
+        a.append(d.storage_identifier()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+
+    let p = factory
+        .property::<::std::collections::HashMap<&str, arg::Variant<Box<dyn arg::RefArg>>>, _>(
+            "StorageSpecificInformation",
+            Default::default(),
+        );
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let dd = fclone(&minfo);
+        let d = dd.as_ref();
+        a.append(d.storage_specific_information()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+
+    let p = factory.property::<u32, _>("StorageRestrictions", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let dd = fclone(&minfo);
+        let d = dd.as_ref();
+        a.append(d.storage_restrictions()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+    i
+}
--- a/src/telepathy/account_manager.rs
+++ b/src/telepathy/account_manager.rs
@@ -0,0 +1,172 @@
+// This code was autogenerated with `dbus-codegen-rust --file telepathy-spec/spec/Account_Manager.xml -i org.freedesktop.Telepathy -a AsRefClosure -o src/telepathy/account_manager.rs`, see https://github.com/diwic/dbus-rs
+use dbus;
+use dbus::arg;
+use dbus::tree;
+
+pub trait AccountManager {
+    fn create_account(
+        &self,
+        connection_manager: &str,
+        protocol: &str,
+        display_name: &str,
+        parameters: ::std::collections::HashMap<&str, arg::Variant<Box<dyn arg::RefArg>>>,
+        properties: ::std::collections::HashMap<&str, arg::Variant<Box<dyn arg::RefArg>>>,
+    ) -> Result<dbus::Path<'static>, tree::MethodErr>;
+    fn interfaces(&self) -> Result<Vec<String>, tree::MethodErr>;
+    fn valid_accounts(&self) -> Result<Vec<dbus::Path<'static>>, tree::MethodErr>;
+    fn invalid_accounts(&self) -> Result<Vec<dbus::Path<'static>>, tree::MethodErr>;
+    fn supported_account_properties(&self) -> Result<Vec<String>, tree::MethodErr>;
+}
+
+pub fn account_manager_server<F, T, D>(
+    factory: &tree::Factory<tree::MTFn<D>, D>,
+    data: D::Interface,
+    f: F,
+) -> tree::Interface<tree::MTFn<D>, D>
+where
+    D: tree::DataType,
+    D::Method: Default,
+    D::Property: Default,
+    D::Signal: Default,
+    T: AsRef<dyn AccountManager>,
+    F: 'static + Fn(&tree::MethodInfo<tree::MTFn<D>, D>) -> T,
+{
+    let i = factory.interface("org.freedesktop.Telepathy.AccountManager", data);
+    let f = ::std::sync::Arc::new(f);
+    let fclone = f.clone();
+    let h = move |minfo: &tree::MethodInfo<tree::MTFn<D>, D>| {
+        let mut i = minfo.msg.iter_init();
+        let connection_manager: &str = i.read()?;
+        let protocol: &str = i.read()?;
+        let display_name: &str = i.read()?;
+        let parameters: ::std::collections::HashMap<&str, arg::Variant<Box<dyn arg::RefArg>>> =
+            i.read()?;
+        let properties: ::std::collections::HashMap<&str, arg::Variant<Box<dyn arg::RefArg>>> =
+            i.read()?;
+        let dd = fclone(minfo);
+        let d = dd.as_ref();
+        let account = d.create_account(
+            connection_manager,
+            protocol,
+            display_name,
+            parameters,
+            properties,
+        )?;
+        let rm = minfo.msg.method_return();
+        let rm = rm.append1(account);
+        Ok(vec![rm])
+    };
+    let m = factory.method("CreateAccount", Default::default(), h);
+    let m = m.in_arg(("Connection_Manager", "s"));
+    let m = m.in_arg(("Protocol", "s"));
+    let m = m.in_arg(("Display_Name", "s"));
+    let m = m.in_arg(("Parameters", "a{sv}"));
+    let m = m.in_arg(("Properties", "a{sv}"));
+    let m = m.out_arg(("Account", "o"));
+    let i = i.add_m(m);
+
+    let p = factory.property::<Vec<&str>, _>("Interfaces", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let dd = fclone(&minfo);
+        let d = dd.as_ref();
+        a.append(d.interfaces()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+
+    let p = factory.property::<Vec<dbus::Path>, _>("ValidAccounts", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let dd = fclone(&minfo);
+        let d = dd.as_ref();
+        a.append(d.valid_accounts()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+
+    let p = factory.property::<Vec<dbus::Path>, _>("InvalidAccounts", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let dd = fclone(&minfo);
+        let d = dd.as_ref();
+        a.append(d.invalid_accounts()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+
+    let p = factory.property::<Vec<&str>, _>("SupportedAccountProperties", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let dd = fclone(&minfo);
+        let d = dd.as_ref();
+        a.append(d.supported_account_properties()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+    let s = factory.signal("AccountRemoved", Default::default());
+    let s = s.arg(("Account", "o"));
+    let i = i.add_s(s);
+    let s = factory.signal("AccountValidityChanged", Default::default());
+    let s = s.arg(("Account", "o"));
+    let s = s.arg(("Valid", "b"));
+    let i = i.add_s(s);
+    i
+}
+
+#[derive(Debug)]
+pub struct AccountManagerAccountRemoved {
+    pub account: dbus::Path<'static>,
+}
+
+impl arg::AppendAll for AccountManagerAccountRemoved {
+    fn append(&self, i: &mut arg::IterAppend) {
+        arg::RefArg::append(&self.account, i);
+    }
+}
+
+impl arg::ReadAll for AccountManagerAccountRemoved {
+    fn read(i: &mut arg::Iter) -> Result<Self, arg::TypeMismatchError> {
+        Ok(AccountManagerAccountRemoved { account: i.read()? })
+    }
+}
+
+impl dbus::message::SignalArgs for AccountManagerAccountRemoved {
+    const NAME: &'static str = "AccountRemoved";
+    const INTERFACE: &'static str = "org.freedesktop.Telepathy.AccountManager";
+}
+
+#[derive(Debug)]
+pub struct AccountManagerAccountValidityChanged {
+    pub account: dbus::Path<'static>,
+    pub valid: bool,
+}
+
+impl arg::AppendAll for AccountManagerAccountValidityChanged {
+    fn append(&self, i: &mut arg::IterAppend) {
+        arg::RefArg::append(&self.account, i);
+        arg::RefArg::append(&self.valid, i);
+    }
+}
+
+impl arg::ReadAll for AccountManagerAccountValidityChanged {
+    fn read(i: &mut arg::Iter) -> Result<Self, arg::TypeMismatchError> {
+        Ok(AccountManagerAccountValidityChanged {
+            account: i.read()?,
+            valid: i.read()?,
+        })
+    }
+}
+
+impl dbus::message::SignalArgs for AccountManagerAccountValidityChanged {
+    const NAME: &'static str = "AccountValidityChanged";
+    const INTERFACE: &'static str = "org.freedesktop.Telepathy.AccountManager";
+}
--- a/src/telepathy/account_manager_interface_hidden.rs
+++ b/src/telepathy/account_manager_interface_hidden.rs
@@ -0,0 +1,113 @@
+// This code was autogenerated with `dbus-codegen-rust --file telepathy-spec/spec/Account_Manager_Interface_Hidden.xml -i org.freedesktop.Telepathy -a AsRefClosure -o src/telepathy/account_manager_interface_hidden.rs`, see https://github.com/diwic/dbus-rs
+use dbus;
+use dbus::arg;
+use dbus::tree;
+
+pub trait AccountManagerInterfaceHiddenDRAFT1 {
+    fn valid_hidden_accounts(&self) -> Result<Vec<dbus::Path<'static>>, tree::MethodErr>;
+    fn invalid_hidden_accounts(&self) -> Result<Vec<dbus::Path<'static>>, tree::MethodErr>;
+}
+
+pub fn account_manager_interface_hidden_draft1_server<F, T, D>(
+    factory: &tree::Factory<tree::MTFn<D>, D>,
+    data: D::Interface,
+    f: F,
+) -> tree::Interface<tree::MTFn<D>, D>
+where
+    D: tree::DataType,
+    D::Method: Default,
+    D::Property: Default,
+    D::Signal: Default,
+    T: AsRef<dyn AccountManagerInterfaceHiddenDRAFT1>,
+    F: 'static + Fn(&tree::MethodInfo<tree::MTFn<D>, D>) -> T,
+{
+    let i = factory.interface(
+        "org.freedesktop.Telepathy.AccountManager.Interface.Hidden.DRAFT1",
+        data,
+    );
+    let f = ::std::sync::Arc::new(f);
+    let p = factory.property::<Vec<dbus::Path>, _>("ValidHiddenAccounts", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let dd = fclone(&minfo);
+        let d = dd.as_ref();
+        a.append(d.valid_hidden_accounts()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+
+    let p = factory.property::<Vec<dbus::Path>, _>("InvalidHiddenAccounts", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let dd = fclone(&minfo);
+        let d = dd.as_ref();
+        a.append(d.invalid_hidden_accounts()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+    let s = factory.signal("HiddenAccountRemoved", Default::default());
+    let s = s.arg(("Account", "o"));
+    let i = i.add_s(s);
+    let s = factory.signal("HiddenAccountValidityChanged", Default::default());
+    let s = s.arg(("Account", "o"));
+    let s = s.arg(("Valid", "b"));
+    let i = i.add_s(s);
+    i
+}
+
+#[derive(Debug)]
+pub struct AccountManagerInterfaceHiddenDRAFT1HiddenAccountRemoved {
+    pub account: dbus::Path<'static>,
+}
+
+impl arg::AppendAll for AccountManagerInterfaceHiddenDRAFT1HiddenAccountRemoved {
+    fn append(&self, i: &mut arg::IterAppend) {
+        arg::RefArg::append(&self.account, i);
+    }
+}
+
+impl arg::ReadAll for AccountManagerInterfaceHiddenDRAFT1HiddenAccountRemoved {
+    fn read(i: &mut arg::Iter) -> Result<Self, arg::TypeMismatchError> {
+        Ok(AccountManagerInterfaceHiddenDRAFT1HiddenAccountRemoved { account: i.read()? })
+    }
+}
+
+impl dbus::message::SignalArgs for AccountManagerInterfaceHiddenDRAFT1HiddenAccountRemoved {
+    const NAME: &'static str = "HiddenAccountRemoved";
+    const INTERFACE: &'static str =
+        "org.freedesktop.Telepathy.AccountManager.Interface.Hidden.DRAFT1";
+}
+
+#[derive(Debug)]
+pub struct AccountManagerInterfaceHiddenDRAFT1HiddenAccountValidityChanged {
+    pub account: dbus::Path<'static>,
+    pub valid: bool,
+}
+
+impl arg::AppendAll for AccountManagerInterfaceHiddenDRAFT1HiddenAccountValidityChanged {
+    fn append(&self, i: &mut arg::IterAppend) {
+        arg::RefArg::append(&self.account, i);
+        arg::RefArg::append(&self.valid, i);
+    }
+}
+
+impl arg::ReadAll for AccountManagerInterfaceHiddenDRAFT1HiddenAccountValidityChanged {
+    fn read(i: &mut arg::Iter) -> Result<Self, arg::TypeMismatchError> {
+        Ok(
+            AccountManagerInterfaceHiddenDRAFT1HiddenAccountValidityChanged {
+                account: i.read()?,
+                valid: i.read()?,
+            },
+        )
+    }
+}
+
+impl dbus::message::SignalArgs for AccountManagerInterfaceHiddenDRAFT1HiddenAccountValidityChanged {
+    const NAME: &'static str = "HiddenAccountValidityChanged";
+    const INTERFACE: &'static str =
+        "org.freedesktop.Telepathy.AccountManager.Interface.Hidden.DRAFT1";
+}
--- a/src/telepathy/all.rs
+++ b/src/telepathy/all.rs
@@ -0,0 +1,4 @@
+// This code was autogenerated with `dbus-codegen-rust --file telepathy-spec/spec/all.xml -i org.freedesktop.Telepathy -a AsRefClosure -o src/telepathy/all.rs`, see https://github.com/diwic/dbus-rs
+use dbus;
+use dbus::arg;
+use dbus::tree;
--- a/src/telepathy/authentication_tls_certificate.rs
+++ b/src/telepathy/authentication_tls_certificate.rs
@@ -0,0 +1,181 @@
+// This code was autogenerated with `dbus-codegen-rust --file telepathy-spec/spec/Authentication_TLS_Certificate.xml -i org.freedesktop.Telepathy -a AsRefClosure -o src/telepathy/authentication_tls_certificate.rs`, see https://github.com/diwic/dbus-rs
+use dbus;
+use dbus::arg;
+use dbus::tree;
+
+pub trait AuthenticationTLSCertificate {
+    fn accept(&self) -> Result<(), tree::MethodErr>;
+    fn reject(
+        &self,
+        rejections: Vec<(
+            u32,
+            &str,
+            ::std::collections::HashMap<&str, arg::Variant<Box<dyn arg::RefArg>>>,
+        )>,
+    ) -> Result<(), tree::MethodErr>;
+    fn state(&self) -> Result<u32, tree::MethodErr>;
+    fn rejections(
+        &self,
+    ) -> Result<
+        Vec<(
+            u32,
+            String,
+            ::std::collections::HashMap<String, arg::Variant<Box<dyn arg::RefArg + 'static>>>,
+        )>,
+        tree::MethodErr,
+    >;
+    fn certificate_type(&self) -> Result<String, tree::MethodErr>;
+    fn certificate_chain_data(&self) -> Result<Vec<Vec<u8>>, tree::MethodErr>;
+}
+
+pub fn authentication_tlscertificate_server<F, T, D>(
+    factory: &tree::Factory<tree::MTFn<D>, D>,
+    data: D::Interface,
+    f: F,
+) -> tree::Interface<tree::MTFn<D>, D>
+where
+    D: tree::DataType,
+    D::Method: Default,
+    D::Property: Default,
+    D::Signal: Default,
+    T: AsRef<dyn AuthenticationTLSCertificate>,
+    F: 'static + Fn(&tree::MethodInfo<tree::MTFn<D>, D>) -> T,
+{
+    let i = factory.interface(
+        "org.freedesktop.Telepathy.Authentication.TLSCertificate",
+        data,
+    );
+    let f = ::std::sync::Arc::new(f);
+    let fclone = f.clone();
+    let h = move |minfo: &tree::MethodInfo<tree::MTFn<D>, D>| {
+        let dd = fclone(minfo);
+        let d = dd.as_ref();
+        d.accept()?;
+        let rm = minfo.msg.method_return();
+        Ok(vec![rm])
+    };
+    let m = factory.method("Accept", Default::default(), h);
+    let i = i.add_m(m);
+
+    let fclone = f.clone();
+    let h = move |minfo: &tree::MethodInfo<tree::MTFn<D>, D>| {
+        let mut i = minfo.msg.iter_init();
+        let rejections: Vec<(
+            u32,
+            &str,
+            ::std::collections::HashMap<&str, arg::Variant<Box<dyn arg::RefArg>>>,
+        )> = i.read()?;
+        let dd = fclone(minfo);
+        let d = dd.as_ref();
+        d.reject(rejections)?;
+        let rm = minfo.msg.method_return();
+        Ok(vec![rm])
+    };
+    let m = factory.method("Reject", Default::default(), h);
+    let m = m.in_arg(("Rejections", "a(usa{sv})"));
+    let i = i.add_m(m);
+
+    let p = factory.property::<u32, _>("State", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let dd = fclone(&minfo);
+        let d = dd.as_ref();
+        a.append(d.state()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+
+    let p = factory.property::<Vec<(
+        u32,
+        &str,
+        ::std::collections::HashMap<&str, arg::Variant<Box<dyn arg::RefArg>>>,
+    )>, _>("Rejections", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let dd = fclone(&minfo);
+        let d = dd.as_ref();
+        a.append(d.rejections()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+
+    let p = factory.property::<&str, _>("CertificateType", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let dd = fclone(&minfo);
+        let d = dd.as_ref();
+        a.append(d.certificate_type()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+
+    let p = factory.property::<Vec<Vec<u8>>, _>("CertificateChainData", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let dd = fclone(&minfo);
+        let d = dd.as_ref();
+        a.append(d.certificate_chain_data()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+    let s = factory.signal("Accepted", Default::default());
+    let i = i.add_s(s);
+    let s = factory.signal("Rejected", Default::default());
+    let s = s.arg(("Rejections", "a(usa{sv})"));
+    let i = i.add_s(s);
+    i
+}
+
+#[derive(Debug)]
+pub struct AuthenticationTLSCertificateAccepted {}
+
+impl arg::AppendAll for AuthenticationTLSCertificateAccepted {
+    fn append(&self, _: &mut arg::IterAppend) {}
+}
+
+impl arg::ReadAll for AuthenticationTLSCertificateAccepted {
+    fn read(_: &mut arg::Iter) -> Result<Self, arg::TypeMismatchError> {
+        Ok(AuthenticationTLSCertificateAccepted {})
+    }
+}
+
+impl dbus::message::SignalArgs for AuthenticationTLSCertificateAccepted {
+    const NAME: &'static str = "Accepted";
+    const INTERFACE: &'static str = "org.freedesktop.Telepathy.Authentication.TLSCertificate";
+}
+
+#[derive(Debug)]
+pub struct AuthenticationTLSCertificateRejected {
+    pub rejections: Vec<(
+        u32,
+        String,
+        ::std::collections::HashMap<String, arg::Variant<Box<dyn arg::RefArg + 'static>>>,
+    )>,
+}
+
+impl arg::AppendAll for AuthenticationTLSCertificateRejected {
+    fn append(&self, i: &mut arg::IterAppend) {
+        arg::RefArg::append(&self.rejections, i);
+    }
+}
+
+impl arg::ReadAll for AuthenticationTLSCertificateRejected {
+    fn read(i: &mut arg::Iter) -> Result<Self, arg::TypeMismatchError> {
+        Ok(AuthenticationTLSCertificateRejected {
+            rejections: i.read()?,
+        })
+    }
+}
+
+impl dbus::message::SignalArgs for AuthenticationTLSCertificateRejected {
+    const NAME: &'static str = "Rejected";
+    const INTERFACE: &'static str = "org.freedesktop.Telepathy.Authentication.TLSCertificate";
+}
--- a/src/telepathy/call_content.rs
+++ b/src/telepathy/call_content.rs
@@ -0,0 +1,157 @@
+// This code was autogenerated with `dbus-codegen-rust --file telepathy-spec/spec/Call_Content.xml -i org.freedesktop.Telepathy -a AsRefClosure -o src/telepathy/call_content.rs`, see https://github.com/diwic/dbus-rs
+use dbus;
+use dbus::arg;
+use dbus::tree;
+
+pub trait Call1Content {
+    fn remove(&self) -> Result<(), tree::MethodErr>;
+    fn interfaces(&self) -> Result<Vec<String>, tree::MethodErr>;
+    fn name(&self) -> Result<String, tree::MethodErr>;
+    fn type_(&self) -> Result<u32, tree::MethodErr>;
+    fn disposition(&self) -> Result<u32, tree::MethodErr>;
+    fn streams(&self) -> Result<Vec<dbus::Path<'static>>, tree::MethodErr>;
+}
+
+pub fn call1_content_server<F, T, D>(
+    factory: &tree::Factory<tree::MTFn<D>, D>,
+    data: D::Interface,
+    f: F,
+) -> tree::Interface<tree::MTFn<D>, D>
+where
+    D: tree::DataType,
+    D::Method: Default,
+    D::Property: Default,
+    D::Signal: Default,
+    T: AsRef<dyn Call1Content>,
+    F: 'static + Fn(&tree::MethodInfo<tree::MTFn<D>, D>) -> T,
+{
+    let i = factory.interface("org.freedesktop.Telepathy.Call1.Content", data);
+    let f = ::std::sync::Arc::new(f);
+    let fclone = f.clone();
+    let h = move |minfo: &tree::MethodInfo<tree::MTFn<D>, D>| {
+        let dd = fclone(minfo);
+        let d = dd.as_ref();
+        d.remove()?;
+        let rm = minfo.msg.method_return();
+        Ok(vec![rm])
+    };
+    let m = factory.method("Remove", Default::default(), h);
+    let i = i.add_m(m);
+
+    let p = factory.property::<Vec<&str>, _>("Interfaces", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let dd = fclone(&minfo);
+        let d = dd.as_ref();
+        a.append(d.interfaces()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+
+    let p = factory.property::<&str, _>("Name", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let dd = fclone(&minfo);
+        let d = dd.as_ref();
+        a.append(d.name()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+
+    let p = factory.property::<u32, _>("Type", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let dd = fclone(&minfo);
+        let d = dd.as_ref();
+        a.append(d.type_()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+
+    let p = factory.property::<u32, _>("Disposition", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let dd = fclone(&minfo);
+        let d = dd.as_ref();
+        a.append(d.disposition()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+
+    let p = factory.property::<Vec<dbus::Path>, _>("Streams", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let dd = fclone(&minfo);
+        let d = dd.as_ref();
+        a.append(d.streams()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+    let s = factory.signal("StreamsAdded", Default::default());
+    let s = s.arg(("Streams", "ao"));
+    let i = i.add_s(s);
+    let s = factory.signal("StreamsRemoved", Default::default());
+    let s = s.arg(("Streams", "ao"));
+    let s = s.arg(("Reason", "(uuss)"));
+    let i = i.add_s(s);
+    i
+}
+
+#[derive(Debug)]
+pub struct Call1ContentStreamsAdded {
+    pub streams: Vec<dbus::Path<'static>>,
+}
+
+impl arg::AppendAll for Call1ContentStreamsAdded {
+    fn append(&self, i: &mut arg::IterAppend) {
+        arg::RefArg::append(&self.streams, i);
+    }
+}
+
+impl arg::ReadAll for Call1ContentStreamsAdded {
+    fn read(i: &mut arg::Iter) -> Result<Self, arg::TypeMismatchError> {
+        Ok(Call1ContentStreamsAdded { streams: i.read()? })
+    }
+}
+
+impl dbus::message::SignalArgs for Call1ContentStreamsAdded {
+    const NAME: &'static str = "StreamsAdded";
+    const INTERFACE: &'static str = "org.freedesktop.Telepathy.Call1.Content";
+}
+
+#[derive(Debug)]
+pub struct Call1ContentStreamsRemoved {
+    pub streams: Vec<dbus::Path<'static>>,
+    pub reason: (u32, u32, String, String),
+}
+
+impl arg::AppendAll for Call1ContentStreamsRemoved {
+    fn append(&self, i: &mut arg::IterAppend) {
+        arg::RefArg::append(&self.streams, i);
+        arg::RefArg::append(&self.reason, i);
+    }
+}
+
+impl arg::ReadAll for Call1ContentStreamsRemoved {
+    fn read(i: &mut arg::Iter) -> Result<Self, arg::TypeMismatchError> {
+        Ok(Call1ContentStreamsRemoved {
+            streams: i.read()?,
+            reason: i.read()?,
+        })
+    }
+}
+
+impl dbus::message::SignalArgs for Call1ContentStreamsRemoved {
+    const NAME: &'static str = "StreamsRemoved";
+    const INTERFACE: &'static str = "org.freedesktop.Telepathy.Call1.Content";
+}
--- a/src/telepathy/call_content_interface_audio_control.rs
+++ b/src/telepathy/call_content_interface_audio_control.rs
@@ -0,0 +1,82 @@
+// This code was autogenerated with `dbus-codegen-rust --file telepathy-spec/spec/Call_Content_Interface_Audio_Control.xml -i org.freedesktop.Telepathy -a AsRefClosure -o src/telepathy/call_content_interface_audio_control.rs`, see https://github.com/diwic/dbus-rs
+use dbus;
+use dbus::arg;
+use dbus::tree;
+
+pub trait Call1ContentInterfaceAudioControl {
+    fn report_input_volume(&self, volume: i32) -> Result<(), tree::MethodErr>;
+    fn report_output_volume(&self, volume: i32) -> Result<(), tree::MethodErr>;
+    fn requested_input_volume(&self) -> Result<i32, tree::MethodErr>;
+    fn requested_output_volume(&self) -> Result<i32, tree::MethodErr>;
+}
+
+pub fn call1_content_interface_audio_control_server<F, T, D>(
+    factory: &tree::Factory<tree::MTFn<D>, D>,
+    data: D::Interface,
+    f: F,
+) -> tree::Interface<tree::MTFn<D>, D>
+where
+    D: tree::DataType,
+    D::Method: Default,
+    D::Property: Default,
+    T: AsRef<dyn Call1ContentInterfaceAudioControl>,
+    F: 'static + Fn(&tree::MethodInfo<tree::MTFn<D>, D>) -> T,
+{
+    let i = factory.interface(
+        "org.freedesktop.Telepathy.Call1.Content.Interface.AudioControl",
+        data,
+    );
+    let f = ::std::sync::Arc::new(f);
+    let fclone = f.clone();
+    let h = move |minfo: &tree::MethodInfo<tree::MTFn<D>, D>| {
+        let mut i = minfo.msg.iter_init();
+        let volume: i32 = i.read()?;
+        let dd = fclone(minfo);
+        let d = dd.as_ref();
+        d.report_input_volume(volume)?;
+        let rm = minfo.msg.method_return();
+        Ok(vec![rm])
+    };
+    let m = factory.method("ReportInputVolume", Default::default(), h);
+    let m = m.in_arg(("Volume", "i"));
+    let i = i.add_m(m);
+
+    let fclone = f.clone();
+    let h = move |minfo: &tree::MethodInfo<tree::MTFn<D>, D>| {
+        let mut i = minfo.msg.iter_init();
+        let volume: i32 = i.read()?;
+        let dd = fclone(minfo);
+        let d = dd.as_ref();
+        d.report_output_volume(volume)?;
+        let rm = minfo.msg.method_return();
+        Ok(vec![rm])
+    };
+    let m = factory.method("ReportOutputVolume", Default::default(), h);
+    let m = m.in_arg(("Volume", "i"));
+    let i = i.add_m(m);
+
+    let p = factory.property::<i32, _>("RequestedInputVolume", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let dd = fclone(&minfo);
+        let d = dd.as_ref();
+        a.append(d.requested_input_volume()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+
+    let p = factory.property::<i32, _>("RequestedOutputVolume", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let dd = fclone(&minfo);
+        let d = dd.as_ref();
+        a.append(d.requested_output_volume()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+    i
+}
--- a/src/telepathy/call_content_interface_dtmf.rs
+++ b/src/telepathy/call_content_interface_dtmf.rs
@@ -0,0 +1,172 @@
+// This code was autogenerated with `dbus-codegen-rust --file telepathy-spec/spec/Call_Content_Interface_DTMF.xml -i org.freedesktop.Telepathy -a AsRefClosure -o src/telepathy/call_content_interface_dtmf.rs`, see https://github.com/diwic/dbus-rs
+use dbus;
+use dbus::arg;
+use dbus::tree;
+
+pub trait Call1ContentInterfaceDTMF {
+    fn start_tone(&self, event: u8) -> Result<(), tree::MethodErr>;
+    fn stop_tone(&self) -> Result<(), tree::MethodErr>;
+    fn multiple_tones(&self, tones: &str) -> Result<(), tree::MethodErr>;
+    fn currently_sending_tones(&self) -> Result<bool, tree::MethodErr>;
+    fn deferred_tones(&self) -> Result<String, tree::MethodErr>;
+}
+
+pub fn call1_content_interface_dtmf_server<F, T, D>(
+    factory: &tree::Factory<tree::MTFn<D>, D>,
+    data: D::Interface,
+    f: F,
+) -> tree::Interface<tree::MTFn<D>, D>
+where
+    D: tree::DataType,
+    D::Method: Default,
+    D::Property: Default,
+    D::Signal: Default,
+    T: AsRef<dyn Call1ContentInterfaceDTMF>,
+    F: 'static + Fn(&tree::MethodInfo<tree::MTFn<D>, D>) -> T,
+{
+    let i = factory.interface(
+        "org.freedesktop.Telepathy.Call1.Content.Interface.DTMF",
+        data,
+    );
+    let f = ::std::sync::Arc::new(f);
+    let fclone = f.clone();
+    let h = move |minfo: &tree::MethodInfo<tree::MTFn<D>, D>| {
+        let mut i = minfo.msg.iter_init();
+        let event: u8 = i.read()?;
+        let dd = fclone(minfo);
+        let d = dd.as_ref();
+        d.start_tone(event)?;
+        let rm = minfo.msg.method_return();
+        Ok(vec![rm])
+    };
+    let m = factory.method("StartTone", Default::default(), h);
+    let m = m.in_arg(("Event", "y"));
+    let i = i.add_m(m);
+
+    let fclone = f.clone();
+    let h = move |minfo: &tree::MethodInfo<tree::MTFn<D>, D>| {
+        let dd = fclone(minfo);
+        let d = dd.as_ref();
+        d.stop_tone()?;
+        let rm = minfo.msg.method_return();
+        Ok(vec![rm])
+    };
+    let m = factory.method("StopTone", Default::default(), h);
+    let i = i.add_m(m);
+
+    let fclone = f.clone();
+    let h = move |minfo: &tree::MethodInfo<tree::MTFn<D>, D>| {
+        let mut i = minfo.msg.iter_init();
+        let tones: &str = i.read()?;
+        let dd = fclone(minfo);
+        let d = dd.as_ref();
+        d.multiple_tones(tones)?;
+        let rm = minfo.msg.method_return();
+        Ok(vec![rm])
+    };
+    let m = factory.method("MultipleTones", Default::default(), h);
+    let m = m.in_arg(("Tones", "s"));
+    let i = i.add_m(m);
+
+    let p = factory.property::<bool, _>("CurrentlySendingTones", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let dd = fclone(&minfo);
+        let d = dd.as_ref();
+        a.append(d.currently_sending_tones()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+
+    let p = factory.property::<&str, _>("DeferredTones", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let dd = fclone(&minfo);
+        let d = dd.as_ref();
+        a.append(d.deferred_tones()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+    let s = factory.signal("TonesDeferred", Default::default());
+    let s = s.arg(("Tones", "s"));
+    let i = i.add_s(s);
+    let s = factory.signal("SendingTones", Default::default());
+    let s = s.arg(("Tones", "s"));
+    let i = i.add_s(s);
+    let s = factory.signal("StoppedTones", Default::default());
+    let s = s.arg(("Cancelled", "b"));
+    let i = i.add_s(s);
+    i
+}
+
+#[derive(Debug)]
+pub struct Call1ContentInterfaceDTMFTonesDeferred {
+    pub tones: String,
+}
+
+impl arg::AppendAll for Call1ContentInterfaceDTMFTonesDeferred {
+    fn append(&self, i: &mut arg::IterAppend) {
+        arg::RefArg::append(&self.tones, i);
+    }
+}
+
+impl arg::ReadAll for Call1ContentInterfaceDTMFTonesDeferred {
+    fn read(i: &mut arg::Iter) -> Result<Self, arg::TypeMismatchError> {
+        Ok(Call1ContentInterfaceDTMFTonesDeferred { tones: i.read()? })
+    }
+}
+
+impl dbus::message::SignalArgs for Call1ContentInterfaceDTMFTonesDeferred {
+    const NAME: &'static str = "TonesDeferred";
+    const INTERFACE: &'static str = "org.freedesktop.Telepathy.Call1.Content.Interface.DTMF";
+}
+
+#[derive(Debug)]
+pub struct Call1ContentInterfaceDTMFSendingTones {
+    pub tones: String,
+}
+
+impl arg::AppendAll for Call1ContentInterfaceDTMFSendingTones {
+    fn append(&self, i: &mut arg::IterAppend) {
+        arg::RefArg::append(&self.tones, i);
+    }
+}
+
+impl arg::ReadAll for Call1ContentInterfaceDTMFSendingTones {
+    fn read(i: &mut arg::Iter) -> Result<Self, arg::TypeMismatchError> {
+        Ok(Call1ContentInterfaceDTMFSendingTones { tones: i.read()? })
+    }
+}
+
+impl dbus::message::SignalArgs for Call1ContentInterfaceDTMFSendingTones {
+    const NAME: &'static str = "SendingTones";
+    const INTERFACE: &'static str = "org.freedesktop.Telepathy.Call1.Content.Interface.DTMF";
+}
+
+#[derive(Debug)]
+pub struct Call1ContentInterfaceDTMFStoppedTones {
+    pub cancelled: bool,
+}
+
+impl arg::AppendAll for Call1ContentInterfaceDTMFStoppedTones {
+    fn append(&self, i: &mut arg::IterAppend) {
+        arg::RefArg::append(&self.cancelled, i);
+    }
+}
+
+impl arg::ReadAll for Call1ContentInterfaceDTMFStoppedTones {
+    fn read(i: &mut arg::Iter) -> Result<Self, arg::TypeMismatchError> {
+        Ok(Call1ContentInterfaceDTMFStoppedTones {
+            cancelled: i.read()?,
+        })
+    }
+}
+
+impl dbus::message::SignalArgs for Call1ContentInterfaceDTMFStoppedTones {
+    const NAME: &'static str = "StoppedTones";
+    const INTERFACE: &'static str = "org.freedesktop.Telepathy.Call1.Content.Interface.DTMF";
+}
--- a/src/telepathy/call_content_interface_media.rs
+++ b/src/telepathy/call_content_interface_media.rs
@@ -0,0 +1,359 @@
+// This code was autogenerated with `dbus-codegen-rust --file telepathy-spec/spec/Call_Content_Interface_Media.xml -i org.freedesktop.Telepathy -a AsRefClosure -o src/telepathy/call_content_interface_media.rs`, see https://github.com/diwic/dbus-rs
+use dbus;
+use dbus::arg;
+use dbus::tree;
+
+pub trait Call1ContentInterfaceMedia {
+    fn update_local_media_description(
+        &self,
+        media_description: ::std::collections::HashMap<&str, arg::Variant<Box<dyn arg::RefArg>>>,
+    ) -> Result<(), tree::MethodErr>;
+    fn acknowledge_dtmfchange(&self, event: u8, state: u32) -> Result<(), tree::MethodErr>;
+    fn fail(&self, reason: (u32, u32, &str, &str)) -> Result<(), tree::MethodErr>;
+    fn remote_media_descriptions(
+        &self,
+    ) -> Result<
+        ::std::collections::HashMap<
+            u32,
+            ::std::collections::HashMap<String, arg::Variant<Box<dyn arg::RefArg + 'static>>>,
+        >,
+        tree::MethodErr,
+    >;
+    fn local_media_descriptions(
+        &self,
+    ) -> Result<
+        ::std::collections::HashMap<
+            u32,
+            ::std::collections::HashMap<String, arg::Variant<Box<dyn arg::RefArg + 'static>>>,
+        >,
+        tree::MethodErr,
+    >;
+    fn media_description_offer(
+        &self,
+    ) -> Result<
+        (
+            dbus::Path<'static>,
+            ::std::collections::HashMap<String, arg::Variant<Box<dyn arg::RefArg + 'static>>>,
+        ),
+        tree::MethodErr,
+    >;
+    fn packetization(&self) -> Result<u32, tree::MethodErr>;
+    fn current_dtmfevent(&self) -> Result<u8, tree::MethodErr>;
+    fn current_dtmfstate(&self) -> Result<u32, tree::MethodErr>;
+}
+
+pub fn call1_content_interface_media_server<F, T, D>(
+    factory: &tree::Factory<tree::MTFn<D>, D>,
+    data: D::Interface,
+    f: F,
+) -> tree::Interface<tree::MTFn<D>, D>
+where
+    D: tree::DataType,
+    D::Method: Default,
+    D::Property: Default,
+    D::Signal: Default,
+    T: AsRef<dyn Call1ContentInterfaceMedia>,
+    F: 'static + Fn(&tree::MethodInfo<tree::MTFn<D>, D>) -> T,
+{
+    let i = factory.interface(
+        "org.freedesktop.Telepathy.Call1.Content.Interface.Media",
+        data,
+    );
+    let f = ::std::sync::Arc::new(f);
+    let fclone = f.clone();
+    let h = move |minfo: &tree::MethodInfo<tree::MTFn<D>, D>| {
+        let mut i = minfo.msg.iter_init();
+        let media_description: ::std::collections::HashMap<
+            &str,
+            arg::Variant<Box<dyn arg::RefArg>>,
+        > = i.read()?;
+        let dd = fclone(minfo);
+        let d = dd.as_ref();
+        d.update_local_media_description(media_description)?;
+        let rm = minfo.msg.method_return();
+        Ok(vec![rm])
+    };
+    let m = factory.method("UpdateLocalMediaDescription", Default::default(), h);
+    let m = m.in_arg(("MediaDescription", "a{sv}"));
+    let i = i.add_m(m);
+
+    let fclone = f.clone();
+    let h = move |minfo: &tree::MethodInfo<tree::MTFn<D>, D>| {
+        let mut i = minfo.msg.iter_init();
+        let event: u8 = i.read()?;
+        let state: u32 = i.read()?;
+        let dd = fclone(minfo);
+        let d = dd.as_ref();
+        d.acknowledge_dtmfchange(event, state)?;
+        let rm = minfo.msg.method_return();
+        Ok(vec![rm])
+    };
+    let m = factory.method("AcknowledgeDTMFChange", Default::default(), h);
+    let m = m.in_arg(("Event", "y"));
+    let m = m.in_arg(("State", "u"));
+    let i = i.add_m(m);
+
+    let fclone = f.clone();
+    let h = move |minfo: &tree::MethodInfo<tree::MTFn<D>, D>| {
+        let mut i = minfo.msg.iter_init();
+        let reason: (u32, u32, &str, &str) = i.read()?;
+        let dd = fclone(minfo);
+        let d = dd.as_ref();
+        d.fail(reason)?;
+        let rm = minfo.msg.method_return();
+        Ok(vec![rm])
+    };
+    let m = factory.method("Fail", Default::default(), h);
+    let m = m.in_arg(("Reason", "(uuss)"));
+    let i = i.add_m(m);
+
+    let p = factory.property::<::std::collections::HashMap<
+        u32,
+        ::std::collections::HashMap<&str, arg::Variant<Box<dyn arg::RefArg>>>,
+    >, _>("RemoteMediaDescriptions", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let dd = fclone(&minfo);
+        let d = dd.as_ref();
+        a.append(d.remote_media_descriptions()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+
+    let p = factory.property::<::std::collections::HashMap<
+        u32,
+        ::std::collections::HashMap<&str, arg::Variant<Box<dyn arg::RefArg>>>,
+    >, _>("LocalMediaDescriptions", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let dd = fclone(&minfo);
+        let d = dd.as_ref();
+        a.append(d.local_media_descriptions()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+
+    let p = factory.property::<(
+        dbus::Path,
+        ::std::collections::HashMap<&str, arg::Variant<Box<dyn arg::RefArg>>>,
+    ), _>("MediaDescriptionOffer", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let dd = fclone(&minfo);
+        let d = dd.as_ref();
+        a.append(d.media_description_offer()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+
+    let p = factory.property::<u32, _>("Packetization", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let dd = fclone(&minfo);
+        let d = dd.as_ref();
+        a.append(d.packetization()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+
+    let p = factory.property::<u8, _>("CurrentDTMFEvent", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let dd = fclone(&minfo);
+        let d = dd.as_ref();
+        a.append(d.current_dtmfevent()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+
+    let p = factory.property::<u32, _>("CurrentDTMFState", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let dd = fclone(&minfo);
+        let d = dd.as_ref();
+        a.append(d.current_dtmfstate()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+    let s = factory.signal("NewMediaDescriptionOffer", Default::default());
+    let s = s.arg(("Media_Description", "o"));
+    let s = s.arg(("Properties", "a{sv}"));
+    let i = i.add_s(s);
+    let s = factory.signal("MediaDescriptionOfferDone", Default::default());
+    let i = i.add_s(s);
+    let s = factory.signal("LocalMediaDescriptionChanged", Default::default());
+    let s = s.arg(("Updated_Media_Description", "a{sv}"));
+    let i = i.add_s(s);
+    let s = factory.signal("RemoteMediaDescriptionsChanged", Default::default());
+    let s = s.arg(("Updated_Media_Descriptions", "a{ua{sv}}"));
+    let i = i.add_s(s);
+    let s = factory.signal("MediaDescriptionsRemoved", Default::default());
+    let s = s.arg(("Removed_Media_Descriptions", "au"));
+    let i = i.add_s(s);
+    let s = factory.signal("DTMFChangeRequested", Default::default());
+    let s = s.arg(("Event", "y"));
+    let s = s.arg(("State", "u"));
+    let i = i.add_s(s);
+    i
+}
+
+#[derive(Debug)]
+pub struct Call1ContentInterfaceMediaNewMediaDescriptionOffer {
+    pub media_description: dbus::Path<'static>,
+    pub properties:
+        ::std::collections::HashMap<String, arg::Variant<Box<dyn arg::RefArg + 'static>>>,
+}
+
+impl arg::AppendAll for Call1ContentInterfaceMediaNewMediaDescriptionOffer {
+    fn append(&self, i: &mut arg::IterAppend) {
+        arg::RefArg::append(&self.media_description, i);
+        arg::RefArg::append(&self.properties, i);
+    }
+}
+
+impl arg::ReadAll for Call1ContentInterfaceMediaNewMediaDescriptionOffer {
+    fn read(i: &mut arg::Iter) -> Result<Self, arg::TypeMismatchError> {
+        Ok(Call1ContentInterfaceMediaNewMediaDescriptionOffer {
+            media_description: i.read()?,
+            properties: i.read()?,
+        })
+    }
+}
+
+impl dbus::message::SignalArgs for Call1ContentInterfaceMediaNewMediaDescriptionOffer {
+    const NAME: &'static str = "NewMediaDescriptionOffer";
+    const INTERFACE: &'static str = "org.freedesktop.Telepathy.Call1.Content.Interface.Media";
+}
+
+#[derive(Debug)]
+pub struct Call1ContentInterfaceMediaMediaDescriptionOfferDone {}
+
+impl arg::AppendAll for Call1ContentInterfaceMediaMediaDescriptionOfferDone {
+    fn append(&self, _: &mut arg::IterAppend) {}
+}
+
+impl arg::ReadAll for Call1ContentInterfaceMediaMediaDescriptionOfferDone {
+    fn read(_: &mut arg::Iter) -> Result<Self, arg::TypeMismatchError> {
+        Ok(Call1ContentInterfaceMediaMediaDescriptionOfferDone {})
+    }
+}
+
+impl dbus::message::SignalArgs for Call1ContentInterfaceMediaMediaDescriptionOfferDone {
+    const NAME: &'static str = "MediaDescriptionOfferDone";
+    const INTERFACE: &'static str = "org.freedesktop.Telepathy.Call1.Content.Interface.Media";
+}
+
+#[derive(Debug)]
+pub struct Call1ContentInterfaceMediaLocalMediaDescriptionChanged {
+    pub updated_media_description:
+        ::std::collections::HashMap<String, arg::Variant<Box<dyn arg::RefArg + 'static>>>,
+}
+
+impl arg::AppendAll for Call1ContentInterfaceMediaLocalMediaDescriptionChanged {
+    fn append(&self, i: &mut arg::IterAppend) {
+        arg::RefArg::append(&self.updated_media_description, i);
+    }
+}
+
+impl arg::ReadAll for Call1ContentInterfaceMediaLocalMediaDescriptionChanged {
+    fn read(i: &mut arg::Iter) -> Result<Self, arg::TypeMismatchError> {
+        Ok(Call1ContentInterfaceMediaLocalMediaDescriptionChanged {
+            updated_media_description: i.read()?,
+        })
+    }
+}
+
+impl dbus::message::SignalArgs for Call1ContentInterfaceMediaLocalMediaDescriptionChanged {
+    const NAME: &'static str = "LocalMediaDescriptionChanged";
+    const INTERFACE: &'static str = "org.freedesktop.Telepathy.Call1.Content.Interface.Media";
+}
+
+#[derive(Debug)]
+pub struct Call1ContentInterfaceMediaRemoteMediaDescriptionsChanged {
+    pub updated_media_descriptions: ::std::collections::HashMap<
+        u32,
+        ::std::collections::HashMap<String, arg::Variant<Box<dyn arg::RefArg + 'static>>>,
+    >,
+}
+
+impl arg::AppendAll for Call1ContentInterfaceMediaRemoteMediaDescriptionsChanged {
+    fn append(&self, i: &mut arg::IterAppend) {
+        arg::RefArg::append(&self.updated_media_descriptions, i);
+    }
+}
+
+impl arg::ReadAll for Call1ContentInterfaceMediaRemoteMediaDescriptionsChanged {
+    fn read(i: &mut arg::Iter) -> Result<Self, arg::TypeMismatchError> {
+        Ok(Call1ContentInterfaceMediaRemoteMediaDescriptionsChanged {
+            updated_media_descriptions: i.read()?,
+        })
+    }
+}
+
+impl dbus::message::SignalArgs for Call1ContentInterfaceMediaRemoteMediaDescriptionsChanged {
+    const NAME: &'static str = "RemoteMediaDescriptionsChanged";
+    const INTERFACE: &'static str = "org.freedesktop.Telepathy.Call1.Content.Interface.Media";
+}
+
+#[derive(Debug)]
+pub struct Call1ContentInterfaceMediaMediaDescriptionsRemoved {
+    pub removed_media_descriptions: Vec<u32>,
+}
+
+impl arg::AppendAll for Call1ContentInterfaceMediaMediaDescriptionsRemoved {
+    fn append(&self, i: &mut arg::IterAppend) {
+        arg::RefArg::append(&self.removed_media_descriptions, i);
+    }
+}
+
+impl arg::ReadAll for Call1ContentInterfaceMediaMediaDescriptionsRemoved {
+    fn read(i: &mut arg::Iter) -> Result<Self, arg::TypeMismatchError> {
+        Ok(Call1ContentInterfaceMediaMediaDescriptionsRemoved {
+            removed_media_descriptions: i.read()?,
+        })
+    }
+}
+
+impl dbus::message::SignalArgs for Call1ContentInterfaceMediaMediaDescriptionsRemoved {
+    const NAME: &'static str = "MediaDescriptionsRemoved";
+    const INTERFACE: &'static str = "org.freedesktop.Telepathy.Call1.Content.Interface.Media";
+}
+
+#[derive(Debug)]
+pub struct Call1ContentInterfaceMediaDTMFChangeRequested {
+    pub event: u8,
+    pub state: u32,
+}
+
+impl arg::AppendAll for Call1ContentInterfaceMediaDTMFChangeRequested {
+    fn append(&self, i: &mut arg::IterAppend) {
+        arg::RefArg::append(&self.event, i);
+        arg::RefArg::append(&self.state, i);
+    }
+}
+
+impl arg::ReadAll for Call1ContentInterfaceMediaDTMFChangeRequested {
+    fn read(i: &mut arg::Iter) -> Result<Self, arg::TypeMismatchError> {
+        Ok(Call1ContentInterfaceMediaDTMFChangeRequested {
+            event: i.read()?,
+            state: i.read()?,
+        })
+    }
+}
+
+impl dbus::message::SignalArgs for Call1ContentInterfaceMediaDTMFChangeRequested {
+    const NAME: &'static str = "DTMFChangeRequested";
+    const INTERFACE: &'static str = "org.freedesktop.Telepathy.Call1.Content.Interface.Media";
+}
--- a/src/telepathy/call_content_interface_video_control.rs
+++ b/src/telepathy/call_content_interface_video_control.rs
@@ -0,0 +1,223 @@
+// This code was autogenerated with `dbus-codegen-rust --file telepathy-spec/spec/Call_Content_Interface_Video_Control.xml -i org.freedesktop.Telepathy -a AsRefClosure -o src/telepathy/call_content_interface_video_control.rs`, see https://github.com/diwic/dbus-rs
+use dbus;
+use dbus::arg;
+use dbus::tree;
+
+pub trait Call1ContentInterfaceVideoControl {
+    fn video_resolution(&self) -> Result<(u32, u32), tree::MethodErr>;
+    fn bitrate(&self) -> Result<u32, tree::MethodErr>;
+    fn framerate(&self) -> Result<u32, tree::MethodErr>;
+    fn mtu(&self) -> Result<u32, tree::MethodErr>;
+    fn manual_key_frames(&self) -> Result<bool, tree::MethodErr>;
+}
+
+pub fn call1_content_interface_video_control_server<F, T, D>(
+    factory: &tree::Factory<tree::MTFn<D>, D>,
+    data: D::Interface,
+    f: F,
+) -> tree::Interface<tree::MTFn<D>, D>
+where
+    D: tree::DataType,
+    D::Method: Default,
+    D::Property: Default,
+    D::Signal: Default,
+    T: AsRef<dyn Call1ContentInterfaceVideoControl>,
+    F: 'static + Fn(&tree::MethodInfo<tree::MTFn<D>, D>) -> T,
+{
+    let i = factory.interface(
+        "org.freedesktop.Telepathy.Call1.Content.Interface.VideoControl",
+        data,
+    );
+    let f = ::std::sync::Arc::new(f);
+    let p = factory.property::<(u32, u32), _>("VideoResolution", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let dd = fclone(&minfo);
+        let d = dd.as_ref();
+        a.append(d.video_resolution()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+
+    let p = factory.property::<u32, _>("Bitrate", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let dd = fclone(&minfo);
+        let d = dd.as_ref();
+        a.append(d.bitrate()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+
+    let p = factory.property::<u32, _>("Framerate", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let dd = fclone(&minfo);
+        let d = dd.as_ref();
+        a.append(d.framerate()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+
+    let p = factory.property::<u32, _>("MTU", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let dd = fclone(&minfo);
+        let d = dd.as_ref();
+        a.append(d.mtu()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+
+    let p = factory.property::<bool, _>("ManualKeyFrames", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let dd = fclone(&minfo);
+        let d = dd.as_ref();
+        a.append(d.manual_key_frames()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+    let s = factory.signal("KeyFrameRequested", Default::default());
+    let i = i.add_s(s);
+    let s = factory.signal("VideoResolutionChanged", Default::default());
+    let s = s.arg(("NewResolution", "(uu)"));
+    let i = i.add_s(s);
+    let s = factory.signal("BitrateChanged", Default::default());
+    let s = s.arg(("NewBitrate", "u"));
+    let i = i.add_s(s);
+    let s = factory.signal("FramerateChanged", Default::default());
+    let s = s.arg(("NewFramerate", "u"));
+    let i = i.add_s(s);
+    let s = factory.signal("MTUChanged", Default::default());
+    let s = s.arg(("NewMTU", "u"));
+    let i = i.add_s(s);
+    i
+}
+
+#[derive(Debug)]
+pub struct Call1ContentInterfaceVideoControlKeyFrameRequested {}
+
+impl arg::AppendAll for Call1ContentInterfaceVideoControlKeyFrameRequested {
+    fn append(&self, _: &mut arg::IterAppend) {}
+}
+
+impl arg::ReadAll for Call1ContentInterfaceVideoControlKeyFrameRequested {
+    fn read(_: &mut arg::Iter) -> Result<Self, arg::TypeMismatchError> {
+        Ok(Call1ContentInterfaceVideoControlKeyFrameRequested {})
+    }
+}
+
+impl dbus::message::SignalArgs for Call1ContentInterfaceVideoControlKeyFrameRequested {
+    const NAME: &'static str = "KeyFrameRequested";
+    const INTERFACE: &'static str =
+        "org.freedesktop.Telepathy.Call1.Content.Interface.VideoControl";
+}
+
+#[derive(Debug)]
+pub struct Call1ContentInterfaceVideoControlVideoResolutionChanged {
+    pub new_resolution: (u32, u32),
+}
+
+impl arg::AppendAll for Call1ContentInterfaceVideoControlVideoResolutionChanged {
+    fn append(&self, i: &mut arg::IterAppend) {
+        arg::RefArg::append(&self.new_resolution, i);
+    }
+}
+
+impl arg::ReadAll for Call1ContentInterfaceVideoControlVideoResolutionChanged {
+    fn read(i: &mut arg::Iter) -> Result<Self, arg::TypeMismatchError> {
+        Ok(Call1ContentInterfaceVideoControlVideoResolutionChanged {
+            new_resolution: i.read()?,
+        })
+    }
+}
+
+impl dbus::message::SignalArgs for Call1ContentInterfaceVideoControlVideoResolutionChanged {
+    const NAME: &'static str = "VideoResolutionChanged";
+    const INTERFACE: &'static str =
+        "org.freedesktop.Telepathy.Call1.Content.Interface.VideoControl";
+}
+
+#[derive(Debug)]
+pub struct Call1ContentInterfaceVideoControlBitrateChanged {
+    pub new_bitrate: u32,
+}
+
+impl arg::AppendAll for Call1ContentInterfaceVideoControlBitrateChanged {
+    fn append(&self, i: &mut arg::IterAppend) {
+        arg::RefArg::append(&self.new_bitrate, i);
+    }
+}
+
+impl arg::ReadAll for Call1ContentInterfaceVideoControlBitrateChanged {
+    fn read(i: &mut arg::Iter) -> Result<Self, arg::TypeMismatchError> {
+        Ok(Call1ContentInterfaceVideoControlBitrateChanged {
+            new_bitrate: i.read()?,
+        })
+    }
+}
+
+impl dbus::message::SignalArgs for Call1ContentInterfaceVideoControlBitrateChanged {
+    const NAME: &'static str = "BitrateChanged";
+    const INTERFACE: &'static str =
+        "org.freedesktop.Telepathy.Call1.Content.Interface.VideoControl";
+}
+
+#[derive(Debug)]
+pub struct Call1ContentInterfaceVideoControlFramerateChanged {
+    pub new_framerate: u32,
+}
+
+impl arg::AppendAll for Call1ContentInterfaceVideoControlFramerateChanged {
+    fn append(&self, i: &mut arg::IterAppend) {
+        arg::RefArg::append(&self.new_framerate, i);
+    }
+}
+
+impl arg::ReadAll for Call1ContentInterfaceVideoControlFramerateChanged {
+    fn read(i: &mut arg::Iter) -> Result<Self, arg::TypeMismatchError> {
+        Ok(Call1ContentInterfaceVideoControlFramerateChanged {
+            new_framerate: i.read()?,
+        })
+    }
+}
+
+impl dbus::message::SignalArgs for Call1ContentInterfaceVideoControlFramerateChanged {
+    const NAME: &'static str = "FramerateChanged";
+    const INTERFACE: &'static str =
+        "org.freedesktop.Telepathy.Call1.Content.Interface.VideoControl";
+}
+
+#[derive(Debug)]
+pub struct Call1ContentInterfaceVideoControlMTUChanged {
+    pub new_mtu: u32,
+}
+
+impl arg::AppendAll for Call1ContentInterfaceVideoControlMTUChanged {
+    fn append(&self, i: &mut arg::IterAppend) {
+        arg::RefArg::append(&self.new_mtu, i);
+    }
+}
+
+impl arg::ReadAll for Call1ContentInterfaceVideoControlMTUChanged {
+    fn read(i: &mut arg::Iter) -> Result<Self, arg::TypeMismatchError> {
+        Ok(Call1ContentInterfaceVideoControlMTUChanged { new_mtu: i.read()? })
+    }
+}
+
+impl dbus::message::SignalArgs for Call1ContentInterfaceVideoControlMTUChanged {
+    const NAME: &'static str = "MTUChanged";
+    const INTERFACE: &'static str =
+        "org.freedesktop.Telepathy.Call1.Content.Interface.VideoControl";
+}
--- a/src/telepathy/call_content_media_description.rs
+++ b/src/telepathy/call_content_media_description.rs
@@ -0,0 +1,163 @@
+// This code was autogenerated with `dbus-codegen-rust --file telepathy-spec/spec/Call_Content_Media_Description.xml -i org.freedesktop.Telepathy -a AsRefClosure -o src/telepathy/call_content_media_description.rs`, see https://github.com/diwic/dbus-rs
+use dbus;
+use dbus::arg;
+use dbus::tree;
+
+pub trait Call1ContentMediaDescription {
+    fn accept(
+        &self,
+        local_media_description: ::std::collections::HashMap<
+            &str,
+            arg::Variant<Box<dyn arg::RefArg>>,
+        >,
+    ) -> Result<(), tree::MethodErr>;
+    fn reject(&self, reason: (u32, u32, &str, &str)) -> Result<(), tree::MethodErr>;
+    fn interfaces(&self) -> Result<Vec<String>, tree::MethodErr>;
+    fn further_negotiation_required(&self) -> Result<bool, tree::MethodErr>;
+    fn has_remote_information(&self) -> Result<bool, tree::MethodErr>;
+    fn codecs(
+        &self,
+    ) -> Result<
+        Vec<(
+            u32,
+            String,
+            u32,
+            u32,
+            bool,
+            ::std::collections::HashMap<String, String>,
+        )>,
+        tree::MethodErr,
+    >;
+    fn remote_contact(&self) -> Result<u32, tree::MethodErr>;
+    fn ssrcs(&self) -> Result<::std::collections::HashMap<u32, Vec<u32>>, tree::MethodErr>;
+}
+
+pub fn call1_content_media_description_server<F, T, D>(
+    factory: &tree::Factory<tree::MTFn<D>, D>,
+    data: D::Interface,
+    f: F,
+) -> tree::Interface<tree::MTFn<D>, D>
+where
+    D: tree::DataType,
+    D::Method: Default,
+    D::Property: Default,
+    T: AsRef<dyn Call1ContentMediaDescription>,
+    F: 'static + Fn(&tree::MethodInfo<tree::MTFn<D>, D>) -> T,
+{
+    let i = factory.interface(
+        "org.freedesktop.Telepathy.Call1.Content.MediaDescription",
+        data,
+    );
+    let f = ::std::sync::Arc::new(f);
+    let fclone = f.clone();
+    let h = move |minfo: &tree::MethodInfo<tree::MTFn<D>, D>| {
+        let mut i = minfo.msg.iter_init();
+        let local_media_description: ::std::collections::HashMap<
+            &str,
+            arg::Variant<Box<dyn arg::RefArg>>,
+        > = i.read()?;
+        let dd = fclone(minfo);
+        let d = dd.as_ref();
+        d.accept(local_media_description)?;
+        let rm = minfo.msg.method_return();
+        Ok(vec![rm])
+    };
+    let m = factory.method("Accept", Default::default(), h);
+    let m = m.in_arg(("Local_Media_Description", "a{sv}"));
+    let i = i.add_m(m);
+
+    let fclone = f.clone();
+    let h = move |minfo: &tree::MethodInfo<tree::MTFn<D>, D>| {
+        let mut i = minfo.msg.iter_init();
+        let reason: (u32, u32, &str, &str) = i.read()?;
+        let dd = fclone(minfo);
+        let d = dd.as_ref();
+        d.reject(reason)?;
+        let rm = minfo.msg.method_return();
+        Ok(vec![rm])
+    };
+    let m = factory.method("Reject", Default::default(), h);
+    let m = m.in_arg(("Reason", "(uuss)"));
+    let i = i.add_m(m);
+
+    let p = factory.property::<Vec<&str>, _>("Interfaces", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let dd = fclone(&minfo);
+        let d = dd.as_ref();
+        a.append(d.interfaces()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+
+    let p = factory.property::<bool, _>("FurtherNegotiationRequired", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let dd = fclone(&minfo);
+        let d = dd.as_ref();
+        a.append(d.further_negotiation_required()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+
+    let p = factory.property::<bool, _>("HasRemoteInformation", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let dd = fclone(&minfo);
+        let d = dd.as_ref();
+        a.append(d.has_remote_information()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+
+    let p = factory.property::<Vec<(
+        u32,
+        &str,
+        u32,
+        u32,
+        bool,
+        ::std::collections::HashMap<&str, &str>,
+    )>, _>("Codecs", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let dd = fclone(&minfo);
+        let d = dd.as_ref();
+        a.append(d.codecs()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+
+    let p = factory.property::<u32, _>("RemoteContact", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let dd = fclone(&minfo);
+        let d = dd.as_ref();
+        a.append(d.remote_contact()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+
+    let p = factory
+        .property::<::std::collections::HashMap<u32, Vec<u32>>, _>("SSRCs", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let dd = fclone(&minfo);
+        let d = dd.as_ref();
+        a.append(d.ssrcs()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+    i
+}
--- a/src/telepathy/call_content_media_description_interface_rtcp_extended_reports.rs
+++ b/src/telepathy/call_content_media_description_interface_rtcp_extended_reports.rs
@@ -0,0 +1,117 @@
+// This code was autogenerated with `dbus-codegen-rust --file telepathy-spec/spec/Call_Content_Media_Description_Interface_RTCP_Extended_Reports.xml -i org.freedesktop.Telepathy -a AsRefClosure -o src/telepathy/call_content_media_description_interface_rtcp_extended_reports.rs`, see https://github.com/diwic/dbus-rs
+use dbus;
+use dbus::arg;
+use dbus::tree;
+
+pub trait Call1ContentMediaDescriptionInterfaceRTCPExtendedReports {
+    fn loss_rlemax_size(&self) -> Result<u32, tree::MethodErr>;
+    fn duplicate_rlemax_size(&self) -> Result<u32, tree::MethodErr>;
+    fn packet_receipt_times_max_size(&self) -> Result<u32, tree::MethodErr>;
+    fn dlrrmax_size(&self) -> Result<u32, tree::MethodErr>;
+    fn rttmode(&self) -> Result<u32, tree::MethodErr>;
+    fn statistics_flags(&self) -> Result<u32, tree::MethodErr>;
+    fn enable_metrics(&self) -> Result<bool, tree::MethodErr>;
+}
+
+pub fn call1_content_media_description_interface_rtcpextended_reports_server<F, T, D>(
+    factory: &tree::Factory<tree::MTFn<D>, D>,
+    data: D::Interface,
+    f: F,
+) -> tree::Interface<tree::MTFn<D>, D>
+where
+    D: tree::DataType,
+    D::Method: Default,
+    D::Property: Default,
+    T: AsRef<dyn Call1ContentMediaDescriptionInterfaceRTCPExtendedReports>,
+    F: 'static + Fn(&tree::MethodInfo<tree::MTFn<D>, D>) -> T,
+{
+    let i = factory.interface(
+        "org.freedesktop.Telepathy.Call1.Content.MediaDescription.Interface.RTCPExtendedReports",
+        data,
+    );
+    let f = ::std::sync::Arc::new(f);
+    let p = factory.property::<u32, _>("LossRLEMaxSize", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let dd = fclone(&minfo);
+        let d = dd.as_ref();
+        a.append(d.loss_rlemax_size()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+
+    let p = factory.property::<u32, _>("DuplicateRLEMaxSize", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let dd = fclone(&minfo);
+        let d = dd.as_ref();
+        a.append(d.duplicate_rlemax_size()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+
+    let p = factory.property::<u32, _>("PacketReceiptTimesMaxSize", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let dd = fclone(&minfo);
+        let d = dd.as_ref();
+        a.append(d.packet_receipt_times_max_size()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+
+    let p = factory.property::<u32, _>("DLRRMaxSize", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let dd = fclone(&minfo);
+        let d = dd.as_ref();
+        a.append(d.dlrrmax_size()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+
+    let p = factory.property::<u32, _>("RTTMode", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let dd = fclone(&minfo);
+        let d = dd.as_ref();
+        a.append(d.rttmode()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+
+    let p = factory.property::<u32, _>("StatisticsFlags", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let dd = fclone(&minfo);
+        let d = dd.as_ref();
+        a.append(d.statistics_flags()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+
+    let p = factory.property::<bool, _>("EnableMetrics", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let dd = fclone(&minfo);
+        let d = dd.as_ref();
+        a.append(d.enable_metrics()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+    i
+}
--- a/src/telepathy/call_content_media_description_interface_rtcp_feedback.rs
+++ b/src/telepathy/call_content_media_description_interface_rtcp_feedback.rs
@@ -0,0 +1,61 @@
+// This code was autogenerated with `dbus-codegen-rust --file telepathy-spec/spec/Call_Content_Media_Description_Interface_RTCP_Feedback.xml -i org.freedesktop.Telepathy -a AsRefClosure -o src/telepathy/call_content_media_description_interface_rtcp_feedback.rs`, see https://github.com/diwic/dbus-rs
+use dbus;
+use dbus::arg;
+use dbus::tree;
+
+pub trait Call1ContentMediaDescriptionInterfaceRTCPFeedback {
+    fn feedback_messages(
+        &self,
+    ) -> Result<
+        ::std::collections::HashMap<u32, (u32, Vec<(String, String, String)>)>,
+        tree::MethodErr,
+    >;
+    fn does_avpf(&self) -> Result<bool, tree::MethodErr>;
+}
+
+pub fn call1_content_media_description_interface_rtcpfeedback_server<F, T, D>(
+    factory: &tree::Factory<tree::MTFn<D>, D>,
+    data: D::Interface,
+    f: F,
+) -> tree::Interface<tree::MTFn<D>, D>
+where
+    D: tree::DataType,
+    D::Method: Default,
+    D::Property: Default,
+    T: AsRef<dyn Call1ContentMediaDescriptionInterfaceRTCPFeedback>,
+    F: 'static + Fn(&tree::MethodInfo<tree::MTFn<D>, D>) -> T,
+{
+    let i = factory.interface(
+        "org.freedesktop.Telepathy.Call1.Content.MediaDescription.Interface.RTCPFeedback",
+        data,
+    );
+    let f = ::std::sync::Arc::new(f);
+    let p = factory
+        .property::<::std::collections::HashMap<u32, (u32, Vec<(&str, &str, &str)>)>, _>(
+            "FeedbackMessages",
+            Default::default(),
+        );
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let dd = fclone(&minfo);
+        let d = dd.as_ref();
+        a.append(d.feedback_messages()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+
+    let p = factory.property::<bool, _>("DoesAVPF", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let dd = fclone(&minfo);
+        let d = dd.as_ref();
+        a.append(d.does_avpf()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+    i
+}
--- a/src/telepathy/call_content_media_description_interface_rtp_header_extensions.rs
+++ b/src/telepathy/call_content_media_description_interface_rtp_header_extensions.rs
@@ -0,0 +1,40 @@
+// This code was autogenerated with `dbus-codegen-rust --file telepathy-spec/spec/Call_Content_Media_Description_Interface_RTP_Header_Extensions.xml -i org.freedesktop.Telepathy -a AsRefClosure -o src/telepathy/call_content_media_description_interface_rtp_header_extensions.rs`, see https://github.com/diwic/dbus-rs
+use dbus;
+use dbus::arg;
+use dbus::tree;
+
+pub trait Call1ContentMediaDescriptionInterfaceRTPHeaderExtensions {
+    fn header_extensions(&self) -> Result<Vec<(u32, u32, String, String)>, tree::MethodErr>;
+}
+
+pub fn call1_content_media_description_interface_rtpheader_extensions_server<F, T, D>(
+    factory: &tree::Factory<tree::MTFn<D>, D>,
+    data: D::Interface,
+    f: F,
+) -> tree::Interface<tree::MTFn<D>, D>
+where
+    D: tree::DataType,
+    D::Method: Default,
+    D::Property: Default,
+    T: AsRef<dyn Call1ContentMediaDescriptionInterfaceRTPHeaderExtensions>,
+    F: 'static + Fn(&tree::MethodInfo<tree::MTFn<D>, D>) -> T,
+{
+    let i = factory.interface(
+        "org.freedesktop.Telepathy.Call1.Content.MediaDescription.Interface.RTPHeaderExtensions",
+        data,
+    );
+    let f = ::std::sync::Arc::new(f);
+    let p =
+        factory.property::<Vec<(u32, u32, &str, &str)>, _>("HeaderExtensions", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let dd = fclone(&minfo);
+        let d = dd.as_ref();
+        a.append(d.header_extensions()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+    i
+}
--- a/src/telepathy/call_interface_mute.rs
+++ b/src/telepathy/call_interface_mute.rs
@@ -0,0 +1,79 @@
+// This code was autogenerated with `dbus-codegen-rust --file telepathy-spec/spec/Call_Interface_Mute.xml -i org.freedesktop.Telepathy -a AsRefClosure -o src/telepathy/call_interface_mute.rs`, see https://github.com/diwic/dbus-rs
+use dbus;
+use dbus::arg;
+use dbus::tree;
+
+pub trait Call1InterfaceMute {
+    fn request_muted(&self, muted: bool) -> Result<(), tree::MethodErr>;
+    fn local_mute_state(&self) -> Result<u32, tree::MethodErr>;
+}
+
+pub fn call1_interface_mute_server<F, T, D>(
+    factory: &tree::Factory<tree::MTFn<D>, D>,
+    data: D::Interface,
+    f: F,
+) -> tree::Interface<tree::MTFn<D>, D>
+where
+    D: tree::DataType,
+    D::Method: Default,
+    D::Property: Default,
+    D::Signal: Default,
+    T: AsRef<dyn Call1InterfaceMute>,
+    F: 'static + Fn(&tree::MethodInfo<tree::MTFn<D>, D>) -> T,
+{
+    let i = factory.interface("org.freedesktop.Telepathy.Call1.Interface.Mute", data);
+    let f = ::std::sync::Arc::new(f);
+    let fclone = f.clone();
+    let h = move |minfo: &tree::MethodInfo<tree::MTFn<D>, D>| {
+        let mut i = minfo.msg.iter_init();
+        let muted: bool = i.read()?;
+        let dd = fclone(minfo);
+        let d = dd.as_ref();
+        d.request_muted(muted)?;
+        let rm = minfo.msg.method_return();
+        Ok(vec![rm])
+    };
+    let m = factory.method("RequestMuted", Default::default(), h);
+    let m = m.in_arg(("Muted", "b"));
+    let i = i.add_m(m);
+
+    let p = factory.property::<u32, _>("LocalMuteState", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let dd = fclone(&minfo);
+        let d = dd.as_ref();
+        a.append(d.local_mute_state()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+    let s = factory.signal("MuteStateChanged", Default::default());
+    let s = s.arg(("MuteState", "u"));
+    let i = i.add_s(s);
+    i
+}
+
+#[derive(Debug)]
+pub struct Call1InterfaceMuteMuteStateChanged {
+    pub mute_state: u32,
+}
+
+impl arg::AppendAll for Call1InterfaceMuteMuteStateChanged {
+    fn append(&self, i: &mut arg::IterAppend) {
+        arg::RefArg::append(&self.mute_state, i);
+    }
+}
+
+impl arg::ReadAll for Call1InterfaceMuteMuteStateChanged {
+    fn read(i: &mut arg::Iter) -> Result<Self, arg::TypeMismatchError> {
+        Ok(Call1InterfaceMuteMuteStateChanged {
+            mute_state: i.read()?,
+        })
+    }
+}
+
+impl dbus::message::SignalArgs for Call1InterfaceMuteMuteStateChanged {
+    const NAME: &'static str = "MuteStateChanged";
+    const INTERFACE: &'static str = "org.freedesktop.Telepathy.Call1.Interface.Mute";
+}
--- a/src/telepathy/call_stream.rs
+++ b/src/telepathy/call_stream.rs
@@ -0,0 +1,197 @@
+// This code was autogenerated with `dbus-codegen-rust --file telepathy-spec/spec/Call_Stream.xml -i org.freedesktop.Telepathy -a AsRefClosure -o src/telepathy/call_stream.rs`, see https://github.com/diwic/dbus-rs
+use dbus;
+use dbus::arg;
+use dbus::tree;
+
+pub trait Call1Stream {
+    fn set_sending(&self, send: bool) -> Result<(), tree::MethodErr>;
+    fn request_receiving(&self, contact: u32, receive: bool) -> Result<(), tree::MethodErr>;
+    fn interfaces(&self) -> Result<Vec<String>, tree::MethodErr>;
+    fn remote_members(&self) -> Result<::std::collections::HashMap<u32, u32>, tree::MethodErr>;
+    fn remote_member_identifiers(
+        &self,
+    ) -> Result<::std::collections::HashMap<u32, String>, tree::MethodErr>;
+    fn local_sending_state(&self) -> Result<u32, tree::MethodErr>;
+    fn can_request_receiving(&self) -> Result<bool, tree::MethodErr>;
+}
+
+pub fn call1_stream_server<F, T, D>(
+    factory: &tree::Factory<tree::MTFn<D>, D>,
+    data: D::Interface,
+    f: F,
+) -> tree::Interface<tree::MTFn<D>, D>
+where
+    D: tree::DataType,
+    D::Method: Default,
+    D::Property: Default,
+    D::Signal: Default,
+    T: AsRef<dyn Call1Stream>,
+    F: 'static + Fn(&tree::MethodInfo<tree::MTFn<D>, D>) -> T,
+{
+    let i = factory.interface("org.freedesktop.Telepathy.Call1.Stream", data);
+    let f = ::std::sync::Arc::new(f);
+    let fclone = f.clone();
+    let h = move |minfo: &tree::MethodInfo<tree::MTFn<D>, D>| {
+        let mut i = minfo.msg.iter_init();
+        let send: bool = i.read()?;
+        let dd = fclone(minfo);
+        let d = dd.as_ref();
+        d.set_sending(send)?;
+        let rm = minfo.msg.method_return();
+        Ok(vec![rm])
+    };
+    let m = factory.method("SetSending", Default::default(), h);
+    let m = m.in_arg(("Send", "b"));
+    let i = i.add_m(m);
+
+    let fclone = f.clone();
+    let h = move |minfo: &tree::MethodInfo<tree::MTFn<D>, D>| {
+        let mut i = minfo.msg.iter_init();
+        let contact: u32 = i.read()?;
+        let receive: bool = i.read()?;
+        let dd = fclone(minfo);
+        let d = dd.as_ref();
+        d.request_receiving(contact, receive)?;
+        let rm = minfo.msg.method_return();
+        Ok(vec![rm])
+    };
+    let m = factory.method("RequestReceiving", Default::default(), h);
+    let m = m.in_arg(("Contact", "u"));
+    let m = m.in_arg(("Receive", "b"));
+    let i = i.add_m(m);
+
+    let p = factory.property::<Vec<&str>, _>("Interfaces", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let dd = fclone(&minfo);
+        let d = dd.as_ref();
+        a.append(d.interfaces()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+
+    let p = factory
+        .property::<::std::collections::HashMap<u32, u32>, _>("RemoteMembers", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let dd = fclone(&minfo);
+        let d = dd.as_ref();
+        a.append(d.remote_members()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+
+    let p = factory.property::<::std::collections::HashMap<u32, &str>, _>(
+        "RemoteMemberIdentifiers",
+        Default::default(),
+    );
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let dd = fclone(&minfo);
+        let d = dd.as_ref();
+        a.append(d.remote_member_identifiers()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+
+    let p = factory.property::<u32, _>("LocalSendingState", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let dd = fclone(&minfo);
+        let d = dd.as_ref();
+        a.append(d.local_sending_state()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+
+    let p = factory.property::<bool, _>("CanRequestReceiving", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let dd = fclone(&minfo);
+        let d = dd.as_ref();
+        a.append(d.can_request_receiving()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+    let s = factory.signal("RemoteMembersChanged", Default::default());
+    let s = s.arg(("Updates", "a{uu}"));
+    let s = s.arg(("Identifiers", "a{us}"));
+    let s = s.arg(("Removed", "au"));
+    let s = s.arg(("Reason", "(uuss)"));
+    let i = i.add_s(s);
+    let s = factory.signal("LocalSendingStateChanged", Default::default());
+    let s = s.arg(("State", "u"));
+    let s = s.arg(("Reason", "(uuss)"));
+    let i = i.add_s(s);
+    i
+}
+
+#[derive(Debug)]
+pub struct Call1StreamRemoteMembersChanged {
+    pub updates: ::std::collections::HashMap<u32, u32>,
+    pub identifiers: ::std::collections::HashMap<u32, String>,
+    pub removed: Vec<u32>,
+    pub reason: (u32, u32, String, String),
+}
+
+impl arg::AppendAll for Call1StreamRemoteMembersChanged {
+    fn append(&self, i: &mut arg::IterAppend) {
+        arg::RefArg::append(&self.updates, i);
+        arg::RefArg::append(&self.identifiers, i);
+        arg::RefArg::append(&self.removed, i);
+        arg::RefArg::append(&self.reason, i);
+    }
+}
+
+impl arg::ReadAll for Call1StreamRemoteMembersChanged {
+    fn read(i: &mut arg::Iter) -> Result<Self, arg::TypeMismatchError> {
+        Ok(Call1StreamRemoteMembersChanged {
+            updates: i.read()?,
+            identifiers: i.read()?,
+            removed: i.read()?,
+            reason: i.read()?,
+        })
+    }
+}
+
+impl dbus::message::SignalArgs for Call1StreamRemoteMembersChanged {
+    const NAME: &'static str = "RemoteMembersChanged";
+    const INTERFACE: &'static str = "org.freedesktop.Telepathy.Call1.Stream";
+}
+
+#[derive(Debug)]
+pub struct Call1StreamLocalSendingStateChanged {
+    pub state: u32,
+    pub reason: (u32, u32, String, String),
+}
+
+impl arg::AppendAll for Call1StreamLocalSendingStateChanged {
+    fn append(&self, i: &mut arg::IterAppend) {
+        arg::RefArg::append(&self.state, i);
+        arg::RefArg::append(&self.reason, i);
+    }
+}
+
+impl arg::ReadAll for Call1StreamLocalSendingStateChanged {
+    fn read(i: &mut arg::Iter) -> Result<Self, arg::TypeMismatchError> {
+        Ok(Call1StreamLocalSendingStateChanged {
+            state: i.read()?,
+            reason: i.read()?,
+        })
+    }
+}
+
+impl dbus::message::SignalArgs for Call1StreamLocalSendingStateChanged {
+    const NAME: &'static str = "LocalSendingStateChanged";
+    const INTERFACE: &'static str = "org.freedesktop.Telepathy.Call1.Stream";
+}
--- a/src/telepathy/call_stream_endpoint.rs
+++ b/src/telepathy/call_stream_endpoint.rs
@@ -0,0 +1,479 @@
+// This code was autogenerated with `dbus-codegen-rust --file telepathy-spec/spec/Call_Stream_Endpoint.xml -i org.freedesktop.Telepathy -a AsRefClosure -o src/telepathy/call_stream_endpoint.rs`, see https://github.com/diwic/dbus-rs
+use dbus;
+use dbus::arg;
+use dbus::tree;
+
+pub trait Call1StreamEndpoint {
+    fn set_selected_candidate_pair(
+        &self,
+        local_candidate: (
+            u32,
+            &str,
+            u32,
+            ::std::collections::HashMap<&str, arg::Variant<Box<dyn arg::RefArg>>>,
+        ),
+        remote_candidate: (
+            u32,
+            &str,
+            u32,
+            ::std::collections::HashMap<&str, arg::Variant<Box<dyn arg::RefArg>>>,
+        ),
+    ) -> Result<(), tree::MethodErr>;
+    fn set_endpoint_state_(&self, component: u32, state: u32) -> Result<(), tree::MethodErr>;
+    fn accept_selected_candidate_pair(
+        &self,
+        local_candidate: (
+            u32,
+            &str,
+            u32,
+            ::std::collections::HashMap<&str, arg::Variant<Box<dyn arg::RefArg>>>,
+        ),
+        remote_candidate: (
+            u32,
+            &str,
+            u32,
+            ::std::collections::HashMap<&str, arg::Variant<Box<dyn arg::RefArg>>>,
+        ),
+    ) -> Result<(), tree::MethodErr>;
+    fn reject_selected_candidate_pair(
+        &self,
+        local_candidate: (
+            u32,
+            &str,
+            u32,
+            ::std::collections::HashMap<&str, arg::Variant<Box<dyn arg::RefArg>>>,
+        ),
+        remote_candidate: (
+            u32,
+            &str,
+            u32,
+            ::std::collections::HashMap<&str, arg::Variant<Box<dyn arg::RefArg>>>,
+        ),
+    ) -> Result<(), tree::MethodErr>;
+    fn set_controlling_(&self, controlling: bool) -> Result<(), tree::MethodErr>;
+    fn remote_credentials(&self) -> Result<(String, String), tree::MethodErr>;
+    fn remote_candidates(
+        &self,
+    ) -> Result<
+        Vec<(
+            u32,
+            String,
+            u32,
+            ::std::collections::HashMap<String, arg::Variant<Box<dyn arg::RefArg + 'static>>>,
+        )>,
+        tree::MethodErr,
+    >;
+    fn selected_candidate_pairs(
+        &self,
+    ) -> Result<
+        Vec<(
+            (
+                u32,
+                String,
+                u32,
+                ::std::collections::HashMap<String, arg::Variant<Box<dyn arg::RefArg + 'static>>>,
+            ),
+            (
+                u32,
+                String,
+                u32,
+                ::std::collections::HashMap<String, arg::Variant<Box<dyn arg::RefArg + 'static>>>,
+            ),
+        )>,
+        tree::MethodErr,
+    >;
+    fn endpoint_state(&self) -> Result<::std::collections::HashMap<u32, u32>, tree::MethodErr>;
+    fn transport(&self) -> Result<u32, tree::MethodErr>;
+    fn controlling(&self) -> Result<bool, tree::MethodErr>;
+    fn is_icelite(&self) -> Result<bool, tree::MethodErr>;
+}
+
+pub fn call1_stream_endpoint_server<F, T, D>(
+    factory: &tree::Factory<tree::MTFn<D>, D>,
+    data: D::Interface,
+    f: F,
+) -> tree::Interface<tree::MTFn<D>, D>
+where
+    D: tree::DataType,
+    D::Method: Default,
+    D::Property: Default,
+    D::Signal: Default,
+    T: AsRef<dyn Call1StreamEndpoint>,
+    F: 'static + Fn(&tree::MethodInfo<tree::MTFn<D>, D>) -> T,
+{
+    let i = factory.interface("org.freedesktop.Telepathy.Call1.Stream.Endpoint", data);
+    let f = ::std::sync::Arc::new(f);
+    let fclone = f.clone();
+    let h = move |minfo: &tree::MethodInfo<tree::MTFn<D>, D>| {
+        let mut i = minfo.msg.iter_init();
+        let local_candidate: (
+            u32,
+            &str,
+            u32,
+            ::std::collections::HashMap<&str, arg::Variant<Box<dyn arg::RefArg>>>,
+        ) = i.read()?;
+        let remote_candidate: (
+            u32,
+            &str,
+            u32,
+            ::std::collections::HashMap<&str, arg::Variant<Box<dyn arg::RefArg>>>,
+        ) = i.read()?;
+        let dd = fclone(minfo);
+        let d = dd.as_ref();
+        d.set_selected_candidate_pair(local_candidate, remote_candidate)?;
+        let rm = minfo.msg.method_return();
+        Ok(vec![rm])
+    };
+    let m = factory.method("SetSelectedCandidatePair", Default::default(), h);
+    let m = m.in_arg(("Local_Candidate", "(usua{sv})"));
+    let m = m.in_arg(("Remote_Candidate", "(usua{sv})"));
+    let i = i.add_m(m);
+
+    let fclone = f.clone();
+    let h = move |minfo: &tree::MethodInfo<tree::MTFn<D>, D>| {
+        let mut i = minfo.msg.iter_init();
+        let component: u32 = i.read()?;
+        let state: u32 = i.read()?;
+        let dd = fclone(minfo);
+        let d = dd.as_ref();
+        d.set_endpoint_state_(component, state)?;
+        let rm = minfo.msg.method_return();
+        Ok(vec![rm])
+    };
+    let m = factory.method("SetEndpointState", Default::default(), h);
+    let m = m.in_arg(("Component", "u"));
+    let m = m.in_arg(("State", "u"));
+    let i = i.add_m(m);
+
+    let fclone = f.clone();
+    let h = move |minfo: &tree::MethodInfo<tree::MTFn<D>, D>| {
+        let mut i = minfo.msg.iter_init();
+        let local_candidate: (
+            u32,
+            &str,
+            u32,
+            ::std::collections::HashMap<&str, arg::Variant<Box<dyn arg::RefArg>>>,
+        ) = i.read()?;
+        let remote_candidate: (
+            u32,
+            &str,
+            u32,
+            ::std::collections::HashMap<&str, arg::Variant<Box<dyn arg::RefArg>>>,
+        ) = i.read()?;
+        let dd = fclone(minfo);
+        let d = dd.as_ref();
+        d.accept_selected_candidate_pair(local_candidate, remote_candidate)?;
+        let rm = minfo.msg.method_return();
+        Ok(vec![rm])
+    };
+    let m = factory.method("AcceptSelectedCandidatePair", Default::default(), h);
+    let m = m.in_arg(("Local_Candidate", "(usua{sv})"));
+    let m = m.in_arg(("Remote_Candidate", "(usua{sv})"));
+    let i = i.add_m(m);
+
+    let fclone = f.clone();
+    let h = move |minfo: &tree::MethodInfo<tree::MTFn<D>, D>| {
+        let mut i = minfo.msg.iter_init();
+        let local_candidate: (
+            u32,
+            &str,
+            u32,
+            ::std::collections::HashMap<&str, arg::Variant<Box<dyn arg::RefArg>>>,
+        ) = i.read()?;
+        let remote_candidate: (
+            u32,
+            &str,
+            u32,
+            ::std::collections::HashMap<&str, arg::Variant<Box<dyn arg::RefArg>>>,
+        ) = i.read()?;
+        let dd = fclone(minfo);
+        let d = dd.as_ref();
+        d.reject_selected_candidate_pair(local_candidate, remote_candidate)?;
+        let rm = minfo.msg.method_return();
+        Ok(vec![rm])
+    };
+    let m = factory.method("RejectSelectedCandidatePair", Default::default(), h);
+    let m = m.in_arg(("Local_Candidate", "(usua{sv})"));
+    let m = m.in_arg(("Remote_Candidate", "(usua{sv})"));
+    let i = i.add_m(m);
+
+    let fclone = f.clone();
+    let h = move |minfo: &tree::MethodInfo<tree::MTFn<D>, D>| {
+        let mut i = minfo.msg.iter_init();
+        let controlling: bool = i.read()?;
+        let dd = fclone(minfo);
+        let d = dd.as_ref();
+        d.set_controlling_(controlling)?;
+        let rm = minfo.msg.method_return();
+        Ok(vec![rm])
+    };
+    let m = factory.method("SetControlling", Default::default(), h);
+    let m = m.in_arg(("Controlling", "b"));
+    let i = i.add_m(m);
+
+    let p = factory.property::<(&str, &str), _>("RemoteCredentials", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let dd = fclone(&minfo);
+        let d = dd.as_ref();
+        a.append(d.remote_credentials()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+
+    let p = factory.property::<Vec<(
+        u32,
+        &str,
+        u32,
+        ::std::collections::HashMap<&str, arg::Variant<Box<dyn arg::RefArg>>>,
+    )>, _>("RemoteCandidates", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let dd = fclone(&minfo);
+        let d = dd.as_ref();
+        a.append(d.remote_candidates()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+
+    let p = factory.property::<Vec<(
+        (
+            u32,
+            &str,
+            u32,
+            ::std::collections::HashMap<&str, arg::Variant<Box<dyn arg::RefArg>>>,
+        ),
+        (
+            u32,
+            &str,
+            u32,
+            ::std::collections::HashMap<&str, arg::Variant<Box<dyn arg::RefArg>>>,
+        ),
+    )>, _>("SelectedCandidatePairs", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let dd = fclone(&minfo);
+        let d = dd.as_ref();
+        a.append(d.selected_candidate_pairs()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+
+    let p = factory
+        .property::<::std::collections::HashMap<u32, u32>, _>("EndpointState", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let dd = fclone(&minfo);
+        let d = dd.as_ref();
+        a.append(d.endpoint_state()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+
+    let p = factory.property::<u32, _>("Transport", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let dd = fclone(&minfo);
+        let d = dd.as_ref();
+        a.append(d.transport()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+
+    let p = factory.property::<bool, _>("Controlling", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let dd = fclone(&minfo);
+        let d = dd.as_ref();
+        a.append(d.controlling()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+
+    let p = factory.property::<bool, _>("IsICELite", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let dd = fclone(&minfo);
+        let d = dd.as_ref();
+        a.append(d.is_icelite()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+    let s = factory.signal("RemoteCredentialsSet", Default::default());
+    let s = s.arg(("Username", "s"));
+    let s = s.arg(("Password", "s"));
+    let i = i.add_s(s);
+    let s = factory.signal("RemoteCandidatesAdded", Default::default());
+    let s = s.arg(("Candidates", "a(usua{sv})"));
+    let i = i.add_s(s);
+    let s = factory.signal("CandidatePairSelected", Default::default());
+    let s = s.arg(("Local_Candidate", "(usua{sv})"));
+    let s = s.arg(("Remote_Candidate", "(usua{sv})"));
+    let i = i.add_s(s);
+    let s = factory.signal("EndpointStateChanged", Default::default());
+    let s = s.arg(("Component", "u"));
+    let s = s.arg(("State", "u"));
+    let i = i.add_s(s);
+    let s = factory.signal("ControllingChanged", Default::default());
+    let s = s.arg(("Controlling", "b"));
+    let i = i.add_s(s);
+    i
+}
+
+#[derive(Debug)]
+pub struct Call1StreamEndpointRemoteCredentialsSet {
+    pub username: String,
+    pub password: String,
+}
+
+impl arg::AppendAll for Call1StreamEndpointRemoteCredentialsSet {
+    fn append(&self, i: &mut arg::IterAppend) {
+        arg::RefArg::append(&self.username, i);
+        arg::RefArg::append(&self.password, i);
+    }
+}
+
+impl arg::ReadAll for Call1StreamEndpointRemoteCredentialsSet {
+    fn read(i: &mut arg::Iter) -> Result<Self, arg::TypeMismatchError> {
+        Ok(Call1StreamEndpointRemoteCredentialsSet {
+            username: i.read()?,
+            password: i.read()?,
+        })
+    }
+}
+
+impl dbus::message::SignalArgs for Call1StreamEndpointRemoteCredentialsSet {
+    const NAME: &'static str = "RemoteCredentialsSet";
+    const INTERFACE: &'static str = "org.freedesktop.Telepathy.Call1.Stream.Endpoint";
+}
+
+#[derive(Debug)]
+pub struct Call1StreamEndpointRemoteCandidatesAdded {
+    pub candidates: Vec<(
+        u32,
+        String,
+        u32,
+        ::std::collections::HashMap<String, arg::Variant<Box<dyn arg::RefArg + 'static>>>,
+    )>,
+}
+
+impl arg::AppendAll for Call1StreamEndpointRemoteCandidatesAdded {
+    fn append(&self, i: &mut arg::IterAppend) {
+        arg::RefArg::append(&self.candidates, i);
+    }
+}
+
+impl arg::ReadAll for Call1StreamEndpointRemoteCandidatesAdded {
+    fn read(i: &mut arg::Iter) -> Result<Self, arg::TypeMismatchError> {
+        Ok(Call1StreamEndpointRemoteCandidatesAdded {
+            candidates: i.read()?,
+        })
+    }
+}
+
+impl dbus::message::SignalArgs for Call1StreamEndpointRemoteCandidatesAdded {
+    const NAME: &'static str = "RemoteCandidatesAdded";
+    const INTERFACE: &'static str = "org.freedesktop.Telepathy.Call1.Stream.Endpoint";
+}
+
+#[derive(Debug)]
+pub struct Call1StreamEndpointCandidatePairSelected {
+    pub local_candidate: (
+        u32,
+        String,
+        u32,
+        ::std::collections::HashMap<String, arg::Variant<Box<dyn arg::RefArg + 'static>>>,
+    ),
+    pub remote_candidate: (
+        u32,
+        String,
+        u32,
+        ::std::collections::HashMap<String, arg::Variant<Box<dyn arg::RefArg + 'static>>>,
+    ),
+}
+
+impl arg::AppendAll for Call1StreamEndpointCandidatePairSelected {
+    fn append(&self, i: &mut arg::IterAppend) {
+        arg::RefArg::append(&self.local_candidate, i);
+        arg::RefArg::append(&self.remote_candidate, i);
+    }
+}
+
+impl arg::ReadAll for Call1StreamEndpointCandidatePairSelected {
+    fn read(i: &mut arg::Iter) -> Result<Self, arg::TypeMismatchError> {
+        Ok(Call1StreamEndpointCandidatePairSelected {
+            local_candidate: i.read()?,
+            remote_candidate: i.read()?,
+        })
+    }
+}
+
+impl dbus::message::SignalArgs for Call1StreamEndpointCandidatePairSelected {
+    const NAME: &'static str = "CandidatePairSelected";
+    const INTERFACE: &'static str = "org.freedesktop.Telepathy.Call1.Stream.Endpoint";
+}
+
+#[derive(Debug)]
+pub struct Call1StreamEndpointEndpointStateChanged {
+    pub component: u32,
+    pub state: u32,
+}
+
+impl arg::AppendAll for Call1StreamEndpointEndpointStateChanged {
+    fn append(&self, i: &mut arg::IterAppend) {
+        arg::RefArg::append(&self.component, i);
+        arg::RefArg::append(&self.state, i);
+    }
+}
+
+impl arg::ReadAll for Call1StreamEndpointEndpointStateChanged {
+    fn read(i: &mut arg::Iter) -> Result<Self, arg::TypeMismatchError> {
+        Ok(Call1StreamEndpointEndpointStateChanged {
+            component: i.read()?,
+            state: i.read()?,
+        })
+    }
+}
+
+impl dbus::message::SignalArgs for Call1StreamEndpointEndpointStateChanged {
+    const NAME: &'static str = "EndpointStateChanged";
+    const INTERFACE: &'static str = "org.freedesktop.Telepathy.Call1.Stream.Endpoint";
+}
+
+#[derive(Debug)]
+pub struct Call1StreamEndpointControllingChanged {
+    pub controlling: bool,
+}
+
+impl arg::AppendAll for Call1StreamEndpointControllingChanged {
+    fn append(&self, i: &mut arg::IterAppend) {
+        arg::RefArg::append(&self.controlling, i);
+    }
+}
+
+impl arg::ReadAll for Call1StreamEndpointControllingChanged {
+    fn read(i: &mut arg::Iter) -> Result<Self, arg::TypeMismatchError> {
+        Ok(Call1StreamEndpointControllingChanged {
+            controlling: i.read()?,
+        })
+    }
+}
+
+impl dbus::message::SignalArgs for Call1StreamEndpointControllingChanged {
+    const NAME: &'static str = "ControllingChanged";
+    const INTERFACE: &'static str = "org.freedesktop.Telepathy.Call1.Stream.Endpoint";
+}
--- a/src/telepathy/call_stream_interface_media.rs
+++ b/src/telepathy/call_stream_interface_media.rs
@@ -0,0 +1,568 @@
+// This code was autogenerated with `dbus-codegen-rust --file telepathy-spec/spec/Call_Stream_Interface_Media.xml -i org.freedesktop.Telepathy -a AsRefClosure -o src/telepathy/call_stream_interface_media.rs`, see https://github.com/diwic/dbus-rs
+use dbus;
+use dbus::arg;
+use dbus::tree;
+
+pub trait Call1StreamInterfaceMedia {
+    fn complete_sending_state_change(&self, state: u32) -> Result<(), tree::MethodErr>;
+    fn report_sending_failure(
+        &self,
+        reason: u32,
+        error: &str,
+        message: &str,
+    ) -> Result<(), tree::MethodErr>;
+    fn complete_receiving_state_change(&self, state: u32) -> Result<(), tree::MethodErr>;
+    fn report_receiving_failure(
+        &self,
+        reason: u32,
+        error: &str,
+        message: &str,
+    ) -> Result<(), tree::MethodErr>;
+    fn set_credentials(&self, username: &str, password: &str) -> Result<(), tree::MethodErr>;
+    fn add_candidates(
+        &self,
+        candidates: Vec<(
+            u32,
+            &str,
+            u32,
+            ::std::collections::HashMap<&str, arg::Variant<Box<dyn arg::RefArg>>>,
+        )>,
+    ) -> Result<(), tree::MethodErr>;
+    fn finish_initial_candidates(&self) -> Result<(), tree::MethodErr>;
+    fn fail(&self, reason: (u32, u32, &str, &str)) -> Result<(), tree::MethodErr>;
+    fn sending_state(&self) -> Result<u32, tree::MethodErr>;
+    fn receiving_state(&self) -> Result<u32, tree::MethodErr>;
+    fn transport(&self) -> Result<u32, tree::MethodErr>;
+    fn local_candidates(
+        &self,
+    ) -> Result<
+        Vec<(
+            u32,
+            String,
+            u32,
+            ::std::collections::HashMap<String, arg::Variant<Box<dyn arg::RefArg + 'static>>>,
+        )>,
+        tree::MethodErr,
+    >;
+    fn local_credentials(&self) -> Result<(String, String), tree::MethodErr>;
+    fn stunservers(&self) -> Result<Vec<(String, u16)>, tree::MethodErr>;
+    fn relay_info(
+        &self,
+    ) -> Result<
+        Vec<::std::collections::HashMap<String, arg::Variant<Box<dyn arg::RefArg + 'static>>>>,
+        tree::MethodErr,
+    >;
+    fn has_server_info(&self) -> Result<bool, tree::MethodErr>;
+    fn endpoints(&self) -> Result<Vec<dbus::Path<'static>>, tree::MethodErr>;
+    fn icerestart_pending(&self) -> Result<bool, tree::MethodErr>;
+}
+
+pub fn call1_stream_interface_media_server<F, T, D>(
+    factory: &tree::Factory<tree::MTFn<D>, D>,
+    data: D::Interface,
+    f: F,
+) -> tree::Interface<tree::MTFn<D>, D>
+where
+    D: tree::DataType,
+    D::Method: Default,
+    D::Property: Default,
+    D::Signal: Default,
+    T: AsRef<dyn Call1StreamInterfaceMedia>,
+    F: 'static + Fn(&tree::MethodInfo<tree::MTFn<D>, D>) -> T,
+{
+    let i = factory.interface(
+        "org.freedesktop.Telepathy.Call1.Stream.Interface.Media",
+        data,
+    );
+    let f = ::std::sync::Arc::new(f);
+    let fclone = f.clone();
+    let h = move |minfo: &tree::MethodInfo<tree::MTFn<D>, D>| {
+        let mut i = minfo.msg.iter_init();
+        let state: u32 = i.read()?;
+        let dd = fclone(minfo);
+        let d = dd.as_ref();
+        d.complete_sending_state_change(state)?;
+        let rm = minfo.msg.method_return();
+        Ok(vec![rm])
+    };
+    let m = factory.method("CompleteSendingStateChange", Default::default(), h);
+    let m = m.in_arg(("State", "u"));
+    let i = i.add_m(m);
+
+    let fclone = f.clone();
+    let h = move |minfo: &tree::MethodInfo<tree::MTFn<D>, D>| {
+        let mut i = minfo.msg.iter_init();
+        let reason: u32 = i.read()?;
+        let error: &str = i.read()?;
+        let message: &str = i.read()?;
+        let dd = fclone(minfo);
+        let d = dd.as_ref();
+        d.report_sending_failure(reason, error, message)?;
+        let rm = minfo.msg.method_return();
+        Ok(vec![rm])
+    };
+    let m = factory.method("ReportSendingFailure", Default::default(), h);
+    let m = m.in_arg(("Reason", "u"));
+    let m = m.in_arg(("Error", "s"));
+    let m = m.in_arg(("Message", "s"));
+    let i = i.add_m(m);
+
+    let fclone = f.clone();
+    let h = move |minfo: &tree::MethodInfo<tree::MTFn<D>, D>| {
+        let mut i = minfo.msg.iter_init();
+        let state: u32 = i.read()?;
+        let dd = fclone(minfo);
+        let d = dd.as_ref();
+        d.complete_receiving_state_change(state)?;
+        let rm = minfo.msg.method_return();
+        Ok(vec![rm])
+    };
+    let m = factory.method("CompleteReceivingStateChange", Default::default(), h);
+    let m = m.in_arg(("State", "u"));
+    let i = i.add_m(m);
+
+    let fclone = f.clone();
+    let h = move |minfo: &tree::MethodInfo<tree::MTFn<D>, D>| {
+        let mut i = minfo.msg.iter_init();
+        let reason: u32 = i.read()?;
+        let error: &str = i.read()?;
+        let message: &str = i.read()?;
+        let dd = fclone(minfo);
+        let d = dd.as_ref();
+        d.report_receiving_failure(reason, error, message)?;
+        let rm = minfo.msg.method_return();
+        Ok(vec![rm])
+    };
+    let m = factory.method("ReportReceivingFailure", Default::default(), h);
+    let m = m.in_arg(("Reason", "u"));
+    let m = m.in_arg(("Error", "s"));
+    let m = m.in_arg(("Message", "s"));
+    let i = i.add_m(m);
+
+    let fclone = f.clone();
+    let h = move |minfo: &tree::MethodInfo<tree::MTFn<D>, D>| {
+        let mut i = minfo.msg.iter_init();
+        let username: &str = i.read()?;
+        let password: &str = i.read()?;
+        let dd = fclone(minfo);
+        let d = dd.as_ref();
+        d.set_credentials(username, password)?;
+        let rm = minfo.msg.method_return();
+        Ok(vec![rm])
+    };
+    let m = factory.method("SetCredentials", Default::default(), h);
+    let m = m.in_arg(("Username", "s"));
+    let m = m.in_arg(("Password", "s"));
+    let i = i.add_m(m);
+
+    let fclone = f.clone();
+    let h = move |minfo: &tree::MethodInfo<tree::MTFn<D>, D>| {
+        let mut i = minfo.msg.iter_init();
+        let candidates: Vec<(
+            u32,
+            &str,
+            u32,
+            ::std::collections::HashMap<&str, arg::Variant<Box<dyn arg::RefArg>>>,
+        )> = i.read()?;
+        let dd = fclone(minfo);
+        let d = dd.as_ref();
+        d.add_candidates(candidates)?;
+        let rm = minfo.msg.method_return();
+        Ok(vec![rm])
+    };
+    let m = factory.method("AddCandidates", Default::default(), h);
+    let m = m.in_arg(("Candidates", "a(usua{sv})"));
+    let i = i.add_m(m);
+
+    let fclone = f.clone();
+    let h = move |minfo: &tree::MethodInfo<tree::MTFn<D>, D>| {
+        let dd = fclone(minfo);
+        let d = dd.as_ref();
+        d.finish_initial_candidates()?;
+        let rm = minfo.msg.method_return();
+        Ok(vec![rm])
+    };
+    let m = factory.method("FinishInitialCandidates", Default::default(), h);
+    let i = i.add_m(m);
+
+    let fclone = f.clone();
+    let h = move |minfo: &tree::MethodInfo<tree::MTFn<D>, D>| {
+        let mut i = minfo.msg.iter_init();
+        let reason: (u32, u32, &str, &str) = i.read()?;
+        let dd = fclone(minfo);
+        let d = dd.as_ref();
+        d.fail(reason)?;
+        let rm = minfo.msg.method_return();
+        Ok(vec![rm])
+    };
+    let m = factory.method("Fail", Default::default(), h);
+    let m = m.in_arg(("Reason", "(uuss)"));
+    let i = i.add_m(m);
+
+    let p = factory.property::<u32, _>("SendingState", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let dd = fclone(&minfo);
+        let d = dd.as_ref();
+        a.append(d.sending_state()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+
+    let p = factory.property::<u32, _>("ReceivingState", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let dd = fclone(&minfo);
+        let d = dd.as_ref();
+        a.append(d.receiving_state()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+
+    let p = factory.property::<u32, _>("Transport", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let dd = fclone(&minfo);
+        let d = dd.as_ref();
+        a.append(d.transport()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+
+    let p = factory.property::<Vec<(
+        u32,
+        &str,
+        u32,
+        ::std::collections::HashMap<&str, arg::Variant<Box<dyn arg::RefArg>>>,
+    )>, _>("LocalCandidates", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let dd = fclone(&minfo);
+        let d = dd.as_ref();
+        a.append(d.local_candidates()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+
+    let p = factory.property::<(&str, &str), _>("LocalCredentials", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let dd = fclone(&minfo);
+        let d = dd.as_ref();
+        a.append(d.local_credentials()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+
+    let p = factory.property::<Vec<(&str, u16)>, _>("STUNServers", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let dd = fclone(&minfo);
+        let d = dd.as_ref();
+        a.append(d.stunservers()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+
+    let p = factory
+        .property::<Vec<::std::collections::HashMap<&str, arg::Variant<Box<dyn arg::RefArg>>>>, _>(
+            "RelayInfo",
+            Default::default(),
+        );
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let dd = fclone(&minfo);
+        let d = dd.as_ref();
+        a.append(d.relay_info()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+
+    let p = factory.property::<bool, _>("HasServerInfo", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let dd = fclone(&minfo);
+        let d = dd.as_ref();
+        a.append(d.has_server_info()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+
+    let p = factory.property::<Vec<dbus::Path>, _>("Endpoints", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let dd = fclone(&minfo);
+        let d = dd.as_ref();
+        a.append(d.endpoints()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+
+    let p = factory.property::<bool, _>("ICERestartPending", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let dd = fclone(&minfo);
+        let d = dd.as_ref();
+        a.append(d.icerestart_pending()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+    let s = factory.signal("SendingStateChanged", Default::default());
+    let s = s.arg(("State", "u"));
+    let i = i.add_s(s);
+    let s = factory.signal("ReceivingStateChanged", Default::default());
+    let s = s.arg(("State", "u"));
+    let i = i.add_s(s);
+    let s = factory.signal("LocalCandidatesAdded", Default::default());
+    let s = s.arg(("Candidates", "a(usua{sv})"));
+    let i = i.add_s(s);
+    let s = factory.signal("LocalCredentialsChanged", Default::default());
+    let s = s.arg(("Username", "s"));
+    let s = s.arg(("Password", "s"));
+    let i = i.add_s(s);
+    let s = factory.signal("RelayInfoChanged", Default::default());
+    let s = s.arg(("Relay_Info", "aa{sv}"));
+    let i = i.add_s(s);
+    let s = factory.signal("STUNServersChanged", Default::default());
+    let s = s.arg(("Servers", "a(sq)"));
+    let i = i.add_s(s);
+    let s = factory.signal("ServerInfoRetrieved", Default::default());
+    let i = i.add_s(s);
+    let s = factory.signal("EndpointsChanged", Default::default());
+    let s = s.arg(("Endpoints_Added", "ao"));
+    let s = s.arg(("Endpoints_Removed", "ao"));
+    let i = i.add_s(s);
+    let s = factory.signal("ICERestartRequested", Default::default());
+    let i = i.add_s(s);
+    i
+}
+
+#[derive(Debug)]
+pub struct Call1StreamInterfaceMediaSendingStateChanged {
+    pub state: u32,
+}
+
+impl arg::AppendAll for Call1StreamInterfaceMediaSendingStateChanged {
+    fn append(&self, i: &mut arg::IterAppend) {
+        arg::RefArg::append(&self.state, i);
+    }
+}
+
+impl arg::ReadAll for Call1StreamInterfaceMediaSendingStateChanged {
+    fn read(i: &mut arg::Iter) -> Result<Self, arg::TypeMismatchError> {
+        Ok(Call1StreamInterfaceMediaSendingStateChanged { state: i.read()? })
+    }
+}
+
+impl dbus::message::SignalArgs for Call1StreamInterfaceMediaSendingStateChanged {
+    const NAME: &'static str = "SendingStateChanged";
+    const INTERFACE: &'static str = "org.freedesktop.Telepathy.Call1.Stream.Interface.Media";
+}
+
+#[derive(Debug)]
+pub struct Call1StreamInterfaceMediaReceivingStateChanged {
+    pub state: u32,
+}
+
+impl arg::AppendAll for Call1StreamInterfaceMediaReceivingStateChanged {
+    fn append(&self, i: &mut arg::IterAppend) {
+        arg::RefArg::append(&self.state, i);
+    }
+}
+
+impl arg::ReadAll for Call1StreamInterfaceMediaReceivingStateChanged {
+    fn read(i: &mut arg::Iter) -> Result<Self, arg::TypeMismatchError> {
+        Ok(Call1StreamInterfaceMediaReceivingStateChanged { state: i.read()? })
+    }
+}
+
+impl dbus::message::SignalArgs for Call1StreamInterfaceMediaReceivingStateChanged {
+    const NAME: &'static str = "ReceivingStateChanged";
+    const INTERFACE: &'static str = "org.freedesktop.Telepathy.Call1.Stream.Interface.Media";
+}
+
+#[derive(Debug)]
+pub struct Call1StreamInterfaceMediaLocalCandidatesAdded {
+    pub candidates: Vec<(
+        u32,
+        String,
+        u32,
+        ::std::collections::HashMap<String, arg::Variant<Box<dyn arg::RefArg + 'static>>>,
+    )>,
+}
+
+impl arg::AppendAll for Call1StreamInterfaceMediaLocalCandidatesAdded {
+    fn append(&self, i: &mut arg::IterAppend) {
+        arg::RefArg::append(&self.candidates, i);
+    }
+}
+
+impl arg::ReadAll for Call1StreamInterfaceMediaLocalCandidatesAdded {
+    fn read(i: &mut arg::Iter) -> Result<Self, arg::TypeMismatchError> {
+        Ok(Call1StreamInterfaceMediaLocalCandidatesAdded {
+            candidates: i.read()?,
+        })
+    }
+}
+
+impl dbus::message::SignalArgs for Call1StreamInterfaceMediaLocalCandidatesAdded {
+    const NAME: &'static str = "LocalCandidatesAdded";
+    const INTERFACE: &'static str = "org.freedesktop.Telepathy.Call1.Stream.Interface.Media";
+}
+
+#[derive(Debug)]
+pub struct Call1StreamInterfaceMediaLocalCredentialsChanged {
+    pub username: String,
+    pub password: String,
+}
+
+impl arg::AppendAll for Call1StreamInterfaceMediaLocalCredentialsChanged {
+    fn append(&self, i: &mut arg::IterAppend) {
+        arg::RefArg::append(&self.username, i);
+        arg::RefArg::append(&self.password, i);
+    }
+}
+
+impl arg::ReadAll for Call1StreamInterfaceMediaLocalCredentialsChanged {
+    fn read(i: &mut arg::Iter) -> Result<Self, arg::TypeMismatchError> {
+        Ok(Call1StreamInterfaceMediaLocalCredentialsChanged {
+            username: i.read()?,
+            password: i.read()?,
+        })
+    }
+}
+
+impl dbus::message::SignalArgs for Call1StreamInterfaceMediaLocalCredentialsChanged {
+    const NAME: &'static str = "LocalCredentialsChanged";
+    const INTERFACE: &'static str = "org.freedesktop.Telepathy.Call1.Stream.Interface.Media";
+}
+
+#[derive(Debug)]
+pub struct Call1StreamInterfaceMediaRelayInfoChanged {
+    pub relay_info:
+        Vec<::std::collections::HashMap<String, arg::Variant<Box<dyn arg::RefArg + 'static>>>>,
+}
+
+impl arg::AppendAll for Call1StreamInterfaceMediaRelayInfoChanged {
+    fn append(&self, i: &mut arg::IterAppend) {
+        arg::RefArg::append(&self.relay_info, i);
+    }
+}
+
+impl arg::ReadAll for Call1StreamInterfaceMediaRelayInfoChanged {
+    fn read(i: &mut arg::Iter) -> Result<Self, arg::TypeMismatchError> {
+        Ok(Call1StreamInterfaceMediaRelayInfoChanged {
+            relay_info: i.read()?,
+        })
+    }
+}
+
+impl dbus::message::SignalArgs for Call1StreamInterfaceMediaRelayInfoChanged {
+    const NAME: &'static str = "RelayInfoChanged";
+    const INTERFACE: &'static str = "org.freedesktop.Telepathy.Call1.Stream.Interface.Media";
+}
+
+#[derive(Debug)]
+pub struct Call1StreamInterfaceMediaSTUNServersChanged {
+    pub servers: Vec<(String, u16)>,
+}
+
+impl arg::AppendAll for Call1StreamInterfaceMediaSTUNServersChanged {
+    fn append(&self, i: &mut arg::IterAppend) {
+        arg::RefArg::append(&self.servers, i);
+    }
+}
+
+impl arg::ReadAll for Call1StreamInterfaceMediaSTUNServersChanged {
+    fn read(i: &mut arg::Iter) -> Result<Self, arg::TypeMismatchError> {
+        Ok(Call1StreamInterfaceMediaSTUNServersChanged { servers: i.read()? })
+    }
+}
+
+impl dbus::message::SignalArgs for Call1StreamInterfaceMediaSTUNServersChanged {
+    const NAME: &'static str = "STUNServersChanged";
+    const INTERFACE: &'static str = "org.freedesktop.Telepathy.Call1.Stream.Interface.Media";
+}
+
+#[derive(Debug)]
+pub struct Call1StreamInterfaceMediaServerInfoRetrieved {}
+
+impl arg::AppendAll for Call1StreamInterfaceMediaServerInfoRetrieved {
+    fn append(&self, _: &mut arg::IterAppend) {}
+}
+
+impl arg::ReadAll for Call1StreamInterfaceMediaServerInfoRetrieved {
+    fn read(_: &mut arg::Iter) -> Result<Self, arg::TypeMismatchError> {
+        Ok(Call1StreamInterfaceMediaServerInfoRetrieved {})
+    }
+}
+
+impl dbus::message::SignalArgs for Call1StreamInterfaceMediaServerInfoRetrieved {
+    const NAME: &'static str = "ServerInfoRetrieved";
+    const INTERFACE: &'static str = "org.freedesktop.Telepathy.Call1.Stream.Interface.Media";
+}
+
+#[derive(Debug)]
+pub struct Call1StreamInterfaceMediaEndpointsChanged {
+    pub endpoints_added: Vec<dbus::Path<'static>>,
+    pub endpoints_removed: Vec<dbus::Path<'static>>,
+}
+
+impl arg::AppendAll for Call1StreamInterfaceMediaEndpointsChanged {
+    fn append(&self, i: &mut arg::IterAppend) {
+        arg::RefArg::append(&self.endpoints_added, i);
+        arg::RefArg::append(&self.endpoints_removed, i);
+    }
+}
+
+impl arg::ReadAll for Call1StreamInterfaceMediaEndpointsChanged {
+    fn read(i: &mut arg::Iter) -> Result<Self, arg::TypeMismatchError> {
+        Ok(Call1StreamInterfaceMediaEndpointsChanged {
+            endpoints_added: i.read()?,
+            endpoints_removed: i.read()?,
+        })
+    }
+}
+
+impl dbus::message::SignalArgs for Call1StreamInterfaceMediaEndpointsChanged {
+    const NAME: &'static str = "EndpointsChanged";
+    const INTERFACE: &'static str = "org.freedesktop.Telepathy.Call1.Stream.Interface.Media";
+}
+
+#[derive(Debug)]
+pub struct Call1StreamInterfaceMediaICERestartRequested {}
+
+impl arg::AppendAll for Call1StreamInterfaceMediaICERestartRequested {
+    fn append(&self, _: &mut arg::IterAppend) {}
+}
+
+impl arg::ReadAll for Call1StreamInterfaceMediaICERestartRequested {
+    fn read(_: &mut arg::Iter) -> Result<Self, arg::TypeMismatchError> {
+        Ok(Call1StreamInterfaceMediaICERestartRequested {})
+    }
+}
+
+impl dbus::message::SignalArgs for Call1StreamInterfaceMediaICERestartRequested {
+    const NAME: &'static str = "ICERestartRequested";
+    const INTERFACE: &'static str = "org.freedesktop.Telepathy.Call1.Stream.Interface.Media";
+}
--- a/src/telepathy/channel.rs
+++ b/src/telepathy/channel.rs
@@ -0,0 +1,204 @@
+// This code was autogenerated with `dbus-codegen-rust --file telepathy-spec/spec/Channel.xml -i org.freedesktop.Telepathy -a AsRefClosure -o src/telepathy/channel.rs`, see https://github.com/diwic/dbus-rs
+use dbus;
+use dbus::arg;
+use dbus::tree;
+
+pub trait Channel {
+    fn close(&self) -> Result<(), tree::MethodErr>;
+    fn get_channel_type(&self) -> Result<String, tree::MethodErr>;
+    fn get_handle(&self) -> Result<(u32, u32), tree::MethodErr>;
+    fn get_interfaces(&self) -> Result<Vec<String>, tree::MethodErr>;
+    fn channel_type(&self) -> Result<String, tree::MethodErr>;
+    fn interfaces(&self) -> Result<Vec<String>, tree::MethodErr>;
+    fn target_handle(&self) -> Result<u32, tree::MethodErr>;
+    fn target_id(&self) -> Result<String, tree::MethodErr>;
+    fn target_handle_type(&self) -> Result<u32, tree::MethodErr>;
+    fn requested(&self) -> Result<bool, tree::MethodErr>;
+    fn initiator_handle(&self) -> Result<u32, tree::MethodErr>;
+    fn initiator_id(&self) -> Result<String, tree::MethodErr>;
+}
+
+pub fn channel_server<F, T, D>(
+    factory: &tree::Factory<tree::MTFn<D>, D>,
+    data: D::Interface,
+    f: F,
+) -> tree::Interface<tree::MTFn<D>, D>
+where
+    D: tree::DataType,
+    D::Method: Default,
+    D::Property: Default,
+    D::Signal: Default,
+    T: AsRef<dyn Channel>,
+    F: 'static + Fn(&tree::MethodInfo<tree::MTFn<D>, D>) -> T,
+{
+    let i = factory.interface("org.freedesktop.Telepathy.Channel", data);
+    let f = ::std::sync::Arc::new(f);
+    let fclone = f.clone();
+    let h = move |minfo: &tree::MethodInfo<tree::MTFn<D>, D>| {
+        let dd = fclone(minfo);
+        let d = dd.as_ref();
+        d.close()?;
+        let rm = minfo.msg.method_return();
+        Ok(vec![rm])
+    };
+    let m = factory.method("Close", Default::default(), h);
+    let i = i.add_m(m);
+
+    let fclone = f.clone();
+    let h = move |minfo: &tree::MethodInfo<tree::MTFn<D>, D>| {
+        let dd = fclone(minfo);
+        let d = dd.as_ref();
+        let channel_type = d.get_channel_type()?;
+        let rm = minfo.msg.method_return();
+        let rm = rm.append1(channel_type);
+        Ok(vec![rm])
+    };
+    let m = factory.method("GetChannelType", Default::default(), h);
+    let m = m.out_arg(("Channel_Type", "s"));
+    let i = i.add_m(m);
+
+    let fclone = f.clone();
+    let h = move |minfo: &tree::MethodInfo<tree::MTFn<D>, D>| {
+        let dd = fclone(minfo);
+        let d = dd.as_ref();
+        let (target_handle_type, target_handle) = d.get_handle()?;
+        let rm = minfo.msg.method_return();
+        let rm = rm.append1(target_handle_type);
+        let rm = rm.append1(target_handle);
+        Ok(vec![rm])
+    };
+    let m = factory.method("GetHandle", Default::default(), h);
+    let m = m.out_arg(("Target_Handle_Type", "u"));
+    let m = m.out_arg(("Target_Handle", "u"));
+    let i = i.add_m(m);
+
+    let fclone = f.clone();
+    let h = move |minfo: &tree::MethodInfo<tree::MTFn<D>, D>| {
+        let dd = fclone(minfo);
+        let d = dd.as_ref();
+        let interfaces = d.get_interfaces()?;
+        let rm = minfo.msg.method_return();
+        let rm = rm.append1(interfaces);
+        Ok(vec![rm])
+    };
+    let m = factory.method("GetInterfaces", Default::default(), h);
+    let m = m.out_arg(("Interfaces", "as"));
+    let i = i.add_m(m);
+
+    let p = factory.property::<&str, _>("ChannelType", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let dd = fclone(&minfo);
+        let d = dd.as_ref();
+        a.append(d.channel_type()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+
+    let p = factory.property::<Vec<&str>, _>("Interfaces", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let dd = fclone(&minfo);
+        let d = dd.as_ref();
+        a.append(d.interfaces()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+
+    let p = factory.property::<u32, _>("TargetHandle", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let dd = fclone(&minfo);
+        let d = dd.as_ref();
+        a.append(d.target_handle()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+
+    let p = factory.property::<&str, _>("TargetID", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let dd = fclone(&minfo);
+        let d = dd.as_ref();
+        a.append(d.target_id()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+
+    let p = factory.property::<u32, _>("TargetHandleType", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let dd = fclone(&minfo);
+        let d = dd.as_ref();
+        a.append(d.target_handle_type()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+
+    let p = factory.property::<bool, _>("Requested", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let dd = fclone(&minfo);
+        let d = dd.as_ref();
+        a.append(d.requested()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+
+    let p = factory.property::<u32, _>("InitiatorHandle", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let dd = fclone(&minfo);
+        let d = dd.as_ref();
+        a.append(d.initiator_handle()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+
+    let p = factory.property::<&str, _>("InitiatorID", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let dd = fclone(&minfo);
+        let d = dd.as_ref();
+        a.append(d.initiator_id()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+    let s = factory.signal("Closed", Default::default());
+    let i = i.add_s(s);
+    i
+}
+
+#[derive(Debug)]
+pub struct ChannelClosed {}
+
+impl arg::AppendAll for ChannelClosed {
+    fn append(&self, _: &mut arg::IterAppend) {}
+}
+
+impl arg::ReadAll for ChannelClosed {
+    fn read(_: &mut arg::Iter) -> Result<Self, arg::TypeMismatchError> {
+        Ok(ChannelClosed {})
+    }
+}
+
+impl dbus::message::SignalArgs for ChannelClosed {
+    const NAME: &'static str = "Closed";
+    const INTERFACE: &'static str = "org.freedesktop.Telepathy.Channel";
+}
--- a/src/telepathy/channel_bundle.rs
+++ b/src/telepathy/channel_bundle.rs
@@ -0,0 +1,36 @@
+// This code was autogenerated with `dbus-codegen-rust --file telepathy-spec/spec/Channel_Bundle.xml -i org.freedesktop.Telepathy -a AsRefClosure -o src/telepathy/channel_bundle.rs`, see https://github.com/diwic/dbus-rs
+use dbus;
+use dbus::arg;
+use dbus::tree;
+
+pub trait ChannelBundleDRAFT {
+    fn interfaces(&self) -> Result<Vec<String>, tree::MethodErr>;
+}
+
+pub fn channel_bundle_draft_server<F, T, D>(
+    factory: &tree::Factory<tree::MTFn<D>, D>,
+    data: D::Interface,
+    f: F,
+) -> tree::Interface<tree::MTFn<D>, D>
+where
+    D: tree::DataType,
+    D::Method: Default,
+    D::Property: Default,
+    T: AsRef<dyn ChannelBundleDRAFT>,
+    F: 'static + Fn(&tree::MethodInfo<tree::MTFn<D>, D>) -> T,
+{
+    let i = factory.interface("org.freedesktop.Telepathy.ChannelBundle.DRAFT", data);
+    let f = ::std::sync::Arc::new(f);
+    let p = factory.property::<Vec<&str>, _>("Interfaces", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let dd = fclone(&minfo);
+        let d = dd.as_ref();
+        a.append(d.interfaces()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+    i
+}
--- a/src/telepathy/channel_dispatch_operation.rs
+++ b/src/telepathy/channel_dispatch_operation.rs
@@ -0,0 +1,200 @@
+// This code was autogenerated with `dbus-codegen-rust --file telepathy-spec/spec/Channel_Dispatch_Operation.xml -i org.freedesktop.Telepathy -a AsRefClosure -o src/telepathy/channel_dispatch_operation.rs`, see https://github.com/diwic/dbus-rs
+use dbus;
+use dbus::arg;
+use dbus::tree;
+
+pub trait ChannelDispatchOperation {
+    fn handle_with(&self, handler: &str) -> Result<(), tree::MethodErr>;
+    fn claim(&self) -> Result<(), tree::MethodErr>;
+    fn handle_with_time(&self, handler: &str, user_action_time: i64)
+        -> Result<(), tree::MethodErr>;
+    fn interfaces(&self) -> Result<Vec<String>, tree::MethodErr>;
+    fn connection(&self) -> Result<dbus::Path<'static>, tree::MethodErr>;
+    fn account(&self) -> Result<dbus::Path<'static>, tree::MethodErr>;
+    fn channels(
+        &self,
+    ) -> Result<
+        Vec<(
+            dbus::Path<'static>,
+            ::std::collections::HashMap<String, arg::Variant<Box<dyn arg::RefArg + 'static>>>,
+        )>,
+        tree::MethodErr,
+    >;
+    fn possible_handlers(&self) -> Result<Vec<String>, tree::MethodErr>;
+}
+
+pub fn channel_dispatch_operation_server<F, T, D>(
+    factory: &tree::Factory<tree::MTFn<D>, D>,
+    data: D::Interface,
+    f: F,
+) -> tree::Interface<tree::MTFn<D>, D>
+where
+    D: tree::DataType,
+    D::Method: Default,
+    D::Property: Default,
+    D::Signal: Default,
+    T: AsRef<dyn ChannelDispatchOperation>,
+    F: 'static + Fn(&tree::MethodInfo<tree::MTFn<D>, D>) -> T,
+{
+    let i = factory.interface("org.freedesktop.Telepathy.ChannelDispatchOperation", data);
+    let f = ::std::sync::Arc::new(f);
+    let fclone = f.clone();
+    let h = move |minfo: &tree::MethodInfo<tree::MTFn<D>, D>| {
+        let mut i = minfo.msg.iter_init();
+        let handler: &str = i.read()?;
+        let dd = fclone(minfo);
+        let d = dd.as_ref();
+        d.handle_with(handler)?;
+        let rm = minfo.msg.method_return();
+        Ok(vec![rm])
+    };
+    let m = factory.method("HandleWith", Default::default(), h);
+    let m = m.in_arg(("Handler", "s"));
+    let i = i.add_m(m);
+
+    let fclone = f.clone();
+    let h = move |minfo: &tree::MethodInfo<tree::MTFn<D>, D>| {
+        let dd = fclone(minfo);
+        let d = dd.as_ref();
+        d.claim()?;
+        let rm = minfo.msg.method_return();
+        Ok(vec![rm])
+    };
+    let m = factory.method("Claim", Default::default(), h);
+    let i = i.add_m(m);
+
+    let fclone = f.clone();
+    let h = move |minfo: &tree::MethodInfo<tree::MTFn<D>, D>| {
+        let mut i = minfo.msg.iter_init();
+        let handler: &str = i.read()?;
+        let user_action_time: i64 = i.read()?;
+        let dd = fclone(minfo);
+        let d = dd.as_ref();
+        d.handle_with_time(handler, user_action_time)?;
+        let rm = minfo.msg.method_return();
+        Ok(vec![rm])
+    };
+    let m = factory.method("HandleWithTime", Default::default(), h);
+    let m = m.in_arg(("Handler", "s"));
+    let m = m.in_arg(("UserActionTime", "x"));
+    let i = i.add_m(m);
+
+    let p = factory.property::<Vec<&str>, _>("Interfaces", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let dd = fclone(&minfo);
+        let d = dd.as_ref();
+        a.append(d.interfaces()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+
+    let p = factory.property::<dbus::Path, _>("Connection", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let dd = fclone(&minfo);
+        let d = dd.as_ref();
+        a.append(d.connection()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+
+    let p = factory.property::<dbus::Path, _>("Account", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let dd = fclone(&minfo);
+        let d = dd.as_ref();
+        a.append(d.account()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+
+    let p = factory.property::<Vec<(
+        dbus::Path,
+        ::std::collections::HashMap<&str, arg::Variant<Box<dyn arg::RefArg>>>,
+    )>, _>("Channels", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let dd = fclone(&minfo);
+        let d = dd.as_ref();
+        a.append(d.channels()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+
+    let p = factory.property::<Vec<&str>, _>("PossibleHandlers", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let dd = fclone(&minfo);
+        let d = dd.as_ref();
+        a.append(d.possible_handlers()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+    let s = factory.signal("ChannelLost", Default::default());
+    let s = s.arg(("Channel", "o"));
+    let s = s.arg(("Error", "s"));
+    let s = s.arg(("Message", "s"));
+    let i = i.add_s(s);
+    let s = factory.signal("Finished", Default::default());
+    let i = i.add_s(s);
+    i
+}
+
+#[derive(Debug)]
+pub struct ChannelDispatchOperationChannelLost {
+    pub channel: dbus::Path<'static>,
+    pub error: String,
+    pub message: String,
+}
+
+impl arg::AppendAll for ChannelDispatchOperationChannelLost {
+    fn append(&self, i: &mut arg::IterAppend) {
+        arg::RefArg::append(&self.channel, i);
+        arg::RefArg::append(&self.error, i);
+        arg::RefArg::append(&self.message, i);
+    }
+}
+
+impl arg::ReadAll for ChannelDispatchOperationChannelLost {
+    fn read(i: &mut arg::Iter) -> Result<Self, arg::TypeMismatchError> {
+        Ok(ChannelDispatchOperationChannelLost {
+            channel: i.read()?,
+            error: i.read()?,
+            message: i.read()?,
+        })
+    }
+}
+
+impl dbus::message::SignalArgs for ChannelDispatchOperationChannelLost {
+    const NAME: &'static str = "ChannelLost";
+    const INTERFACE: &'static str = "org.freedesktop.Telepathy.ChannelDispatchOperation";
+}
+
+#[derive(Debug)]
+pub struct ChannelDispatchOperationFinished {}
+
+impl arg::AppendAll for ChannelDispatchOperationFinished {
+    fn append(&self, _: &mut arg::IterAppend) {}
+}
+
+impl arg::ReadAll for ChannelDispatchOperationFinished {
+    fn read(_: &mut arg::Iter) -> Result<Self, arg::TypeMismatchError> {
+        Ok(ChannelDispatchOperationFinished {})
+    }
+}
+
+impl dbus::message::SignalArgs for ChannelDispatchOperationFinished {
+    const NAME: &'static str = "Finished";
+    const INTERFACE: &'static str = "org.freedesktop.Telepathy.ChannelDispatchOperation";
+}
--- a/src/telepathy/channel_dispatcher.rs
+++ b/src/telepathy/channel_dispatcher.rs
@@ -0,0 +1,263 @@
+// This code was autogenerated with `dbus-codegen-rust --file telepathy-spec/spec/Channel_Dispatcher.xml -i org.freedesktop.Telepathy -a AsRefClosure -o src/telepathy/channel_dispatcher.rs`, see https://github.com/diwic/dbus-rs
+use dbus;
+use dbus::arg;
+use dbus::tree;
+
+pub trait ChannelDispatcher {
+    fn create_channel(
+        &self,
+        account: dbus::Path,
+        requested_properties: ::std::collections::HashMap<&str, arg::Variant<Box<dyn arg::RefArg>>>,
+        user_action_time: i64,
+        preferred_handler: &str,
+    ) -> Result<dbus::Path<'static>, tree::MethodErr>;
+    fn ensure_channel(
+        &self,
+        account: dbus::Path,
+        requested_properties: ::std::collections::HashMap<&str, arg::Variant<Box<dyn arg::RefArg>>>,
+        user_action_time: i64,
+        preferred_handler: &str,
+    ) -> Result<dbus::Path<'static>, tree::MethodErr>;
+    fn create_channel_with_hints(
+        &self,
+        account: dbus::Path,
+        requested_properties: ::std::collections::HashMap<&str, arg::Variant<Box<dyn arg::RefArg>>>,
+        user_action_time: i64,
+        preferred_handler: &str,
+        hints: ::std::collections::HashMap<&str, arg::Variant<Box<dyn arg::RefArg>>>,
+    ) -> Result<dbus::Path<'static>, tree::MethodErr>;
+    fn ensure_channel_with_hints(
+        &self,
+        account: dbus::Path,
+        requested_properties: ::std::collections::HashMap<&str, arg::Variant<Box<dyn arg::RefArg>>>,
+        user_action_time: i64,
+        preferred_handler: &str,
+        hints: ::std::collections::HashMap<&str, arg::Variant<Box<dyn arg::RefArg>>>,
+    ) -> Result<dbus::Path<'static>, tree::MethodErr>;
+    fn delegate_channels(
+        &self,
+        channels: Vec<dbus::Path>,
+        user_action_time: i64,
+        preferred_handler: &str,
+    ) -> Result<
+        (
+            Vec<dbus::Path<'static>>,
+            ::std::collections::HashMap<dbus::Path<'static>, (String, String)>,
+        ),
+        tree::MethodErr,
+    >;
+    fn present_channel(
+        &self,
+        channel: dbus::Path,
+        user_action_time: i64,
+    ) -> Result<(), tree::MethodErr>;
+    fn interfaces(&self) -> Result<Vec<String>, tree::MethodErr>;
+    fn supports_request_hints(&self) -> Result<bool, tree::MethodErr>;
+}
+
+pub fn channel_dispatcher_server<F, T, D>(
+    factory: &tree::Factory<tree::MTFn<D>, D>,
+    data: D::Interface,
+    f: F,
+) -> tree::Interface<tree::MTFn<D>, D>
+where
+    D: tree::DataType,
+    D::Method: Default,
+    D::Property: Default,
+    T: AsRef<dyn ChannelDispatcher>,
+    F: 'static + Fn(&tree::MethodInfo<tree::MTFn<D>, D>) -> T,
+{
+    let i = factory.interface("org.freedesktop.Telepathy.ChannelDispatcher", data);
+    let f = ::std::sync::Arc::new(f);
+    let fclone = f.clone();
+    let h = move |minfo: &tree::MethodInfo<tree::MTFn<D>, D>| {
+        let mut i = minfo.msg.iter_init();
+        let account: dbus::Path = i.read()?;
+        let requested_properties: ::std::collections::HashMap<
+            &str,
+            arg::Variant<Box<dyn arg::RefArg>>,
+        > = i.read()?;
+        let user_action_time: i64 = i.read()?;
+        let preferred_handler: &str = i.read()?;
+        let dd = fclone(minfo);
+        let d = dd.as_ref();
+        let request = d.create_channel(
+            account,
+            requested_properties,
+            user_action_time,
+            preferred_handler,
+        )?;
+        let rm = minfo.msg.method_return();
+        let rm = rm.append1(request);
+        Ok(vec![rm])
+    };
+    let m = factory.method("CreateChannel", Default::default(), h);
+    let m = m.in_arg(("Account", "o"));
+    let m = m.in_arg(("Requested_Properties", "a{sv}"));
+    let m = m.in_arg(("User_Action_Time", "x"));
+    let m = m.in_arg(("Preferred_Handler", "s"));
+    let m = m.out_arg(("Request", "o"));
+    let i = i.add_m(m);
+
+    let fclone = f.clone();
+    let h = move |minfo: &tree::MethodInfo<tree::MTFn<D>, D>| {
+        let mut i = minfo.msg.iter_init();
+        let account: dbus::Path = i.read()?;
+        let requested_properties: ::std::collections::HashMap<
+            &str,
+            arg::Variant<Box<dyn arg::RefArg>>,
+        > = i.read()?;
+        let user_action_time: i64 = i.read()?;
+        let preferred_handler: &str = i.read()?;
+        let dd = fclone(minfo);
+        let d = dd.as_ref();
+        let request = d.ensure_channel(
+            account,
+            requested_properties,
+            user_action_time,
+            preferred_handler,
+        )?;
+        let rm = minfo.msg.method_return();
+        let rm = rm.append1(request);
+        Ok(vec![rm])
+    };
+    let m = factory.method("EnsureChannel", Default::default(), h);
+    let m = m.in_arg(("Account", "o"));
+    let m = m.in_arg(("Requested_Properties", "a{sv}"));
+    let m = m.in_arg(("User_Action_Time", "x"));
+    let m = m.in_arg(("Preferred_Handler", "s"));
+    let m = m.out_arg(("Request", "o"));
+    let i = i.add_m(m);
+
+    let fclone = f.clone();
+    let h = move |minfo: &tree::MethodInfo<tree::MTFn<D>, D>| {
+        let mut i = minfo.msg.iter_init();
+        let account: dbus::Path = i.read()?;
+        let requested_properties: ::std::collections::HashMap<
+            &str,
+            arg::Variant<Box<dyn arg::RefArg>>,
+        > = i.read()?;
+        let user_action_time: i64 = i.read()?;
+        let preferred_handler: &str = i.read()?;
+        let hints: ::std::collections::HashMap<&str, arg::Variant<Box<dyn arg::RefArg>>> =
+            i.read()?;
+        let dd = fclone(minfo);
+        let d = dd.as_ref();
+        let request = d.create_channel_with_hints(
+            account,
+            requested_properties,
+            user_action_time,
+            preferred_handler,
+            hints,
+        )?;
+        let rm = minfo.msg.method_return();
+        let rm = rm.append1(request);
+        Ok(vec![rm])
+    };
+    let m = factory.method("CreateChannelWithHints", Default::default(), h);
+    let m = m.in_arg(("Account", "o"));
+    let m = m.in_arg(("Requested_Properties", "a{sv}"));
+    let m = m.in_arg(("User_Action_Time", "x"));
+    let m = m.in_arg(("Preferred_Handler", "s"));
+    let m = m.in_arg(("Hints", "a{sv}"));
+    let m = m.out_arg(("Request", "o"));
+    let i = i.add_m(m);
+
+    let fclone = f.clone();
+    let h = move |minfo: &tree::MethodInfo<tree::MTFn<D>, D>| {
+        let mut i = minfo.msg.iter_init();
+        let account: dbus::Path = i.read()?;
+        let requested_properties: ::std::collections::HashMap<
+            &str,
+            arg::Variant<Box<dyn arg::RefArg>>,
+        > = i.read()?;
+        let user_action_time: i64 = i.read()?;
+        let preferred_handler: &str = i.read()?;
+        let hints: ::std::collections::HashMap<&str, arg::Variant<Box<dyn arg::RefArg>>> =
+            i.read()?;
+        let dd = fclone(minfo);
+        let d = dd.as_ref();
+        let request = d.ensure_channel_with_hints(
+            account,
+            requested_properties,
+            user_action_time,
+            preferred_handler,
+            hints,
+        )?;
+        let rm = minfo.msg.method_return();
+        let rm = rm.append1(request);
+        Ok(vec![rm])
+    };
+    let m = factory.method("EnsureChannelWithHints", Default::default(), h);
+    let m = m.in_arg(("Account", "o"));
+    let m = m.in_arg(("Requested_Properties", "a{sv}"));
+    let m = m.in_arg(("User_Action_Time", "x"));
+    let m = m.in_arg(("Preferred_Handler", "s"));
+    let m = m.in_arg(("Hints", "a{sv}"));
+    let m = m.out_arg(("Request", "o"));
+    let i = i.add_m(m);
+
+    let fclone = f.clone();
+    let h = move |minfo: &tree::MethodInfo<tree::MTFn<D>, D>| {
+        let mut i = minfo.msg.iter_init();
+        let channels: Vec<dbus::Path> = i.read()?;
+        let user_action_time: i64 = i.read()?;
+        let preferred_handler: &str = i.read()?;
+        let dd = fclone(minfo);
+        let d = dd.as_ref();
+        let (delegated, not_delegated) =
+            d.delegate_channels(channels, user_action_time, preferred_handler)?;
+        let rm = minfo.msg.method_return();
+        let rm = rm.append1(delegated);
+        let rm = rm.append1(not_delegated);
+        Ok(vec![rm])
+    };
+    let m = factory.method("DelegateChannels", Default::default(), h);
+    let m = m.in_arg(("Channels", "ao"));
+    let m = m.in_arg(("User_Action_Time", "x"));
+    let m = m.in_arg(("Preferred_Handler", "s"));
+    let m = m.out_arg(("Delegated", "ao"));
+    let m = m.out_arg(("Not_Delegated", "a{o(ss)}"));
+    let i = i.add_m(m);
+
+    let fclone = f.clone();
+    let h = move |minfo: &tree::MethodInfo<tree::MTFn<D>, D>| {
+        let mut i = minfo.msg.iter_init();
+        let channel: dbus::Path = i.read()?;
+        let user_action_time: i64 = i.read()?;
+        let dd = fclone(minfo);
+        let d = dd.as_ref();
+        d.present_channel(channel, user_action_time)?;
+        let rm = minfo.msg.method_return();
+        Ok(vec![rm])
+    };
+    let m = factory.method("PresentChannel", Default::default(), h);
+    let m = m.in_arg(("Channel", "o"));
+    let m = m.in_arg(("User_Action_Time", "x"));
+    let i = i.add_m(m);
+
+    let p = factory.property::<Vec<&str>, _>("Interfaces", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let dd = fclone(&minfo);
+        let d = dd.as_ref();
+        a.append(d.interfaces()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+
+    let p = factory.property::<bool, _>("SupportsRequestHints", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let dd = fclone(&minfo);
+        let d = dd.as_ref();
+        a.append(d.supports_request_hints()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+    i
+}
--- a/src/telepathy/channel_dispatcher_interface_messages1.rs
+++ b/src/telepathy/channel_dispatcher_interface_messages1.rs
@@ -0,0 +1,55 @@
+// This code was autogenerated with `dbus-codegen-rust --file telepathy-spec/spec/Channel_Dispatcher_Interface_Messages1.xml -i org.freedesktop.Telepathy -a AsRefClosure -o src/telepathy/channel_dispatcher_interface_messages1.rs`, see https://github.com/diwic/dbus-rs
+use dbus;
+use dbus::arg;
+use dbus::tree;
+
+pub trait ChannelDispatcherInterfaceMessages1 {
+    fn send_message(
+        &self,
+        account: dbus::Path,
+        target_id: &str,
+        message: Vec<::std::collections::HashMap<&str, arg::Variant<Box<dyn arg::RefArg>>>>,
+        flags: u32,
+    ) -> Result<String, tree::MethodErr>;
+}
+
+pub fn channel_dispatcher_interface_messages1_server<F, T, D>(
+    factory: &tree::Factory<tree::MTFn<D>, D>,
+    data: D::Interface,
+    f: F,
+) -> tree::Interface<tree::MTFn<D>, D>
+where
+    D: tree::DataType,
+    D::Method: Default,
+    T: AsRef<dyn ChannelDispatcherInterfaceMessages1>,
+    F: 'static + Fn(&tree::MethodInfo<tree::MTFn<D>, D>) -> T,
+{
+    let i = factory.interface(
+        "org.freedesktop.Telepathy.ChannelDispatcher.Interface.Messages1",
+        data,
+    );
+    let f = ::std::sync::Arc::new(f);
+    let fclone = f.clone();
+    let h = move |minfo: &tree::MethodInfo<tree::MTFn<D>, D>| {
+        let mut i = minfo.msg.iter_init();
+        let account: dbus::Path = i.read()?;
+        let target_id: &str = i.read()?;
+        let message: Vec<::std::collections::HashMap<&str, arg::Variant<Box<dyn arg::RefArg>>>> =
+            i.read()?;
+        let flags: u32 = i.read()?;
+        let dd = fclone(minfo);
+        let d = dd.as_ref();
+        let token = d.send_message(account, target_id, message, flags)?;
+        let rm = minfo.msg.method_return();
+        let rm = rm.append1(token);
+        Ok(vec![rm])
+    };
+    let m = factory.method("SendMessage", Default::default(), h);
+    let m = m.in_arg(("Account", "o"));
+    let m = m.in_arg(("Target_ID", "s"));
+    let m = m.in_arg(("Message", "aa{sv}"));
+    let m = m.in_arg(("Flags", "u"));
+    let m = m.out_arg(("Token", "s"));
+    let i = i.add_m(m);
+    i
+}
--- a/src/telepathy/channel_dispatcher_interface_operation_list.rs
+++ b/src/telepathy/channel_dispatcher_interface_operation_list.rs
@@ -0,0 +1,118 @@
+// This code was autogenerated with `dbus-codegen-rust --file telepathy-spec/spec/Channel_Dispatcher_Interface_Operation_List.xml -i org.freedesktop.Telepathy -a AsRefClosure -o src/telepathy/channel_dispatcher_interface_operation_list.rs`, see https://github.com/diwic/dbus-rs
+use dbus;
+use dbus::arg;
+use dbus::tree;
+
+pub trait ChannelDispatcherInterfaceOperationList {
+    fn dispatch_operations(
+        &self,
+    ) -> Result<
+        Vec<(
+            dbus::Path<'static>,
+            ::std::collections::HashMap<String, arg::Variant<Box<dyn arg::RefArg + 'static>>>,
+        )>,
+        tree::MethodErr,
+    >;
+}
+
+pub fn channel_dispatcher_interface_operation_list_server<F, T, D>(
+    factory: &tree::Factory<tree::MTFn<D>, D>,
+    data: D::Interface,
+    f: F,
+) -> tree::Interface<tree::MTFn<D>, D>
+where
+    D: tree::DataType,
+    D::Method: Default,
+    D::Property: Default,
+    D::Signal: Default,
+    T: AsRef<dyn ChannelDispatcherInterfaceOperationList>,
+    F: 'static + Fn(&tree::MethodInfo<tree::MTFn<D>, D>) -> T,
+{
+    let i = factory.interface(
+        "org.freedesktop.Telepathy.ChannelDispatcher.Interface.OperationList",
+        data,
+    );
+    let f = ::std::sync::Arc::new(f);
+    let p = factory.property::<Vec<(
+        dbus::Path,
+        ::std::collections::HashMap<&str, arg::Variant<Box<dyn arg::RefArg>>>,
+    )>, _>("DispatchOperations", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let dd = fclone(&minfo);
+        let d = dd.as_ref();
+        a.append(d.dispatch_operations()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+    let s = factory.signal("NewDispatchOperation", Default::default());
+    let s = s.arg(("Dispatch_Operation", "o"));
+    let s = s.arg(("Properties", "a{sv}"));
+    let i = i.add_s(s);
+    let s = factory.signal("DispatchOperationFinished", Default::default());
+    let s = s.arg(("Dispatch_Operation", "o"));
+    let i = i.add_s(s);
+    i
+}
+
+#[derive(Debug)]
+pub struct ChannelDispatcherInterfaceOperationListNewDispatchOperation {
+    pub dispatch_operation: dbus::Path<'static>,
+    pub properties:
+        ::std::collections::HashMap<String, arg::Variant<Box<dyn arg::RefArg + 'static>>>,
+}
+
+impl arg::AppendAll for ChannelDispatcherInterfaceOperationListNewDispatchOperation {
+    fn append(&self, i: &mut arg::IterAppend) {
+        arg::RefArg::append(&self.dispatch_operation, i);
+        arg::RefArg::append(&self.properties, i);
+    }
+}
+
+impl arg::ReadAll for ChannelDispatcherInterfaceOperationListNewDispatchOperation {
+    fn read(i: &mut arg::Iter) -> Result<Self, arg::TypeMismatchError> {
+        Ok(
+            ChannelDispatcherInterfaceOperationListNewDispatchOperation {
+                dispatch_operation: i.read()?,
+                properties: i.read()?,
+            },
+        )
+    }
+}
+
+impl dbus::message::SignalArgs for ChannelDispatcherInterfaceOperationListNewDispatchOperation {
+    const NAME: &'static str = "NewDispatchOperation";
+    const INTERFACE: &'static str =
+        "org.freedesktop.Telepathy.ChannelDispatcher.Interface.OperationList";
+}
+
+#[derive(Debug)]
+pub struct ChannelDispatcherInterfaceOperationListDispatchOperationFinished {
+    pub dispatch_operation: dbus::Path<'static>,
+}
+
+impl arg::AppendAll for ChannelDispatcherInterfaceOperationListDispatchOperationFinished {
+    fn append(&self, i: &mut arg::IterAppend) {
+        arg::RefArg::append(&self.dispatch_operation, i);
+    }
+}
+
+impl arg::ReadAll for ChannelDispatcherInterfaceOperationListDispatchOperationFinished {
+    fn read(i: &mut arg::Iter) -> Result<Self, arg::TypeMismatchError> {
+        Ok(
+            ChannelDispatcherInterfaceOperationListDispatchOperationFinished {
+                dispatch_operation: i.read()?,
+            },
+        )
+    }
+}
+
+impl dbus::message::SignalArgs
+    for ChannelDispatcherInterfaceOperationListDispatchOperationFinished
+{
+    const NAME: &'static str = "DispatchOperationFinished";
+    const INTERFACE: &'static str =
+        "org.freedesktop.Telepathy.ChannelDispatcher.Interface.OperationList";
+}
--- a/src/telepathy/channel_future.rs
+++ b/src/telepathy/channel_future.rs
@@ -0,0 +1,36 @@
+// This code was autogenerated with `dbus-codegen-rust --file telepathy-spec/spec/Channel_Future.xml -i org.freedesktop.Telepathy -a AsRefClosure -o src/telepathy/channel_future.rs`, see https://github.com/diwic/dbus-rs
+use dbus;
+use dbus::arg;
+use dbus::tree;
+
+pub trait ChannelFUTURE {
+    fn bundle(&self) -> Result<dbus::Path<'static>, tree::MethodErr>;
+}
+
+pub fn channel_future_server<F, T, D>(
+    factory: &tree::Factory<tree::MTFn<D>, D>,
+    data: D::Interface,
+    f: F,
+) -> tree::Interface<tree::MTFn<D>, D>
+where
+    D: tree::DataType,
+    D::Method: Default,
+    D::Property: Default,
+    T: AsRef<dyn ChannelFUTURE>,
+    F: 'static + Fn(&tree::MethodInfo<tree::MTFn<D>, D>) -> T,
+{
+    let i = factory.interface("org.freedesktop.Telepathy.Channel.FUTURE", data);
+    let f = ::std::sync::Arc::new(f);
+    let p = factory.property::<dbus::Path, _>("Bundle", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let dd = fclone(&minfo);
+        let d = dd.as_ref();
+        a.append(d.bundle()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+    i
+}
--- a/src/telepathy/channel_handler.rs
+++ b/src/telepathy/channel_handler.rs
@@ -0,0 +1,62 @@
+// This code was autogenerated with `dbus-codegen-rust --file telepathy-spec/spec/Channel_Handler.xml -i org.freedesktop.Telepathy -a AsRefClosure -o src/telepathy/channel_handler.rs`, see https://github.com/diwic/dbus-rs
+use dbus;
+use dbus::arg;
+use dbus::tree;
+
+pub trait ChannelHandler {
+    fn handle_channel(
+        &self,
+        bus_name: &str,
+        connection: dbus::Path,
+        channel_type: &str,
+        channel: dbus::Path,
+        handle_type: u32,
+        handle: u32,
+    ) -> Result<(), tree::MethodErr>;
+}
+
+pub fn channel_handler_server<F, T, D>(
+    factory: &tree::Factory<tree::MTFn<D>, D>,
+    data: D::Interface,
+    f: F,
+) -> tree::Interface<tree::MTFn<D>, D>
+where
+    D: tree::DataType,
+    D::Method: Default,
+    T: AsRef<dyn ChannelHandler>,
+    F: 'static + Fn(&tree::MethodInfo<tree::MTFn<D>, D>) -> T,
+{
+    let i = factory.interface("org.freedesktop.Telepathy.ChannelHandler", data);
+    let f = ::std::sync::Arc::new(f);
+    let fclone = f.clone();
+    let h = move |minfo: &tree::MethodInfo<tree::MTFn<D>, D>| {
+        let mut i = minfo.msg.iter_init();
+        let bus_name: &str = i.read()?;
+        let connection: dbus::Path = i.read()?;
+        let channel_type: &str = i.read()?;
+        let channel: dbus::Path = i.read()?;
+        let handle_type: u32 = i.read()?;
+        let handle: u32 = i.read()?;
+        let dd = fclone(minfo);
+        let d = dd.as_ref();
+        d.handle_channel(
+            bus_name,
+            connection,
+            channel_type,
+            channel,
+            handle_type,
+            handle,
+        )?;
+        let rm = minfo.msg.method_return();
+        Ok(vec![rm])
+    };
+    let m = factory.method("HandleChannel", Default::default(), h);
+    let m = m.in_arg(("Bus_Name", "s"));
+    let m = m.in_arg(("Connection", "o"));
+    let m = m.in_arg(("Channel_Type", "s"));
+    let m = m.in_arg(("Channel", "o"));
+    let m = m.in_arg(("Handle_Type", "u"));
+    let m = m.in_arg(("Handle", "u"));
+    let i = i.add_m(m);
+    i
+}
--- a/src/telepathy/channel_interface_addressing.rs
+++ b/src/telepathy/channel_interface_addressing.rs
@@ -0,0 +1,78 @@
+// This code was autogenerated with `dbus-codegen-rust --file telepathy-spec/spec/Channel_Interface_Addressing.xml -i org.freedesktop.Telepathy -a AsRefClosure -o src/telepathy/channel_interface_addressing.rs`, see https://github.com/diwic/dbus-rs
+use dbus;
+use dbus::arg;
+use dbus::tree;
+
+pub trait ChannelInterfaceAddressing1 {
+    fn target_vcard_field(&self) -> Result<String, tree::MethodErr>;
+    fn target_urischeme(&self) -> Result<String, tree::MethodErr>;
+    fn target_vcard_address(&self) -> Result<String, tree::MethodErr>;
+    fn target_uri(&self) -> Result<String, tree::MethodErr>;
+}
+
+pub fn channel_interface_addressing1_server<F, T, D>(
+    factory: &tree::Factory<tree::MTFn<D>, D>,
+    data: D::Interface,
+    f: F,
+) -> tree::Interface<tree::MTFn<D>, D>
+where
+    D: tree::DataType,
+    D::Method: Default,
+    D::Property: Default,
+    T: AsRef<dyn ChannelInterfaceAddressing1>,
+    F: 'static + Fn(&tree::MethodInfo<tree::MTFn<D>, D>) -> T,
+{
+    let i = factory.interface(
+        "org.freedesktop.Telepathy.Channel.Interface.Addressing1",
+        data,
+    );
+    let f = ::std::sync::Arc::new(f);
+    let p = factory.property::<&str, _>("TargetVCardField", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let dd = fclone(&minfo);
+        let d = dd.as_ref();
+        a.append(d.target_vcard_field()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+
+    let p = factory.property::<&str, _>("TargetURIScheme", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let dd = fclone(&minfo);
+        let d = dd.as_ref();
+        a.append(d.target_urischeme()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+
+    let p = factory.property::<&str, _>("TargetVCardAddress", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let dd = fclone(&minfo);
+        let d = dd.as_ref();
+        a.append(d.target_vcard_address()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+
+    let p = factory.property::<&str, _>("TargetURI", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let dd = fclone(&minfo);
+        let d = dd.as_ref();
+        a.append(d.target_uri()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+    i
+}
--- a/src/telepathy/channel_interface_anonymity.rs
+++ b/src/telepathy/channel_interface_anonymity.rs
@@ -0,0 +1,65 @@
+// This code was autogenerated with `dbus-codegen-rust --file telepathy-spec/spec/Channel_Interface_Anonymity.xml -i org.freedesktop.Telepathy -a AsRefClosure -o src/telepathy/channel_interface_anonymity.rs`, see https://github.com/diwic/dbus-rs
+use dbus;
+use dbus::arg;
+use dbus::tree;
+
+pub trait ChannelInterfaceAnonymity {
+    fn anonymity_modes(&self) -> Result<u32, tree::MethodErr>;
+    fn anonymity_mandatory(&self) -> Result<bool, tree::MethodErr>;
+    fn anonymous_id(&self) -> Result<String, tree::MethodErr>;
+}
+
+pub fn channel_interface_anonymity_server<F, T, D>(
+    factory: &tree::Factory<tree::MTFn<D>, D>,
+    data: D::Interface,
+    f: F,
+) -> tree::Interface<tree::MTFn<D>, D>
+where
+    D: tree::DataType,
+    D::Method: Default,
+    D::Property: Default,
+    T: AsRef<dyn ChannelInterfaceAnonymity>,
+    F: 'static + Fn(&tree::MethodInfo<tree::MTFn<D>, D>) -> T,
+{
+    let i = factory.interface(
+        "org.freedesktop.Telepathy.Channel.Interface.Anonymity",
+        data,
+    );
+    let f = ::std::sync::Arc::new(f);
+    let p = factory.property::<u32, _>("AnonymityModes", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let dd = fclone(&minfo);
+        let d = dd.as_ref();
+        a.append(d.anonymity_modes()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+
+    let p = factory.property::<bool, _>("AnonymityMandatory", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let dd = fclone(&minfo);
+        let d = dd.as_ref();
+        a.append(d.anonymity_mandatory()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+
+    let p = factory.property::<&str, _>("AnonymousID", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let dd = fclone(&minfo);
+        let d = dd.as_ref();
+        a.append(d.anonymous_id()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+    i
+}
--- a/src/telepathy/channel_interface_call_state.rs
+++ b/src/telepathy/channel_interface_call_state.rs
@@ -0,0 +1,71 @@
+// This code was autogenerated with `dbus-codegen-rust --file telepathy-spec/spec/Channel_Interface_Call_State.xml -i org.freedesktop.Telepathy -a AsRefClosure -o src/telepathy/channel_interface_call_state.rs`, see https://github.com/diwic/dbus-rs
+use dbus;
+use dbus::arg;
+use dbus::tree;
+
+pub trait ChannelInterfaceCallState {
+    fn get_call_states(&self) -> Result<::std::collections::HashMap<u32, u32>, tree::MethodErr>;
+}
+
+pub fn channel_interface_call_state_server<F, T, D>(
+    factory: &tree::Factory<tree::MTFn<D>, D>,
+    data: D::Interface,
+    f: F,
+) -> tree::Interface<tree::MTFn<D>, D>
+where
+    D: tree::DataType,
+    D::Method: Default,
+    D::Signal: Default,
+    T: AsRef<dyn ChannelInterfaceCallState>,
+    F: 'static + Fn(&tree::MethodInfo<tree::MTFn<D>, D>) -> T,
+{
+    let i = factory.interface(
+        "org.freedesktop.Telepathy.Channel.Interface.CallState",
+        data,
+    );
+    let f = ::std::sync::Arc::new(f);
+    let fclone = f.clone();
+    let h = move |minfo: &tree::MethodInfo<tree::MTFn<D>, D>| {
+        let dd = fclone(minfo);
+        let d = dd.as_ref();
+        let states = d.get_call_states()?;
+        let rm = minfo.msg.method_return();
+        let rm = rm.append1(states);
+        Ok(vec![rm])
+    };
+    let m = factory.method("GetCallStates", Default::default(), h);
+    let m = m.out_arg(("States", "a{uu}"));
+    let i = i.add_m(m);
+    let s = factory.signal("CallStateChanged", Default::default());
+    let s = s.arg(("Contact", "u"));
+    let s = s.arg(("State", "u"));
+    let i = i.add_s(s);
+    i
+}
+
+#[derive(Debug)]
+pub struct ChannelInterfaceCallStateCallStateChanged {
+    pub contact: u32,
+    pub state: u32,
+}
+
+impl arg::AppendAll for ChannelInterfaceCallStateCallStateChanged {
+    fn append(&self, i: &mut arg::IterAppend) {
+        arg::RefArg::append(&self.contact, i);
+        arg::RefArg::append(&self.state, i);
+    }
+}
+
+impl arg::ReadAll for ChannelInterfaceCallStateCallStateChanged {
+    fn read(i: &mut arg::Iter) -> Result<Self, arg::TypeMismatchError> {
+        Ok(ChannelInterfaceCallStateCallStateChanged {
+            contact: i.read()?,
+            state: i.read()?,
+        })
+    }
+}
+
+impl dbus::message::SignalArgs for ChannelInterfaceCallStateCallStateChanged {
+    const NAME: &'static str = "CallStateChanged";
+    const INTERFACE: &'static str = "org.freedesktop.Telepathy.Channel.Interface.CallState";
+}
--- a/src/telepathy/channel_interface_captcha_authentication.rs
+++ b/src/telepathy/channel_interface_captcha_authentication.rs
@@ -0,0 +1,161 @@
+// This code was autogenerated with `dbus-codegen-rust --file telepathy-spec/spec/Channel_Interface_Captcha_Authentication.xml -i org.freedesktop.Telepathy -a AsRefClosure -o src/telepathy/channel_interface_captcha_authentication.rs`, see https://github.com/diwic/dbus-rs
+use dbus;
+use dbus::arg;
+use dbus::tree;
+
+pub trait ChannelInterfaceCaptchaAuthentication1 {
+    fn get_captchas(
+        &self,
+    ) -> Result<(Vec<(u32, String, String, u32, Vec<String>)>, u32, String), tree::MethodErr>;
+    fn get_captcha_data(&self, id: u32, mime_type: &str) -> Result<Vec<u8>, tree::MethodErr>;
+    fn answer_captchas(
+        &self,
+        answers: ::std::collections::HashMap<u32, &str>,
+    ) -> Result<(), tree::MethodErr>;
+    fn cancel_captcha(&self, reason: u32, debug_message: &str) -> Result<(), tree::MethodErr>;
+    fn can_retry_captcha(&self) -> Result<bool, tree::MethodErr>;
+    fn captcha_status(&self) -> Result<u32, tree::MethodErr>;
+    fn captcha_error(&self) -> Result<String, tree::MethodErr>;
+    fn captcha_error_details(
+        &self,
+    ) -> Result<
+        ::std::collections::HashMap<String, arg::Variant<Box<dyn arg::RefArg + 'static>>>,
+        tree::MethodErr,
+    >;
+}
+
+pub fn channel_interface_captcha_authentication1_server<F, T, D>(
+    factory: &tree::Factory<tree::MTFn<D>, D>,
+    data: D::Interface,
+    f: F,
+) -> tree::Interface<tree::MTFn<D>, D>
+where
+    D: tree::DataType,
+    D::Method: Default,
+    D::Property: Default,
+    T: AsRef<dyn ChannelInterfaceCaptchaAuthentication1>,
+    F: 'static + Fn(&tree::MethodInfo<tree::MTFn<D>, D>) -> T,
+{
+    let i = factory.interface(
+        "org.freedesktop.Telepathy.Channel.Interface.CaptchaAuthentication1",
+        data,
+    );
+    let f = ::std::sync::Arc::new(f);
+    let fclone = f.clone();
+    let h = move |minfo: &tree::MethodInfo<tree::MTFn<D>, D>| {
+        let dd = fclone(minfo);
+        let d = dd.as_ref();
+        let (captcha_info, number_required, language) = d.get_captchas()?;
+        let rm = minfo.msg.method_return();
+        let rm = rm.append1(captcha_info);
+        let rm = rm.append1(number_required);
+        let rm = rm.append1(language);
+        Ok(vec![rm])
+    };
+    let m = factory.method("GetCaptchas", Default::default(), h);
+    let m = m.out_arg(("Captcha_Info", "a(ussuas)"));
+    let m = m.out_arg(("Number_Required", "u"));
+    let m = m.out_arg(("Language", "s"));
+    let i = i.add_m(m);
+
+    let fclone = f.clone();
+    let h = move |minfo: &tree::MethodInfo<tree::MTFn<D>, D>| {
+        let mut i = minfo.msg.iter_init();
+        let id: u32 = i.read()?;
+        let mime_type: &str = i.read()?;
+        let dd = fclone(minfo);
+        let d = dd.as_ref();
+        let captcha_data = d.get_captcha_data(id, mime_type)?;
+        let rm = minfo.msg.method_return();
+        let rm = rm.append1(captcha_data);
+        Ok(vec![rm])
+    };
+    let m = factory.method("GetCaptchaData", Default::default(), h);
+    let m = m.in_arg(("ID", "u"));
+    let m = m.in_arg(("Mime_Type", "s"));
+    let m = m.out_arg(("Captcha_Data", "ay"));
+    let i = i.add_m(m);
+
+    let fclone = f.clone();
+    let h = move |minfo: &tree::MethodInfo<tree::MTFn<D>, D>| {
+        let mut i = minfo.msg.iter_init();
+        let answers: ::std::collections::HashMap<u32, &str> = i.read()?;
+        let dd = fclone(minfo);
+        let d = dd.as_ref();
+        d.answer_captchas(answers)?;
+        let rm = minfo.msg.method_return();
+        Ok(vec![rm])
+    };
+    let m = factory.method("AnswerCaptchas", Default::default(), h);
+    let m = m.in_arg(("Answers", "a{us}"));
+    let i = i.add_m(m);
+
+    let fclone = f.clone();
+    let h = move |minfo: &tree::MethodInfo<tree::MTFn<D>, D>| {
+        let mut i = minfo.msg.iter_init();
+        let reason: u32 = i.read()?;
+        let debug_message: &str = i.read()?;
+        let dd = fclone(minfo);
+        let d = dd.as_ref();
+        d.cancel_captcha(reason, debug_message)?;
+        let rm = minfo.msg.method_return();
+        Ok(vec![rm])
+    };
+    let m = factory.method("CancelCaptcha", Default::default(), h);
+    let m = m.in_arg(("Reason", "u"));
+    let m = m.in_arg(("Debug_Message", "s"));
+    let i = i.add_m(m);
+
+    let p = factory.property::<bool, _>("CanRetryCaptcha", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let dd = fclone(&minfo);
+        let d = dd.as_ref();
+        a.append(d.can_retry_captcha()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+
+    let p = factory.property::<u32, _>("CaptchaStatus", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let dd = fclone(&minfo);
+        let d = dd.as_ref();
+        a.append(d.captcha_status()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+
+    let p = factory.property::<&str, _>("CaptchaError", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let dd = fclone(&minfo);
+        let d = dd.as_ref();
+        a.append(d.captcha_error()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+
+    let p = factory
+        .property::<::std::collections::HashMap<&str, arg::Variant<Box<dyn arg::RefArg>>>, _>(
+            "CaptchaErrorDetails",
+            Default::default(),
+        );
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let dd = fclone(&minfo);
+        let d = dd.as_ref();
+        a.append(d.captcha_error_details()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+    i
+}
--- a/src/telepathy/channel_interface_chat_state.rs
+++ b/src/telepathy/channel_interface_chat_state.rs
@@ -0,0 +1,87 @@
+// This code was autogenerated with `dbus-codegen-rust --file telepathy-spec/spec/Channel_Interface_Chat_State.xml -i org.freedesktop.Telepathy -a AsRefClosure -o src/telepathy/channel_interface_chat_state.rs`, see https://github.com/diwic/dbus-rs
+use dbus;
+use dbus::arg;
+use dbus::tree;
+
+pub trait ChannelInterfaceChatState {
+    fn set_chat_state(&self, state: u32) -> Result<(), tree::MethodErr>;
+    fn chat_states(&self) -> Result<::std::collections::HashMap<u32, u32>, tree::MethodErr>;
+}
+
+pub fn channel_interface_chat_state_server<F, T, D>(
+    factory: &tree::Factory<tree::MTFn<D>, D>,
+    data: D::Interface,
+    f: F,
+) -> tree::Interface<tree::MTFn<D>, D>
+where
+    D: tree::DataType,
+    D::Method: Default,
+    D::Property: Default,
+    D::Signal: Default,
+    T: AsRef<dyn ChannelInterfaceChatState>,
+    F: 'static + Fn(&tree::MethodInfo<tree::MTFn<D>, D>) -> T,
+{
+    let i = factory.interface(
+        "org.freedesktop.Telepathy.Channel.Interface.ChatState",
+        data,
+    );
+    let f = ::std::sync::Arc::new(f);
+    let fclone = f.clone();
+    let h = move |minfo: &tree::MethodInfo<tree::MTFn<D>, D>| {
+        let mut i = minfo.msg.iter_init();
+        let state: u32 = i.read()?;
+        let dd = fclone(minfo);
+        let d = dd.as_ref();
+        d.set_chat_state(state)?;
+        let rm = minfo.msg.method_return();
+        Ok(vec![rm])
+    };
+    let m = factory.method("SetChatState", Default::default(), h);
+    let m = m.in_arg(("State", "u"));
+    let i = i.add_m(m);
+
+    let p = factory
+        .property::<::std::collections::HashMap<u32, u32>, _>("ChatStates", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let dd = fclone(&minfo);
+        let d = dd.as_ref();
+        a.append(d.chat_states()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+    let s = factory.signal("ChatStateChanged", Default::default());
+    let s = s.arg(("Contact", "u"));
+    let s = s.arg(("State", "u"));
+    let i = i.add_s(s);
+    i
+}
+
+#[derive(Debug)]
+pub struct ChannelInterfaceChatStateChatStateChanged {
+    pub contact: u32,
+    pub state: u32,
+}
+
+impl arg::AppendAll for ChannelInterfaceChatStateChatStateChanged {
+    fn append(&self, i: &mut arg::IterAppend) {
+        arg::RefArg::append(&self.contact, i);
+        arg::RefArg::append(&self.state, i);
+    }
+}
+
+impl arg::ReadAll for ChannelInterfaceChatStateChatStateChanged {
+    fn read(i: &mut arg::Iter) -> Result<Self, arg::TypeMismatchError> {
+        Ok(ChannelInterfaceChatStateChatStateChanged {
+            contact: i.read()?,
+            state: i.read()?,
+        })
+    }
+}
+
+impl dbus::message::SignalArgs for ChannelInterfaceChatStateChatStateChanged {
+    const NAME: &'static str = "ChatStateChanged";
+    const INTERFACE: &'static str = "org.freedesktop.Telepathy.Channel.Interface.ChatState";
+}
--- a/src/telepathy/channel_interface_conference.rs
+++ b/src/telepathy/channel_interface_conference.rs
@@ -0,0 +1,177 @@
+// This code was autogenerated with `dbus-codegen-rust --file telepathy-spec/spec/Channel_Interface_Conference.xml -i org.freedesktop.Telepathy -a AsRefClosure -o src/telepathy/channel_interface_conference.rs`, see https://github.com/diwic/dbus-rs
+use dbus;
+use dbus::arg;
+use dbus::tree;
+
+pub trait ChannelInterfaceConference {
+    fn channels(&self) -> Result<Vec<dbus::Path<'static>>, tree::MethodErr>;
+    fn initial_channels(&self) -> Result<Vec<dbus::Path<'static>>, tree::MethodErr>;
+    fn initial_invitee_handles(&self) -> Result<Vec<u32>, tree::MethodErr>;
+    fn initial_invitee_ids(&self) -> Result<Vec<String>, tree::MethodErr>;
+    fn invitation_message(&self) -> Result<String, tree::MethodErr>;
+    fn original_channels(
+        &self,
+    ) -> Result<::std::collections::HashMap<u32, dbus::Path<'static>>, tree::MethodErr>;
+}
+
+pub fn channel_interface_conference_server<F, T, D>(
+    factory: &tree::Factory<tree::MTFn<D>, D>,
+    data: D::Interface,
+    f: F,
+) -> tree::Interface<tree::MTFn<D>, D>
+where
+    D: tree::DataType,
+    D::Method: Default,
+    D::Property: Default,
+    D::Signal: Default,
+    T: AsRef<dyn ChannelInterfaceConference>,
+    F: 'static + Fn(&tree::MethodInfo<tree::MTFn<D>, D>) -> T,
+{
+    let i = factory.interface(
+        "org.freedesktop.Telepathy.Channel.Interface.Conference",
+        data,
+    );
+    let f = ::std::sync::Arc::new(f);
+    let p = factory.property::<Vec<dbus::Path>, _>("Channels", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let dd = fclone(&minfo);
+        let d = dd.as_ref();
+        a.append(d.channels()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+
+    let p = factory.property::<Vec<dbus::Path>, _>("InitialChannels", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let dd = fclone(&minfo);
+        let d = dd.as_ref();
+        a.append(d.initial_channels()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+
+    let p = factory.property::<Vec<u32>, _>("InitialInviteeHandles", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let dd = fclone(&minfo);
+        let d = dd.as_ref();
+        a.append(d.initial_invitee_handles()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+
+    let p = factory.property::<Vec<&str>, _>("InitialInviteeIDs", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let dd = fclone(&minfo);
+        let d = dd.as_ref();
+        a.append(d.initial_invitee_ids()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+
+    let p = factory.property::<&str, _>("InvitationMessage", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let dd = fclone(&minfo);
+        let d = dd.as_ref();
+        a.append(d.invitation_message()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+
+    let p = factory.property::<::std::collections::HashMap<u32, dbus::Path>, _>(
+        "OriginalChannels",
+        Default::default(),
+    );
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let dd = fclone(&minfo);
+        let d = dd.as_ref();
+        a.append(d.original_channels()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+    let s = factory.signal("ChannelMerged", Default::default());
+    let s = s.arg(("Channel", "o"));
+    let s = s.arg(("Channel_Specific_Handle", "u"));
+    let s = s.arg(("Properties", "a{sv}"));
+    let i = i.add_s(s);
+    let s = factory.signal("ChannelRemoved", Default::default());
+    let s = s.arg(("Channel", "o"));
+    let s = s.arg(("Details", "a{sv}"));
+    let i = i.add_s(s);
+    i
+}
+
+#[derive(Debug)]
+pub struct ChannelInterfaceConferenceChannelMerged {
+    pub channel: dbus::Path<'static>,
+    pub channel_specific_handle: u32,
+    pub properties:
+        ::std::collections::HashMap<String, arg::Variant<Box<dyn arg::RefArg + 'static>>>,
+}
+
+impl arg::AppendAll for ChannelInterfaceConferenceChannelMerged {
+    fn append(&self, i: &mut arg::IterAppend) {
+        arg::RefArg::append(&self.channel, i);
+        arg::RefArg::append(&self.channel_specific_handle, i);
+        arg::RefArg::append(&self.properties, i);
+    }
+}
+
+impl arg::ReadAll for ChannelInterfaceConferenceChannelMerged {
+    fn read(i: &mut arg::Iter) -> Result<Self, arg::TypeMismatchError> {
+        Ok(ChannelInterfaceConferenceChannelMerged {
+            channel: i.read()?,
+            channel_specific_handle: i.read()?,
+            properties: i.read()?,
+        })
+    }
+}
+
+impl dbus::message::SignalArgs for ChannelInterfaceConferenceChannelMerged {
+    const NAME: &'static str = "ChannelMerged";
+    const INTERFACE: &'static str = "org.freedesktop.Telepathy.Channel.Interface.Conference";
+}
+
+#[derive(Debug)]
+pub struct ChannelInterfaceConferenceChannelRemoved {
+    pub channel: dbus::Path<'static>,
+    pub details: ::std::collections::HashMap<String, arg::Variant<Box<dyn arg::RefArg + 'static>>>,
+}
+
+impl arg::AppendAll for ChannelInterfaceConferenceChannelRemoved {
+    fn append(&self, i: &mut arg::IterAppend) {
+        arg::RefArg::append(&self.channel, i);
+        arg::RefArg::append(&self.details, i);
+    }
+}
+
+impl arg::ReadAll for ChannelInterfaceConferenceChannelRemoved {
+    fn read(i: &mut arg::Iter) -> Result<Self, arg::TypeMismatchError> {
+        Ok(ChannelInterfaceConferenceChannelRemoved {
+            channel: i.read()?,
+            details: i.read()?,
+        })
+    }
+}
+
+impl dbus::message::SignalArgs for ChannelInterfaceConferenceChannelRemoved {
+    const NAME: &'static str = "ChannelRemoved";
+    const INTERFACE: &'static str = "org.freedesktop.Telepathy.Channel.Interface.Conference";
+}
--- a/src/telepathy/channel_interface_credentials_storage.rs
+++ b/src/telepathy/channel_interface_credentials_storage.rs
@@ -0,0 +1,40 @@
+// This code was autogenerated with `dbus-codegen-rust --file telepathy-spec/spec/Channel_Interface_Credentials_Storage.xml -i org.freedesktop.Telepathy -a AsRefClosure -o src/telepathy/channel_interface_credentials_storage.rs`, see https://github.com/diwic/dbus-rs
+use dbus;
+use dbus::arg;
+use dbus::tree;
+
+pub trait ChannelInterfaceCredentialsStorageDRAFT {
+    fn store_credentials(&self, store: bool) -> Result<(), tree::MethodErr>;
+}
+
+pub fn channel_interface_credentials_storage_draft_server<F, T, D>(
+    factory: &tree::Factory<tree::MTFn<D>, D>,
+    data: D::Interface,
+    f: F,
+) -> tree::Interface<tree::MTFn<D>, D>
+where
+    D: tree::DataType,
+    D::Method: Default,
+    T: AsRef<dyn ChannelInterfaceCredentialsStorageDRAFT>,
+    F: 'static + Fn(&tree::MethodInfo<tree::MTFn<D>, D>) -> T,
+{
+    let i = factory.interface(
+        "org.freedesktop.Telepathy.Channel.Interface.CredentialsStorage.DRAFT",
+        data,
+    );
+    let f = ::std::sync::Arc::new(f);
+    let fclone = f.clone();
+    let h = move |minfo: &tree::MethodInfo<tree::MTFn<D>, D>| {
+        let mut i = minfo.msg.iter_init();
+        let store: bool = i.read()?;
+        let dd = fclone(minfo);
+        let d = dd.as_ref();
+        d.store_credentials(store)?;
+        let rm = minfo.msg.method_return();
+        Ok(vec![rm])
+    };
+    let m = factory.method("StoreCredentials", Default::default(), h);
+    let m = m.in_arg(("Store", "b"));
+    let i = i.add_m(m);
+    i
+}
--- a/src/telepathy/channel_interface_destroyable.rs
+++ b/src/telepathy/channel_interface_destroyable.rs
@@ -0,0 +1,37 @@
+// This code was autogenerated with `dbus-codegen-rust --file telepathy-spec/spec/Channel_Interface_Destroyable.xml -i org.freedesktop.Telepathy -a AsRefClosure -o src/telepathy/channel_interface_destroyable.rs`, see https://github.com/diwic/dbus-rs
+use dbus;
+use dbus::arg;
+use dbus::tree;
+
+pub trait ChannelInterfaceDestroyable {
+    fn destroy(&self) -> Result<(), tree::MethodErr>;
+}
+
+pub fn channel_interface_destroyable_server<F, T, D>(
+    factory: &tree::Factory<tree::MTFn<D>, D>,
+    data: D::Interface,
+    f: F,
+) -> tree::Interface<tree::MTFn<D>, D>
+where
+    D: tree::DataType,
+    D::Method: Default,
+    T: AsRef<dyn ChannelInterfaceDestroyable>,
+    F: 'static + Fn(&tree::MethodInfo<tree::MTFn<D>, D>) -> T,
+{
+    let i = factory.interface(
+        "org.freedesktop.Telepathy.Channel.Interface.Destroyable",
+        data,
+    );
+    let f = ::std::sync::Arc::new(f);
+    let fclone = f.clone();
+    let h = move |minfo: &tree::MethodInfo<tree::MTFn<D>, D>| {
+        let dd = fclone(minfo);
+        let d = dd.as_ref();
+        d.destroy()?;
+        let rm = minfo.msg.method_return();
+        Ok(vec![rm])
+    };
+    let m = factory.method("Destroy", Default::default(), h);
+    let i = i.add_m(m);
+    i
+}
--- a/src/telepathy/channel_interface_dtmf.rs
+++ b/src/telepathy/channel_interface_dtmf.rs
@@ -0,0 +1,187 @@
+// This code was autogenerated with `dbus-codegen-rust --file telepathy-spec/spec/Channel_Interface_DTMF.xml -i org.freedesktop.Telepathy -a AsRefClosure -o src/telepathy/channel_interface_dtmf.rs`, see https://github.com/diwic/dbus-rs
+use dbus;
+use dbus::arg;
+use dbus::tree;
+
+pub trait ChannelInterfaceDTMF {
+    fn start_tone(&self, stream_id: u32, event: u8) -> Result<(), tree::MethodErr>;
+    fn stop_tone(&self, stream_id: u32) -> Result<(), tree::MethodErr>;
+    fn multiple_tones(&self, tones: &str) -> Result<(), tree::MethodErr>;
+    fn currently_sending_tones(&self) -> Result<bool, tree::MethodErr>;
+    fn initial_tones(&self) -> Result<String, tree::MethodErr>;
+    fn deferred_tones(&self) -> Result<String, tree::MethodErr>;
+}
+
+pub fn channel_interface_dtmf_server<F, T, D>(
+    factory: &tree::Factory<tree::MTFn<D>, D>,
+    data: D::Interface,
+    f: F,
+) -> tree::Interface<tree::MTFn<D>, D>
+where
+    D: tree::DataType,
+    D::Method: Default,
+    D::Property: Default,
+    D::Signal: Default,
+    T: AsRef<dyn ChannelInterfaceDTMF>,
+    F: 'static + Fn(&tree::MethodInfo<tree::MTFn<D>, D>) -> T,
+{
+    let i = factory.interface("org.freedesktop.Telepathy.Channel.Interface.DTMF", data);
+    let f = ::std::sync::Arc::new(f);
+    let fclone = f.clone();
+    let h = move |minfo: &tree::MethodInfo<tree::MTFn<D>, D>| {
+        let mut i = minfo.msg.iter_init();
+        let stream_id: u32 = i.read()?;
+        let event: u8 = i.read()?;
+        let dd = fclone(minfo);
+        let d = dd.as_ref();
+        d.start_tone(stream_id, event)?;
+        let rm = minfo.msg.method_return();
+        Ok(vec![rm])
+    };
+    let m = factory.method("StartTone", Default::default(), h);
+    let m = m.in_arg(("Stream_ID", "u"));
+    let m = m.in_arg(("Event", "y"));
+    let i = i.add_m(m);
+
+    let fclone = f.clone();
+    let h = move |minfo: &tree::MethodInfo<tree::MTFn<D>, D>| {
+        let mut i = minfo.msg.iter_init();
+        let stream_id: u32 = i.read()?;
+        let dd = fclone(minfo);
+        let d = dd.as_ref();
+        d.stop_tone(stream_id)?;
+        let rm = minfo.msg.method_return();
+        Ok(vec![rm])
+    };
+    let m = factory.method("StopTone", Default::default(), h);
+    let m = m.in_arg(("Stream_ID", "u"));
+    let i = i.add_m(m);
+
+    let fclone = f.clone();
+    let h = move |minfo: &tree::MethodInfo<tree::MTFn<D>, D>| {
+        let mut i = minfo.msg.iter_init();
+        let tones: &str = i.read()?;
+        let dd = fclone(minfo);
+        let d = dd.as_ref();
+        d.multiple_tones(tones)?;
+        let rm = minfo.msg.method_return();
+        Ok(vec![rm])
+    };
+    let m = factory.method("MultipleTones", Default::default(), h);
+    let m = m.in_arg(("Tones", "s"));
+    let i = i.add_m(m);
+
+    let p = factory.property::<bool, _>("CurrentlySendingTones", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let dd = fclone(&minfo);
+        let d = dd.as_ref();
+        a.append(d.currently_sending_tones()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+
+    let p = factory.property::<&str, _>("InitialTones", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let dd = fclone(&minfo);
+        let d = dd.as_ref();
+        a.append(d.initial_tones()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+
+    let p = factory.property::<&str, _>("DeferredTones", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let dd = fclone(&minfo);
+        let d = dd.as_ref();
+        a.append(d.deferred_tones()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+    let s = factory.signal("TonesDeferred", Default::default());
+    let s = s.arg(("Tones", "s"));
+    let i = i.add_s(s);
+    let s = factory.signal("SendingTones", Default::default());
+    let s = s.arg(("Tones", "s"));
+    let i = i.add_s(s);
+    let s = factory.signal("StoppedTones", Default::default());
+    let s = s.arg(("Cancelled", "b"));
+    let i = i.add_s(s);
+    i
+}
+
+#[derive(Debug)]
+pub struct ChannelInterfaceDTMFTonesDeferred {
+    pub tones: String,
+}
+
+impl arg::AppendAll for ChannelInterfaceDTMFTonesDeferred {
+    fn append(&self, i: &mut arg::IterAppend) {
+        arg::RefArg::append(&self.tones, i);
+    }
+}
+
+impl arg::ReadAll for ChannelInterfaceDTMFTonesDeferred {
+    fn read(i: &mut arg::Iter) -> Result<Self, arg::TypeMismatchError> {
+        Ok(ChannelInterfaceDTMFTonesDeferred { tones: i.read()? })
+    }
+}
+
+impl dbus::message::SignalArgs for ChannelInterfaceDTMFTonesDeferred {
+    const NAME: &'static str = "TonesDeferred";
+    const INTERFACE: &'static str = "org.freedesktop.Telepathy.Channel.Interface.DTMF";
+}
+
+#[derive(Debug)]
+pub struct ChannelInterfaceDTMFSendingTones {
+    pub tones: String,
+}
+
+impl arg::AppendAll for ChannelInterfaceDTMFSendingTones {
+    fn append(&self, i: &mut arg::IterAppend) {
+        arg::RefArg::append(&self.tones, i);
+    }
+}
+
+impl arg::ReadAll for ChannelInterfaceDTMFSendingTones {
+    fn read(i: &mut arg::Iter) -> Result<Self, arg::TypeMismatchError> {
+        Ok(ChannelInterfaceDTMFSendingTones { tones: i.read()? })
+    }
+}
+
+impl dbus::message::SignalArgs for ChannelInterfaceDTMFSendingTones {
+    const NAME: &'static str = "SendingTones";
+    const INTERFACE: &'static str = "org.freedesktop.Telepathy.Channel.Interface.DTMF";
+}
+
+#[derive(Debug)]
+pub struct ChannelInterfaceDTMFStoppedTones {
+    pub cancelled: bool,
+}
+
+impl arg::AppendAll for ChannelInterfaceDTMFStoppedTones {
+    fn append(&self, i: &mut arg::IterAppend) {
+        arg::RefArg::append(&self.cancelled, i);
+    }
+}
+
+impl arg::ReadAll for ChannelInterfaceDTMFStoppedTones {
+    fn read(i: &mut arg::Iter) -> Result<Self, arg::TypeMismatchError> {
+        Ok(ChannelInterfaceDTMFStoppedTones {
+            cancelled: i.read()?,
+        })
+    }
+}
+
+impl dbus::message::SignalArgs for ChannelInterfaceDTMFStoppedTones {
+    const NAME: &'static str = "StoppedTones";
+    const INTERFACE: &'static str = "org.freedesktop.Telepathy.Channel.Interface.DTMF";
+}
--- a/src/telepathy/channel_interface_file_transfer_metadata.rs
+++ b/src/telepathy/channel_interface_file_transfer_metadata.rs
@@ -0,0 +1,77 @@
+// This code was autogenerated with `dbus-codegen-rust --file telepathy-spec/spec/Channel_Interface_File_Transfer_Metadata.xml -i org.freedesktop.Telepathy -a AsRefClosure -o src/telepathy/channel_interface_file_transfer_metadata.rs`, see https://github.com/diwic/dbus-rs
+use dbus;
+use dbus::arg;
+use dbus::tree;
+
+pub trait ChannelInterfaceFileTransferMetadata {
+    fn service_name(&self) -> Result<String, tree::MethodErr>;
+    fn set_service_name(&self, value: String) -> Result<(), tree::MethodErr>;
+    fn metadata(&self)
+        -> Result<::std::collections::HashMap<String, Vec<String>>, tree::MethodErr>;
+    fn set_metadata(
+        &self,
+        value: ::std::collections::HashMap<String, Vec<String>>,
+    ) -> Result<(), tree::MethodErr>;
+}
+
+pub fn channel_interface_file_transfer_metadata_server<F, T, D>(
+    factory: &tree::Factory<tree::MTFn<D>, D>,
+    data: D::Interface,
+    f: F,
+) -> tree::Interface<tree::MTFn<D>, D>
+where
+    D: tree::DataType,
+    D::Method: Default,
+    D::Property: Default,
+    T: AsRef<dyn ChannelInterfaceFileTransferMetadata>,
+    F: 'static + Fn(&tree::MethodInfo<tree::MTFn<D>, D>) -> T,
+{
+    let i = factory.interface(
+        "org.freedesktop.Telepathy.Channel.Interface.FileTransfer.Metadata",
+        data,
+    );
+    let f = ::std::sync::Arc::new(f);
+    let p = factory.property::<&str, _>("ServiceName", Default::default());
+    let p = p.access(tree::Access::ReadWrite);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let dd = fclone(&minfo);
+        let d = dd.as_ref();
+        a.append(d.service_name()?);
+        Ok(())
+    });
+    let fclone = f.clone();
+    let p = p.on_set(move |iter, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let dd = fclone(&minfo);
+        let d = dd.as_ref();
+        d.set_service_name(iter.read()?)?;
+        Ok(())
+    });
+    let i = i.add_p(p);
+
+    let p = factory.property::<::std::collections::HashMap<&str, Vec<&str>>, _>(
+        "Metadata",
+        Default::default(),
+    );
+    let p = p.access(tree::Access::ReadWrite);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let dd = fclone(&minfo);
+        let d = dd.as_ref();
+        a.append(d.metadata()?);
+        Ok(())
+    });
+    let fclone = f.clone();
+    let p = p.on_set(move |iter, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let dd = fclone(&minfo);
+        let d = dd.as_ref();
+        d.set_metadata(iter.read()?)?;
+        Ok(())
+    });
+    let i = i.add_p(p);
+    i
+}
--- a/src/telepathy/channel_interface_group.rs
+++ b/src/telepathy/channel_interface_group.rs
@@ -0,0 +1,550 @@
+// This code was autogenerated with `dbus-codegen-rust --file telepathy-spec/spec/Channel_Interface_Group.xml -i org.freedesktop.Telepathy -a AsRefClosure -o src/telepathy/channel_interface_group.rs`, see https://github.com/diwic/dbus-rs
+use dbus;
+use dbus::arg;
+use dbus::tree;
+
+pub trait ChannelInterfaceGroup {
+    fn add_members(&self, contacts: Vec<u32>, message: &str) -> Result<(), tree::MethodErr>;
+    fn get_all_members(&self) -> Result<(Vec<u32>, Vec<u32>, Vec<u32>), tree::MethodErr>;
+    fn get_group_flags(&self) -> Result<u32, tree::MethodErr>;
+    fn get_handle_owners(&self, handles: Vec<u32>) -> Result<Vec<u32>, tree::MethodErr>;
+    fn get_local_pending_members(&self) -> Result<Vec<u32>, tree::MethodErr>;
+    fn get_local_pending_members_with_info(
+        &self,
+    ) -> Result<Vec<(u32, u32, u32, String)>, tree::MethodErr>;
+    fn get_members(&self) -> Result<Vec<u32>, tree::MethodErr>;
+    fn get_remote_pending_members(&self) -> Result<Vec<u32>, tree::MethodErr>;
+    fn get_self_handle(&self) -> Result<u32, tree::MethodErr>;
+    fn remove_members(&self, contacts: Vec<u32>, message: &str) -> Result<(), tree::MethodErr>;
+    fn remove_members_with_reason(
+        &self,
+        contacts: Vec<u32>,
+        message: &str,
+        reason: u32,
+    ) -> Result<(), tree::MethodErr>;
+    fn group_flags(&self) -> Result<u32, tree::MethodErr>;
+    fn handle_owners(&self) -> Result<::std::collections::HashMap<u32, u32>, tree::MethodErr>;
+    fn local_pending_members(&self) -> Result<Vec<(u32, u32, u32, String)>, tree::MethodErr>;
+    fn members(&self) -> Result<Vec<u32>, tree::MethodErr>;
+    fn remote_pending_members(&self) -> Result<Vec<u32>, tree::MethodErr>;
+    fn self_handle(&self) -> Result<u32, tree::MethodErr>;
+    fn member_identifiers(
+        &self,
+    ) -> Result<::std::collections::HashMap<u32, String>, tree::MethodErr>;
+}
+
+pub fn channel_interface_group_server<F, T, D>(
+    factory: &tree::Factory<tree::MTFn<D>, D>,
+    data: D::Interface,
+    f: F,
+) -> tree::Interface<tree::MTFn<D>, D>
+where
+    D: tree::DataType,
+    D::Method: Default,
+    D::Property: Default,
+    D::Signal: Default,
+    T: AsRef<dyn ChannelInterfaceGroup>,
+    F: 'static + Fn(&tree::MethodInfo<tree::MTFn<D>, D>) -> T,
+{
+    let i = factory.interface("org.freedesktop.Telepathy.Channel.Interface.Group", data);
+    let f = ::std::sync::Arc::new(f);
+    let fclone = f.clone();
+    let h = move |minfo: &tree::MethodInfo<tree::MTFn<D>, D>| {
+        let mut i = minfo.msg.iter_init();
+        let contacts: Vec<u32> = i.read()?;
+        let message: &str = i.read()?;
+        let dd = fclone(minfo);
+        let d = dd.as_ref();
+        d.add_members(contacts, message)?;
+        let rm = minfo.msg.method_return();
+        Ok(vec![rm])
+    };
+    let m = factory.method("AddMembers", Default::default(), h);
+    let m = m.in_arg(("Contacts", "au"));
+    let m = m.in_arg(("Message", "s"));
+    let i = i.add_m(m);
+
+    let fclone = f.clone();
+    let h = move |minfo: &tree::MethodInfo<tree::MTFn<D>, D>| {
+        let dd = fclone(minfo);
+        let d = dd.as_ref();
+        let (members, local_pending, remote_pending) = d.get_all_members()?;
+        let rm = minfo.msg.method_return();
+        let rm = rm.append1(members);
+        let rm = rm.append1(local_pending);
+        let rm = rm.append1(remote_pending);
+        Ok(vec![rm])
+    };
+    let m = factory.method("GetAllMembers", Default::default(), h);
+    let m = m.out_arg(("Members", "au"));
+    let m = m.out_arg(("Local_Pending", "au"));
+    let m = m.out_arg(("Remote_Pending", "au"));
+    let i = i.add_m(m);
+
+    let fclone = f.clone();
+    let h = move |minfo: &tree::MethodInfo<tree::MTFn<D>, D>| {
+        let dd = fclone(minfo);
+        let d = dd.as_ref();
+        let group_flags = d.get_group_flags()?;
+        let rm = minfo.msg.method_return();
+        let rm = rm.append1(group_flags);
+        Ok(vec![rm])
+    };
+    let m = factory.method("GetGroupFlags", Default::default(), h);
+    let m = m.out_arg(("Group_Flags", "u"));
+    let i = i.add_m(m);
+
+    let fclone = f.clone();
+    let h = move |minfo: &tree::MethodInfo<tree::MTFn<D>, D>| {
+        let mut i = minfo.msg.iter_init();
+        let handles: Vec<u32> = i.read()?;
+        let dd = fclone(minfo);
+        let d = dd.as_ref();
+        let owners = d.get_handle_owners(handles)?;
+        let rm = minfo.msg.method_return();
+        let rm = rm.append1(owners);
+        Ok(vec![rm])
+    };
+    let m = factory.method("GetHandleOwners", Default::default(), h);
+    let m = m.in_arg(("Handles", "au"));
+    let m = m.out_arg(("Owners", "au"));
+    let i = i.add_m(m);
+
+    let fclone = f.clone();
+    let h = move |minfo: &tree::MethodInfo<tree::MTFn<D>, D>| {
+        let dd = fclone(minfo);
+        let d = dd.as_ref();
+        let handles = d.get_local_pending_members()?;
+        let rm = minfo.msg.method_return();
+        let rm = rm.append1(handles);
+        Ok(vec![rm])
+    };
+    let m = factory.method("GetLocalPendingMembers", Default::default(), h);
+    let m = m.out_arg(("Handles", "au"));
+    let i = i.add_m(m);
+
+    let fclone = f.clone();
+    let h = move |minfo: &tree::MethodInfo<tree::MTFn<D>, D>| {
+        let dd = fclone(minfo);
+        let d = dd.as_ref();
+        let info = d.get_local_pending_members_with_info()?;
+        let rm = minfo.msg.method_return();
+        let rm = rm.append1(info);
+        Ok(vec![rm])
+    };
+    let m = factory.method("GetLocalPendingMembersWithInfo", Default::default(), h);
+    let m = m.out_arg(("Info", "a(uuus)"));
+    let i = i.add_m(m);
+
+    let fclone = f.clone();
+    let h = move |minfo: &tree::MethodInfo<tree::MTFn<D>, D>| {
+        let dd = fclone(minfo);
+        let d = dd.as_ref();
+        let handles = d.get_members()?;
+        let rm = minfo.msg.method_return();
+        let rm = rm.append1(handles);
+        Ok(vec![rm])
+    };
+    let m = factory.method("GetMembers", Default::default(), h);
+    let m = m.out_arg(("Handles", "au"));
+    let i = i.add_m(m);
+
+    let fclone = f.clone();
+    let h = move |minfo: &tree::MethodInfo<tree::MTFn<D>, D>| {
+        let dd = fclone(minfo);
+        let d = dd.as_ref();
+        let handles = d.get_remote_pending_members()?;
+        let rm = minfo.msg.method_return();
+        let rm = rm.append1(handles);
+        Ok(vec![rm])
+    };
+    let m = factory.method("GetRemotePendingMembers", Default::default(), h);
+    let m = m.out_arg(("Handles", "au"));
+    let i = i.add_m(m);
+
+    let fclone = f.clone();
+    let h = move |minfo: &tree::MethodInfo<tree::MTFn<D>, D>| {
+        let dd = fclone(minfo);
+        let d = dd.as_ref();
+        let self_handle = d.get_self_handle()?;
+        let rm = minfo.msg.method_return();
+        let rm = rm.append1(self_handle);
+        Ok(vec![rm])
+    };
+    let m = factory.method("GetSelfHandle", Default::default(), h);
+    let m = m.out_arg(("Self_Handle", "u"));
+    let i = i.add_m(m);
+
+    let fclone = f.clone();
+    let h = move |minfo: &tree::MethodInfo<tree::MTFn<D>, D>| {
+        let mut i = minfo.msg.iter_init();
+        let contacts: Vec<u32> = i.read()?;
+        let message: &str = i.read()?;
+        let dd = fclone(minfo);
+        let d = dd.as_ref();
+        d.remove_members(contacts, message)?;
+        let rm = minfo.msg.method_return();
+        Ok(vec![rm])
+    };
+    let m = factory.method("RemoveMembers", Default::default(), h);
+    let m = m.in_arg(("Contacts", "au"));
+    let m = m.in_arg(("Message", "s"));
+    let i = i.add_m(m);
+
+    let fclone = f.clone();
+    let h = move |minfo: &tree::MethodInfo<tree::MTFn<D>, D>| {
+        let mut i = minfo.msg.iter_init();
+        let contacts: Vec<u32> = i.read()?;
+        let message: &str = i.read()?;
+        let reason: u32 = i.read()?;
+        let dd = fclone(minfo);
+        let d = dd.as_ref();
+        d.remove_members_with_reason(contacts, message, reason)?;
+        let rm = minfo.msg.method_return();
+        Ok(vec![rm])
+    };
+    let m = factory.method("RemoveMembersWithReason", Default::default(), h);
+    let m = m.in_arg(("Contacts", "au"));
+    let m = m.in_arg(("Message", "s"));
+    let m = m.in_arg(("Reason", "u"));
+    let i = i.add_m(m);
+
+    let p = factory.property::<u32, _>("GroupFlags", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let dd = fclone(&minfo);
+        let d = dd.as_ref();
+        a.append(d.group_flags()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+
+    let p = factory
+        .property::<::std::collections::HashMap<u32, u32>, _>("HandleOwners", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let dd = fclone(&minfo);
+        let d = dd.as_ref();
+        a.append(d.handle_owners()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+
+    let p = factory
+        .property::<Vec<(u32, u32, u32, &str)>, _>("LocalPendingMembers", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let dd = fclone(&minfo);
+        let d = dd.as_ref();
+        a.append(d.local_pending_members()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+
+    let p = factory.property::<Vec<u32>, _>("Members", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let dd = fclone(&minfo);
+        let d = dd.as_ref();
+        a.append(d.members()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+
+    let p = factory.property::<Vec<u32>, _>("RemotePendingMembers", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let dd = fclone(&minfo);
+        let d = dd.as_ref();
+        a.append(d.remote_pending_members()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+
+    let p = factory.property::<u32, _>("SelfHandle", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let dd = fclone(&minfo);
+        let d = dd.as_ref();
+        a.append(d.self_handle()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+
+    let p = factory.property::<::std::collections::HashMap<u32, &str>, _>(
+        "MemberIdentifiers",
+        Default::default(),
+    );
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let dd = fclone(&minfo);
+        let d = dd.as_ref();
+        a.append(d.member_identifiers()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+    let s = factory.signal("HandleOwnersChanged", Default::default());
+    let s = s.arg(("Added", "a{uu}"));
+    let s = s.arg(("Removed", "au"));
+    let i = i.add_s(s);
+    let s = factory.signal("HandleOwnersChangedDetailed", Default::default());
+    let s = s.arg(("Added", "a{uu}"));
+    let s = s.arg(("Removed", "au"));
+    let s = s.arg(("Identifiers", "a{us}"));
+    let i = i.add_s(s);
+    let s = factory.signal("SelfHandleChanged", Default::default());
+    let s = s.arg(("Self_Handle", "u"));
+    let i = i.add_s(s);
+    let s = factory.signal("SelfContactChanged", Default::default());
+    let s = s.arg(("Self_Handle", "u"));
+    let s = s.arg(("Self_ID", "s"));
+    let i = i.add_s(s);
+    let s = factory.signal("GroupFlagsChanged", Default::default());
+    let s = s.arg(("Added", "u"));
+    let s = s.arg(("Removed", "u"));
+    let i = i.add_s(s);
+    let s = factory.signal("MembersChanged", Default::default());
+    let s = s.arg(("Message", "s"));
+    let s = s.arg(("Added", "au"));
+    let s = s.arg(("Removed", "au"));
+    let s = s.arg(("Local_Pending", "au"));
+    let s = s.arg(("Remote_Pending", "au"));
+    let s = s.arg(("Actor", "u"));
+    let s = s.arg(("Reason", "u"));
+    let i = i.add_s(s);
+    let s = factory.signal("MembersChangedDetailed", Default::default());
+    let s = s.arg(("Added", "au"));
+    let s = s.arg(("Removed", "au"));
+    let s = s.arg(("Local_Pending", "au"));
+    let s = s.arg(("Remote_Pending", "au"));
+    let s = s.arg(("Details", "a{sv}"));
+    let i = i.add_s(s);
+    i
+}
+
+#[derive(Debug)]
+pub struct ChannelInterfaceGroupHandleOwnersChanged {
+    pub added: ::std::collections::HashMap<u32, u32>,
+    pub removed: Vec<u32>,
+}
+
+impl arg::AppendAll for ChannelInterfaceGroupHandleOwnersChanged {
+    fn append(&self, i: &mut arg::IterAppend) {
+        arg::RefArg::append(&self.added, i);
+        arg::RefArg::append(&self.removed, i);
+    }
+}
+
+impl arg::ReadAll for ChannelInterfaceGroupHandleOwnersChanged {
+    fn read(i: &mut arg::Iter) -> Result<Self, arg::TypeMismatchError> {
+        Ok(ChannelInterfaceGroupHandleOwnersChanged {
+            added: i.read()?,
+            removed: i.read()?,
+        })
+    }
+}
+
+impl dbus::message::SignalArgs for ChannelInterfaceGroupHandleOwnersChanged {
+    const NAME: &'static str = "HandleOwnersChanged";
+    const INTERFACE: &'static str = "org.freedesktop.Telepathy.Channel.Interface.Group";
+}
+
+#[derive(Debug)]
+pub struct ChannelInterfaceGroupHandleOwnersChangedDetailed {
+    pub added: ::std::collections::HashMap<u32, u32>,
+    pub removed: Vec<u32>,
+    pub identifiers: ::std::collections::HashMap<u32, String>,
+}
+
+impl arg::AppendAll for ChannelInterfaceGroupHandleOwnersChangedDetailed {
+    fn append(&self, i: &mut arg::IterAppend) {
+        arg::RefArg::append(&self.added, i);
+        arg::RefArg::append(&self.removed, i);
+        arg::RefArg::append(&self.identifiers, i);
+    }
+}
+
+impl arg::ReadAll for ChannelInterfaceGroupHandleOwnersChangedDetailed {
+    fn read(i: &mut arg::Iter) -> Result<Self, arg::TypeMismatchError> {
+        Ok(ChannelInterfaceGroupHandleOwnersChangedDetailed {
+            added: i.read()?,
+            removed: i.read()?,
+            identifiers: i.read()?,
+        })
+    }
+}
+
+impl dbus::message::SignalArgs for ChannelInterfaceGroupHandleOwnersChangedDetailed {
+    const NAME: &'static str = "HandleOwnersChangedDetailed";
+    const INTERFACE: &'static str = "org.freedesktop.Telepathy.Channel.Interface.Group";
+}
+
+#[derive(Debug)]
+pub struct ChannelInterfaceGroupSelfHandleChanged {
+    pub self_handle: u32,
+}
+
+impl arg::AppendAll for ChannelInterfaceGroupSelfHandleChanged {
+    fn append(&self, i: &mut arg::IterAppend) {
+        arg::RefArg::append(&self.self_handle, i);
+    }
+}
+
+impl arg::ReadAll for ChannelInterfaceGroupSelfHandleChanged {
+    fn read(i: &mut arg::Iter) -> Result<Self, arg::TypeMismatchError> {
+        Ok(ChannelInterfaceGroupSelfHandleChanged {
+            self_handle: i.read()?,
+        })
+    }
+}
+
+impl dbus::message::SignalArgs for ChannelInterfaceGroupSelfHandleChanged {
+    const NAME: &'static str = "SelfHandleChanged";
+    const INTERFACE: &'static str = "org.freedesktop.Telepathy.Channel.Interface.Group";
+}
+
+#[derive(Debug)]
+pub struct ChannelInterfaceGroupSelfContactChanged {
+    pub self_handle: u32,
+    pub self_id: String,
+}
+
+impl arg::AppendAll for ChannelInterfaceGroupSelfContactChanged {
+    fn append(&self, i: &mut arg::IterAppend) {
+        arg::RefArg::append(&self.self_handle, i);
+        arg::RefArg::append(&self.self_id, i);
+    }
+}
+
+impl arg::ReadAll for ChannelInterfaceGroupSelfContactChanged {
+    fn read(i: &mut arg::Iter) -> Result<Self, arg::TypeMismatchError> {
+        Ok(ChannelInterfaceGroupSelfContactChanged {
+            self_handle: i.read()?,
+            self_id: i.read()?,
+        })
+    }
+}
+
+impl dbus::message::SignalArgs for ChannelInterfaceGroupSelfContactChanged {
+    const NAME: &'static str = "SelfContactChanged";
+    const INTERFACE: &'static str = "org.freedesktop.Telepathy.Channel.Interface.Group";
+}
+
+#[derive(Debug)]
+pub struct ChannelInterfaceGroupGroupFlagsChanged {
+    pub added: u32,
+    pub removed: u32,
+}
+
+impl arg::AppendAll for ChannelInterfaceGroupGroupFlagsChanged {
+    fn append(&self, i: &mut arg::IterAppend) {
+        arg::RefArg::append(&self.added, i);
+        arg::RefArg::append(&self.removed, i);
+    }
+}
+
+impl arg::ReadAll for ChannelInterfaceGroupGroupFlagsChanged {
+    fn read(i: &mut arg::Iter) -> Result<Self, arg::TypeMismatchError> {
+        Ok(ChannelInterfaceGroupGroupFlagsChanged {
+            added: i.read()?,
+            removed: i.read()?,
+        })
+    }
+}
+
+impl dbus::message::SignalArgs for ChannelInterfaceGroupGroupFlagsChanged {
+    const NAME: &'static str = "GroupFlagsChanged";
+    const INTERFACE: &'static str = "org.freedesktop.Telepathy.Channel.Interface.Group";
+}
+
+#[derive(Debug)]
+pub struct ChannelInterfaceGroupMembersChanged {
+    pub message: String,
+    pub added: Vec<u32>,
+    pub removed: Vec<u32>,
+    pub local_pending: Vec<u32>,
+    pub remote_pending: Vec<u32>,
+    pub actor: u32,
+    pub reason: u32,
+}
+
+impl arg::AppendAll for ChannelInterfaceGroupMembersChanged {
+    fn append(&self, i: &mut arg::IterAppend) {
+        arg::RefArg::append(&self.message, i);
+        arg::RefArg::append(&self.added, i);
+        arg::RefArg::append(&self.removed, i);
+        arg::RefArg::append(&self.local_pending, i);
+        arg::RefArg::append(&self.remote_pending, i);
+        arg::RefArg::append(&self.actor, i);
+        arg::RefArg::append(&self.reason, i);
+    }
+}
+
+impl arg::ReadAll for ChannelInterfaceGroupMembersChanged {
+    fn read(i: &mut arg::Iter) -> Result<Self, arg::TypeMismatchError> {
+        Ok(ChannelInterfaceGroupMembersChanged {
+            message: i.read()?,
+            added: i.read()?,
+            removed: i.read()?,
+            local_pending: i.read()?,
+            remote_pending: i.read()?,
+            actor: i.read()?,
+            reason: i.read()?,
+        })
+    }
+}
+
+impl dbus::message::SignalArgs for ChannelInterfaceGroupMembersChanged {
+    const NAME: &'static str = "MembersChanged";
+    const INTERFACE: &'static str = "org.freedesktop.Telepathy.Channel.Interface.Group";
+}
+
+#[derive(Debug)]
+pub struct ChannelInterfaceGroupMembersChangedDetailed {
+    pub added: Vec<u32>,
+    pub removed: Vec<u32>,
+    pub local_pending: Vec<u32>,
+    pub remote_pending: Vec<u32>,
+    pub details: ::std::collections::HashMap<String, arg::Variant<Box<dyn arg::RefArg + 'static>>>,
+}
+
+impl arg::AppendAll for ChannelInterfaceGroupMembersChangedDetailed {
+    fn append(&self, i: &mut arg::IterAppend) {
+        arg::RefArg::append(&self.added, i);
+        arg::RefArg::append(&self.removed, i);
+        arg::RefArg::append(&self.local_pending, i);
+        arg::RefArg::append(&self.remote_pending, i);
+        arg::RefArg::append(&self.details, i);
+    }
+}
+
+impl arg::ReadAll for ChannelInterfaceGroupMembersChangedDetailed {
+    fn read(i: &mut arg::Iter) -> Result<Self, arg::TypeMismatchError> {
+        Ok(ChannelInterfaceGroupMembersChangedDetailed {
+            added: i.read()?,
+            removed: i.read()?,
+            local_pending: i.read()?,
+            remote_pending: i.read()?,
+            details: i.read()?,
+        })
+    }
+}
+
+impl dbus::message::SignalArgs for ChannelInterfaceGroupMembersChangedDetailed {
+    const NAME: &'static str = "MembersChangedDetailed";
+    const INTERFACE: &'static str = "org.freedesktop.Telepathy.Channel.Interface.Group";
+}
--- a/src/telepathy/channel_interface_hold.rs
+++ b/src/telepathy/channel_interface_hold.rs
@@ -0,0 +1,85 @@
+// This code was autogenerated with `dbus-codegen-rust --file telepathy-spec/spec/Channel_Interface_Hold.xml -i org.freedesktop.Telepathy -a AsRefClosure -o src/telepathy/channel_interface_hold.rs`, see https://github.com/diwic/dbus-rs
+use dbus;
+use dbus::arg;
+use dbus::tree;
+
+pub trait ChannelInterfaceHold {
+    fn get_hold_state(&self) -> Result<(u32, u32), tree::MethodErr>;
+    fn request_hold(&self, hold: bool) -> Result<(), tree::MethodErr>;
+}
+
+pub fn channel_interface_hold_server<F, T, D>(
+    factory: &tree::Factory<tree::MTFn<D>, D>,
+    data: D::Interface,
+    f: F,
+) -> tree::Interface<tree::MTFn<D>, D>
+where
+    D: tree::DataType,
+    D::Method: Default,
+    D::Signal: Default,
+    T: AsRef<dyn ChannelInterfaceHold>,
+    F: 'static + Fn(&tree::MethodInfo<tree::MTFn<D>, D>) -> T,
+{
+    let i = factory.interface("org.freedesktop.Telepathy.Channel.Interface.Hold", data);
+    let f = ::std::sync::Arc::new(f);
+    let fclone = f.clone();
+    let h = move |minfo: &tree::MethodInfo<tree::MTFn<D>, D>| {
+        let dd = fclone(minfo);
+        let d = dd.as_ref();
+        let (hold_state, reason) = d.get_hold_state()?;
+        let rm = minfo.msg.method_return();
+        let rm = rm.append1(hold_state);
+        let rm = rm.append1(reason);
+        Ok(vec![rm])
+    };
+    let m = factory.method("GetHoldState", Default::default(), h);
+    let m = m.out_arg(("HoldState", "u"));
+    let m = m.out_arg(("Reason", "u"));
+    let i = i.add_m(m);
+
+    let fclone = f.clone();
+    let h = move |minfo: &tree::MethodInfo<tree::MTFn<D>, D>| {
+        let mut i = minfo.msg.iter_init();
+        let hold: bool = i.read()?;
+        let dd = fclone(minfo);
+        let d = dd.as_ref();
+        d.request_hold(hold)?;
+        let rm = minfo.msg.method_return();
+        Ok(vec![rm])
+    };
+    let m = factory.method("RequestHold", Default::default(), h);
+    let m = m.in_arg(("Hold", "b"));
+    let i = i.add_m(m);
+    let s = factory.signal("HoldStateChanged", Default::default());
+    let s = s.arg(("HoldState", "u"));
+    let s = s.arg(("Reason", "u"));
+    let i = i.add_s(s);
+    i
+}
+
+#[derive(Debug)]
+pub struct ChannelInterfaceHoldHoldStateChanged {
+    pub hold_state: u32,
+    pub reason: u32,
+}
+
+impl arg::AppendAll for ChannelInterfaceHoldHoldStateChanged {
+    fn append(&self, i: &mut arg::IterAppend) {
+        arg::RefArg::append(&self.hold_state, i);
+        arg::RefArg::append(&self.reason, i);
+    }
+}
+
+impl arg::ReadAll for ChannelInterfaceHoldHoldStateChanged {
+    fn read(i: &mut arg::Iter) -> Result<Self, arg::TypeMismatchError> {
+        Ok(ChannelInterfaceHoldHoldStateChanged {
+            hold_state: i.read()?,
+            reason: i.read()?,
+        })
+    }
+}
+
+impl dbus::message::SignalArgs for ChannelInterfaceHoldHoldStateChanged {
+    const NAME: &'static str = "HoldStateChanged";
+    const INTERFACE: &'static str = "org.freedesktop.Telepathy.Channel.Interface.Hold";
+}
--- a/src/telepathy/channel_interface_html.rs
+++ b/src/telepathy/channel_interface_html.rs
@@ -0,0 +1,25 @@
+// This code was autogenerated with `dbus-codegen-rust --file telepathy-spec/spec/Channel_Interface_HTML.xml -i org.freedesktop.Telepathy -a AsRefClosure -o src/telepathy/channel_interface_html.rs`, see https://github.com/diwic/dbus-rs
+use dbus;
+use dbus::arg;
+use dbus::tree;
+
+pub trait ChannelInterfaceHTMLDRAFT {}
+
+pub fn channel_interface_htmldraft_server<F, T, D>(
+    factory: &tree::Factory<tree::MTFn<D>, D>,
+    data: D::Interface,
+    f: F,
+) -> tree::Interface<tree::MTFn<D>, D>
+where
+    D: tree::DataType,
+    D::Method: Default,
+    T: AsRef<dyn ChannelInterfaceHTMLDRAFT>,
+    F: 'static + Fn(&tree::MethodInfo<tree::MTFn<D>, D>) -> T,
+{
+    let i = factory.interface(
+        "org.freedesktop.Telepathy.Channel.Interface.HTML.DRAFT",
+        data,
+    );
+    let f = ::std::sync::Arc::new(f);
+    i
+}
--- a/src/telepathy/channel_interface_media_signalling.rs
+++ b/src/telepathy/channel_interface_media_signalling.rs
@@ -0,0 +1,71 @@
+// This code was autogenerated with `dbus-codegen-rust --file telepathy-spec/spec/Channel_Interface_Media_Signalling.xml -i org.freedesktop.Telepathy -a AsRefClosure -o src/telepathy/channel_interface_media_signalling.rs`, see https://github.com/diwic/dbus-rs
+use dbus;
+use dbus::arg;
+use dbus::tree;
+
+pub trait ChannelInterfaceMediaSignalling {
+    fn get_session_handlers(&self) -> Result<Vec<(dbus::Path<'static>, String)>, tree::MethodErr>;
+}
+
+pub fn channel_interface_media_signalling_server<F, T, D>(
+    factory: &tree::Factory<tree::MTFn<D>, D>,
+    data: D::Interface,
+    f: F,
+) -> tree::Interface<tree::MTFn<D>, D>
+where
+    D: tree::DataType,
+    D::Method: Default,
+    D::Signal: Default,
+    T: AsRef<dyn ChannelInterfaceMediaSignalling>,
+    F: 'static + Fn(&tree::MethodInfo<tree::MTFn<D>, D>) -> T,
+{
+    let i = factory.interface(
+        "org.freedesktop.Telepathy.Channel.Interface.MediaSignalling",
+        data,
+    );
+    let f = ::std::sync::Arc::new(f);
+    let fclone = f.clone();
+    let h = move |minfo: &tree::MethodInfo<tree::MTFn<D>, D>| {
+        let dd = fclone(minfo);
+        let d = dd.as_ref();
+        let session_handlers = d.get_session_handlers()?;
+        let rm = minfo.msg.method_return();
+        let rm = rm.append1(session_handlers);
+        Ok(vec![rm])
+    };
+    let m = factory.method("GetSessionHandlers", Default::default(), h);
+    let m = m.out_arg(("Session_Handlers", "a(os)"));
+    let i = i.add_m(m);
+    let s = factory.signal("NewSessionHandler", Default::default());
+    let s = s.arg(("Session_Handler", "o"));
+    let s = s.arg(("Session_Type", "s"));
+    let i = i.add_s(s);
+    i
+}
+
+#[derive(Debug)]
+pub struct ChannelInterfaceMediaSignallingNewSessionHandler {
+    pub session_handler: dbus::Path<'static>,
+    pub session_type: String,
+}
+
+impl arg::AppendAll for ChannelInterfaceMediaSignallingNewSessionHandler {
+    fn append(&self, i: &mut arg::IterAppend) {
+        arg::RefArg::append(&self.session_handler, i);
+        arg::RefArg::append(&self.session_type, i);
+    }
+}
+
+impl arg::ReadAll for ChannelInterfaceMediaSignallingNewSessionHandler {
+    fn read(i: &mut arg::Iter) -> Result<Self, arg::TypeMismatchError> {
+        Ok(ChannelInterfaceMediaSignallingNewSessionHandler {
+            session_handler: i.read()?,
+            session_type: i.read()?,
+        })
+    }
+}
+
+impl dbus::message::SignalArgs for ChannelInterfaceMediaSignallingNewSessionHandler {
+    const NAME: &'static str = "NewSessionHandler";
+    const INTERFACE: &'static str = "org.freedesktop.Telepathy.Channel.Interface.MediaSignalling";
+}
--- a/src/telepathy/channel_interface_mergeable_conference.rs
+++ b/src/telepathy/channel_interface_mergeable_conference.rs
@@ -0,0 +1,40 @@
+// This code was autogenerated with `dbus-codegen-rust --file telepathy-spec/spec/Channel_Interface_Mergeable_Conference.xml -i org.freedesktop.Telepathy -a AsRefClosure -o src/telepathy/channel_interface_mergeable_conference.rs`, see https://github.com/diwic/dbus-rs
+use dbus;
+use dbus::arg;
+use dbus::tree;
+
+pub trait ChannelInterfaceMergeableConferenceDRAFT {
+    fn merge(&self, channel: dbus::Path) -> Result<(), tree::MethodErr>;
+}
+
+pub fn channel_interface_mergeable_conference_draft_server<F, T, D>(
+    factory: &tree::Factory<tree::MTFn<D>, D>,
+    data: D::Interface,
+    f: F,
+) -> tree::Interface<tree::MTFn<D>, D>
+where
+    D: tree::DataType,
+    D::Method: Default,
+    T: AsRef<dyn ChannelInterfaceMergeableConferenceDRAFT>,
+    F: 'static + Fn(&tree::MethodInfo<tree::MTFn<D>, D>) -> T,
+{
+    let i = factory.interface(
+        "org.freedesktop.Telepathy.Channel.Interface.MergeableConference.DRAFT",
+        data,
+    );
+    let f = ::std::sync::Arc::new(f);
+    let fclone = f.clone();
+    let h = move |minfo: &tree::MethodInfo<tree::MTFn<D>, D>| {
+        let mut i = minfo.msg.iter_init();
+        let channel: dbus::Path = i.read()?;
+        let dd = fclone(minfo);
+        let d = dd.as_ref();
+        d.merge(channel)?;
+        let rm = minfo.msg.method_return();
+        Ok(vec![rm])
+    };
+    let m = factory.method("Merge", Default::default(), h);
+    let m = m.in_arg(("Channel", "o"));
+    let i = i.add_m(m);
+    i
+}
--- a/src/telepathy/channel_interface_messages.rs
+++ b/src/telepathy/channel_interface_messages.rs
@@ -0,0 +1,233 @@
+// This code was autogenerated with `dbus-codegen-rust --file telepathy-spec/spec/Channel_Interface_Messages.xml -i org.freedesktop.Telepathy -a AsRefClosure -o src/telepathy/channel_interface_messages.rs`, see https://github.com/diwic/dbus-rs
+use dbus;
+use dbus::arg;
+use dbus::tree;
+
+pub trait ChannelInterfaceMessages {
+    fn send_message(
+        &self,
+        message: Vec<::std::collections::HashMap<&str, arg::Variant<Box<dyn arg::RefArg>>>>,
+        flags: u32,
+    ) -> Result<String, tree::MethodErr>;
+    fn get_pending_message_content(
+        &self,
+        message_id: u32,
+        parts: Vec<u32>,
+    ) -> Result<
+        ::std::collections::HashMap<u32, arg::Variant<Box<dyn arg::RefArg + 'static>>>,
+        tree::MethodErr,
+    >;
+    fn supported_content_types(&self) -> Result<Vec<String>, tree::MethodErr>;
+    fn message_types(&self) -> Result<Vec<u32>, tree::MethodErr>;
+    fn message_part_support_flags(&self) -> Result<u32, tree::MethodErr>;
+    fn pending_messages(
+        &self,
+    ) -> Result<
+        Vec<Vec<::std::collections::HashMap<String, arg::Variant<Box<dyn arg::RefArg + 'static>>>>>,
+        tree::MethodErr,
+    >;
+    fn delivery_reporting_support(&self) -> Result<u32, tree::MethodErr>;
+}
+
+pub fn channel_interface_messages_server<F, T, D>(
+    factory: &tree::Factory<tree::MTFn<D>, D>,
+    data: D::Interface,
+    f: F,
+) -> tree::Interface<tree::MTFn<D>, D>
+where
+    D: tree::DataType,
+    D::Method: Default,
+    D::Property: Default,
+    D::Signal: Default,
+    T: AsRef<dyn ChannelInterfaceMessages>,
+    F: 'static + Fn(&tree::MethodInfo<tree::MTFn<D>, D>) -> T,
+{
+    let i = factory.interface("org.freedesktop.Telepathy.Channel.Interface.Messages", data);
+    let f = ::std::sync::Arc::new(f);
+    let fclone = f.clone();
+    let h = move |minfo: &tree::MethodInfo<tree::MTFn<D>, D>| {
+        let mut i = minfo.msg.iter_init();
+        let message: Vec<::std::collections::HashMap<&str, arg::Variant<Box<dyn arg::RefArg>>>> =
+            i.read()?;
+        let flags: u32 = i.read()?;
+        let dd = fclone(minfo);
+        let d = dd.as_ref();
+        let token = d.send_message(message, flags)?;
+        let rm = minfo.msg.method_return();
+        let rm = rm.append1(token);
+        Ok(vec![rm])
+    };
+    let m = factory.method("SendMessage", Default::default(), h);
+    let m = m.in_arg(("Message", "aa{sv}"));
+    let m = m.in_arg(("Flags", "u"));
+    let m = m.out_arg(("Token", "s"));
+    let i = i.add_m(m);
+
+    let fclone = f.clone();
+    let h = move |minfo: &tree::MethodInfo<tree::MTFn<D>, D>| {
+        let mut i = minfo.msg.iter_init();
+        let message_id: u32 = i.read()?;
+        let parts: Vec<u32> = i.read()?;
+        let dd = fclone(minfo);
+        let d = dd.as_ref();
+        let content = d.get_pending_message_content(message_id, parts)?;
+        let rm = minfo.msg.method_return();
+        let rm = rm.append1(content);
+        Ok(vec![rm])
+    };
+    let m = factory.method("GetPendingMessageContent", Default::default(), h);
+    let m = m.in_arg(("Message_ID", "u"));
+    let m = m.in_arg(("Parts", "au"));
+    let m = m.out_arg(("Content", "a{uv}"));
+    let i = i.add_m(m);
+
+    let p = factory.property::<Vec<&str>, _>("SupportedContentTypes", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let dd = fclone(&minfo);
+        let d = dd.as_ref();
+        a.append(d.supported_content_types()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+
+    let p = factory.property::<Vec<u32>, _>("MessageTypes", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let dd = fclone(&minfo);
+        let d = dd.as_ref();
+        a.append(d.message_types()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+
+    let p = factory.property::<u32, _>("MessagePartSupportFlags", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let dd = fclone(&minfo);
+        let d = dd.as_ref();
+        a.append(d.message_part_support_flags()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+
+    let p = factory.property::<Vec<Vec<::std::collections::HashMap<&str, arg::Variant<Box<dyn arg::RefArg>>>>>, _>("PendingMessages", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let dd = fclone(&minfo);
+        let d = dd.as_ref();
+        a.append(d.pending_messages()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+
+    let p = factory.property::<u32, _>("DeliveryReportingSupport", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let dd = fclone(&minfo);
+        let d = dd.as_ref();
+        a.append(d.delivery_reporting_support()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+    let s = factory.signal("MessageSent", Default::default());
+    let s = s.arg(("Content", "aa{sv}"));
+    let s = s.arg(("Flags", "u"));
+    let s = s.arg(("Message_Token", "s"));
+    let i = i.add_s(s);
+    let s = factory.signal("PendingMessagesRemoved", Default::default());
+    let s = s.arg(("Message_IDs", "au"));
+    let i = i.add_s(s);
+    let s = factory.signal("MessageReceived", Default::default());
+    let s = s.arg(("Message", "aa{sv}"));
+    let i = i.add_s(s);
+    i
+}
+
+#[derive(Debug)]
+pub struct ChannelInterfaceMessagesMessageSent {
+    pub content:
+        Vec<::std::collections::HashMap<String, arg::Variant<Box<dyn arg::RefArg + 'static>>>>,
+    pub flags: u32,
+    pub message_token: String,
+}
+
+impl arg::AppendAll for ChannelInterfaceMessagesMessageSent {
+    fn append(&self, i: &mut arg::IterAppend) {
+        arg::RefArg::append(&self.content, i);
+        arg::RefArg::append(&self.flags, i);
+        arg::RefArg::append(&self.message_token, i);
+    }
+}
+
+impl arg::ReadAll for ChannelInterfaceMessagesMessageSent {
+    fn read(i: &mut arg::Iter) -> Result<Self, arg::TypeMismatchError> {
+        Ok(ChannelInterfaceMessagesMessageSent {
+            content: i.read()?,
+            flags: i.read()?,
+            message_token: i.read()?,
+        })
+    }
+}
+
+impl dbus::message::SignalArgs for ChannelInterfaceMessagesMessageSent {
+    const NAME: &'static str = "MessageSent";
+    const INTERFACE: &'static str = "org.freedesktop.Telepathy.Channel.Interface.Messages";
+}
+
+#[derive(Debug)]
+pub struct ChannelInterfaceMessagesPendingMessagesRemoved {
+    pub message_ids: Vec<u32>,
+}
+
+impl arg::AppendAll for ChannelInterfaceMessagesPendingMessagesRemoved {
+    fn append(&self, i: &mut arg::IterAppend) {
+        arg::RefArg::append(&self.message_ids, i);
+    }
+}
+
+impl arg::ReadAll for ChannelInterfaceMessagesPendingMessagesRemoved {
+    fn read(i: &mut arg::Iter) -> Result<Self, arg::TypeMismatchError> {
+        Ok(ChannelInterfaceMessagesPendingMessagesRemoved {
+            message_ids: i.read()?,
+        })
+    }
+}
+
+impl dbus::message::SignalArgs for ChannelInterfaceMessagesPendingMessagesRemoved {
+    const NAME: &'static str = "PendingMessagesRemoved";
+    const INTERFACE: &'static str = "org.freedesktop.Telepathy.Channel.Interface.Messages";
+}
+
+#[derive(Debug)]
+pub struct ChannelInterfaceMessagesMessageReceived {
+    pub message:
+        Vec<::std::collections::HashMap<String, arg::Variant<Box<dyn arg::RefArg + 'static>>>>,
+}
+
+impl arg::AppendAll for ChannelInterfaceMessagesMessageReceived {
+    fn append(&self, i: &mut arg::IterAppend) {
+        arg::RefArg::append(&self.message, i);
+    }
+}
+
+impl arg::ReadAll for ChannelInterfaceMessagesMessageReceived {
+    fn read(i: &mut arg::Iter) -> Result<Self, arg::TypeMismatchError> {
+        Ok(ChannelInterfaceMessagesMessageReceived { message: i.read()? })
+    }
+}
+
+impl dbus::message::SignalArgs for ChannelInterfaceMessagesMessageReceived {
+    const NAME: &'static str = "MessageReceived";
+    const INTERFACE: &'static str = "org.freedesktop.Telepathy.Channel.Interface.Messages";
+}
--- a/src/telepathy/channel_interface_password.rs
+++ b/src/telepathy/channel_interface_password.rs
@@ -0,0 +1,85 @@
+// This code was autogenerated with `dbus-codegen-rust --file telepathy-spec/spec/Channel_Interface_Password.xml -i org.freedesktop.Telepathy -a AsRefClosure -o src/telepathy/channel_interface_password.rs`, see https://github.com/diwic/dbus-rs
+use dbus;
+use dbus::arg;
+use dbus::tree;
+
+pub trait ChannelInterfacePassword {
+    fn get_password_flags(&self) -> Result<u32, tree::MethodErr>;
+    fn provide_password(&self, password: &str) -> Result<bool, tree::MethodErr>;
+}
+
+pub fn channel_interface_password_server<F, T, D>(
+    factory: &tree::Factory<tree::MTFn<D>, D>,
+    data: D::Interface,
+    f: F,
+) -> tree::Interface<tree::MTFn<D>, D>
+where
+    D: tree::DataType,
+    D::Method: Default,
+    D::Signal: Default,
+    T: AsRef<dyn ChannelInterfacePassword>,
+    F: 'static + Fn(&tree::MethodInfo<tree::MTFn<D>, D>) -> T,
+{
+    let i = factory.interface("org.freedesktop.Telepathy.Channel.Interface.Password", data);
+    let f = ::std::sync::Arc::new(f);
+    let fclone = f.clone();
+    let h = move |minfo: &tree::MethodInfo<tree::MTFn<D>, D>| {
+        let dd = fclone(minfo);
+        let d = dd.as_ref();
+        let password_flags = d.get_password_flags()?;
+        let rm = minfo.msg.method_return();
+        let rm = rm.append1(password_flags);
+        Ok(vec![rm])
+    };
+    let m = factory.method("GetPasswordFlags", Default::default(), h);
+    let m = m.out_arg(("Password_Flags", "u"));
+    let i = i.add_m(m);
+
+    let fclone = f.clone();
+    let h = move |minfo: &tree::MethodInfo<tree::MTFn<D>, D>| {
+        let mut i = minfo.msg.iter_init();
+        let password: &str = i.read()?;
+        let dd = fclone(minfo);
+        let d = dd.as_ref();
+        let correct = d.provide_password(password)?;
+        let rm = minfo.msg.method_return();
+        let rm = rm.append1(correct);
+        Ok(vec![rm])
+    };
+    let m = factory.method("ProvidePassword", Default::default(), h);
+    let m = m.in_arg(("Password", "s"));
+    let m = m.out_arg(("Correct", "b"));
+    let i = i.add_m(m);
+    let s = factory.signal("PasswordFlagsChanged", Default::default());
+    let s = s.arg(("Added", "u"));
+    let s = s.arg(("Removed", "u"));
+    let i = i.add_s(s);
+    i
+}
+
+#[derive(Debug)]
+pub struct ChannelInterfacePasswordPasswordFlagsChanged {
+    pub added: u32,
+    pub removed: u32,
+}
+
+impl arg::AppendAll for ChannelInterfacePasswordPasswordFlagsChanged {
+    fn append(&self, i: &mut arg::IterAppend) {
+        arg::RefArg::append(&self.added, i);
+        arg::RefArg::append(&self.removed, i);
+    }
+}
+
+impl arg::ReadAll for ChannelInterfacePasswordPasswordFlagsChanged {
+    fn read(i: &mut arg::Iter) -> Result<Self, arg::TypeMismatchError> {
+        Ok(ChannelInterfacePasswordPasswordFlagsChanged {
+            added: i.read()?,
+            removed: i.read()?,
+        })
+    }
+}
+
+impl dbus::message::SignalArgs for ChannelInterfacePasswordPasswordFlagsChanged {
+    const NAME: &'static str = "PasswordFlagsChanged";
+    const INTERFACE: &'static str = "org.freedesktop.Telepathy.Channel.Interface.Password";
+}
--- a/src/telepathy/channel_interface_picture.rs
+++ b/src/telepathy/channel_interface_picture.rs
@@ -0,0 +1,209 @@
+// This code was autogenerated with `dbus-codegen-rust --file telepathy-spec/spec/Channel_Interface_Picture.xml -i org.freedesktop.Telepathy -a AsRefClosure -o src/telepathy/channel_interface_picture.rs`, see https://github.com/diwic/dbus-rs
+use dbus;
+use dbus::arg;
+use dbus::tree;
+
+pub trait ChannelInterfacePicture1 {
+    fn set_picture(&self, picture: Vec<u8>, mimetype: &str) -> Result<(), tree::MethodErr>;
+    fn picture(&self) -> Result<(Vec<u8>, String), tree::MethodErr>;
+    fn actor(&self) -> Result<String, tree::MethodErr>;
+    fn actor_handle(&self) -> Result<u32, tree::MethodErr>;
+    fn timestamp(&self) -> Result<i64, tree::MethodErr>;
+    fn can_set(&self) -> Result<bool, tree::MethodErr>;
+    fn supported_mimetypes(&self) -> Result<Vec<String>, tree::MethodErr>;
+    fn minimum_height(&self) -> Result<u32, tree::MethodErr>;
+    fn minimum_width(&self) -> Result<u32, tree::MethodErr>;
+    fn recommended_height(&self) -> Result<u32, tree::MethodErr>;
+    fn recommended_width(&self) -> Result<u32, tree::MethodErr>;
+    fn maximum_height(&self) -> Result<u32, tree::MethodErr>;
+    fn maximum_width(&self) -> Result<u32, tree::MethodErr>;
+    fn maximum_bytes(&self) -> Result<u32, tree::MethodErr>;
+}
+
+pub fn channel_interface_picture1_server<F, T, D>(
+    factory: &tree::Factory<tree::MTFn<D>, D>,
+    data: D::Interface,
+    f: F,
+) -> tree::Interface<tree::MTFn<D>, D>
+where
+    D: tree::DataType,
+    D::Method: Default,
+    D::Property: Default,
+    T: AsRef<dyn ChannelInterfacePicture1>,
+    F: 'static + Fn(&tree::MethodInfo<tree::MTFn<D>, D>) -> T,
+{
+    let i = factory.interface("org.freedesktop.Telepathy.Channel.Interface.Picture1", data);
+    let f = ::std::sync::Arc::new(f);
+    let fclone = f.clone();
+    let h = move |minfo: &tree::MethodInfo<tree::MTFn<D>, D>| {
+        let mut i = minfo.msg.iter_init();
+        let picture: Vec<u8> = i.read()?;
+        let mimetype: &str = i.read()?;
+        let dd = fclone(minfo);
+        let d = dd.as_ref();
+        d.set_picture(picture, mimetype)?;
+        let rm = minfo.msg.method_return();
+        Ok(vec![rm])
+    };
+    let m = factory.method("SetPicture", Default::default(), h);
+    let m = m.in_arg(("Picture", "ay"));
+    let m = m.in_arg(("MIME_Type", "s"));
+    let i = i.add_m(m);
+
+    let p = factory.property::<(Vec<u8>, &str), _>("Picture", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let dd = fclone(&minfo);
+        let d = dd.as_ref();
+        a.append(d.picture()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+
+    let p = factory.property::<&str, _>("Actor", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let dd = fclone(&minfo);
+        let d = dd.as_ref();
+        a.append(d.actor()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+
+    let p = factory.property::<u32, _>("ActorHandle", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let dd = fclone(&minfo);
+        let d = dd.as_ref();
+        a.append(d.actor_handle()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+
+    let p = factory.property::<i64, _>("Timestamp", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let dd = fclone(&minfo);
+        let d = dd.as_ref();
+        a.append(d.timestamp()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+
+    let p = factory.property::<bool, _>("CanSet", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let dd = fclone(&minfo);
+        let d = dd.as_ref();
+        a.append(d.can_set()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+
+    let p = factory.property::<Vec<&str>, _>("SupportedMIMETypes", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let dd = fclone(&minfo);
+        let d = dd.as_ref();
+        a.append(d.supported_mimetypes()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+
+    let p = factory.property::<u32, _>("MinimumHeight", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let dd = fclone(&minfo);
+        let d = dd.as_ref();
+        a.append(d.minimum_height()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+
+    let p = factory.property::<u32, _>("MinimumWidth", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let dd = fclone(&minfo);
+        let d = dd.as_ref();
+        a.append(d.minimum_width()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+
+    let p = factory.property::<u32, _>("RecommendedHeight", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let dd = fclone(&minfo);
+        let d = dd.as_ref();
+        a.append(d.recommended_height()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+
+    let p = factory.property::<u32, _>("RecommendedWidth", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let dd = fclone(&minfo);
+        let d = dd.as_ref();
+        a.append(d.recommended_width()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+
+    let p = factory.property::<u32, _>("MaximumHeight", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let dd = fclone(&minfo);
+        let d = dd.as_ref();
+        a.append(d.maximum_height()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+
+    let p = factory.property::<u32, _>("MaximumWidth", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let dd = fclone(&minfo);
+        let d = dd.as_ref();
+        a.append(d.maximum_width()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+
+    let p = factory.property::<u32, _>("MaximumBytes", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let dd = fclone(&minfo);
+        let d = dd.as_ref();
+        a.append(d.maximum_bytes()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+    i
+}
--- a/src/telepathy/channel_interface_room.rs
+++ b/src/telepathy/channel_interface_room.rs
@@ -0,0 +1,88 @@
+// This code was autogenerated with `dbus-codegen-rust --file telepathy-spec/spec/Channel_Interface_Room.xml -i org.freedesktop.Telepathy -a AsRefClosure -o src/telepathy/channel_interface_room.rs`, see https://github.com/diwic/dbus-rs
+use dbus;
+use dbus::arg;
+use dbus::tree;
+
+pub trait ChannelInterfaceRoom2 {
+    fn room_name(&self) -> Result<String, tree::MethodErr>;
+    fn server(&self) -> Result<String, tree::MethodErr>;
+    fn creator(&self) -> Result<String, tree::MethodErr>;
+    fn creator_handle(&self) -> Result<u32, tree::MethodErr>;
+    fn creation_timestamp(&self) -> Result<i64, tree::MethodErr>;
+}
+
+pub fn channel_interface_room2_server<F, T, D>(
+    factory: &tree::Factory<tree::MTFn<D>, D>,
+    data: D::Interface,
+    f: F,
+) -> tree::Interface<tree::MTFn<D>, D>
+where
+    D: tree::DataType,
+    D::Method: Default,
+    D::Property: Default,
+    T: AsRef<dyn ChannelInterfaceRoom2>,
+    F: 'static + Fn(&tree::MethodInfo<tree::MTFn<D>, D>) -> T,
+{
+    let i = factory.interface("org.freedesktop.Telepathy.Channel.Interface.Room2", data);
+    let f = ::std::sync::Arc::new(f);
+    let p = factory.property::<&str, _>("RoomName", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let dd = fclone(&minfo);
+        let d = dd.as_ref();
+        a.append(d.room_name()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+
+    let p = factory.property::<&str, _>("Server", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let dd = fclone(&minfo);
+        let d = dd.as_ref();
+        a.append(d.server()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+
+    let p = factory.property::<&str, _>("Creator", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let dd = fclone(&minfo);
+        let d = dd.as_ref();
+        a.append(d.creator()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+
+    let p = factory.property::<u32, _>("CreatorHandle", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let dd = fclone(&minfo);
+        let d = dd.as_ref();
+        a.append(d.creator_handle()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+
+    let p = factory.property::<i64, _>("CreationTimestamp", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let dd = fclone(&minfo);
+        let d = dd.as_ref();
+        a.append(d.creation_timestamp()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+    i
+}
--- a/src/telepathy/channel_interface_room_config.rs
+++ b/src/telepathy/channel_interface_room_config.rs
@@ -0,0 +1,227 @@
+// This code was autogenerated with `dbus-codegen-rust --file telepathy-spec/spec/Channel_Interface_Room_Config.xml -i org.freedesktop.Telepathy -a AsRefClosure -o src/telepathy/channel_interface_room_config.rs`, see https://github.com/diwic/dbus-rs
+use dbus;
+use dbus::arg;
+use dbus::tree;
+
+pub trait ChannelInterfaceRoomConfig1 {
+    fn update_configuration(
+        &self,
+        properties: ::std::collections::HashMap<&str, arg::Variant<Box<dyn arg::RefArg>>>,
+    ) -> Result<(), tree::MethodErr>;
+    fn anonymous(&self) -> Result<bool, tree::MethodErr>;
+    fn invite_only(&self) -> Result<bool, tree::MethodErr>;
+    fn limit(&self) -> Result<u32, tree::MethodErr>;
+    fn moderated(&self) -> Result<bool, tree::MethodErr>;
+    fn title(&self) -> Result<String, tree::MethodErr>;
+    fn description(&self) -> Result<String, tree::MethodErr>;
+    fn persistent(&self) -> Result<bool, tree::MethodErr>;
+    fn private(&self) -> Result<bool, tree::MethodErr>;
+    fn password_protected(&self) -> Result<bool, tree::MethodErr>;
+    fn password(&self) -> Result<String, tree::MethodErr>;
+    fn password_hint(&self) -> Result<String, tree::MethodErr>;
+    fn can_update_configuration(&self) -> Result<bool, tree::MethodErr>;
+    fn mutable_properties(&self) -> Result<Vec<String>, tree::MethodErr>;
+    fn configuration_retrieved(&self) -> Result<bool, tree::MethodErr>;
+}
+
+pub fn channel_interface_room_config1_server<F, T, D>(
+    factory: &tree::Factory<tree::MTFn<D>, D>,
+    data: D::Interface,
+    f: F,
+) -> tree::Interface<tree::MTFn<D>, D>
+where
+    D: tree::DataType,
+    D::Method: Default,
+    D::Property: Default,
+    T: AsRef<dyn ChannelInterfaceRoomConfig1>,
+    F: 'static + Fn(&tree::MethodInfo<tree::MTFn<D>, D>) -> T,
+{
+    let i = factory.interface(
+        "org.freedesktop.Telepathy.Channel.Interface.RoomConfig1",
+        data,
+    );
+    let f = ::std::sync::Arc::new(f);
+    let fclone = f.clone();
+    let h = move |minfo: &tree::MethodInfo<tree::MTFn<D>, D>| {
+        let mut i = minfo.msg.iter_init();
+        let properties: ::std::collections::HashMap<&str, arg::Variant<Box<dyn arg::RefArg>>> =
+            i.read()?;
+        let dd = fclone(minfo);
+        let d = dd.as_ref();
+        d.update_configuration(properties)?;
+        let rm = minfo.msg.method_return();
+        Ok(vec![rm])
+    };
+    let m = factory.method("UpdateConfiguration", Default::default(), h);
+    let m = m.in_arg(("Properties", "a{sv}"));
+    let i = i.add_m(m);
+
+    let p = factory.property::<bool, _>("Anonymous", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let dd = fclone(&minfo);
+        let d = dd.as_ref();
+        a.append(d.anonymous()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+
+    let p = factory.property::<bool, _>("InviteOnly", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let dd = fclone(&minfo);
+        let d = dd.as_ref();
+        a.append(d.invite_only()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+
+    let p = factory.property::<u32, _>("Limit", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let dd = fclone(&minfo);
+        let d = dd.as_ref();
+        a.append(d.limit()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+
+    let p = factory.property::<bool, _>("Moderated", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let dd = fclone(&minfo);
+        let d = dd.as_ref();
+        a.append(d.moderated()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+
+    let p = factory.property::<&str, _>("Title", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let dd = fclone(&minfo);
+        let d = dd.as_ref();
+        a.append(d.title()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+
+    let p = factory.property::<&str, _>("Description", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let dd = fclone(&minfo);
+        let d = dd.as_ref();
+        a.append(d.description()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+
+    let p = factory.property::<bool, _>("Persistent", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let dd = fclone(&minfo);
+        let d = dd.as_ref();
+        a.append(d.persistent()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+
+    let p = factory.property::<bool, _>("Private", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let dd = fclone(&minfo);
+        let d = dd.as_ref();
+        a.append(d.private()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+
+    let p = factory.property::<bool, _>("PasswordProtected", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let dd = fclone(&minfo);
+        let d = dd.as_ref();
+        a.append(d.password_protected()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+
+    let p = factory.property::<&str, _>("Password", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let dd = fclone(&minfo);
+        let d = dd.as_ref();
+        a.append(d.password()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+
+    let p = factory.property::<&str, _>("PasswordHint", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let dd = fclone(&minfo);
+        let d = dd.as_ref();
+        a.append(d.password_hint()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+
+    let p = factory.property::<bool, _>("CanUpdateConfiguration", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let dd = fclone(&minfo);
+        let d = dd.as_ref();
+        a.append(d.can_update_configuration()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+
+    let p = factory.property::<Vec<&str>, _>("MutableProperties", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let dd = fclone(&minfo);
+        let d = dd.as_ref();
+        a.append(d.mutable_properties()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+
+    let p = factory.property::<bool, _>("ConfigurationRetrieved", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let dd = fclone(&minfo);
+        let d = dd.as_ref();
+        a.append(d.configuration_retrieved()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+    i
+}
--- a/src/telepathy/channel_interface_sasl_authentication.rs
+++ b/src/telepathy/channel_interface_sasl_authentication.rs
@@ -0,0 +1,310 @@
+// This code was autogenerated with `dbus-codegen-rust --file telepathy-spec/spec/Channel_Interface_SASL_Authentication.xml -i org.freedesktop.Telepathy -a AsRefClosure -o src/telepathy/channel_interface_sasl_authentication.rs`, see https://github.com/diwic/dbus-rs
+use dbus;
+use dbus::arg;
+use dbus::tree;
+
+pub trait ChannelInterfaceSASLAuthentication {
+    fn start_mechanism(&self, mechanism: &str) -> Result<(), tree::MethodErr>;
+    fn start_mechanism_with_data(
+        &self,
+        mechanism: &str,
+        initial_data: Vec<u8>,
+    ) -> Result<(), tree::MethodErr>;
+    fn respond(&self, response_data: Vec<u8>) -> Result<(), tree::MethodErr>;
+    fn accept_sasl(&self) -> Result<(), tree::MethodErr>;
+    fn abort_sasl(&self, reason: u32, debug_message: &str) -> Result<(), tree::MethodErr>;
+    fn available_mechanisms(&self) -> Result<Vec<String>, tree::MethodErr>;
+    fn has_initial_data(&self) -> Result<bool, tree::MethodErr>;
+    fn can_try_again(&self) -> Result<bool, tree::MethodErr>;
+    fn saslstatus(&self) -> Result<u32, tree::MethodErr>;
+    fn saslerror(&self) -> Result<String, tree::MethodErr>;
+    fn saslerror_details(
+        &self,
+    ) -> Result<
+        ::std::collections::HashMap<String, arg::Variant<Box<dyn arg::RefArg + 'static>>>,
+        tree::MethodErr,
+    >;
+    fn authorization_identity(&self) -> Result<String, tree::MethodErr>;
+    fn default_username(&self) -> Result<String, tree::MethodErr>;
+    fn default_realm(&self) -> Result<String, tree::MethodErr>;
+    fn may_save_response(&self) -> Result<bool, tree::MethodErr>;
+}
+
+pub fn channel_interface_saslauthentication_server<F, T, D>(
+    factory: &tree::Factory<tree::MTFn<D>, D>,
+    data: D::Interface,
+    f: F,
+) -> tree::Interface<tree::MTFn<D>, D>
+where
+    D: tree::DataType,
+    D::Method: Default,
+    D::Property: Default,
+    D::Signal: Default,
+    T: AsRef<dyn ChannelInterfaceSASLAuthentication>,
+    F: 'static + Fn(&tree::MethodInfo<tree::MTFn<D>, D>) -> T,
+{
+    let i = factory.interface(
+        "org.freedesktop.Telepathy.Channel.Interface.SASLAuthentication",
+        data,
+    );
+    let f = ::std::sync::Arc::new(f);
+    let fclone = f.clone();
+    let h = move |minfo: &tree::MethodInfo<tree::MTFn<D>, D>| {
+        let mut i = minfo.msg.iter_init();
+        let mechanism: &str = i.read()?;
+        let dd = fclone(minfo);
+        let d = dd.as_ref();
+        d.start_mechanism(mechanism)?;
+        let rm = minfo.msg.method_return();
+        Ok(vec![rm])
+    };
+    let m = factory.method("StartMechanism", Default::default(), h);
+    let m = m.in_arg(("Mechanism", "s"));
+    let i = i.add_m(m);
+
+    let fclone = f.clone();
+    let h = move |minfo: &tree::MethodInfo<tree::MTFn<D>, D>| {
+        let mut i = minfo.msg.iter_init();
+        let mechanism: &str = i.read()?;
+        let initial_data: Vec<u8> = i.read()?;
+        let dd = fclone(minfo);
+        let d = dd.as_ref();
+        d.start_mechanism_with_data(mechanism, initial_data)?;
+        let rm = minfo.msg.method_return();
+        Ok(vec![rm])
+    };
+    let m = factory.method("StartMechanismWithData", Default::default(), h);
+    let m = m.in_arg(("Mechanism", "s"));
+    let m = m.in_arg(("Initial_Data", "ay"));
+    let i = i.add_m(m);
+
+    let fclone = f.clone();
+    let h = move |minfo: &tree::MethodInfo<tree::MTFn<D>, D>| {
+        let mut i = minfo.msg.iter_init();
+        let response_data: Vec<u8> = i.read()?;
+        let dd = fclone(minfo);
+        let d = dd.as_ref();
+        d.respond(response_data)?;
+        let rm = minfo.msg.method_return();
+        Ok(vec![rm])
+    };
+    let m = factory.method("Respond", Default::default(), h);
+    let m = m.in_arg(("Response_Data", "ay"));
+    let i = i.add_m(m);
+
+    let fclone = f.clone();
+    let h = move |minfo: &tree::MethodInfo<tree::MTFn<D>, D>| {
+        let dd = fclone(minfo);
+        let d = dd.as_ref();
+        d.accept_sasl()?;
+        let rm = minfo.msg.method_return();
+        Ok(vec![rm])
+    };
+    let m = factory.method("AcceptSASL", Default::default(), h);
+    let i = i.add_m(m);
+
+    let fclone = f.clone();
+    let h = move |minfo: &tree::MethodInfo<tree::MTFn<D>, D>| {
+        let mut i = minfo.msg.iter_init();
+        let reason: u32 = i.read()?;
+        let debug_message: &str = i.read()?;
+        let dd = fclone(minfo);
+        let d = dd.as_ref();
+        d.abort_sasl(reason, debug_message)?;
+        let rm = minfo.msg.method_return();
+        Ok(vec![rm])
+    };
+    let m = factory.method("AbortSASL", Default::default(), h);
+    let m = m.in_arg(("Reason", "u"));
+    let m = m.in_arg(("Debug_Message", "s"));
+    let i = i.add_m(m);
+
+    let p = factory.property::<Vec<&str>, _>("AvailableMechanisms", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let dd = fclone(&minfo);
+        let d = dd.as_ref();
+        a.append(d.available_mechanisms()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+
+    let p = factory.property::<bool, _>("HasInitialData", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let dd = fclone(&minfo);
+        let d = dd.as_ref();
+        a.append(d.has_initial_data()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+
+    let p = factory.property::<bool, _>("CanTryAgain", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let dd = fclone(&minfo);
+        let d = dd.as_ref();
+        a.append(d.can_try_again()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+
+    let p = factory.property::<u32, _>("SASLStatus", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let dd = fclone(&minfo);
+        let d = dd.as_ref();
+        a.append(d.saslstatus()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+
+    let p = factory.property::<&str, _>("SASLError", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let dd = fclone(&minfo);
+        let d = dd.as_ref();
+        a.append(d.saslerror()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+
+    let p = factory
+        .property::<::std::collections::HashMap<&str, arg::Variant<Box<dyn arg::RefArg>>>, _>(
+            "SASLErrorDetails",
+            Default::default(),
+        );
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let dd = fclone(&minfo);
+        let d = dd.as_ref();
+        a.append(d.saslerror_details()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+
+    let p = factory.property::<&str, _>("AuthorizationIdentity", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let dd = fclone(&minfo);
+        let d = dd.as_ref();
+        a.append(d.authorization_identity()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+
+    let p = factory.property::<&str, _>("DefaultUsername", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let dd = fclone(&minfo);
+        let d = dd.as_ref();
+        a.append(d.default_username()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+
+    let p = factory.property::<&str, _>("DefaultRealm", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let dd = fclone(&minfo);
+        let d = dd.as_ref();
+        a.append(d.default_realm()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+
+    let p = factory.property::<bool, _>("MaySaveResponse", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let dd = fclone(&minfo);
+        let d = dd.as_ref();
+        a.append(d.may_save_response()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+    let s = factory.signal("SASLStatusChanged", Default::default());
+    let s = s.arg(("Status", "u"));
+    let s = s.arg(("Reason", "s"));
+    let s = s.arg(("Details", "a{sv}"));
+    let i = i.add_s(s);
+    let s = factory.signal("NewChallenge", Default::default());
+    let s = s.arg(("Challenge_Data", "ay"));
+    let i = i.add_s(s);
+    i
+}
+
+#[derive(Debug)]
+pub struct ChannelInterfaceSASLAuthenticationSASLStatusChanged {
+    pub status: u32,
+    pub reason: String,
+    pub details: ::std::collections::HashMap<String, arg::Variant<Box<dyn arg::RefArg + 'static>>>,
+}
+
+impl arg::AppendAll for ChannelInterfaceSASLAuthenticationSASLStatusChanged {
+    fn append(&self, i: &mut arg::IterAppend) {
+        arg::RefArg::append(&self.status, i);
+        arg::RefArg::append(&self.reason, i);
+        arg::RefArg::append(&self.details, i);
+    }
+}
+
+impl arg::ReadAll for ChannelInterfaceSASLAuthenticationSASLStatusChanged {
+    fn read(i: &mut arg::Iter) -> Result<Self, arg::TypeMismatchError> {
+        Ok(ChannelInterfaceSASLAuthenticationSASLStatusChanged {
+            status: i.read()?,
+            reason: i.read()?,
+            details: i.read()?,
+        })
+    }
+}
+
+impl dbus::message::SignalArgs for ChannelInterfaceSASLAuthenticationSASLStatusChanged {
+    const NAME: &'static str = "SASLStatusChanged";
+    const INTERFACE: &'static str =
+        "org.freedesktop.Telepathy.Channel.Interface.SASLAuthentication";
+}
+
+#[derive(Debug)]
+pub struct ChannelInterfaceSASLAuthenticationNewChallenge {
+    pub challenge_data: Vec<u8>,
+}
+
+impl arg::AppendAll for ChannelInterfaceSASLAuthenticationNewChallenge {
+    fn append(&self, i: &mut arg::IterAppend) {
+        arg::RefArg::append(&self.challenge_data, i);
+    }
+}
+
+impl arg::ReadAll for ChannelInterfaceSASLAuthenticationNewChallenge {
+    fn read(i: &mut arg::Iter) -> Result<Self, arg::TypeMismatchError> {
+        Ok(ChannelInterfaceSASLAuthenticationNewChallenge {
+            challenge_data: i.read()?,
+        })
+    }
+}
+
+impl dbus::message::SignalArgs for ChannelInterfaceSASLAuthenticationNewChallenge {
+    const NAME: &'static str = "NewChallenge";
+    const INTERFACE: &'static str =
+        "org.freedesktop.Telepathy.Channel.Interface.SASLAuthentication";
+}
--- a/src/telepathy/channel_interface_securable.rs
+++ b/src/telepathy/channel_interface_securable.rs
@@ -0,0 +1,52 @@
+// This code was autogenerated with `dbus-codegen-rust --file telepathy-spec/spec/Channel_Interface_Securable.xml -i org.freedesktop.Telepathy -a AsRefClosure -o src/telepathy/channel_interface_securable.rs`, see https://github.com/diwic/dbus-rs
+use dbus;
+use dbus::arg;
+use dbus::tree;
+
+pub trait ChannelInterfaceSecurable {
+    fn encrypted(&self) -> Result<bool, tree::MethodErr>;
+    fn verified(&self) -> Result<bool, tree::MethodErr>;
+}
+
+pub fn channel_interface_securable_server<F, T, D>(
+    factory: &tree::Factory<tree::MTFn<D>, D>,
+    data: D::Interface,
+    f: F,
+) -> tree::Interface<tree::MTFn<D>, D>
+where
+    D: tree::DataType,
+    D::Method: Default,
+    D::Property: Default,
+    T: AsRef<dyn ChannelInterfaceSecurable>,
+    F: 'static + Fn(&tree::MethodInfo<tree::MTFn<D>, D>) -> T,
+{
+    let i = factory.interface(
+        "org.freedesktop.Telepathy.Channel.Interface.Securable",
+        data,
+    );
+    let f = ::std::sync::Arc::new(f);
+    let p = factory.property::<bool, _>("Encrypted", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let dd = fclone(&minfo);
+        let d = dd.as_ref();
+        a.append(d.encrypted()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+
+    let p = factory.property::<bool, _>("Verified", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let dd = fclone(&minfo);
+        let d = dd.as_ref();
+        a.append(d.verified()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+    i
+}
--- a/src/telepathy/channel_interface_service_point.rs
+++ b/src/telepathy/channel_interface_service_point.rs
@@ -0,0 +1,80 @@
+// This code was autogenerated with `dbus-codegen-rust --file telepathy-spec/spec/Channel_Interface_Service_Point.xml -i org.freedesktop.Telepathy -a AsRefClosure -o src/telepathy/channel_interface_service_point.rs`, see https://github.com/diwic/dbus-rs
+use dbus;
+use dbus::arg;
+use dbus::tree;
+
+pub trait ChannelInterfaceServicePoint {
+    fn initial_service_point(&self) -> Result<(u32, String), tree::MethodErr>;
+    fn current_service_point(&self) -> Result<(u32, String), tree::MethodErr>;
+}
+
+pub fn channel_interface_service_point_server<F, T, D>(
+    factory: &tree::Factory<tree::MTFn<D>, D>,
+    data: D::Interface,
+    f: F,
+) -> tree::Interface<tree::MTFn<D>, D>
+where
+    D: tree::DataType,
+    D::Method: Default,
+    D::Property: Default,
+    D::Signal: Default,
+    T: AsRef<dyn ChannelInterfaceServicePoint>,
+    F: 'static + Fn(&tree::MethodInfo<tree::MTFn<D>, D>) -> T,
+{
+    let i = factory.interface(
+        "org.freedesktop.Telepathy.Channel.Interface.ServicePoint",
+        data,
+    );
+    let f = ::std::sync::Arc::new(f);
+    let p = factory.property::<(u32, &str), _>("InitialServicePoint", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let dd = fclone(&minfo);
+        let d = dd.as_ref();
+        a.append(d.initial_service_point()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+
+    let p = factory.property::<(u32, &str), _>("CurrentServicePoint", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let dd = fclone(&minfo);
+        let d = dd.as_ref();
+        a.append(d.current_service_point()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+    let s = factory.signal("ServicePointChanged", Default::default());
+    let s = s.arg(("Service_Point", "(us)"));
+    let i = i.add_s(s);
+    i
+}
+
+#[derive(Debug)]
+pub struct ChannelInterfaceServicePointServicePointChanged {
+    pub service_point: (u32, String),
+}
+
+impl arg::AppendAll for ChannelInterfaceServicePointServicePointChanged {
+    fn append(&self, i: &mut arg::IterAppend) {
+        arg::RefArg::append(&self.service_point, i);
+    }
+}
+
+impl arg::ReadAll for ChannelInterfaceServicePointServicePointChanged {
+    fn read(i: &mut arg::Iter) -> Result<Self, arg::TypeMismatchError> {
+        Ok(ChannelInterfaceServicePointServicePointChanged {
+            service_point: i.read()?,
+        })
+    }
+}
+
+impl dbus::message::SignalArgs for ChannelInterfaceServicePointServicePointChanged {
+    const NAME: &'static str = "ServicePointChanged";
+    const INTERFACE: &'static str = "org.freedesktop.Telepathy.Channel.Interface.ServicePoint";
+}
--- a/src/telepathy/channel_interface_sms.rs
+++ b/src/telepathy/channel_interface_sms.rs
@@ -0,0 +1,102 @@
+// This code was autogenerated with `dbus-codegen-rust --file telepathy-spec/spec/Channel_Interface_SMS.xml -i org.freedesktop.Telepathy -a AsRefClosure -o src/telepathy/channel_interface_sms.rs`, see https://github.com/diwic/dbus-rs
+use dbus;
+use dbus::arg;
+use dbus::tree;
+
+pub trait ChannelInterfaceSMS {
+    fn get_smslength(
+        &self,
+        message: Vec<::std::collections::HashMap<&str, arg::Variant<Box<dyn arg::RefArg>>>>,
+    ) -> Result<(u32, i32, i32), tree::MethodErr>;
+    fn flash(&self) -> Result<bool, tree::MethodErr>;
+    fn smschannel(&self) -> Result<bool, tree::MethodErr>;
+}
+
+pub fn channel_interface_sms_server<F, T, D>(
+    factory: &tree::Factory<tree::MTFn<D>, D>,
+    data: D::Interface,
+    f: F,
+) -> tree::Interface<tree::MTFn<D>, D>
+where
+    D: tree::DataType,
+    D::Method: Default,
+    D::Property: Default,
+    D::Signal: Default,
+    T: AsRef<dyn ChannelInterfaceSMS>,
+    F: 'static + Fn(&tree::MethodInfo<tree::MTFn<D>, D>) -> T,
+{
+    let i = factory.interface("org.freedesktop.Telepathy.Channel.Interface.SMS", data);
+    let f = ::std::sync::Arc::new(f);
+    let fclone = f.clone();
+    let h = move |minfo: &tree::MethodInfo<tree::MTFn<D>, D>| {
+        let mut i = minfo.msg.iter_init();
+        let message: Vec<::std::collections::HashMap<&str, arg::Variant<Box<dyn arg::RefArg>>>> =
+            i.read()?;
+        let dd = fclone(minfo);
+        let d = dd.as_ref();
+        let (chunks_required, remaining_characters, estimated_cost) = d.get_smslength(message)?;
+        let rm = minfo.msg.method_return();
+        let rm = rm.append1(chunks_required);
+        let rm = rm.append1(remaining_characters);
+        let rm = rm.append1(estimated_cost);
+        Ok(vec![rm])
+    };
+    let m = factory.method("GetSMSLength", Default::default(), h);
+    let m = m.in_arg(("Message", "aa{sv}"));
+    let m = m.out_arg(("Chunks_Required", "u"));
+    let m = m.out_arg(("Remaining_Characters", "i"));
+    let m = m.out_arg(("Estimated_Cost", "i"));
+    let i = i.add_m(m);
+
+    let p = factory.property::<bool, _>("Flash", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let dd = fclone(&minfo);
+        let d = dd.as_ref();
+        a.append(d.flash()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+
+    let p = factory.property::<bool, _>("SMSChannel", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let dd = fclone(&minfo);
+        let d = dd.as_ref();
+        a.append(d.smschannel()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+    let s = factory.signal("SMSChannelChanged", Default::default());
+    let s = s.arg(("SMSChannel", "b"));
+    let i = i.add_s(s);
+    i
+}
+
+#[derive(Debug)]
+pub struct ChannelInterfaceSMSSMSChannelChanged {
+    pub smschannel: bool,
+}
+
+impl arg::AppendAll for ChannelInterfaceSMSSMSChannelChanged {
+    fn append(&self, i: &mut arg::IterAppend) {
+        arg::RefArg::append(&self.smschannel, i);
+    }
+}
+
+impl arg::ReadAll for ChannelInterfaceSMSSMSChannelChanged {
+    fn read(i: &mut arg::Iter) -> Result<Self, arg::TypeMismatchError> {
+        Ok(ChannelInterfaceSMSSMSChannelChanged {
+            smschannel: i.read()?,
+        })
+    }
+}
+
+impl dbus::message::SignalArgs for ChannelInterfaceSMSSMSChannelChanged {
+    const NAME: &'static str = "SMSChannelChanged";
+    const INTERFACE: &'static str = "org.freedesktop.Telepathy.Channel.Interface.SMS";
+}
--- a/src/telepathy/channel_interface_splittable.rs
+++ b/src/telepathy/channel_interface_splittable.rs
@@ -0,0 +1,37 @@
+// This code was autogenerated with `dbus-codegen-rust --file telepathy-spec/spec/Channel_Interface_Splittable.xml -i org.freedesktop.Telepathy -a AsRefClosure -o src/telepathy/channel_interface_splittable.rs`, see https://github.com/diwic/dbus-rs
+use dbus;
+use dbus::arg;
+use dbus::tree;
+
+pub trait ChannelInterfaceSplittableDRAFT {
+    fn split(&self) -> Result<(), tree::MethodErr>;
+}
+
+pub fn channel_interface_splittable_draft_server<F, T, D>(
+    factory: &tree::Factory<tree::MTFn<D>, D>,
+    data: D::Interface,
+    f: F,
+) -> tree::Interface<tree::MTFn<D>, D>
+where
+    D: tree::DataType,
+    D::Method: Default,
+    T: AsRef<dyn ChannelInterfaceSplittableDRAFT>,
+    F: 'static + Fn(&tree::MethodInfo<tree::MTFn<D>, D>) -> T,
+{
+    let i = factory.interface(
+        "org.freedesktop.Telepathy.Channel.Interface.Splittable.DRAFT",
+        data,
+    );
+    let f = ::std::sync::Arc::new(f);
+    let fclone = f.clone();
+    let h = move |minfo: &tree::MethodInfo<tree::MTFn<D>, D>| {
+        let dd = fclone(minfo);
+        let d = dd.as_ref();
+        d.split()?;
+        let rm = minfo.msg.method_return();
+        Ok(vec![rm])
+    };
+    let m = factory.method("Split", Default::default(), h);
+    let i = i.add_m(m);
+    i
+}
--- a/src/telepathy/channel_interface_subject.rs
+++ b/src/telepathy/channel_interface_subject.rs
@@ -0,0 +1,103 @@
+// This code was autogenerated with `dbus-codegen-rust --file telepathy-spec/spec/Channel_Interface_Subject.xml -i org.freedesktop.Telepathy -a AsRefClosure -o src/telepathy/channel_interface_subject.rs`, see https://github.com/diwic/dbus-rs
+use dbus;
+use dbus::arg;
+use dbus::tree;
+
+pub trait ChannelInterfaceSubject2 {
+    fn set_subject(&self, subject: &str) -> Result<(), tree::MethodErr>;
+    fn subject(&self) -> Result<String, tree::MethodErr>;
+    fn actor(&self) -> Result<String, tree::MethodErr>;
+    fn actor_handle(&self) -> Result<u32, tree::MethodErr>;
+    fn timestamp(&self) -> Result<i64, tree::MethodErr>;
+    fn can_set(&self) -> Result<bool, tree::MethodErr>;
+}
+
+pub fn channel_interface_subject2_server<F, T, D>(
+    factory: &tree::Factory<tree::MTFn<D>, D>,
+    data: D::Interface,
+    f: F,
+) -> tree::Interface<tree::MTFn<D>, D>
+where
+    D: tree::DataType,
+    D::Method: Default,
+    D::Property: Default,
+    T: AsRef<dyn ChannelInterfaceSubject2>,
+    F: 'static + Fn(&tree::MethodInfo<tree::MTFn<D>, D>) -> T,
+{
+    let i = factory.interface("org.freedesktop.Telepathy.Channel.Interface.Subject2", data);
+    let f = ::std::sync::Arc::new(f);
+    let fclone = f.clone();
+    let h = move |minfo: &tree::MethodInfo<tree::MTFn<D>, D>| {
+        let mut i = minfo.msg.iter_init();
+        let subject: &str = i.read()?;
+        let dd = fclone(minfo);
+        let d = dd.as_ref();
+        d.set_subject(subject)?;
+        let rm = minfo.msg.method_return();
+        Ok(vec![rm])
+    };
+    let m = factory.method("SetSubject", Default::default(), h);
+    let m = m.in_arg(("Subject", "s"));
+    let i = i.add_m(m);
+
+    let p = factory.property::<&str, _>("Subject", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let dd = fclone(&minfo);
+        let d = dd.as_ref();
+        a.append(d.subject()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+
+    let p = factory.property::<&str, _>("Actor", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let dd = fclone(&minfo);
+        let d = dd.as_ref();
+        a.append(d.actor()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+
+    let p = factory.property::<u32, _>("ActorHandle", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let dd = fclone(&minfo);
+        let d = dd.as_ref();
+        a.append(d.actor_handle()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+
+    let p = factory.property::<i64, _>("Timestamp", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let dd = fclone(&minfo);
+        let d = dd.as_ref();
+        a.append(d.timestamp()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+
+    let p = factory.property::<bool, _>("CanSet", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let dd = fclone(&minfo);
+        let d = dd.as_ref();
+        a.append(d.can_set()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+    i
+}
--- a/src/telepathy/channel_interface_transfer.rs
+++ b/src/telepathy/channel_interface_transfer.rs
@@ -0,0 +1,39 @@
+// This code was autogenerated with `dbus-codegen-rust --file telepathy-spec/spec/Channel_Interface_Transfer.xml -i org.freedesktop.Telepathy -a AsRefClosure -o src/telepathy/channel_interface_transfer.rs`, see https://github.com/diwic/dbus-rs
+use dbus;
+use dbus::arg;
+use dbus::tree;
+
+pub trait ChannelInterfaceTransfer {
+    fn transfer(&self, member: u32, destination: u32) -> Result<(), tree::MethodErr>;
+}
+
+pub fn channel_interface_transfer_server<F, T, D>(
+    factory: &tree::Factory<tree::MTFn<D>, D>,
+    data: D::Interface,
+    f: F,
+) -> tree::Interface<tree::MTFn<D>, D>
+where
+    D: tree::DataType,
+    D::Method: Default,
+    T: AsRef<dyn ChannelInterfaceTransfer>,
+    F: 'static + Fn(&tree::MethodInfo<tree::MTFn<D>, D>) -> T,
+{
+    let i = factory.interface("org.freedesktop.Telepathy.Channel.Interface.Transfer", data);
+    let f = ::std::sync::Arc::new(f);
+    let fclone = f.clone();
+    let h = move |minfo: &tree::MethodInfo<tree::MTFn<D>, D>| {
+        let mut i = minfo.msg.iter_init();
+        let member: u32 = i.read()?;
+        let destination: u32 = i.read()?;
+        let dd = fclone(minfo);
+        let d = dd.as_ref();
+        d.transfer(member, destination)?;
+        let rm = minfo.msg.method_return();
+        Ok(vec![rm])
+    };
+    let m = factory.method("Transfer", Default::default(), h);
+    let m = m.in_arg(("Member", "u"));
+    let m = m.in_arg(("Destination", "u"));
+    let i = i.add_m(m);
+    i
+}
--- a/src/telepathy/channel_interface_tube.rs
+++ b/src/telepathy/channel_interface_tube.rs
@@ -0,0 +1,84 @@
+// This code was autogenerated with `dbus-codegen-rust --file telepathy-spec/spec/Channel_Interface_Tube.xml -i org.freedesktop.Telepathy -a AsRefClosure -o src/telepathy/channel_interface_tube.rs`, see https://github.com/diwic/dbus-rs
+use dbus;
+use dbus::arg;
+use dbus::tree;
+
+pub trait ChannelInterfaceTube {
+    fn parameters(
+        &self,
+    ) -> Result<
+        ::std::collections::HashMap<String, arg::Variant<Box<dyn arg::RefArg + 'static>>>,
+        tree::MethodErr,
+    >;
+    fn state(&self) -> Result<u32, tree::MethodErr>;
+}
+
+pub fn channel_interface_tube_server<F, T, D>(
+    factory: &tree::Factory<tree::MTFn<D>, D>,
+    data: D::Interface,
+    f: F,
+) -> tree::Interface<tree::MTFn<D>, D>
+where
+    D: tree::DataType,
+    D::Method: Default,
+    D::Property: Default,
+    D::Signal: Default,
+    T: AsRef<dyn ChannelInterfaceTube>,
+    F: 'static + Fn(&tree::MethodInfo<tree::MTFn<D>, D>) -> T,
+{
+    let i = factory.interface("org.freedesktop.Telepathy.Channel.Interface.Tube", data);
+    let f = ::std::sync::Arc::new(f);
+    let p = factory
+        .property::<::std::collections::HashMap<&str, arg::Variant<Box<dyn arg::RefArg>>>, _>(
+            "Parameters",
+            Default::default(),
+        );
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let dd = fclone(&minfo);
+        let d = dd.as_ref();
+        a.append(d.parameters()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+
+    let p = factory.property::<u32, _>("State", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let dd = fclone(&minfo);
+        let d = dd.as_ref();
+        a.append(d.state()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+    let s = factory.signal("TubeChannelStateChanged", Default::default());
+    let s = s.arg(("State", "u"));
+    let i = i.add_s(s);
+    i
+}
+
+#[derive(Debug)]
+pub struct ChannelInterfaceTubeTubeChannelStateChanged {
+    pub state: u32,
+}
+
+impl arg::AppendAll for ChannelInterfaceTubeTubeChannelStateChanged {
+    fn append(&self, i: &mut arg::IterAppend) {
+        arg::RefArg::append(&self.state, i);
+    }
+}
+
+impl arg::ReadAll for ChannelInterfaceTubeTubeChannelStateChanged {
+    fn read(i: &mut arg::Iter) -> Result<Self, arg::TypeMismatchError> {
+        Ok(ChannelInterfaceTubeTubeChannelStateChanged { state: i.read()? })
+    }
+}
+
+impl dbus::message::SignalArgs for ChannelInterfaceTubeTubeChannelStateChanged {
+    const NAME: &'static str = "TubeChannelStateChanged";
+    const INTERFACE: &'static str = "org.freedesktop.Telepathy.Channel.Interface.Tube";
+}
--- a/src/telepathy/channel_request.rs
+++ b/src/telepathy/channel_request.rs
@@ -0,0 +1,236 @@
+// This code was autogenerated with `dbus-codegen-rust --file telepathy-spec/spec/Channel_Request.xml -i org.freedesktop.Telepathy -a AsRefClosure -o src/telepathy/channel_request.rs`, see https://github.com/diwic/dbus-rs
+use dbus;
+use dbus::arg;
+use dbus::tree;
+
+pub trait ChannelRequest {
+    fn proceed(&self) -> Result<(), tree::MethodErr>;
+    fn cancel(&self) -> Result<(), tree::MethodErr>;
+    fn account(&self) -> Result<dbus::Path<'static>, tree::MethodErr>;
+    fn user_action_time(&self) -> Result<i64, tree::MethodErr>;
+    fn preferred_handler(&self) -> Result<String, tree::MethodErr>;
+    fn requests(
+        &self,
+    ) -> Result<
+        Vec<::std::collections::HashMap<String, arg::Variant<Box<dyn arg::RefArg + 'static>>>>,
+        tree::MethodErr,
+    >;
+    fn interfaces(&self) -> Result<Vec<String>, tree::MethodErr>;
+    fn hints(
+        &self,
+    ) -> Result<
+        ::std::collections::HashMap<String, arg::Variant<Box<dyn arg::RefArg + 'static>>>,
+        tree::MethodErr,
+    >;
+}
+
+pub fn channel_request_server<F, T, D>(
+    factory: &tree::Factory<tree::MTFn<D>, D>,
+    data: D::Interface,
+    f: F,
+) -> tree::Interface<tree::MTFn<D>, D>
+where
+    D: tree::DataType,
+    D::Method: Default,
+    D::Property: Default,
+    D::Signal: Default,
+    T: AsRef<dyn ChannelRequest>,
+    F: 'static + Fn(&tree::MethodInfo<tree::MTFn<D>, D>) -> T,
+{
+    let i = factory.interface("org.freedesktop.Telepathy.ChannelRequest", data);
+    let f = ::std::sync::Arc::new(f);
+    let fclone = f.clone();
+    let h = move |minfo: &tree::MethodInfo<tree::MTFn<D>, D>| {
+        let dd = fclone(minfo);
+        let d = dd.as_ref();
+        d.proceed()?;
+        let rm = minfo.msg.method_return();
+        Ok(vec![rm])
+    };
+    let m = factory.method("Proceed", Default::default(), h);
+    let i = i.add_m(m);
+
+    let fclone = f.clone();
+    let h = move |minfo: &tree::MethodInfo<tree::MTFn<D>, D>| {
+        let dd = fclone(minfo);
+        let d = dd.as_ref();
+        d.cancel()?;
+        let rm = minfo.msg.method_return();
+        Ok(vec![rm])
+    };
+    let m = factory.method("Cancel", Default::default(), h);
+    let i = i.add_m(m);
+
+    let p = factory.property::<dbus::Path, _>("Account", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let dd = fclone(&minfo);
+        let d = dd.as_ref();
+        a.append(d.account()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+
+    let p = factory.property::<i64, _>("UserActionTime", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let dd = fclone(&minfo);
+        let d = dd.as_ref();
+        a.append(d.user_action_time()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+
+    let p = factory.property::<&str, _>("PreferredHandler", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let dd = fclone(&minfo);
+        let d = dd.as_ref();
+        a.append(d.preferred_handler()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+
+    let p = factory
+        .property::<Vec<::std::collections::HashMap<&str, arg::Variant<Box<dyn arg::RefArg>>>>, _>(
+            "Requests",
+            Default::default(),
+        );
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let dd = fclone(&minfo);
+        let d = dd.as_ref();
+        a.append(d.requests()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+
+    let p = factory.property::<Vec<&str>, _>("Interfaces", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let dd = fclone(&minfo);
+        let d = dd.as_ref();
+        a.append(d.interfaces()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+
+    let p = factory
+        .property::<::std::collections::HashMap<&str, arg::Variant<Box<dyn arg::RefArg>>>, _>(
+            "Hints",
+            Default::default(),
+        );
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let dd = fclone(&minfo);
+        let d = dd.as_ref();
+        a.append(d.hints()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+    let s = factory.signal("Failed", Default::default());
+    let s = s.arg(("Error", "s"));
+    let s = s.arg(("Message", "s"));
+    let i = i.add_s(s);
+    let s = factory.signal("Succeeded", Default::default());
+    let i = i.add_s(s);
+    let s = factory.signal("SucceededWithChannel", Default::default());
+    let s = s.arg(("Connection", "o"));
+    let s = s.arg(("Connection_Properties", "a{sv}"));
+    let s = s.arg(("Channel", "o"));
+    let s = s.arg(("Channel_Properties", "a{sv}"));
+    let i = i.add_s(s);
+    i
+}
+
+#[derive(Debug)]
+pub struct ChannelRequestFailed {
+    pub error: String,
+    pub message: String,
+}
+
+impl arg::AppendAll for ChannelRequestFailed {
+    fn append(&self, i: &mut arg::IterAppend) {
+        arg::RefArg::append(&self.error, i);
+        arg::RefArg::append(&self.message, i);
+    }
+}
+
+impl arg::ReadAll for ChannelRequestFailed {
+    fn read(i: &mut arg::Iter) -> Result<Self, arg::TypeMismatchError> {
+        Ok(ChannelRequestFailed {
+            error: i.read()?,
+            message: i.read()?,
+        })
+    }
+}
+
+impl dbus::message::SignalArgs for ChannelRequestFailed {
+    const NAME: &'static str = "Failed";
+    const INTERFACE: &'static str = "org.freedesktop.Telepathy.ChannelRequest";
+}
+
+#[derive(Debug)]
+pub struct ChannelRequestSucceeded {}
+
+impl arg::AppendAll for ChannelRequestSucceeded {
+    fn append(&self, _: &mut arg::IterAppend) {}
+}
+
+impl arg::ReadAll for ChannelRequestSucceeded {
+    fn read(_: &mut arg::Iter) -> Result<Self, arg::TypeMismatchError> {
+        Ok(ChannelRequestSucceeded {})
+    }
+}
+
+impl dbus::message::SignalArgs for ChannelRequestSucceeded {
+    const NAME: &'static str = "Succeeded";
+    const INTERFACE: &'static str = "org.freedesktop.Telepathy.ChannelRequest";
+}
+
+#[derive(Debug)]
+pub struct ChannelRequestSucceededWithChannel {
+    pub connection: dbus::Path<'static>,
+    pub connection_properties:
+        ::std::collections::HashMap<String, arg::Variant<Box<dyn arg::RefArg + 'static>>>,
+    pub channel: dbus::Path<'static>,
+    pub channel_properties:
+        ::std::collections::HashMap<String, arg::Variant<Box<dyn arg::RefArg + 'static>>>,
+}
+
+impl arg::AppendAll for ChannelRequestSucceededWithChannel {
+    fn append(&self, i: &mut arg::IterAppend) {
+        arg::RefArg::append(&self.connection, i);
+        arg::RefArg::append(&self.connection_properties, i);
+        arg::RefArg::append(&self.channel, i);
+        arg::RefArg::append(&self.channel_properties, i);
+    }
+}
+
+impl arg::ReadAll for ChannelRequestSucceededWithChannel {
+    fn read(i: &mut arg::Iter) -> Result<Self, arg::TypeMismatchError> {
+        Ok(ChannelRequestSucceededWithChannel {
+            connection: i.read()?,
+            connection_properties: i.read()?,
+            channel: i.read()?,
+            channel_properties: i.read()?,
+        })
+    }
+}
+
+impl dbus::message::SignalArgs for ChannelRequestSucceededWithChannel {
+    const NAME: &'static str = "SucceededWithChannel";
+    const INTERFACE: &'static str = "org.freedesktop.Telepathy.ChannelRequest";
+}
--- a/src/telepathy/channel_type_call.rs
+++ b/src/telepathy/channel_type_call.rs
@@ -0,0 +1,442 @@
+// This code was autogenerated with `dbus-codegen-rust --file telepathy-spec/spec/Channel_Type_Call.xml -i org.freedesktop.Telepathy -a AsRefClosure -o src/telepathy/channel_type_call.rs`, see https://github.com/diwic/dbus-rs
+use dbus;
+use dbus::arg;
+use dbus::tree;
+
+pub trait ChannelTypeCall1 {
+    fn set_ringing(&self) -> Result<(), tree::MethodErr>;
+    fn set_queued(&self) -> Result<(), tree::MethodErr>;
+    fn accept(&self) -> Result<(), tree::MethodErr>;
+    fn hangup(
+        &self,
+        reason: u32,
+        detailed_hangup_reason: &str,
+        message: &str,
+    ) -> Result<(), tree::MethodErr>;
+    fn add_content(
+        &self,
+        content_name: &str,
+        content_type: u32,
+        initial_direction: u32,
+    ) -> Result<dbus::Path<'static>, tree::MethodErr>;
+    fn contents(&self) -> Result<Vec<dbus::Path<'static>>, tree::MethodErr>;
+    fn call_state_details(
+        &self,
+    ) -> Result<
+        ::std::collections::HashMap<String, arg::Variant<Box<dyn arg::RefArg + 'static>>>,
+        tree::MethodErr,
+    >;
+    fn call_state(&self) -> Result<u32, tree::MethodErr>;
+    fn call_flags(&self) -> Result<u32, tree::MethodErr>;
+    fn call_state_reason(&self) -> Result<(u32, u32, String, String), tree::MethodErr>;
+    fn hardware_streaming(&self) -> Result<bool, tree::MethodErr>;
+    fn call_members(&self) -> Result<::std::collections::HashMap<u32, u32>, tree::MethodErr>;
+    fn member_identifiers(
+        &self,
+    ) -> Result<::std::collections::HashMap<u32, String>, tree::MethodErr>;
+    fn initial_transport(&self) -> Result<u32, tree::MethodErr>;
+    fn initial_audio(&self) -> Result<bool, tree::MethodErr>;
+    fn initial_video(&self) -> Result<bool, tree::MethodErr>;
+    fn initial_audio_name(&self) -> Result<String, tree::MethodErr>;
+    fn initial_video_name(&self) -> Result<String, tree::MethodErr>;
+    fn mutable_contents(&self) -> Result<bool, tree::MethodErr>;
+}
+
+pub fn channel_type_call1_server<F, T, D>(
+    factory: &tree::Factory<tree::MTFn<D>, D>,
+    data: D::Interface,
+    f: F,
+) -> tree::Interface<tree::MTFn<D>, D>
+where
+    D: tree::DataType,
+    D::Method: Default,
+    D::Property: Default,
+    D::Signal: Default,
+    T: AsRef<dyn ChannelTypeCall1>,
+    F: 'static + Fn(&tree::MethodInfo<tree::MTFn<D>, D>) -> T,
+{
+    let i = factory.interface("org.freedesktop.Telepathy.Channel.Type.Call1", data);
+    let f = ::std::sync::Arc::new(f);
+    let fclone = f.clone();
+    let h = move |minfo: &tree::MethodInfo<tree::MTFn<D>, D>| {
+        let dd = fclone(minfo);
+        let d = dd.as_ref();
+        d.set_ringing()?;
+        let rm = minfo.msg.method_return();
+        Ok(vec![rm])
+    };
+    let m = factory.method("SetRinging", Default::default(), h);
+    let i = i.add_m(m);
+
+    let fclone = f.clone();
+    let h = move |minfo: &tree::MethodInfo<tree::MTFn<D>, D>| {
+        let dd = fclone(minfo);
+        let d = dd.as_ref();
+        d.set_queued()?;
+        let rm = minfo.msg.method_return();
+        Ok(vec![rm])
+    };
+    let m = factory.method("SetQueued", Default::default(), h);
+    let i = i.add_m(m);
+
+    let fclone = f.clone();
+    let h = move |minfo: &tree::MethodInfo<tree::MTFn<D>, D>| {
+        let dd = fclone(minfo);
+        let d = dd.as_ref();
+        d.accept()?;
+        let rm = minfo.msg.method_return();
+        Ok(vec![rm])
+    };
+    let m = factory.method("Accept", Default::default(), h);
+    let i = i.add_m(m);
+
+    let fclone = f.clone();
+    let h = move |minfo: &tree::MethodInfo<tree::MTFn<D>, D>| {
+        let mut i = minfo.msg.iter_init();
+        let reason: u32 = i.read()?;
+        let detailed_hangup_reason: &str = i.read()?;
+        let message: &str = i.read()?;
+        let dd = fclone(minfo);
+        let d = dd.as_ref();
+        d.hangup(reason, detailed_hangup_reason, message)?;
+        let rm = minfo.msg.method_return();
+        Ok(vec![rm])
+    };
+    let m = factory.method("Hangup", Default::default(), h);
+    let m = m.in_arg(("Reason", "u"));
+    let m = m.in_arg(("Detailed_Hangup_Reason", "s"));
+    let m = m.in_arg(("Message", "s"));
+    let i = i.add_m(m);
+
+    let fclone = f.clone();
+    let h = move |minfo: &tree::MethodInfo<tree::MTFn<D>, D>| {
+        let mut i = minfo.msg.iter_init();
+        let content_name: &str = i.read()?;
+        let content_type: u32 = i.read()?;
+        let initial_direction: u32 = i.read()?;
+        let dd = fclone(minfo);
+        let d = dd.as_ref();
+        let content = d.add_content(content_name, content_type, initial_direction)?;
+        let rm = minfo.msg.method_return();
+        let rm = rm.append1(content);
+        Ok(vec![rm])
+    };
+    let m = factory.method("AddContent", Default::default(), h);
+    let m = m.in_arg(("Content_Name", "s"));
+    let m = m.in_arg(("Content_Type", "u"));
+    let m = m.in_arg(("InitialDirection", "u"));
+    let m = m.out_arg(("Content", "o"));
+    let i = i.add_m(m);
+
+    let p = factory.property::<Vec<dbus::Path>, _>("Contents", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let dd = fclone(&minfo);
+        let d = dd.as_ref();
+        a.append(d.contents()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+
+    let p = factory
+        .property::<::std::collections::HashMap<&str, arg::Variant<Box<dyn arg::RefArg>>>, _>(
+            "CallStateDetails",
+            Default::default(),
+        );
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let dd = fclone(&minfo);
+        let d = dd.as_ref();
+        a.append(d.call_state_details()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+
+    let p = factory.property::<u32, _>("CallState", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let dd = fclone(&minfo);
+        let d = dd.as_ref();
+        a.append(d.call_state()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+
+    let p = factory.property::<u32, _>("CallFlags", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let dd = fclone(&minfo);
+        let d = dd.as_ref();
+        a.append(d.call_flags()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+
+    let p = factory.property::<(u32, u32, &str, &str), _>("CallStateReason", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let dd = fclone(&minfo);
+        let d = dd.as_ref();
+        a.append(d.call_state_reason()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+
+    let p = factory.property::<bool, _>("HardwareStreaming", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let dd = fclone(&minfo);
+        let d = dd.as_ref();
+        a.append(d.hardware_streaming()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+
+    let p = factory
+        .property::<::std::collections::HashMap<u32, u32>, _>("CallMembers", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let dd = fclone(&minfo);
+        let d = dd.as_ref();
+        a.append(d.call_members()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+
+    let p = factory.property::<::std::collections::HashMap<u32, &str>, _>(
+        "MemberIdentifiers",
+        Default::default(),
+    );
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let dd = fclone(&minfo);
+        let d = dd.as_ref();
+        a.append(d.member_identifiers()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+
+    let p = factory.property::<u32, _>("InitialTransport", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let dd = fclone(&minfo);
+        let d = dd.as_ref();
+        a.append(d.initial_transport()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+
+    let p = factory.property::<bool, _>("InitialAudio", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let dd = fclone(&minfo);
+        let d = dd.as_ref();
+        a.append(d.initial_audio()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+
+    let p = factory.property::<bool, _>("InitialVideo", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let dd = fclone(&minfo);
+        let d = dd.as_ref();
+        a.append(d.initial_video()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+
+    let p = factory.property::<&str, _>("InitialAudioName", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let dd = fclone(&minfo);
+        let d = dd.as_ref();
+        a.append(d.initial_audio_name()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+
+    let p = factory.property::<&str, _>("InitialVideoName", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let dd = fclone(&minfo);
+        let d = dd.as_ref();
+        a.append(d.initial_video_name()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+
+    let p = factory.property::<bool, _>("MutableContents", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let dd = fclone(&minfo);
+        let d = dd.as_ref();
+        a.append(d.mutable_contents()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+    let s = factory.signal("ContentAdded", Default::default());
+    let s = s.arg(("Content", "o"));
+    let i = i.add_s(s);
+    let s = factory.signal("ContentRemoved", Default::default());
+    let s = s.arg(("Content", "o"));
+    let s = s.arg(("Reason", "(uuss)"));
+    let i = i.add_s(s);
+    let s = factory.signal("CallStateChanged", Default::default());
+    let s = s.arg(("Call_State", "u"));
+    let s = s.arg(("Call_Flags", "u"));
+    let s = s.arg(("Call_State_Reason", "(uuss)"));
+    let s = s.arg(("Call_State_Details", "a{sv}"));
+    let i = i.add_s(s);
+    let s = factory.signal("CallMembersChanged", Default::default());
+    let s = s.arg(("Flags_Changed", "a{uu}"));
+    let s = s.arg(("Identifiers", "a{us}"));
+    let s = s.arg(("Removed", "au"));
+    let s = s.arg(("Reason", "(uuss)"));
+    let i = i.add_s(s);
+    i
+}
+
+#[derive(Debug)]
+pub struct ChannelTypeCall1ContentAdded {
+    pub content: dbus::Path<'static>,
+}
+
+impl arg::AppendAll for ChannelTypeCall1ContentAdded {
+    fn append(&self, i: &mut arg::IterAppend) {
+        arg::RefArg::append(&self.content, i);
+    }
+}
+
+impl arg::ReadAll for ChannelTypeCall1ContentAdded {
+    fn read(i: &mut arg::Iter) -> Result<Self, arg::TypeMismatchError> {
+        Ok(ChannelTypeCall1ContentAdded { content: i.read()? })
+    }
+}
+
+impl dbus::message::SignalArgs for ChannelTypeCall1ContentAdded {
+    const NAME: &'static str = "ContentAdded";
+    const INTERFACE: &'static str = "org.freedesktop.Telepathy.Channel.Type.Call1";
+}
+
+#[derive(Debug)]
+pub struct ChannelTypeCall1ContentRemoved {
+    pub content: dbus::Path<'static>,
+    pub reason: (u32, u32, String, String),
+}
+
+impl arg::AppendAll for ChannelTypeCall1ContentRemoved {
+    fn append(&self, i: &mut arg::IterAppend) {
+        arg::RefArg::append(&self.content, i);
+        arg::RefArg::append(&self.reason, i);
+    }
+}
+
+impl arg::ReadAll for ChannelTypeCall1ContentRemoved {
+    fn read(i: &mut arg::Iter) -> Result<Self, arg::TypeMismatchError> {
+        Ok(ChannelTypeCall1ContentRemoved {
+            content: i.read()?,
+            reason: i.read()?,
+        })
+    }
+}
+
+impl dbus::message::SignalArgs for ChannelTypeCall1ContentRemoved {
+    const NAME: &'static str = "ContentRemoved";
+    const INTERFACE: &'static str = "org.freedesktop.Telepathy.Channel.Type.Call1";
+}
+
+#[derive(Debug)]
+pub struct ChannelTypeCall1CallStateChanged {
+    pub call_state: u32,
+    pub call_flags: u32,
+    pub call_state_reason: (u32, u32, String, String),
+    pub call_state_details:
+        ::std::collections::HashMap<String, arg::Variant<Box<dyn arg::RefArg + 'static>>>,
+}
+
+impl arg::AppendAll for ChannelTypeCall1CallStateChanged {
+    fn append(&self, i: &mut arg::IterAppend) {
+        arg::RefArg::append(&self.call_state, i);
+        arg::RefArg::append(&self.call_flags, i);
+        arg::RefArg::append(&self.call_state_reason, i);
+        arg::RefArg::append(&self.call_state_details, i);
+    }
+}
+
+impl arg::ReadAll for ChannelTypeCall1CallStateChanged {
+    fn read(i: &mut arg::Iter) -> Result<Self, arg::TypeMismatchError> {
+        Ok(ChannelTypeCall1CallStateChanged {
+            call_state: i.read()?,
+            call_flags: i.read()?,
+            call_state_reason: i.read()?,
+            call_state_details: i.read()?,
+        })
+    }
+}
+
+impl dbus::message::SignalArgs for ChannelTypeCall1CallStateChanged {
+    const NAME: &'static str = "CallStateChanged";
+    const INTERFACE: &'static str = "org.freedesktop.Telepathy.Channel.Type.Call1";
+}
+
+#[derive(Debug)]
+pub struct ChannelTypeCall1CallMembersChanged {
+    pub flags_changed: ::std::collections::HashMap<u32, u32>,
+    pub identifiers: ::std::collections::HashMap<u32, String>,
+    pub removed: Vec<u32>,
+    pub reason: (u32, u32, String, String),
+}
+
+impl arg::AppendAll for ChannelTypeCall1CallMembersChanged {
+    fn append(&self, i: &mut arg::IterAppend) {
+        arg::RefArg::append(&self.flags_changed, i);
+        arg::RefArg::append(&self.identifiers, i);
+        arg::RefArg::append(&self.removed, i);
+        arg::RefArg::append(&self.reason, i);
+    }
+}
+
+impl arg::ReadAll for ChannelTypeCall1CallMembersChanged {
+    fn read(i: &mut arg::Iter) -> Result<Self, arg::TypeMismatchError> {
+        Ok(ChannelTypeCall1CallMembersChanged {
+            flags_changed: i.read()?,
+            identifiers: i.read()?,
+            removed: i.read()?,
+            reason: i.read()?,
+        })
+    }
+}
+
+impl dbus::message::SignalArgs for ChannelTypeCall1CallMembersChanged {
+    const NAME: &'static str = "CallMembersChanged";
+    const INTERFACE: &'static str = "org.freedesktop.Telepathy.Channel.Type.Call1";
+}
--- a/src/telepathy/channel_type_contact_list.rs
+++ b/src/telepathy/channel_type_contact_list.rs
@@ -0,0 +1,22 @@
+// This code was autogenerated with `dbus-codegen-rust --file telepathy-spec/spec/Channel_Type_Contact_List.xml -i org.freedesktop.Telepathy -a AsRefClosure -o src/telepathy/channel_type_contact_list.rs`, see https://github.com/diwic/dbus-rs
+use dbus;
+use dbus::arg;
+use dbus::tree;
+
+pub trait ChannelTypeContactList {}
+
+pub fn channel_type_contact_list_server<F, T, D>(
+    factory: &tree::Factory<tree::MTFn<D>, D>,
+    data: D::Interface,
+    f: F,
+) -> tree::Interface<tree::MTFn<D>, D>
+where
+    D: tree::DataType,
+    D::Method: Default,
+    T: AsRef<dyn ChannelTypeContactList>,
+    F: 'static + Fn(&tree::MethodInfo<tree::MTFn<D>, D>) -> T,
+{
+    let i = factory.interface("org.freedesktop.Telepathy.Channel.Type.ContactList", data);
+    let f = ::std::sync::Arc::new(f);
+    i
+}
--- a/src/telepathy/channel_type_contact_search.rs
+++ b/src/telepathy/channel_type_contact_search.rs
@@ -0,0 +1,176 @@
+// This code was autogenerated with `dbus-codegen-rust --file telepathy-spec/spec/Channel_Type_Contact_Search.xml -i org.freedesktop.Telepathy -a AsRefClosure -o src/telepathy/channel_type_contact_search.rs`, see https://github.com/diwic/dbus-rs
+use dbus;
+use dbus::arg;
+use dbus::tree;
+
+pub trait ChannelTypeContactSearch {
+    fn search(&self, terms: ::std::collections::HashMap<&str, &str>)
+        -> Result<(), tree::MethodErr>;
+    fn more(&self) -> Result<(), tree::MethodErr>;
+    fn stop(&self) -> Result<(), tree::MethodErr>;
+    fn search_state(&self) -> Result<u32, tree::MethodErr>;
+    fn limit(&self) -> Result<u32, tree::MethodErr>;
+    fn available_search_keys(&self) -> Result<Vec<String>, tree::MethodErr>;
+    fn server(&self) -> Result<String, tree::MethodErr>;
+}
+
+pub fn channel_type_contact_search_server<F, T, D>(
+    factory: &tree::Factory<tree::MTFn<D>, D>,
+    data: D::Interface,
+    f: F,
+) -> tree::Interface<tree::MTFn<D>, D>
+where
+    D: tree::DataType,
+    D::Method: Default,
+    D::Property: Default,
+    D::Signal: Default,
+    T: AsRef<dyn ChannelTypeContactSearch>,
+    F: 'static + Fn(&tree::MethodInfo<tree::MTFn<D>, D>) -> T,
+{
+    let i = factory.interface("org.freedesktop.Telepathy.Channel.Type.ContactSearch", data);
+    let f = ::std::sync::Arc::new(f);
+    let fclone = f.clone();
+    let h = move |minfo: &tree::MethodInfo<tree::MTFn<D>, D>| {
+        let mut i = minfo.msg.iter_init();
+        let terms: ::std::collections::HashMap<&str, &str> = i.read()?;
+        let dd = fclone(minfo);
+        let d = dd.as_ref();
+        d.search(terms)?;
+        let rm = minfo.msg.method_return();
+        Ok(vec![rm])
+    };
+    let m = factory.method("Search", Default::default(), h);
+    let m = m.in_arg(("Terms", "a{ss}"));
+    let i = i.add_m(m);
+
+    let fclone = f.clone();
+    let h = move |minfo: &tree::MethodInfo<tree::MTFn<D>, D>| {
+        let dd = fclone(minfo);
+        let d = dd.as_ref();
+        d.more()?;
+        let rm = minfo.msg.method_return();
+        Ok(vec![rm])
+    };
+    let m = factory.method("More", Default::default(), h);
+    let i = i.add_m(m);
+
+    let fclone = f.clone();
+    let h = move |minfo: &tree::MethodInfo<tree::MTFn<D>, D>| {
+        let dd = fclone(minfo);
+        let d = dd.as_ref();
+        d.stop()?;
+        let rm = minfo.msg.method_return();
+        Ok(vec![rm])
+    };
+    let m = factory.method("Stop", Default::default(), h);
+    let i = i.add_m(m);
+
+    let p = factory.property::<u32, _>("SearchState", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let dd = fclone(&minfo);
+        let d = dd.as_ref();
+        a.append(d.search_state()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+
+    let p = factory.property::<u32, _>("Limit", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let dd = fclone(&minfo);
+        let d = dd.as_ref();
+        a.append(d.limit()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+
+    let p = factory.property::<Vec<&str>, _>("AvailableSearchKeys", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let dd = fclone(&minfo);
+        let d = dd.as_ref();
+        a.append(d.available_search_keys()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+
+    let p = factory.property::<&str, _>("Server", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let dd = fclone(&minfo);
+        let d = dd.as_ref();
+        a.append(d.server()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+    let s = factory.signal("SearchStateChanged", Default::default());
+    let s = s.arg(("State", "u"));
+    let s = s.arg(("Error", "s"));
+    let s = s.arg(("Details", "a{sv}"));
+    let i = i.add_s(s);
+    let s = factory.signal("SearchResultReceived", Default::default());
+    let s = s.arg(("Result", "a{sa(sasas)}"));
+    let i = i.add_s(s);
+    i
+}
+
+#[derive(Debug)]
+pub struct ChannelTypeContactSearchSearchStateChanged {
+    pub state: u32,
+    pub error: String,
+    pub details: ::std::collections::HashMap<String, arg::Variant<Box<dyn arg::RefArg + 'static>>>,
+}
+
+impl arg::AppendAll for ChannelTypeContactSearchSearchStateChanged {
+    fn append(&self, i: &mut arg::IterAppend) {
+        arg::RefArg::append(&self.state, i);
+        arg::RefArg::append(&self.error, i);
+        arg::RefArg::append(&self.details, i);
+    }
+}
+
+impl arg::ReadAll for ChannelTypeContactSearchSearchStateChanged {
+    fn read(i: &mut arg::Iter) -> Result<Self, arg::TypeMismatchError> {
+        Ok(ChannelTypeContactSearchSearchStateChanged {
+            state: i.read()?,
+            error: i.read()?,
+            details: i.read()?,
+        })
+    }
+}
+
+impl dbus::message::SignalArgs for ChannelTypeContactSearchSearchStateChanged {
+    const NAME: &'static str = "SearchStateChanged";
+    const INTERFACE: &'static str = "org.freedesktop.Telepathy.Channel.Type.ContactSearch";
+}
+
+#[derive(Debug)]
+pub struct ChannelTypeContactSearchSearchResultReceived {
+    pub result: ::std::collections::HashMap<String, Vec<(String, Vec<String>, Vec<String>)>>,
+}
+
+impl arg::AppendAll for ChannelTypeContactSearchSearchResultReceived {
+    fn append(&self, i: &mut arg::IterAppend) {
+        arg::RefArg::append(&self.result, i);
+    }
+}
+
+impl arg::ReadAll for ChannelTypeContactSearchSearchResultReceived {
+    fn read(i: &mut arg::Iter) -> Result<Self, arg::TypeMismatchError> {
+        Ok(ChannelTypeContactSearchSearchResultReceived { result: i.read()? })
+    }
+}
+
+impl dbus::message::SignalArgs for ChannelTypeContactSearchSearchResultReceived {
+    const NAME: &'static str = "SearchResultReceived";
+    const INTERFACE: &'static str = "org.freedesktop.Telepathy.Channel.Type.ContactSearch";
+}
--- a/src/telepathy/channel_type_dbus_tube.rs
+++ b/src/telepathy/channel_type_dbus_tube.rs
@@ -0,0 +1,136 @@
+// This code was autogenerated with `dbus-codegen-rust --file telepathy-spec/spec/Channel_Type_DBus_Tube.xml -i org.freedesktop.Telepathy -a AsRefClosure -o src/telepathy/channel_type_dbus_tube.rs`, see https://github.com/diwic/dbus-rs
+use dbus;
+use dbus::arg;
+use dbus::tree;
+
+pub trait ChannelTypeDBusTube {
+    fn offer(
+        &self,
+        parameters: ::std::collections::HashMap<&str, arg::Variant<Box<dyn arg::RefArg>>>,
+        access_control: u32,
+    ) -> Result<String, tree::MethodErr>;
+    fn accept(&self, access_control: u32) -> Result<String, tree::MethodErr>;
+    fn service_name(&self) -> Result<String, tree::MethodErr>;
+    fn dbus_names(&self) -> Result<::std::collections::HashMap<u32, String>, tree::MethodErr>;
+    fn supported_access_controls(&self) -> Result<Vec<u32>, tree::MethodErr>;
+}
+
+pub fn channel_type_dbus_tube_server<F, T, D>(
+    factory: &tree::Factory<tree::MTFn<D>, D>,
+    data: D::Interface,
+    f: F,
+) -> tree::Interface<tree::MTFn<D>, D>
+where
+    D: tree::DataType,
+    D::Method: Default,
+    D::Property: Default,
+    D::Signal: Default,
+    T: AsRef<dyn ChannelTypeDBusTube>,
+    F: 'static + Fn(&tree::MethodInfo<tree::MTFn<D>, D>) -> T,
+{
+    let i = factory.interface("org.freedesktop.Telepathy.Channel.Type.DBusTube", data);
+    let f = ::std::sync::Arc::new(f);
+    let fclone = f.clone();
+    let h = move |minfo: &tree::MethodInfo<tree::MTFn<D>, D>| {
+        let mut i = minfo.msg.iter_init();
+        let parameters: ::std::collections::HashMap<&str, arg::Variant<Box<dyn arg::RefArg>>> =
+            i.read()?;
+        let access_control: u32 = i.read()?;
+        let dd = fclone(minfo);
+        let d = dd.as_ref();
+        let address = d.offer(parameters, access_control)?;
+        let rm = minfo.msg.method_return();
+        let rm = rm.append1(address);
+        Ok(vec![rm])
+    };
+    let m = factory.method("Offer", Default::default(), h);
+    let m = m.in_arg(("parameters", "a{sv}"));
+    let m = m.in_arg(("access_control", "u"));
+    let m = m.out_arg(("address", "s"));
+    let i = i.add_m(m);
+
+    let fclone = f.clone();
+    let h = move |minfo: &tree::MethodInfo<tree::MTFn<D>, D>| {
+        let mut i = minfo.msg.iter_init();
+        let access_control: u32 = i.read()?;
+        let dd = fclone(minfo);
+        let d = dd.as_ref();
+        let address = d.accept(access_control)?;
+        let rm = minfo.msg.method_return();
+        let rm = rm.append1(address);
+        Ok(vec![rm])
+    };
+    let m = factory.method("Accept", Default::default(), h);
+    let m = m.in_arg(("access_control", "u"));
+    let m = m.out_arg(("address", "s"));
+    let i = i.add_m(m);
+
+    let p = factory.property::<&str, _>("ServiceName", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let dd = fclone(&minfo);
+        let d = dd.as_ref();
+        a.append(d.service_name()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+
+    let p = factory
+        .property::<::std::collections::HashMap<u32, &str>, _>("DBusNames", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let dd = fclone(&minfo);
+        let d = dd.as_ref();
+        a.append(d.dbus_names()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+
+    let p = factory.property::<Vec<u32>, _>("SupportedAccessControls", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let dd = fclone(&minfo);
+        let d = dd.as_ref();
+        a.append(d.supported_access_controls()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+    let s = factory.signal("DBusNamesChanged", Default::default());
+    let s = s.arg(("Added", "a{us}"));
+    let s = s.arg(("Removed", "au"));
+    let i = i.add_s(s);
+    i
+}
+
+#[derive(Debug)]
+pub struct ChannelTypeDBusTubeDBusNamesChanged {
+    pub added: ::std::collections::HashMap<u32, String>,
+    pub removed: Vec<u32>,
+}
+
+impl arg::AppendAll for ChannelTypeDBusTubeDBusNamesChanged {
+    fn append(&self, i: &mut arg::IterAppend) {
+        arg::RefArg::append(&self.added, i);
+        arg::RefArg::append(&self.removed, i);
+    }
+}
+
+impl arg::ReadAll for ChannelTypeDBusTubeDBusNamesChanged {
+    fn read(i: &mut arg::Iter) -> Result<Self, arg::TypeMismatchError> {
+        Ok(ChannelTypeDBusTubeDBusNamesChanged {
+            added: i.read()?,
+            removed: i.read()?,
+        })
+    }
+}
+
+impl dbus::message::SignalArgs for ChannelTypeDBusTubeDBusNamesChanged {
+    const NAME: &'static str = "DBusNamesChanged";
+    const INTERFACE: &'static str = "org.freedesktop.Telepathy.Channel.Type.DBusTube";
+}
--- a/src/telepathy/channel_type_file_transfer.rs
+++ b/src/telepathy/channel_type_file_transfer.rs
@@ -0,0 +1,370 @@
+// This code was autogenerated with `dbus-codegen-rust --file telepathy-spec/spec/Channel_Type_File_Transfer.xml -i org.freedesktop.Telepathy -a AsRefClosure -o src/telepathy/channel_type_file_transfer.rs`, see https://github.com/diwic/dbus-rs
+use dbus;
+use dbus::arg;
+use dbus::tree;
+
+pub trait ChannelTypeFileTransfer {
+    fn accept_file(
+        &self,
+        address_type: u32,
+        access_control: u32,
+        access_control_param: arg::Variant<Box<dyn arg::RefArg>>,
+        offset: u64,
+    ) -> Result<arg::Variant<Box<dyn arg::RefArg + 'static>>, tree::MethodErr>;
+    fn provide_file(
+        &self,
+        address_type: u32,
+        access_control: u32,
+        access_control_param: arg::Variant<Box<dyn arg::RefArg>>,
+    ) -> Result<arg::Variant<Box<dyn arg::RefArg + 'static>>, tree::MethodErr>;
+    fn state(&self) -> Result<u32, tree::MethodErr>;
+    fn content_type(&self) -> Result<String, tree::MethodErr>;
+    fn filename(&self) -> Result<String, tree::MethodErr>;
+    fn size(&self) -> Result<u64, tree::MethodErr>;
+    fn content_hash_type(&self) -> Result<u32, tree::MethodErr>;
+    fn content_hash(&self) -> Result<String, tree::MethodErr>;
+    fn description(&self) -> Result<String, tree::MethodErr>;
+    fn date(&self) -> Result<i64, tree::MethodErr>;
+    fn available_socket_types(
+        &self,
+    ) -> Result<::std::collections::HashMap<u32, Vec<u32>>, tree::MethodErr>;
+    fn transferred_bytes(&self) -> Result<u64, tree::MethodErr>;
+    fn initial_offset(&self) -> Result<u64, tree::MethodErr>;
+    fn uri(&self) -> Result<String, tree::MethodErr>;
+    fn set_uri(&self, value: String) -> Result<(), tree::MethodErr>;
+    fn file_collection(&self) -> Result<String, tree::MethodErr>;
+}
+
+pub fn channel_type_file_transfer_server<F, T, D>(
+    factory: &tree::Factory<tree::MTFn<D>, D>,
+    data: D::Interface,
+    f: F,
+) -> tree::Interface<tree::MTFn<D>, D>
+where
+    D: tree::DataType,
+    D::Method: Default,
+    D::Property: Default,
+    D::Signal: Default,
+    T: AsRef<dyn ChannelTypeFileTransfer>,
+    F: 'static + Fn(&tree::MethodInfo<tree::MTFn<D>, D>) -> T,
+{
+    let i = factory.interface("org.freedesktop.Telepathy.Channel.Type.FileTransfer", data);
+    let f = ::std::sync::Arc::new(f);
+    let fclone = f.clone();
+    let h = move |minfo: &tree::MethodInfo<tree::MTFn<D>, D>| {
+        let mut i = minfo.msg.iter_init();
+        let address_type: u32 = i.read()?;
+        let access_control: u32 = i.read()?;
+        let access_control_param: arg::Variant<Box<dyn arg::RefArg>> = i.read()?;
+        let offset: u64 = i.read()?;
+        let dd = fclone(minfo);
+        let d = dd.as_ref();
+        let address = d.accept_file(address_type, access_control, access_control_param, offset)?;
+        let rm = minfo.msg.method_return();
+        let rm = rm.append1(address);
+        Ok(vec![rm])
+    };
+    let m = factory.method("AcceptFile", Default::default(), h);
+    let m = m.in_arg(("Address_Type", "u"));
+    let m = m.in_arg(("Access_Control", "u"));
+    let m = m.in_arg(("Access_Control_Param", "v"));
+    let m = m.in_arg(("Offset", "t"));
+    let m = m.out_arg(("Address", "v"));
+    let i = i.add_m(m);
+
+    let fclone = f.clone();
+    let h = move |minfo: &tree::MethodInfo<tree::MTFn<D>, D>| {
+        let mut i = minfo.msg.iter_init();
+        let address_type: u32 = i.read()?;
+        let access_control: u32 = i.read()?;
+        let access_control_param: arg::Variant<Box<dyn arg::RefArg>> = i.read()?;
+        let dd = fclone(minfo);
+        let d = dd.as_ref();
+        let address = d.provide_file(address_type, access_control, access_control_param)?;
+        let rm = minfo.msg.method_return();
+        let rm = rm.append1(address);
+        Ok(vec![rm])
+    };
+    let m = factory.method("ProvideFile", Default::default(), h);
+    let m = m.in_arg(("Address_Type", "u"));
+    let m = m.in_arg(("Access_Control", "u"));
+    let m = m.in_arg(("Access_Control_Param", "v"));
+    let m = m.out_arg(("Address", "v"));
+    let i = i.add_m(m);
+
+    let p = factory.property::<u32, _>("State", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let dd = fclone(&minfo);
+        let d = dd.as_ref();
+        a.append(d.state()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+
+    let p = factory.property::<&str, _>("ContentType", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let dd = fclone(&minfo);
+        let d = dd.as_ref();
+        a.append(d.content_type()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+
+    let p = factory.property::<&str, _>("Filename", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let dd = fclone(&minfo);
+        let d = dd.as_ref();
+        a.append(d.filename()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+
+    let p = factory.property::<u64, _>("Size", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let dd = fclone(&minfo);
+        let d = dd.as_ref();
+        a.append(d.size()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+
+    let p = factory.property::<u32, _>("ContentHashType", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let dd = fclone(&minfo);
+        let d = dd.as_ref();
+        a.append(d.content_hash_type()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+
+    let p = factory.property::<&str, _>("ContentHash", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let dd = fclone(&minfo);
+        let d = dd.as_ref();
+        a.append(d.content_hash()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+
+    let p = factory.property::<&str, _>("Description", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let dd = fclone(&minfo);
+        let d = dd.as_ref();
+        a.append(d.description()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+
+    let p = factory.property::<i64, _>("Date", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let dd = fclone(&minfo);
+        let d = dd.as_ref();
+        a.append(d.date()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+
+    let p = factory.property::<::std::collections::HashMap<u32, Vec<u32>>, _>(
+        "AvailableSocketTypes",
+        Default::default(),
+    );
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let dd = fclone(&minfo);
+        let d = dd.as_ref();
+        a.append(d.available_socket_types()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+
+    let p = factory.property::<u64, _>("TransferredBytes", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let dd = fclone(&minfo);
+        let d = dd.as_ref();
+        a.append(d.transferred_bytes()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+
+    let p = factory.property::<u64, _>("InitialOffset", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let dd = fclone(&minfo);
+        let d = dd.as_ref();
+        a.append(d.initial_offset()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+
+    let p = factory.property::<&str, _>("URI", Default::default());
+    let p = p.access(tree::Access::ReadWrite);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let dd = fclone(&minfo);
+        let d = dd.as_ref();
+        a.append(d.uri()?);
+        Ok(())
+    });
+    let fclone = f.clone();
+    let p = p.on_set(move |iter, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let dd = fclone(&minfo);
+        let d = dd.as_ref();
+        d.set_uri(iter.read()?)?;
+        Ok(())
+    });
+    let i = i.add_p(p);
+
+    let p = factory.property::<&str, _>("FileCollection", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let dd = fclone(&minfo);
+        let d = dd.as_ref();
+        a.append(d.file_collection()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+    let s = factory.signal("FileTransferStateChanged", Default::default());
+    let s = s.arg(("State", "u"));
+    let s = s.arg(("Reason", "u"));
+    let i = i.add_s(s);
+    let s = factory.signal("TransferredBytesChanged", Default::default());
+    let s = s.arg(("Count", "t"));
+    let i = i.add_s(s);
+    let s = factory.signal("InitialOffsetDefined", Default::default());
+    let s = s.arg(("InitialOffset", "t"));
+    let i = i.add_s(s);
+    let s = factory.signal("URIDefined", Default::default());
+    let s = s.arg(("URI", "s"));
+    let i = i.add_s(s);
+    i
+}
+
+#[derive(Debug)]
+pub struct ChannelTypeFileTransferFileTransferStateChanged {
+    pub state: u32,
+    pub reason: u32,
+}
+
+impl arg::AppendAll for ChannelTypeFileTransferFileTransferStateChanged {
+    fn append(&self, i: &mut arg::IterAppend) {
+        arg::RefArg::append(&self.state, i);
+        arg::RefArg::append(&self.reason, i);
+    }
+}
+
+impl arg::ReadAll for ChannelTypeFileTransferFileTransferStateChanged {
+    fn read(i: &mut arg::Iter) -> Result<Self, arg::TypeMismatchError> {
+        Ok(ChannelTypeFileTransferFileTransferStateChanged {
+            state: i.read()?,
+            reason: i.read()?,
+        })
+    }
+}
+
+impl dbus::message::SignalArgs for ChannelTypeFileTransferFileTransferStateChanged {
+    const NAME: &'static str = "FileTransferStateChanged";
+    const INTERFACE: &'static str = "org.freedesktop.Telepathy.Channel.Type.FileTransfer";
+}
+
+#[derive(Debug)]
+pub struct ChannelTypeFileTransferTransferredBytesChanged {
+    pub count: u64,
+}
+
+impl arg::AppendAll for ChannelTypeFileTransferTransferredBytesChanged {
+    fn append(&self, i: &mut arg::IterAppend) {
+        arg::RefArg::append(&self.count, i);
+    }
+}
+
+impl arg::ReadAll for ChannelTypeFileTransferTransferredBytesChanged {
+    fn read(i: &mut arg::Iter) -> Result<Self, arg::TypeMismatchError> {
+        Ok(ChannelTypeFileTransferTransferredBytesChanged { count: i.read()? })
+    }
+}
+
+impl dbus::message::SignalArgs for ChannelTypeFileTransferTransferredBytesChanged {
+    const NAME: &'static str = "TransferredBytesChanged";
+    const INTERFACE: &'static str = "org.freedesktop.Telepathy.Channel.Type.FileTransfer";
+}
+
+#[derive(Debug)]
+pub struct ChannelTypeFileTransferInitialOffsetDefined {
+    pub initial_offset: u64,
+}
+
+impl arg::AppendAll for ChannelTypeFileTransferInitialOffsetDefined {
+    fn append(&self, i: &mut arg::IterAppend) {
+        arg::RefArg::append(&self.initial_offset, i);
+    }
+}
+
+impl arg::ReadAll for ChannelTypeFileTransferInitialOffsetDefined {
+    fn read(i: &mut arg::Iter) -> Result<Self, arg::TypeMismatchError> {
+        Ok(ChannelTypeFileTransferInitialOffsetDefined {
+            initial_offset: i.read()?,
+        })
+    }
+}
+
+impl dbus::message::SignalArgs for ChannelTypeFileTransferInitialOffsetDefined {
+    const NAME: &'static str = "InitialOffsetDefined";
+    const INTERFACE: &'static str = "org.freedesktop.Telepathy.Channel.Type.FileTransfer";
+}
+
+#[derive(Debug)]
+pub struct ChannelTypeFileTransferURIDefined {
+    pub uri: String,
+}
+
+impl arg::AppendAll for ChannelTypeFileTransferURIDefined {
+    fn append(&self, i: &mut arg::IterAppend) {
+        arg::RefArg::append(&self.uri, i);
+    }
+}
+
+impl arg::ReadAll for ChannelTypeFileTransferURIDefined {
+    fn read(i: &mut arg::Iter) -> Result<Self, arg::TypeMismatchError> {
+        Ok(ChannelTypeFileTransferURIDefined { uri: i.read()? })
+    }
+}
+
+impl dbus::message::SignalArgs for ChannelTypeFileTransferURIDefined {
+    const NAME: &'static str = "URIDefined";
+    const INTERFACE: &'static str = "org.freedesktop.Telepathy.Channel.Type.FileTransfer";
+}
--- a/src/telepathy/channel_type_room_list.rs
+++ b/src/telepathy/channel_type_room_list.rs
@@ -0,0 +1,129 @@
+// This code was autogenerated with `dbus-codegen-rust --file telepathy-spec/spec/Channel_Type_Room_List.xml -i org.freedesktop.Telepathy -a AsRefClosure -o src/telepathy/channel_type_room_list.rs`, see https://github.com/diwic/dbus-rs
+use dbus;
+use dbus::arg;
+use dbus::tree;
+
+pub trait ChannelTypeRoomList {
+    fn get_listing_rooms(&self) -> Result<bool, tree::MethodErr>;
+    fn list_rooms(&self) -> Result<(), tree::MethodErr>;
+    fn stop_listing(&self) -> Result<(), tree::MethodErr>;
+    fn server(&self) -> Result<String, tree::MethodErr>;
+}
+
+pub fn channel_type_room_list_server<F, T, D>(
+    factory: &tree::Factory<tree::MTFn<D>, D>,
+    data: D::Interface,
+    f: F,
+) -> tree::Interface<tree::MTFn<D>, D>
+where
+    D: tree::DataType,
+    D::Method: Default,
+    D::Property: Default,
+    D::Signal: Default,
+    T: AsRef<dyn ChannelTypeRoomList>,
+    F: 'static + Fn(&tree::MethodInfo<tree::MTFn<D>, D>) -> T,
+{
+    let i = factory.interface("org.freedesktop.Telepathy.Channel.Type.RoomList", data);
+    let f = ::std::sync::Arc::new(f);
+    let fclone = f.clone();
+    let h = move |minfo: &tree::MethodInfo<tree::MTFn<D>, D>| {
+        let dd = fclone(minfo);
+        let d = dd.as_ref();
+        let in_progress = d.get_listing_rooms()?;
+        let rm = minfo.msg.method_return();
+        let rm = rm.append1(in_progress);
+        Ok(vec![rm])
+    };
+    let m = factory.method("GetListingRooms", Default::default(), h);
+    let m = m.out_arg(("In_Progress", "b"));
+    let i = i.add_m(m);
+
+    let fclone = f.clone();
+    let h = move |minfo: &tree::MethodInfo<tree::MTFn<D>, D>| {
+        let dd = fclone(minfo);
+        let d = dd.as_ref();
+        d.list_rooms()?;
+        let rm = minfo.msg.method_return();
+        Ok(vec![rm])
+    };
+    let m = factory.method("ListRooms", Default::default(), h);
+    let i = i.add_m(m);
+
+    let fclone = f.clone();
+    let h = move |minfo: &tree::MethodInfo<tree::MTFn<D>, D>| {
+        let dd = fclone(minfo);
+        let d = dd.as_ref();
+        d.stop_listing()?;
+        let rm = minfo.msg.method_return();
+        Ok(vec![rm])
+    };
+    let m = factory.method("StopListing", Default::default(), h);
+    let i = i.add_m(m);
+
+    let p = factory.property::<&str, _>("Server", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let dd = fclone(&minfo);
+        let d = dd.as_ref();
+        a.append(d.server()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+    let s = factory.signal("GotRooms", Default::default());
+    let s = s.arg(("Rooms", "a(usa{sv})"));
+    let i = i.add_s(s);
+    let s = factory.signal("ListingRooms", Default::default());
+    let s = s.arg(("Listing", "b"));
+    let i = i.add_s(s);
+    i
+}
+
+#[derive(Debug)]
+pub struct ChannelTypeRoomListGotRooms {
+    pub rooms: Vec<(
+        u32,
+        String,
+        ::std::collections::HashMap<String, arg::Variant<Box<dyn arg::RefArg + 'static>>>,
+    )>,
+}
+
+impl arg::AppendAll for ChannelTypeRoomListGotRooms {
+    fn append(&self, i: &mut arg::IterAppend) {
+        arg::RefArg::append(&self.rooms, i);
+    }
+}
+
+impl arg::ReadAll for ChannelTypeRoomListGotRooms {
+    fn read(i: &mut arg::Iter) -> Result<Self, arg::TypeMismatchError> {
+        Ok(ChannelTypeRoomListGotRooms { rooms: i.read()? })
+    }
+}
+
+impl dbus::message::SignalArgs for ChannelTypeRoomListGotRooms {
+    const NAME: &'static str = "GotRooms";
+    const INTERFACE: &'static str = "org.freedesktop.Telepathy.Channel.Type.RoomList";
+}
+
+#[derive(Debug)]
+pub struct ChannelTypeRoomListListingRooms {
+    pub listing: bool,
+}
+
+impl arg::AppendAll for ChannelTypeRoomListListingRooms {
+    fn append(&self, i: &mut arg::IterAppend) {
+        arg::RefArg::append(&self.listing, i);
+    }
+}
+
+impl arg::ReadAll for ChannelTypeRoomListListingRooms {
+    fn read(i: &mut arg::Iter) -> Result<Self, arg::TypeMismatchError> {
+        Ok(ChannelTypeRoomListListingRooms { listing: i.read()? })
+    }
+}
+
+impl dbus::message::SignalArgs for ChannelTypeRoomListListingRooms {
+    const NAME: &'static str = "ListingRooms";
+    const INTERFACE: &'static str = "org.freedesktop.Telepathy.Channel.Type.RoomList";
+}
--- a/src/telepathy/channel_type_server_authentication.rs
+++ b/src/telepathy/channel_type_server_authentication.rs
@@ -0,0 +1,39 @@
+// This code was autogenerated with `dbus-codegen-rust --file telepathy-spec/spec/Channel_Type_Server_Authentication.xml -i org.freedesktop.Telepathy -a AsRefClosure -o src/telepathy/channel_type_server_authentication.rs`, see https://github.com/diwic/dbus-rs
+use dbus;
+use dbus::arg;
+use dbus::tree;
+
+pub trait ChannelTypeServerAuthentication {
+    fn authentication_method(&self) -> Result<String, tree::MethodErr>;
+}
+
+pub fn channel_type_server_authentication_server<F, T, D>(
+    factory: &tree::Factory<tree::MTFn<D>, D>,
+    data: D::Interface,
+    f: F,
+) -> tree::Interface<tree::MTFn<D>, D>
+where
+    D: tree::DataType,
+    D::Method: Default,
+    D::Property: Default,
+    T: AsRef<dyn ChannelTypeServerAuthentication>,
+    F: 'static + Fn(&tree::MethodInfo<tree::MTFn<D>, D>) -> T,
+{
+    let i = factory.interface(
+        "org.freedesktop.Telepathy.Channel.Type.ServerAuthentication",
+        data,
+    );
+    let f = ::std::sync::Arc::new(f);
+    let p = factory.property::<&str, _>("AuthenticationMethod", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let dd = fclone(&minfo);
+        let d = dd.as_ref();
+        a.append(d.authentication_method()?);
+        Ok(())
+    });
+    let i = i.add_p(p);
+    i
+}
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
Nick Thomas	7707242d10	Merge branch 'async'	2020-05-28 09:38:48 +01:00
Nick Thomas	bd76603c54	Upgrade to Delta v1.33.0 Despite the incremental version number, this is a backward-incompatible change, switching code to async. It does allow us to reduce the number of threads significantly, though.	2020-05-28 09:37:50 +01:00
Nick Thomas	9e764d72a1	Add image receipt to the text channel This is disturbingly useless with Empathy because it doesn't know how to display text/html parts, or plain image/png parts either :/ Time to start playing with KDE Spacebar? How does it handle them?	2020-05-27 01:19:43 +01:00
Nick Thomas	b9faad742b	Partial implementation of contact removal Empathy needs you to cycle the connection before it notices.	2020-05-24 00:24:15 +01:00
Nick Thomas	370f5076a1	Add and set the "Bcc self" option.	2020-05-23 23:52:42 +01:00
Nick Thomas	373311e826	HAXXX: A crude form of setup message acceptance	2020-05-23 22:49:15 +01:00
Nick Thomas	67a8715a25	Add an (untested) service file	2020-05-23 17:57:37 +01:00
Nick Thomas	c773146b26	It's called Mobian, not Moblin	2020-05-23 17:51:39 +01:00
Nick Thomas	7b1b8bdc83	cargo-about output	2020-05-23 17:48:13 +01:00
Nick Thomas	d06badfc96	sobbing subsides	2020-05-23 16:05:05 +01:00
Nick Thomas	8dbd023718	More sobbing	2020-05-23 14:48:35 +01:00
Nick Thomas	7cee6348fd	Cry in public	2020-05-23 14:35:26 +01:00
Nick Thomas	14aa639a4b	Fight with mobile linux for a bit	2020-05-22 10:29:10 +01:00
Nick Thomas	efe97a33c4	Fix messages on self-initiated channels	2020-05-21 11:06:07 +01:00
Nick Thomas	d77d04e9b1	Fix messages on remote-initiated chats	2020-05-21 10:49:33 +01:00
Nick Thomas	db7ecc6d98	Add the ContactList interface to the manager file	2020-05-21 10:49:15 +01:00
Nick Thomas	15174ea03f	Add a very broken ContactList + outgoing channel implementation Right now, messages don't show on the padfoot side any more, but they do get sent and received successfully on the other side, and empathy can manage contacts now, so I'm calling it an overall win.	2020-05-21 02:30:47 +01:00
Nick Thomas	aae7607c7f	Pin to the same version of rust nightly as delta	2020-05-19 00:16:01 +01:00
Nick Thomas	825f5d90ed	Update compile and install instructions	2020-05-18 23:40:43 +01:00
Nick Thomas	a95be7ee4b	Implement sending text messages This works in a very simplistic way, but it's enough for two-way communication. Hurrah!	2020-05-18 23:08:11 +01:00
Nick Thomas	72947bc99d	Allow incoming messages to be seen by Empathy MDNs don't work because the sender is not in a "real chat" yet- it's coming from an unknown user - but we mark them as seen anyway.	2020-05-18 21:15:56 +01:00
Nick Thomas	b511dd873b	Make text messages show on incoming	2020-05-18 19:37:35 +01:00
Nick Thomas	667eb3b3f6	By hook or by crook, amke empathy open a window	2020-05-18 01:57:22 +01:00
Nick Thomas	cb463336bc	Rework automatic code generation	2020-05-17 23:23:45 +01:00
Nick Thomas	1e481d4c9a	Wire up the additional channel interfaces a bit	2020-05-17 22:49:41 +01:00
Nick Thomas	e5e06c55f9	Reorder Channel::new args	2020-05-17 22:37:25 +01:00
Nick Thomas	576fec63cd	Complete channel-closing behaviour We now emit appropriate signals and return a non-error status code when a channel is closed.	2020-05-17 22:23:57 +01:00
Nick Thomas	782662b82f	Flesh out channels some more. They can now be closed. As part of this, move Connection's queue to mpsc and have all channels for a connection share that connection's main loop.	2020-05-17 22:05:24 +01:00
Nick Thomas	1eefce4f1c	Create a channel on incoming messages We don't yet emit signals, but we're getting closer. This commit also partially implements the deprecated ListChannels method on the Connection interface.	2020-05-17 15:20:16 +01:00
Nick Thomas	b814a9aab0	Partially on the way to receiving an incoming message This is getting really ugly, but let's run with it for now.	2020-05-17 03:01:21 +01:00
Nick Thomas	49362a6606	Ignore lints in autogenerated code	2020-05-17 00:55:29 +01:00
Nick Thomas	7003b56ce6	A bit more progress on channels	2020-05-17 00:49:46 +01:00
Nick Thomas	09afdf51a4	Add DBUS stubs for a basic Channel type	2020-05-16 23:05:14 +01:00
Nick Thomas	a202dd84e8	Clean up dbus::arg::Variant type alias	2020-05-16 22:11:38 +01:00
Nick Thomas	0f9dcf476b	Sync the .manager file	2020-05-16 21:33:58 +01:00
Nick Thomas	54a73c8219	Advertise the protocol interfaces correctly	2020-05-16 21:25:40 +01:00
Nick Thomas	011ee98340	Implement the Presence interface for the protocol	2020-05-16 21:22:49 +01:00
Nick Thomas	4a501b2e07	Backfill the Protocol interface	2020-05-16 21:05:58 +01:00
Nick Thomas	9473a13b65	Finish implementing the Contacts interface	2020-05-16 20:54:05 +01:00
Nick Thomas	9564a16aa2	Fix compilation	2020-05-16 20:44:34 +01:00
Nick Thomas	52f13a3589	Disable the ContactList interface for now	2020-05-16 20:19:04 +01:00
Nick Thomas	64bbaccc3a	Move name escaping into its own module	2020-05-16 20:16:23 +01:00
Nick Thomas	53bce50978	Extract tree building from Connection#run	2020-05-16 19:42:41 +01:00
Nick Thomas	411f34e6ce	Make disconnection clean up completely Now we can disconnect and reconnect the same account multiple times.	2020-05-16 19:26:52 +01:00
Nick Thomas	169249b716	Don't build a new connection if it already exists There was also a lot of unneeded overhead in Connection::new() to get the path to compare against, so split that out into a settings struct	2020-05-16 18:44:02 +01:00
Nick Thomas	e08ec6b476	Replace a sleep() with an MPSC channel	2020-05-16 18:09:40 +01:00
Nick Thomas	640948241a	Address a number of clippy complaints	2020-05-16 14:51:41 +01:00
Nick Thomas	33d522779a	Split padfoot/connection.rs into multiple files	2020-05-16 14:23:20 +01:00
Nick Thomas	c0e62ba6de	Update README.md	2020-05-15 00:54:05 +01:00
Nick Thomas	41309d9f39	Look online to Empathy It seems Empathy requires the ContactLists and Presence interfaces if it is to use your connection and show it as online. In addition, we were emitting the "connected" signal from the wrong source - it needed to have the object path of the specific connection, rather than the general connection object path. So now we can show as connected in Empathy, but we can't add a contact yet - presumably that's another interface. Sending a message to a connected deltachat account does nothing yet, as the message from deltachat-core is unhandled.	2020-05-15 00:42:15 +01:00
Nick Thomas	5eea970cf7	Implement some contact and request interfaces Empathy still isn't happy, but it's going to take some debugging to work out why. I suspect it requires one of the "optional" interfaces in practice... but which one?	2020-05-13 01:46:35 +01:00
Nick Thomas	b6fbcfeeb8	Track connection state and implement more properties Empathy still doesn't show us as connected. I think we need to add the Requests and Contacts interfaces (which we're advertising as a minimal requirement, but not implementing) before it will.	2020-05-12 23:52:52 +01:00
Nick Thomas	ef43c81955	Don't start delta until the connect signal is received We also introduce a sleep() to "fix" a race condition where empathy tries to contact the connection bus name before the thread has gotten around to starting it. That really needs fixing better, but for now I'm focused on basic functionality.	2020-05-12 22:28:36 +01:00
Nick Thomas	ef1342f372	Move account name escaping code to the end	2020-05-12 22:12:08 +01:00
Nick Thomas	2a565b3ee7	Deltachat connects on connection startup	2020-05-12 01:25:48 +01:00
Nick Thomas	9151f64a6d	Use AsRefClosure when generating the bindings This simplifies things significantly \o/	2020-05-11 00:48:18 +01:00
Nick Thomas	ad0d95ab40	Add some debugging output to connection	2020-05-10 23:25:41 +01:00
Nick Thomas	baafd12354	Initial connection interface stubs, emit NewConnection signal	2020-05-10 23:09:58 +01:00
Nick Thomas	6d79491e32	Rework to get a map of connections in ConnectionManager	2020-05-10 19:04:14 +01:00
Nick Thomas	04bf72637d	Enable LTO for release	2020-05-10 01:34:28 +01:00
Nick Thomas	1212ff20e4	Why why why	2020-05-10 01:03:36 +01:00
Nick Thomas	6e3ad7383f	Add deltachat-core-rust to the build	2020-05-10 01:01:28 +01:00
Nick Thomas	ffb190385e	Make the protocol advertise a requestable channel Without this, telepathy-glib/empathy doesn't believe the protocol is bonafide (i.e., implementing TP_PROTOCOL_FEATURE_CORE). Adding a dummy gets empathy to display the protocol without needing to be patched \o/.	2020-05-10 00:33:15 +01:00
Nick Thomas	c643c42fa5	Initial protocol implementation Empathy needs this patch before it will display the settings: https://gitlab.gnome.org/GNOME/telepathy-account-widgets/-/merge_requests/1	2020-05-09 21:45:29 +01:00
Nick Thomas	c861f6fdd9	Displays the protocol in empathy	2020-05-09 11:48:13 +01:00
Nick Thomas	40ea57a0cc	Return protocol parameters	2020-05-09 11:19:40 +01:00
Nick Thomas	5328ae9bd6	Initial checkin	2020-05-09 01:48:14 +01:00