Add multiparty call support to libdino and xmpp-vala

26 files changed, 1313 insertions, 522 deletions

diff --git a/libdino/CMakeLists.txt b/libdino/CMakeLists.txt
index d7f7583c..ce836f62 100644
--- a/libdino/CMakeLists.txt
+++ b/libdino/CMakeLists.txt
@@ -29,6 +29,8 @@ SOURCES
     src/service/avatar_manager.vala
     src/service/blocking_manager.vala
     src/service/call_store.vala
+    src/service/call_state.vala
+    src/service/call_peer_state.vala
     src/service/calls.vala
     src/service/chat_interaction.vala
     src/service/connection_manager.vala
diff --git a/libdino/src/entity/call.vala b/libdino/src/entity/call.vala
index 577b3ab8..a5ab672e 100644
--- a/libdino/src/entity/call.vala
+++ b/libdino/src/entity/call.vala
@@ -20,14 +20,9 @@ namespace Dino.Entities {
 
         public int id { get; set; default=-1; }
         public Account account { get; set; }
-        public Jid counterpart { get; set; }
+        public Jid counterpart { get; set; } // For backwards compatibility with db version 21. Not to be used anymore.
+        public Gee.List<Jid> counterparts = new Gee.ArrayList<Jid>(Jid.equals_bare_func);
         public Jid ourpart { get; set; }
-        public Jid? from {
-            get { return direction == DIRECTION_OUTGOING ? ourpart : counterpart; }
-        }
-        public Jid? to {
-            get { return direction == DIRECTION_OUTGOING ? counterpart : ourpart; }
-        }
         public bool direction { get; set; }
         public DateTime time { get; set; }
         public DateTime local_time { get; set; }
@@ -47,6 +42,7 @@ namespace Dino.Entities {
             counterpart = db.get_jid_by_id(row[db.call.counterpart_id]);
             string counterpart_resource = row[db.call.counterpart_resource];
             if (counterpart_resource != null) counterpart = counterpart.with_resource(counterpart_resource);
+            counterparts.add(counterpart);
 
             string our_resource = row[db.call.our_resource];
             if (our_resource != null) {
@@ -61,6 +57,15 @@ namespace Dino.Entities {
             encryption = (Encryption) row[db.call.encryption];
             state = (State) row[db.call.state];
 
+            Qlite.QueryBuilder counterparts_select = db.call_counterpart.select().with(db.call_counterpart.call_id, "=", id);
+            foreach (Qlite.Row counterparts_row in counterparts_select) {
+                Jid peer = db.get_jid_by_id(counterparts_row[db.call_counterpart.jid_id]);
+                if (!counterparts.contains(peer)) { // Legacy: The first peer is also in the `call` table. Don't add twice.
+                    counterparts.add(peer);
+                }
+                if (counterpart == null) counterpart = peer;
+            }
+
             notify.connect(on_update);
         }
 
@@ -70,8 +75,6 @@ namespace Dino.Entities {
             this.db = db;
             Qlite.InsertBuilder builder = db.call.insert()
                     .value(db.call.account_id, account.id)
-                    .value(db.call.counterpart_id, db.get_jid_id(counterpart))
-                    .value(db.call.counterpart_resource, counterpart.resourcepart)
                     .value(db.call.our_resource, ourpart.resourcepart)
                     .value(db.call.direction, direction)
                     .value(db.call.time, (long) time.to_unix())
@@ -83,11 +86,38 @@ namespace Dino.Entities {
             } else {
                 builder.value(db.call.end_time, (long) local_time.to_unix());
             }
+            if (counterpart != null) {
+                builder.value(db.call.counterpart_id, db.get_jid_id(counterpart))
+                    .value(db.call.counterpart_resource, counterpart.resourcepart);
+            }
             id = (int) builder.perform();
 
+            foreach (Jid peer in counterparts) {
+                db.call_counterpart.insert()
+                        .value(db.call_counterpart.call_id, id)
+                        .value(db.call_counterpart.jid_id, db.get_jid_id(peer))
+                        .value(db.call_counterpart.resource, peer.resourcepart)
+                        .perform();
+            }
+
             notify.connect(on_update);
         }
 
+        public void add_peer(Jid peer) {
+            if (counterpart == null) counterpart = peer;
+
+            if (counterparts.contains(peer)) return;
+
+            counterparts.add(peer);
+            if (db != null) {
+                db.call_counterpart.insert()
+                        .value(db.call_counterpart.call_id, id)
+                        .value(db.call_counterpart.jid_id, db.get_jid_id(peer))
+                        .value(db.call_counterpart.resource, peer.resourcepart)
+                        .perform();
+            }
+        }
+
         public bool equals(Call c) {
             return equals_func(this, c);
         }
diff --git a/libdino/src/plugin/interfaces.vala b/libdino/src/plugin/interfaces.vala
index eadbb085..fb80fef6 100644
--- a/libdino/src/plugin/interfaces.vala
+++ b/libdino/src/plugin/interfaces.vala
@@ -106,11 +106,13 @@ public abstract interface VideoCallPlugin : Object {
     public abstract MediaDevice? get_device(Xmpp.Xep.JingleRtp.Stream stream, bool incoming);
     public abstract void set_pause(Xmpp.Xep.JingleRtp.Stream stream, bool pause);
     public abstract void set_device(Xmpp.Xep.JingleRtp.Stream stream, MediaDevice? device);
+
+    public abstract void dump_dot();
 }
 
 public abstract interface VideoCallWidget : Object {
     public signal void resolution_changed(uint width, uint height);
-    public abstract void display_stream(Xmpp.Xep.JingleRtp.Stream stream); // TODO: Multi participant
+    public abstract void display_stream(Xmpp.Xep.JingleRtp.Stream stream, Jid jid);
     public abstract void display_device(MediaDevice device);
     public abstract void detach();
 }
diff --git a/libdino/src/service/call_peer_state.vala b/libdino/src/service/call_peer_state.vala
new file mode 100644
index 00000000..ddd0d8dd
--- /dev/null
+++ b/libdino/src/service/call_peer_state.vala
@@ -0,0 +1,453 @@
+using Dino.Entities;
+using Gee;
+using Xmpp;
+
+public class Dino.PeerState : Object {
+    public signal void counterpart_sends_video_updated(bool mute);
+    public signal void info_received(Xep.JingleRtp.CallSessionInfo session_info);
+
+    public signal void connection_ready();
+    public signal void session_terminated(bool we_terminated, string? reason_name, string? reason_text);
+    public signal void encryption_updated(Xep.Jingle.ContentEncryption? audio_encryption, Xep.Jingle.ContentEncryption? video_encryption, bool same);
+
+    public StreamInteractor stream_interactor;
+    public Calls calls;
+    public Call call;
+    public Jid jid;
+    public Xep.Jingle.Session session;
+    public string sid;
+    public string internal_id = Xmpp.random_uuid();
+
+    public Xep.JingleRtp.Parameters? audio_content_parameter = null;
+    public Xep.JingleRtp.Parameters? video_content_parameter = null;
+    public Xep.Jingle.Content? audio_content = null;
+    public Xep.Jingle.Content? video_content = null;
+    public Xep.Jingle.ContentEncryption? video_encryption = null;
+    public Xep.Jingle.ContentEncryption? audio_encryption = null;
+    public bool encryption_keys_same = false;
+    public HashMap<string, Xep.Jingle.ContentEncryption>? video_encryptions = null;
+    public HashMap<string, Xep.Jingle.ContentEncryption>? audio_encryptions = null;
+
+    public bool first_peer = false;
+    public bool accepted_jmi = false;
+    public bool waiting_for_inbound_muji_connection = false;
+    public Xep.Muji.GroupCall? group_call { get; set; }
+
+    public bool counterpart_sends_video = false;
+    public bool we_should_send_audio { get; set; default=false; }
+    public bool we_should_send_video { get; set; default=false; }
+
+    public PeerState(Jid jid, Call call, StreamInteractor stream_interactor) {
+        this.jid = jid;
+        this.call = call;
+        this.stream_interactor = stream_interactor;
+        this.calls = stream_interactor.get_module(Calls.IDENTITY);
+
+        var session_info_type = stream_interactor.module_manager.get_module(call.account, Xep.JingleRtp.Module.IDENTITY).session_info_type;
+        session_info_type.mute_update_received.connect((session,mute, name) => {
+            if (this.sid != session.sid) return;
+
+            foreach (Xep.Jingle.Content content in session.contents) {
+                if (name == null || content.content_name == name) {
+                    Xep.JingleRtp.Parameters? rtp_content_parameter = content.content_params as Xep.JingleRtp.Parameters;
+                    if (rtp_content_parameter != null) {
+                        on_counterpart_mute_update(mute, rtp_content_parameter.media);
+                    }
+                }
+            }
+        });
+        session_info_type.info_received.connect((session, session_info) => {
+            if (this.sid != session.sid) return;
+
+            info_received(session_info);
+        });
+    }
+
+    public async void initiate_call(Jid counterpart) {
+        Gee.List<Jid> call_resources = yield calls.get_call_resources(call.account, counterpart);
+
+        bool do_jmi = false;
+        Jid? jid_for_direct = null;
+        if (yield calls.contains_jmi_resources(call.account, call_resources)) {
+            do_jmi = true;
+        } else if (!call_resources.is_empty) {
+            jid_for_direct = call_resources[0];
+        } else if (calls.has_jmi_resources(jid)) {
+            do_jmi = true;
+        }
+
+        sid = Xmpp.random_uuid();
+
+        if (do_jmi) {
+            XmppStream? stream = stream_interactor.get_stream(call.account);
+
+            calls.current_jmi_request_call[call.account] = calls.call_states[call];
+            calls.current_jmi_request_peer[call.account] = this;
+
+            var descriptions = new ArrayList<StanzaNode>();
+            descriptions.add(new StanzaNode.build("description", Xep.JingleRtp.NS_URI).add_self_xmlns().put_attribute("media", "audio"));
+            if (we_should_send_video) {
+                descriptions.add(new StanzaNode.build("description", Xep.JingleRtp.NS_URI).add_self_xmlns().put_attribute("media", "video"));
+            }
+
+            stream.get_module(Xmpp.Xep.JingleMessageInitiation.Module.IDENTITY).send_session_propose_to_peer(stream, jid, sid, descriptions);
+        } else if (jid_for_direct != null) {
+            yield call_resource(jid_for_direct);
+        }
+    }
+
+    public async void call_resource(Jid full_jid) {
+        XmppStream? stream = stream_interactor.get_stream(call.account);
+        if (stream == null) return;
+
+        if (sid == null) sid = Xmpp.random_uuid();
+
+        Xep.Jingle.Session session = yield stream.get_module(Xep.JingleRtp.Module.IDENTITY).start_call(stream, full_jid, we_should_send_video, sid, group_call != null ? group_call.muc_jid : null);
+        set_session(session);
+    }
+
+    public void accept() {
+        if (session != null) {
+            foreach (Xep.Jingle.Content content in session.contents) {
+                content.accept();
+            }
+        } else {
+            // Only a JMI so far
+            XmppStream stream = stream_interactor.get_stream(call.account);
+            if (stream == null) return;
+
+            accepted_jmi = true;
+
+            calls.current_jmi_request_call[call.account] = calls.call_states[call];
+            calls.current_jmi_request_peer[call.account] = this;
+
+            stream.get_module(Xep.JingleMessageInitiation.Module.IDENTITY).send_session_accept_to_self(stream, sid);
+            stream.get_module(Xep.JingleMessageInitiation.Module.IDENTITY).send_session_proceed_to_peer(stream, jid, sid);
+        }
+    }
+
+    public void reject() {
+        call.state = Call.State.DECLINED;
+
+        if (session != null) {
+            foreach (Xep.Jingle.Content content in session.contents) {
+                content.reject();
+            }
+        } else {
+            // Only a JMI so far
+            XmppStream stream = stream_interactor.get_stream(call.account);
+            if (stream == null) return;
+
+            stream.get_module(Xep.JingleMessageInitiation.Module.IDENTITY).send_session_reject_to_peer(stream, jid, sid);
+            stream.get_module(Xep.JingleMessageInitiation.Module.IDENTITY).send_session_reject_to_self(stream, sid);
+        }
+    }
+
+    public void end(string terminate_reason, string? reason_text = null) {
+        switch (terminate_reason) {
+            case Xep.Jingle.ReasonElement.SUCCESS:
+                if (session != null) {
+                    session.terminate(terminate_reason, reason_text, "success");
+                }
+                break;
+            case Xep.Jingle.ReasonElement.CANCEL:
+                if (session != null) {
+                    session.terminate(terminate_reason, reason_text, "cancel");
+                } else if (group_call != null) {
+                    // We don't have to do anything (?)
+                } else {
+                    // Only a JMI so far
+                    XmppStream? stream = stream_interactor.get_stream(call.account);
+                    if (stream == null) return;
+                    stream.get_module(Xep.JingleMessageInitiation.Module.IDENTITY).send_session_retract_to_peer(stream, jid, sid);
+                }
+                break;
+        }
+    }
+
+    internal void mute_own_audio(bool mute) {
+        // Call isn't fully established yet. Audio will be muted once the stream is created.
+        if (session == null || audio_content_parameter == null || audio_content_parameter.stream == null) return;
+
+        Xep.JingleRtp.Stream stream = audio_content_parameter.stream;
+
+        // Inform our counterpart that we (un)muted our audio
+        stream_interactor.module_manager.get_module(call.account, Xep.JingleRtp.Module.IDENTITY).session_info_type.send_mute(session, mute, "audio");
+
+        // Start/Stop sending audio data
+        Application.get_default().plugin_registry.video_call_plugin.set_pause(stream, mute);
+    }
+
+    internal void mute_own_video(bool mute) {
+
+        if (session == null) {
+            // Call hasn't been established yet
+            return;
+        }
+
+        Xep.JingleRtp.Module rtp_module = stream_interactor.module_manager.get_module(call.account, Xep.JingleRtp.Module.IDENTITY);
+
+        if (video_content_parameter != null &&
+                video_content_parameter.stream != null &&
+                session.senders_include_us(video_content.senders)) {
+            // A video content already exists
+
+            // Start/Stop sending video data
+            Xep.JingleRtp.Stream stream = video_content_parameter.stream;
+            if (stream != null) {
+                Application.get_default().plugin_registry.video_call_plugin.set_pause(stream, mute);
+            }
+
+            // Inform our counterpart that we started/stopped our video
+            rtp_module.session_info_type.send_mute(session, mute, "video");
+        } else if (!mute) {
+            // Add a new video content
+            XmppStream stream = stream_interactor.get_stream(call.account);
+            rtp_module.add_outgoing_video_content.begin(stream, session, group_call != null ? group_call.muc_jid : null, (_, res) => {
+                if (video_content_parameter == null) {
+                    Xep.Jingle.Content content = rtp_module.add_outgoing_video_content.end(res);
+                    Xep.JingleRtp.Parameters? rtp_content_parameter = content.content_params as Xep.JingleRtp.Parameters;
+                    if (rtp_content_parameter != null) {
+                        connect_content_signals(content, rtp_content_parameter);
+                    }
+                }
+            });
+        }
+        // If video_content_parameter == null && !mute we're trying to mute a non-existant feed. It will be muted as soon as it is created.
+    }
+
+    public Xep.JingleRtp.Stream? get_video_stream(Call call) {
+        if (video_content_parameter != null) {
+            return video_content_parameter.stream;
+        }
+        return null;
+    }
+
+    public Xep.JingleRtp.Stream? get_audio_stream(Call call) {
+        if (audio_content_parameter != null) {
+            return audio_content_parameter.stream;
+        }
+        return null;
+    }
+
+    internal void set_session(Xep.Jingle.Session session) {
+        this.session = session;
+        this.sid = session.sid;
+
+        session.terminated.connect((stream, we_terminated, reason_name, reason_text) =>
+            session_terminated(we_terminated, reason_name, reason_text)
+        );
+        session.additional_content_add_incoming.connect((session,stream, content) =>
+            on_incoming_content_add(stream, session, content)
+        );
+
+        foreach (Xep.Jingle.Content content in session.contents) {
+            Xep.JingleRtp.Parameters? rtp_content_parameter = content.content_params as Xep.JingleRtp.Parameters;
+            if (rtp_content_parameter == null) continue;
+
+            connect_content_signals(content, rtp_content_parameter);
+        }
+    }
+
+    public PeerInfo get_info() {
+        var ret = new PeerInfo();
+
+        if (audio_content_parameter != null) {
+            ret.audio_rtcp_ready = audio_content_parameter.rtcp_ready;
+            ret.audio_rtp_ready = audio_content_parameter.rtp_ready;
+
+            if (audio_content_parameter.agreed_payload_type != null) {
+                ret.audio_codec = audio_content_parameter.agreed_payload_type.name;
+                ret.audio_clockrate = audio_content_parameter.agreed_payload_type.clockrate;
+            }
+        }
+
+        if (audio_content != null) {
+            Xmpp.Xep.Jingle.ComponentConnection? component0 = audio_content.get_transport_connection(1);
+            if (component0 != null) {
+                ret.audio_bytes_received = component0.bytes_received;
+                ret.audio_bytes_sent = component0.bytes_sent;
+            }
+        }
+
+        if (video_content_parameter != null) {
+            ret.video_content_exists = true;
+            ret.video_rtcp_ready = video_content_parameter.rtcp_ready;
+            ret.video_rtp_ready = video_content_parameter.rtp_ready;
+
+            if (video_content_parameter.agreed_payload_type != null) {
+                ret.video_codec = video_content_parameter.agreed_payload_type.name;
+            }
+        }
+
+        if (video_content != null) {
+            Xmpp.Xep.Jingle.ComponentConnection? component0 = video_content.get_transport_connection(1);
+            if (component0 != null) {
+                ret.video_bytes_received = component0.bytes_received;
+                ret.video_bytes_sent = component0.bytes_sent;
+            }
+        }
+        return ret;
+    }
+
+    private void connect_content_signals(Xep.Jingle.Content content, Xep.JingleRtp.Parameters rtp_content_parameter) {
+        if (rtp_content_parameter.media == "audio") {
+            audio_content = content;
+            audio_content_parameter = rtp_content_parameter;
+        } else if (rtp_content_parameter.media == "video") {
+            video_content = content;
+            video_content_parameter = rtp_content_parameter;
+        }
+
+        debug(@"[%s] %s connecting content signals %s", call.account.bare_jid.to_string(), jid.to_string(), rtp_content_parameter.media);
+        rtp_content_parameter.stream_created.connect((stream) => on_stream_created(rtp_content_parameter.media, stream));
+        rtp_content_parameter.connection_ready.connect((status) => on_connection_ready(content, rtp_content_parameter.media));
+
+        content.senders_modify_incoming.connect((content, proposed_senders) => {
+            if (content.session.senders_include_us(content.senders) != content.session.senders_include_us(proposed_senders)) {
+                warning("counterpart set us to (not)sending %s. ignoring", content.content_name);
+                return;
+            }
+
+            if (!content.session.senders_include_counterpart(content.senders) && content.session.senders_include_counterpart(proposed_senders)) {
+                // Counterpart wants to start sending. Ok.
+                content.accept_content_modify(proposed_senders);
+                on_counterpart_mute_update(false, "video");
+            }
+        });
+    }
+
+    private void on_incoming_content_add(XmppStream stream, Xep.Jingle.Session session, Xep.Jingle.Content content) {
+        Xep.JingleRtp.Parameters? rtp_content_parameter = content.content_params as Xep.JingleRtp.Parameters;
+
+        if (rtp_content_parameter == null) {
+            content.reject();
+            return;
+        }
+
+        // Our peer shouldn't tell us to start sending, that's for us to initiate
+        if (session.senders_include_us(content.senders)) {
+            if (session.senders_include_counterpart(content.senders)) {
+                // If our peer wants to send, let them
+                content.modify(session.we_initiated ? Xep.Jingle.Senders.RESPONDER : Xep.Jingle.Senders.INITIATOR);
+            } else {
+                // If only we're supposed to send, reject
+                content.reject();
+            }
+        }
+
+        connect_content_signals(content, rtp_content_parameter);
+        content.accept();
+    }
+
+    private void on_stream_created(string media, Xep.JingleRtp.Stream stream) {
+        if (media == "video" && stream.receiving) {
+            counterpart_sends_video = true;
+            video_content_parameter.connection_ready.connect((status) => {
+                counterpart_sends_video_updated(false);
+            });
+        }
+
+        // Outgoing audio/video might have been muted in the meanwhile.
+        if (media == "video" && !we_should_send_video) {
+            mute_own_video(true);
+        } else if (media == "audio" && !we_should_send_audio) {
+            mute_own_audio(true);
+        }
+    }
+
+    private void on_counterpart_mute_update(bool mute, string? media) {
+        if (!call.equals(call)) return;
+
+        if (media == "video") {
+            counterpart_sends_video = !mute;
+            debug(@"[%s] %s video muted %s", call.account.bare_jid.to_string(), jid.to_string(), mute.to_string());
+            counterpart_sends_video_updated(mute);
+        }
+    }
+
+    private void on_connection_ready(Xep.Jingle.Content content, string media) {
+        debug("[%s] %s on_connection_ready", call.account.bare_jid.to_string(), jid.to_string());
+        connection_ready();
+
+        if (call.state == Call.State.RINGING || call.state == Call.State.ESTABLISHING) {
+            call.state = Call.State.IN_PROGRESS;
+        }
+
+        if (media == "audio") {
+            audio_encryptions = content.encryptions;
+        } else if (media == "video") {
+            video_encryptions = content.encryptions;
+        }
+
+        if ((audio_encryptions != null && audio_encryptions.is_empty) || (video_encryptions != null && video_encryptions.is_empty)) {
+            call.encryption = Encryption.NONE;
+            encryption_updated(null, null, true);
+            return;
+        }
+
+        HashMap<string, Xep.Jingle.ContentEncryption> encryptions = audio_encryptions ?? video_encryptions;
+
+        Xep.Jingle.ContentEncryption? omemo_encryption = null, dtls_encryption = null, srtp_encryption = null;
+        foreach (string encr_name in encryptions.keys) {
+            if (video_encryptions != null && !video_encryptions.has_key(encr_name)) continue;
+
+            var encryption = encryptions[encr_name];
+            if (encryption.encryption_ns == "http://gultsch.de/xmpp/drafts/omemo/dlts-srtp-verification") {
+                omemo_encryption = encryption;
+            } else if (encryption.encryption_ns == Xep.JingleIceUdp.DTLS_NS_URI) {
+                dtls_encryption = encryption;
+            } else if (encryption.encryption_name == "SRTP") {
+                srtp_encryption = encryption;
+            }
+        }
+
+        if (omemo_encryption != null && dtls_encryption != null) {
+            call.encryption = Encryption.OMEMO;
+            omemo_encryption.peer_key = dtls_encryption.peer_key;
+            omemo_encryption.our_key = dtls_encryption.our_key;
+            audio_encryption = omemo_encryption;
+            encryption_keys_same = true;
+            video_encryption = video_encryptions != null ? video_encryptions["http://gultsch.de/xmpp/drafts/omemo/dlts-srtp-verification"] : null;
+        } else if (dtls_encryption != null) {
+            call.encryption = Encryption.DTLS_SRTP;
+            audio_encryption = dtls_encryption;
+            video_encryption = video_encryptions != null ? video_encryptions[Xep.JingleIceUdp.DTLS_NS_URI] : null;
+            encryption_keys_same = true;
+            if (video_encryption != null && dtls_encryption.peer_key.length == video_encryption.peer_key.length) {
+                for (int i = 0; i < dtls_encryption.peer_key.length; i++) {
+                    if (dtls_encryption.peer_key[i] != video_encryption.peer_key[i]) {
+                        encryption_keys_same = false;
+                        break;
+                    }
+                }
+            }
+        } else if (srtp_encryption != null) {
+            call.encryption = Encryption.SRTP;
+            audio_encryption = srtp_encryption;
+            video_encryption = video_encryptions != null ? video_encryptions["SRTP"] : null;
+            encryption_keys_same = false;
+        } else {
+            call.encryption = Encryption.NONE;
+            encryption_keys_same = true;
+        }
+
+        encryption_updated(audio_encryption, video_encryption, encryption_keys_same);
+    }
+}
+
+public class Dino.PeerInfo {
+    public bool audio_rtp_ready { get; set; }
+    public bool audio_rtcp_ready { get; set; }
+    public ulong? audio_bytes_sent { get; set; default=0; }
+    public ulong? audio_bytes_received { get; set; default=0; }
+    public string? audio_codec { get; set; }
+    public uint32 audio_clockrate { get; set; }
+
+    public bool video_content_exists { get; set; }
+    public bool video_rtp_ready { get; set; }
+    public bool video_rtcp_ready { get; set; }
+    public ulong? video_bytes_sent { get; set; default=0; }
+    public ulong? video_bytes_received { get; set; default=0; }
+    public string? video_codec { get; set; }
+}
\ No newline at end of file
diff --git a/libdino/src/service/call_state.vala b/libdino/src/service/call_state.vala
new file mode 100644
index 00000000..385cf9dc
--- /dev/null
+++ b/libdino/src/service/call_state.vala
@@ -0,0 +1,302 @@
+using Dino.Entities;
+using Gee;
+using Xmpp;
+
+public class Dino.CallState : Object {
+
+    public signal void terminated(Jid who_terminated, string? reason_name, string? reason_text);
+    public signal void peer_joined(Jid jid, PeerState peer_state);
+    public signal void peer_left(Jid jid, PeerState peer_state, string? reason_name, string? reason_text);
+
+    public StreamInteractor stream_interactor;
+    public Call call;
+    public Xep.Muji.GroupCall? group_call { get; set; }
+    public Jid? invited_to_group_call = null;
+    public Jid? group_call_inviter = null;
+    public bool accepted { get; private set; default=false; }
+
+    public bool we_should_send_audio { get; set; default=false; }
+    public bool we_should_send_video { get; set; default=false; }
+    public HashMap<Jid, PeerState> peers = new HashMap<Jid, PeerState>(Jid.hash_func, Jid.equals_func);
+
+    public CallState(Call call, StreamInteractor stream_interactor) {
+        this.call = call;
+        this.stream_interactor = stream_interactor;
+
+        if (call.direction == Call.DIRECTION_OUTGOING) {
+            accepted = true;
+
+            Timeout.add_seconds(30, () => {
+                if (this == null) return false; // TODO enough?
+                if (call.state == Call.State.ESTABLISHING) {
+                    call.state = Call.State.MISSED;
+                    terminated(call.account.bare_jid, null, null);
+                }
+                return false;
+            });
+        }
+    }
+
+    internal PeerState set_first_peer(Jid peer) {
+        var peer_state = new PeerState(peer, call, stream_interactor);
+        peer_state.first_peer = true;
+        add_peer(peer_state);
+        return peer_state;
+    }
+
+    internal void add_peer(PeerState peer) {
+        call.add_peer(peer.jid.bare_jid);
+        connect_peer_signals(peer);
+        peer_joined(peer.jid, peer);
+    }
+
+    public void accept() {
+        accepted = true;
+        call.state = Call.State.ESTABLISHING;
+
+        if (invited_to_group_call != null) {
+            XmppStream stream = stream_interactor.get_stream(call.account);
+            if (stream == null) return;
+            stream.get_module(Xep.MujiMeta.Module.IDENTITY).send_invite_accept_to_peer(stream, group_call_inviter, invited_to_group_call);
+            join_group_call.begin(invited_to_group_call);
+        } else {
+            foreach (PeerState peer in peers.values) {
+                peer.accept();
+            }
+        }
+    }
+
+    public void reject() {
+        call.state = Call.State.DECLINED;
+
+        if (invited_to_group_call != null) {
+            XmppStream stream = stream_interactor.get_stream(call.account);
+            if (stream == null) return;
+            stream.get_module(Xep.MujiMeta.Module.IDENTITY).send_invite_reject_to_self(stream, invited_to_group_call);
+            stream.get_module(Xep.MujiMeta.Module.IDENTITY).send_invite_reject_to_peer(stream, group_call_inviter, invited_to_group_call);
+        }
+        var peers_cpy = new ArrayList<PeerState>();
+        peers_cpy.add_all(peers.values);
+        foreach (PeerState peer in peers_cpy) {
+            peer.reject();
+        }
+        terminated(call.account.bare_jid, null, null);
+    }
+
+    public void end() {
+        var peers_cpy = new ArrayList<PeerState>();
+        peers_cpy.add_all(peers.values);
+
+        if (call.state == Call.State.IN_PROGRESS || call.state == Call.State.ESTABLISHING) {
+            foreach (PeerState peer in peers_cpy) {
+                peer.end(Xep.Jingle.ReasonElement.SUCCESS);
+            }
+            call.state = Call.State.ENDED;
+        } else if (call.state == Call.State.RINGING) {
+            foreach (PeerState peer in peers_cpy) {
+                peer.end(Xep.Jingle.ReasonElement.CANCEL);
+            }
+            call.state = Call.State.MISSED;
+        } else {
+            return;
+        }
+
+        call.end_time = new DateTime.now_utc();
+
+        terminated(call.account.bare_jid, null, null);
+    }
+
+    public void mute_own_audio(bool mute) {
+        we_should_send_audio = !mute;
+        foreach (PeerState peer in peers.values) {
+            peer.mute_own_audio(mute);
+        }
+    }
+
+    public void mute_own_video(bool mute) {
+        we_should_send_video = !mute;
+        foreach (PeerState peer in peers.values) {
+            peer.mute_own_video(mute);
+        }
+    }
+
+    public bool should_we_send_video() {
+        return we_should_send_video;
+    }
+
+    public async void invite_to_call(Jid invitee) {
+        if (this.group_call == null) yield convert_into_group_call();
+        if (this.group_call == null) return;
+
+        XmppStream stream = stream_interactor.get_stream(call.account);
+        if (stream == null) return;
+
+        debug("[%s] Inviting to muji call %s", call.account.bare_jid.to_string(), invitee.to_string());
+        yield stream.get_module(Xep.Muc.Module.IDENTITY).change_affiliation(stream, group_call.muc_jid, invitee, null, "owner");
+        stream.get_module(Xep.MujiMeta.Module.IDENTITY).send_invite(stream, invitee, group_call.muc_jid, we_should_send_video);
+
+        // If the peer hasn't accepted within a minute, retract the invite
+        Timeout.add_seconds(60, () => {
+            if (this == null) return false;
+
+            bool contains_peer = false;
+            foreach (Jid peer in peers.keys) {
+                if (peer.equals_bare(invitee)) {
+                    contains_peer = true;
+                }
+            }
+
+            if (!contains_peer) {
+                debug("[%s] Retracting invite to %s from %s", call.account.bare_jid.to_string(), group_call.muc_jid.to_string(), invitee.to_string());
+                stream.get_module(Xep.MujiMeta.Module.IDENTITY).send_invite_retract_to_peer(stream, invitee, group_call.muc_jid);
+                stream.get_module(Xep.Muc.Module.IDENTITY).change_affiliation.begin(stream, group_call.muc_jid, invitee, null, "none");
+            }
+            return false;
+        });
+    }
+
+    internal void rename_peer(Jid from_jid, Jid to_jid) {
+        debug("[%s] Renaming %s to %s exists %b", call.account.bare_jid.to_string(), from_jid.to_string(), to_jid.to_string(), peers.has_key(from_jid));
+        PeerState? peer_state = peers[from_jid];
+        if (peer_state == null) return;
+
+        // Adjust the internal mapping of this `PeerState` object
+        peers.unset(from_jid);
+        peers[to_jid] = peer_state;
+        peer_state.jid = to_jid;
+    }
+
+    private void on_call_terminated(Jid who_terminated, bool we_terminated, string? reason_name, string? reason_text) {
+        if (call.state == Call.State.RINGING || call.state == Call.State.IN_PROGRESS || call.state == Call.State.ESTABLISHING) {
+            call.end_time = new DateTime.now_utc();
+        }
+        if (call.state == Call.State.IN_PROGRESS) {
+            call.state = Call.State.ENDED;
+        } else if (call.state == Call.State.RINGING || call.state == Call.State.ESTABLISHING) {
+            if (reason_name == Xep.Jingle.ReasonElement.DECLINE) {
+                call.state = Call.State.DECLINED;
+            } else {
+                call.state = Call.State.FAILED;
+            }
+        }
+
+        terminated(who_terminated, reason_name, reason_text);
+    }
+
+    private void connect_peer_signals(PeerState peer_state) {
+        peers[peer_state.jid] = peer_state;
+
+        this.bind_property("we-should-send-audio", peer_state, "we-should-send-audio", BindingFlags.SYNC_CREATE | BindingFlags.BIDIRECTIONAL);
+        this.bind_property("we-should-send-video", peer_state, "we-should-send-video", BindingFlags.SYNC_CREATE | BindingFlags.BIDIRECTIONAL);
+        this.bind_property("group-call", peer_state, "group-call", BindingFlags.SYNC_CREATE | BindingFlags.BIDIRECTIONAL);
+
+        peer_state.session_terminated.connect((we_terminated, reason_name, reason_text) => {
+            peers.unset(peer_state.jid);
+            debug("[%s] Peer left %s left %i", call.account.bare_jid.to_string(), peer_state.jid.to_string(), peers.size);
+
+            if (peers.is_empty) {
+                if (group_call != null) group_call.leave(stream_interactor.get_stream(call.account));
+                on_call_terminated(peer_state.jid, we_terminated, reason_name, reason_text);
+            } else {
+                peer_left(peer_state.jid, peer_state, reason_name, reason_text);
+            }
+        });
+    }
+
+    public async void convert_into_group_call() {
+        XmppStream stream = stream_interactor.get_stream(call.account);
+        if (stream == null) return;
+
+        Jid muc_jid = stream_interactor.get_module(MucManager.IDENTITY).default_muc_server[call.account] ?? new Jid("chat.jabberfr.org");
+        muc_jid = new Jid("%08x@".printf(Random.next_int()) + muc_jid.to_string()); // TODO longer?
+
+        debug("[%s] Converting call to groupcall %s", call.account.bare_jid.to_string(), muc_jid.to_string());
+        yield join_group_call(muc_jid);
+
+        Xep.DataForms.DataForm? data_form = yield stream_interactor.get_module(MucManager.IDENTITY).get_config_form(call.account, muc_jid);
+        if (data_form == null) return;
+
+        foreach (Xep.DataForms.DataForm.Field field in data_form.fields) {
+            switch (field.var) {
+                case "muc#roomconfig_allowinvites":
+                    if (field.type_ == Xep.DataForms.DataForm.Type.BOOLEAN) {
+                        ((Xep.DataForms.DataForm.BooleanField) field).value = true;
+                    }
+                    break;
+                case "muc#roomconfig_persistentroom":
+                    if (field.type_ == Xep.DataForms.DataForm.Type.BOOLEAN) {
+                        ((Xep.DataForms.DataForm.BooleanField) field).value = false;
+                    }
+                    break;
+                case "muc#roomconfig_membersonly":
+                    if (field.type_ == Xep.DataForms.DataForm.Type.BOOLEAN) {
+                        ((Xep.DataForms.DataForm.BooleanField) field).value = true;
+                    }
+                    break;
+                case "muc#roomconfig_whois":
+                    if (field.type_ == Xep.DataForms.DataForm.Type.LIST_SINGLE) {
+                        ((Xep.DataForms.DataForm.ListSingleField) field).value = "anyone";
+                    }
+                    break;
+            }
+        }
+        yield stream_interactor.get_module(MucManager.IDENTITY).set_config_form(call.account, muc_jid, data_form);
+
+        foreach (Jid peer_jid in peers.keys) {
+            debug("[%s] Group call inviting %s", call.account.bare_jid.to_string(), peer_jid.to_string());
+            yield invite_to_call(peer_jid);
+        }
+    }
+
+    public async void join_group_call(Jid muc_jid) {
+        debug("[%s] Joining group call %s", call.account.bare_jid.to_string(), muc_jid.to_string());
+        XmppStream stream = stream_interactor.get_stream(call.account);
+        if (stream == null) return;
+
+        this.group_call = yield stream.get_module(Xep.Muji.Module.IDENTITY).join_call(stream, muc_jid, we_should_send_video);
+        if (this.group_call == null) {
+            warning("[%s] Couldn't join MUJI MUC", call.account.bare_jid.to_string());
+            return;
+        }
+
+        this.group_call.peer_joined.connect((jid) => {
+            debug("[%s] Group call peer joined: %s", call.account.bare_jid.to_string(), jid.to_string());
+
+            // Newly joined peers have to call us, not the other way round
+            // Maybe they called us already. Accept the call.
+            // (Except for the first peer, we already have a connection to that one.)
+            if (peers.has_key(jid)) {
+                if (!peers[jid].first_peer) {
+                    peers[jid].accept();
+                }
+                // else: Connection to first peer already active
+            } else {
+                var peer_state = new PeerState(jid, call, stream_interactor);
+                peer_state.waiting_for_inbound_muji_connection = true;
+                debug("[%s] Waiting for call from %s", call.account.bare_jid.to_string(), jid.to_string());
+                add_peer(peer_state);
+            }
+        });
+
+        this.group_call.peer_left.connect((jid) => {
+            debug("[%s] Group call peer left: %s", call.account.bare_jid.to_string(), jid.to_string());
+            if (!peers.has_key(jid)) return;
+            // end() will in the end cause a `peer_left` signal and removal from `peers`
+            peers[jid].end(Xep.Jingle.ReasonElement.CANCEL, "Peer left the MUJI MUC");
+        });
+
+        // Call all peers that are in the room already
+        foreach (Jid peer_jid in group_call.peers_to_connect_to) {
+            // Don't establish connection if we have one already (the person that invited us to the call)
+            if (peers.has_key(peer_jid)) continue;
+
+            debug("[%s] Calling %s because they were in the MUC already", call.account.bare_jid.to_string(), peer_jid.to_string());
+
+            PeerState peer_state = new PeerState(peer_jid, call, stream_interactor);
+            add_peer(peer_state);
+            peer_state.call_resource.begin(peer_jid);
+        }
+
+        debug("[%s] Finished joining MUJI muc %s", call.account.bare_jid.to_string(), muc_jid.to_string());
+    }
+}
\ No newline at end of file
diff --git a/libdino/src/service/calls.vala b/libdino/src/service/calls.vala
index 365c15d9..51ed6e78 100644
--- a/libdino/src/service/calls.vala
+++ b/libdino/src/service/calls.vala
@@ -7,16 +7,11 @@ namespace Dino {
 
     public class Calls : StreamInteractionModule, Object {
 
-        public signal void call_incoming(Call call, Conversation conversation, bool video);
-        public signal void call_outgoing(Call call, Conversation conversation);
+        public signal void call_incoming(Call call, CallState state, Conversation conversation, bool video);
+        public signal void call_outgoing(Call call, CallState state, Conversation conversation);
 
         public signal void call_terminated(Call call, string? reason_name, string? reason_text);
-        public signal void counterpart_ringing(Call call);
-        public signal void counterpart_sends_video_updated(Call call, bool mute);
-        public signal void info_received(Call call, Xep.JingleRtp.CallSessionInfo session_info);
-        public signal void encryption_updated(Call call, Xep.Jingle.ContentEncryption? audio_encryption, Xep.Jingle.ContentEncryption? video_encryption, bool same);
-
-        public signal void stream_created(Call call, string media);
+        public signal void conference_info_received(Call call, Xep.Coin.ConferenceInfo conference_info);
 
         public static ModuleIdentity<Calls> IDENTITY = new ModuleIdentity<Calls>("calls");
         public string id { get { return IDENTITY.id; } }
@@ -24,24 +19,9 @@ namespace Dino {
         private StreamInteractor stream_interactor;
         private Database db;
 
-        private HashMap<Account, HashMap<Call, string>> sid_by_call = new HashMap<Account, HashMap<Call, string>>(Account.hash_func, Account.equals_func);
-        private HashMap<Account, HashMap<string, Call>> call_by_sid = new HashMap<Account, HashMap<string, Call>>(Account.hash_func, Account.equals_func);
-        public HashMap<Call, Xep.Jingle.Session> sessions = new HashMap<Call, Xep.Jingle.Session>(Call.hash_func, Call.equals_func);
-
-        public HashMap<Account, Call> jmi_call = new HashMap<Account, Call>(Account.hash_func, Account.equals_func);
-        public HashMap<Account, string> jmi_sid = new HashMap<Account, string>(Account.hash_func, Account.equals_func);
-        public HashMap<Account, bool> jmi_video = new HashMap<Account, bool>(Account.hash_func, Account.equals_func);
-
-        private HashMap<Call, bool> counterpart_sends_video = new HashMap<Call, bool>(Call.hash_func, Call.equals_func);
-        private HashMap<Call, bool> we_should_send_video = new HashMap<Call, bool>(Call.hash_func, Call.equals_func);
-        private HashMap<Call, bool> we_should_send_audio = new HashMap<Call, bool>(Call.hash_func, Call.equals_func);
-
-        private HashMap<Call, Xep.JingleRtp.Parameters> audio_content_parameter = new HashMap<Call, Xep.JingleRtp.Parameters>(Call.hash_func, Call.equals_func);
-        private HashMap<Call, Xep.JingleRtp.Parameters> video_content_parameter = new HashMap<Call, Xep.JingleRtp.Parameters>(Call.hash_func, Call.equals_func);
-        private HashMap<Call, Xep.Jingle.Content> audio_content = new HashMap<Call, Xep.Jingle.Content>(Call.hash_func, Call.equals_func);
-        private HashMap<Call, Xep.Jingle.Content> video_content = new HashMap<Call, Xep.Jingle.Content>(Call.hash_func, Call.equals_func);
-        private HashMap<Call, HashMap<string, Xep.Jingle.ContentEncryption>> video_encryptions = new HashMap<Call, HashMap<string, Xep.Jingle.ContentEncryption>>(Call.hash_func, Call.equals_func);
-        private HashMap<Call, HashMap<string, Xep.Jingle.ContentEncryption>> audio_encryptions = new HashMap<Call, HashMap<string, Xep.Jingle.ContentEncryption>>(Call.hash_func, Call.equals_func);
+        public HashMap<Account, CallState> current_jmi_request_call = new HashMap<Account, CallState>(Account.hash_func, Account.equals_func);
+        public HashMap<Account, PeerState> current_jmi_request_peer = new HashMap<Account, PeerState>(Account.hash_func, Account.equals_func);
+        public HashMap<Call, CallState> call_states = new HashMap<Call, CallState>(Call.hash_func, Call.equals_func);
 
         public static void start(StreamInteractor stream_interactor, Database db) {
             Calls m = new Calls(stream_interactor, db);
@@ -55,210 +35,35 @@ namespace Dino {
             stream_interactor.account_added.connect(on_account_added);
         }
 
-        public Xep.JingleRtp.Stream? get_video_stream(Call call) {
-            if (video_content_parameter.has_key(call)) {
-                return video_content_parameter[call].stream;
-            }
-            return null;
-        }
-
-        public Xep.JingleRtp.Stream? get_audio_stream(Call call) {
-            if (audio_content_parameter.has_key(call)) {
-                return audio_content_parameter[call].stream;
-            }
-            return null;
-        }
-
-        public async Call? initiate_call(Conversation conversation, bool video) {
+        public async CallState? initiate_call(Conversation conversation, bool video) {
             Call call = new Call();
             call.direction = Call.DIRECTION_OUTGOING;
             call.account = conversation.account;
-            call.counterpart = conversation.counterpart;
+            call.add_peer(conversation.counterpart);
             call.ourpart = conversation.account.full_jid;
             call.time = call.local_time = call.end_time = new DateTime.now_utc();
             call.state = Call.State.RINGING;
 
             stream_interactor.get_module(CallStore.IDENTITY).add_call(call, conversation);
 
-            we_should_send_video[call] = video;
-            we_should_send_audio[call] = true;
-
-            Gee.List<Jid> call_resources = yield get_call_resources(conversation);
-
-            bool do_jmi = false;
-            Jid? jid_for_direct = null;
-            if (yield contains_jmi_resources(conversation.account, call_resources)) {
-                do_jmi = true;
-            } else if (!call_resources.is_empty) {
-                jid_for_direct = call_resources[0];
-            } else if (has_jmi_resources(conversation)) {
-                do_jmi = true;
-            }
-
-            if (do_jmi) {
-                XmppStream? stream = stream_interactor.get_stream(conversation.account);
-                jmi_call[conversation.account] = call;
-                jmi_video[conversation.account] = video;
-                jmi_sid[conversation.account] = Xmpp.random_uuid();
-
-                call_by_sid[call.account][jmi_sid[conversation.account]] = call;
+            var call_state = new CallState(call, stream_interactor);
+            call_state.we_should_send_video = video;
+            call_state.we_should_send_audio = true;
+            connect_call_state_signals(call_state);
+            PeerState peer_state = call_state.set_first_peer(conversation.counterpart);
 
-                var descriptions = new ArrayList<StanzaNode>();
-                descriptions.add(new StanzaNode.build("description", Xep.JingleRtp.NS_URI).add_self_xmlns().put_attribute("media", "audio"));
-                if (video) {
-                    descriptions.add(new StanzaNode.build("description", Xep.JingleRtp.NS_URI).add_self_xmlns().put_attribute("media", "video"));
-                }
-
-                stream.get_module(Xmpp.Xep.JingleMessageInitiation.Module.IDENTITY).send_session_propose_to_peer(stream, conversation.counterpart, jmi_sid[call.account], descriptions);
-            } else if (jid_for_direct != null) {
-                yield call_resource(conversation.account, jid_for_direct, call, video);
-            }
+            yield peer_state.initiate_call(conversation.counterpart);
 
             conversation.last_active = call.time;
-            call_outgoing(call, conversation);
-
-            return call;
-        }
-
-        private async void call_resource(Account account, Jid full_jid, Call call, bool video, string? sid = null) {
-            XmppStream? stream = stream_interactor.get_stream(account);
-            if (stream == null) return;
-
-            try {
-                Xep.Jingle.Session session = yield stream.get_module(Xep.JingleRtp.Module.IDENTITY).start_call(stream, full_jid, video, sid);
-                sessions[call] = session;
-                sid_by_call[call.account][call] = session.sid;
-
-                connect_session_signals(call, session);
-            } catch (Error e) {
-                warning("Failed to start call: %s", e.message);
-            }
-        }
-
-        public void end_call(Conversation conversation, Call call) {
-            XmppStream? stream = stream_interactor.get_stream(call.account);
-            if (stream == null) return;
-
-            if (call.state == Call.State.IN_PROGRESS || call.state == Call.State.ESTABLISHING) {
-                sessions[call].terminate(Xep.Jingle.ReasonElement.SUCCESS, null, "success");
-                call.state = Call.State.ENDED;
-            } else if (call.state == Call.State.RINGING) {
-                if (sessions.has_key(call)) {
-                    sessions[call].terminate(Xep.Jingle.ReasonElement.CANCEL, null, "cancel");
-                } else {
-                    // Only a JMI so far
-                    stream.get_module(Xep.JingleMessageInitiation.Module.IDENTITY).send_session_retract_to_peer(stream, call.counterpart, jmi_sid[call.account]);
-                }
-                call.state = Call.State.MISSED;
-            } else {
-                return;
-            }
-
-            call.end_time = new DateTime.now_utc();
-
-            remove_call_from_datastructures(call);
-        }
-
-        public void accept_call(Call call) {
-            call.state = Call.State.ESTABLISHING;
-
-            if (sessions.has_key(call)) {
-                foreach (Xep.Jingle.Content content in sessions[call].contents) {
-                    content.accept();
-                }
-            } else {
-                // Only a JMI so far
-                Account account = call.account;
-                string sid = sid_by_call[call.account][call];
-                XmppStream stream = stream_interactor.get_stream(account);
-                if (stream == null) return;
-
-                jmi_call[account] = call;
-                jmi_sid[account] = sid;
-                jmi_video[account] = we_should_send_video[call];
-
-                stream.get_module(Xep.JingleMessageInitiation.Module.IDENTITY).send_session_accept_to_self(stream, sid);
-                stream.get_module(Xep.JingleMessageInitiation.Module.IDENTITY).send_session_proceed_to_peer(stream, call.counterpart, sid);
-            }
-        }
-
-        public void reject_call(Call call) {
-            call.state = Call.State.DECLINED;
-
-            if (sessions.has_key(call)) {
-                foreach (Xep.Jingle.Content content in sessions[call].contents) {
-                    content.reject();
-                }
-                remove_call_from_datastructures(call);
-            } else {
-                // Only a JMI so far
-                XmppStream stream = stream_interactor.get_stream(call.account);
-                if (stream == null) return;
-
-                string sid = sid_by_call[call.account][call];
-                stream.get_module(Xep.JingleMessageInitiation.Module.IDENTITY).send_session_reject_to_peer(stream, call.counterpart, sid);
-                stream.get_module(Xep.JingleMessageInitiation.Module.IDENTITY).send_session_reject_to_self(stream, sid);
-                remove_call_from_datastructures(call);
-            }
-        }
-
-        public void mute_own_audio(Call call, bool mute) {
-            we_should_send_audio[call] = !mute;
-
-            Xep.JingleRtp.Stream stream = audio_content_parameter[call].stream;
-            // The user might mute audio before a feed was created. The feed will be muted as soon as it has been created.
-            if (stream == null) return;
-
-            // Inform our counterpart that we (un)muted our audio
-            stream_interactor.module_manager.get_module(call.account, Xep.JingleRtp.Module.IDENTITY).session_info_type.send_mute(sessions[call], mute, "audio");
-
-            // Start/Stop sending audio data
-            Application.get_default().plugin_registry.video_call_plugin.set_pause(stream, mute);
-        }
-
-        public void mute_own_video(Call call, bool mute) {
-            we_should_send_video[call] = !mute;
-
-            if (!sessions.has_key(call)) {
-                // Call hasn't been established yet
-                return;
-            }
-
-            Xep.JingleRtp.Module rtp_module = stream_interactor.module_manager.get_module(call.account, Xep.JingleRtp.Module.IDENTITY);
 
-            if (video_content_parameter.has_key(call) &&
-                    video_content_parameter[call].stream != null &&
-                    sessions[call].senders_include_us(video_content[call].senders)) {
-                // A video feed has already been established
+            call_outgoing(call, call_state, conversation);
 
-                // Start/Stop sending video data
-                Xep.JingleRtp.Stream stream = video_content_parameter[call].stream;
-                if (stream != null) {
-                    // TODO maybe the user muted video before the feed was created...
-                    Application.get_default().plugin_registry.video_call_plugin.set_pause(stream, mute);
-                }
-
-                // Inform our counterpart that we started/stopped our video
-                rtp_module.session_info_type.send_mute(sessions[call], mute, "video");
-            } else if (!mute) {
-                // Need to start a new video feed
-                XmppStream stream = stream_interactor.get_stream(call.account);
-                rtp_module.add_outgoing_video_content.begin(stream, sessions[call], (_, res) => {
-                    if (video_content_parameter[call] == null) {
-                        Xep.Jingle.Content content = rtp_module.add_outgoing_video_content.end(res);
-                        Xep.JingleRtp.Parameters? rtp_content_parameter = content.content_params as Xep.JingleRtp.Parameters;
-                        if (rtp_content_parameter != null) {
-                            connect_content_signals(call, content, rtp_content_parameter);
-                        }
-                    }
-                });
-            }
-            // If video_feed == null && !mute we're trying to mute a non-existant feed. It will be muted as soon as it is created.
+            return call_state;
         }
 
         public async bool can_do_audio_calls_async(Conversation conversation) {
             if (!can_do_audio_calls()) return false;
-            return (yield get_call_resources(conversation)).size > 0 || has_jmi_resources(conversation);
+            return (yield get_call_resources(conversation.account, conversation.counterpart)).size > 0 || has_jmi_resources(conversation.counterpart);
         }
 
         private bool can_do_audio_calls() {
@@ -270,7 +75,7 @@ namespace Dino {
 
         public async bool can_do_video_calls_async(Conversation conversation) {
             if (!can_do_video_calls()) return false;
-            return (yield get_call_resources(conversation)).size > 0 || has_jmi_resources(conversation);
+            return (yield get_call_resources(conversation.account, conversation.counterpart)).size > 0 || has_jmi_resources(conversation.counterpart);
         }
 
         private bool can_do_video_calls() {
@@ -280,13 +85,13 @@ namespace Dino {
             return plugin.supports("video");
         }
 
-        private async Gee.List<Jid> get_call_resources(Conversation conversation) {
+        public async Gee.List<Jid> get_call_resources(Account account, Jid counterpart) {
             ArrayList<Jid> ret = new ArrayList<Jid>();
 
-            XmppStream? stream = stream_interactor.get_stream(conversation.account);
+            XmppStream? stream = stream_interactor.get_stream(account);
             if (stream == null) return ret;
 
-            Gee.List<Jid>? full_jids = stream.get_flag(Presence.Flag.IDENTITY).get_resources(conversation.counterpart);
+            Gee.List<Jid>? full_jids = stream.get_flag(Presence.Flag.IDENTITY).get_resources(counterpart);
             if (full_jids == null) return ret;
 
             foreach (Jid full_jid in full_jids) {
@@ -297,7 +102,7 @@ namespace Dino {
             return ret;
         }
 
-        private async bool contains_jmi_resources(Account account, Gee.List<Jid> full_jids) {
+        public async bool contains_jmi_resources(Account account, Gee.List<Jid> full_jids) {
             XmppStream? stream = stream_interactor.get_stream(account);
             if (stream == null) return false;
 
@@ -308,26 +113,22 @@ namespace Dino {
             return false;
         }
 
-        private bool has_jmi_resources(Conversation conversation) {
+        public bool has_jmi_resources(Jid counterpart) {
             int64 jmi_resources = db.entity.select()
-                    .with(db.entity.jid_id, "=", db.get_jid_id(conversation.counterpart))
+                    .with(db.entity.jid_id, "=", db.get_jid_id(counterpart))
                     .join_with(db.entity_feature, db.entity.caps_hash, db.entity_feature.entity)
                     .with(db.entity_feature.feature, "=", Xep.JingleMessageInitiation.NS_URI)
                     .count();
             return jmi_resources > 0;
         }
 
-        public bool should_we_send_video(Call call) {
-            return we_should_send_video[call];
-        }
-
-        public Jid? is_call_in_progress() {
-            foreach (Call call in sessions.keys) {
+        public bool is_call_in_progress() {
+            foreach (Call call in call_states.keys) {
                 if (call.state == Call.State.IN_PROGRESS || call.state == Call.State.RINGING || call.state == Call.State.ESTABLISHING) {
-                    return call.counterpart;
+                    return true;
                 }
             }
-            return null;
+            return false;
         }
 
         private void on_incoming_call(Account account, Xep.Jingle.Session session) {
@@ -336,265 +137,168 @@ namespace Dino {
                 return;
             }
 
+            Jid? muji_muc = null;
             bool counterpart_wants_video = false;
             foreach (Xep.Jingle.Content content in session.contents) {
                 Xep.JingleRtp.Parameters? rtp_content_parameter = content.content_params as Xep.JingleRtp.Parameters;
                 if (rtp_content_parameter == null) continue;
+                muji_muc = rtp_content_parameter.muji_muc;
                 if (rtp_content_parameter.media == "video" && session.senders_include_us(content.senders)) {
                     counterpart_wants_video = true;
                 }
             }
 
-            // Session might have already been accepted via Jingle Message Initiation
-            bool already_accepted = jmi_sid.has_key(account) &&
-                    jmi_sid[account] == session.sid && jmi_call[account].account.equals(account) &&
-                    jmi_call[account].counterpart.equals_bare(session.peer_full_jid) &&
-                    jmi_video[account] == counterpart_wants_video;
-
-            Call? call = null;
-            if (already_accepted) {
-                call = jmi_call[account];
-            } else {
-                call = create_received_call(account, session.peer_full_jid, account.full_jid, counterpart_wants_video);
+            // Check if this comes from a MUJI MUC => accept
+            if (muji_muc != null) {
+                debug("[%s] Incoming call from %s from MUJI muc %s", account.bare_jid.to_string(), session.peer_full_jid.to_string(), muji_muc.to_string());
+
+                foreach (CallState call_state in call_states.values) {
+                    if (call_state.group_call != null && call_state.group_call.muc_jid.equals(muji_muc)) {
+                        if (call_state.peers.keys.contains(session.peer_full_jid)) {
+                            PeerState peer_state = call_state.peers[session.peer_full_jid];
+                            debug("[%s] Incoming call, we know the peer. Expected %b", account.bare_jid.to_string(), peer_state.waiting_for_inbound_muji_connection);
+                            if (!peer_state.waiting_for_inbound_muji_connection) return;
+
+                            peer_state.set_session(session);
+                            debug(@"[%s] Accepting incoming MUJI call from %s", account.bare_jid.to_string(), session.peer_full_jid.to_string());
+                            peer_state.accept();
+                        } else {
+                            debug(@"[%s] Incoming call, but didn't see peer in MUC yet", account.bare_jid.to_string());
+                            PeerState peer_state = new PeerState(session.peer_full_jid, call_state.call, stream_interactor);
+                            peer_state.set_session(session);
+                            call_state.add_peer(peer_state);
+                        }
+                        return;
+                    }
+                }
+                return;
             }
-            sessions[call] = session;
 
-            call_by_sid[account][session.sid] = call;
-            sid_by_call[account][call] = session.sid;
+            debug(@"[%s] Incoming call from %s", account.bare_jid.to_string(), session.peer_full_jid.to_string());
 
-            connect_session_signals(call, session);
+            // Check if we already accepted this call via Jingle Message Initiation => accept
+            if (current_jmi_request_call.has_key(account) &&
+                    current_jmi_request_peer[account].sid == session.sid &&
+                    current_jmi_request_peer[account].we_should_send_video == counterpart_wants_video &&
+                    current_jmi_request_peer[account].accepted_jmi) {
+                current_jmi_request_peer[account].set_session(session);
+                current_jmi_request_call[account].accept();
 
-            if (already_accepted) {
-                accept_call(call);
-            } else {
-                stream_interactor.module_manager.get_module(account, Xep.JingleRtp.Module.IDENTITY).session_info_type.send_ringing(session);
+                current_jmi_request_peer.unset(account);
+                current_jmi_request_call.unset(account);
+                return;
             }
+
+            // This is a direct call without prior JMI. Ask user.
+            PeerState peer_state = create_received_call(account, session.peer_full_jid, account.full_jid, counterpart_wants_video);
+            peer_state.set_session(session);
+            stream_interactor.module_manager.get_module(account, Xep.JingleRtp.Module.IDENTITY).session_info_type.send_ringing(session);
         }
 
-        private Call create_received_call(Account account, Jid from, Jid to, bool video_requested) {
+        private PeerState create_received_call(Account account, Jid from, Jid to, bool video_requested) {
             Call call = new Call();
+            Jid counterpart = null;
             if (from.equals_bare(account.bare_jid)) {
                 // Call requested by another of our devices
                 call.direction = Call.DIRECTION_OUTGOING;
                 call.ourpart = from;
-                call.counterpart = to;
+                counterpart = to;
             } else {
                 call.direction = Call.DIRECTION_INCOMING;
                 call.ourpart = account.full_jid;
-                call.counterpart = from;
+                counterpart = from;
             }
+            call.add_peer(counterpart);
             call.account = account;
             call.time = call.local_time = call.end_time = new DateTime.now_utc();
             call.state = Call.State.RINGING;
 
-            Conversation conversation = stream_interactor.get_module(ConversationManager.IDENTITY).create_conversation(call.counterpart.bare_jid, account, Conversation.Type.CHAT);
+            Conversation conversation = stream_interactor.get_module(ConversationManager.IDENTITY).create_conversation(counterpart.bare_jid, account, Conversation.Type.CHAT);
 
             stream_interactor.get_module(CallStore.IDENTITY).add_call(call, conversation);
 
             conversation.last_active = call.time;
 
-            we_should_send_video[call] = video_requested;
-            we_should_send_audio[call] = true;
+            var call_state = new CallState(call, stream_interactor);
+            connect_call_state_signals(call_state);
+            PeerState peer_state = call_state.set_first_peer(counterpart);
+            call_state.we_should_send_video = video_requested;
+            call_state.we_should_send_audio = true;
 
             if (call.direction == Call.DIRECTION_INCOMING) {
-                call_incoming(call, conversation, video_requested);
+                call_incoming(call, call_state, conversation, video_requested);
             } else {
-                call_outgoing(call, conversation);
+                call_outgoing(call, call_state, conversation);
             }
 
-            return call;
+            return peer_state;
         }
 
-        private void on_incoming_content_add(XmppStream stream, Call call, Xep.Jingle.Session session, Xep.Jingle.Content content) {
-            Xep.JingleRtp.Parameters? rtp_content_parameter = content.content_params as Xep.JingleRtp.Parameters;
-
-            if (rtp_content_parameter == null) {
-                content.reject();
-                return;
-            }
-
-            // Our peer shouldn't tell us to start sending, that's for us to initiate
-            if (session.senders_include_us(content.senders)) {
-                if (session.senders_include_counterpart(content.senders)) {
-                    // If our peer wants to send, let them
-                    content.modify(session.we_initiated ? Xep.Jingle.Senders.RESPONDER : Xep.Jingle.Senders.INITIATOR);
-                } else {
-                    // If only we're supposed to send, reject
-                    content.reject();
+        private CallState? get_call_state_for_groupcall(Account account, Jid muc_jid) {
+            foreach (CallState call_state in call_states.values) {
+                if (call_state.group_call != null && call_state.call.account.equals(account) && call_state.group_call.muc_jid.equals(muc_jid)) {
+                    return call_state;
                 }
             }
-
-            connect_content_signals(call, content, rtp_content_parameter);
-            content.accept();
+            return null;
         }
 
-        private void on_call_terminated(Call call, bool we_terminated, string? reason_name, string? reason_text) {
-            if (call.state == Call.State.RINGING || call.state == Call.State.IN_PROGRESS || call.state == Call.State.ESTABLISHING) {
-                call.end_time = new DateTime.now_utc();
-            }
-            if (call.state == Call.State.IN_PROGRESS) {
-                call.state = Call.State.ENDED;
-            } else if (call.state == Call.State.RINGING || call.state == Call.State.ESTABLISHING) {
-                if (reason_name == Xep.Jingle.ReasonElement.DECLINE) {
-                    call.state = Call.State.DECLINED;
-                } else {
-                    call.state = Call.State.FAILED;
+        private async void on_muji_call_received(Account account, Jid inviter_jid, Jid muc_jid, Gee.List<StanzaNode> descriptions) {
+            debug("[%s] on_muji_call_received", account.bare_jid.to_string());
+            foreach (Call call in call_states.keys) {
+                if (call.account.equals(account) && call.counterparts.contains(inviter_jid) && call_states[call].accepted) {
+                    // A call is converted into a group call.
+                    yield call_states[call].join_group_call(muc_jid);
+                    return;
                 }
             }
 
-            call_terminated(call, reason_name, reason_text);
-            remove_call_from_datastructures(call);
-        }
+            bool audio_requested = descriptions.any_match((description) => description.ns_uri == Xep.JingleRtp.NS_URI && description.get_attribute("media") == "audio");
+            bool video_requested = descriptions.any_match((description) => description.ns_uri == Xep.JingleRtp.NS_URI && description.get_attribute("media") == "video");
 
-        private void on_stream_created(Call call, string media, Xep.JingleRtp.Stream stream) {
-            if (media == "video" && stream.receiving) {
-                counterpart_sends_video[call] = true;
-                video_content_parameter[call].connection_ready.connect((status) => {
-                    counterpart_sends_video_updated(call, false);
-                });
-            }
-            stream_created(call, media);
+            Call call = new Call();
+            call.direction = Call.DIRECTION_INCOMING;
+            call.ourpart = account.full_jid;
+            call.add_peer(inviter_jid); // not rly
+            call.account = account;
+            call.time = call.local_time = call.end_time = new DateTime.now_utc();
+            call.state = Call.State.RINGING;
 
-            // Outgoing audio/video might have been muted in the meanwhile.
-            if (media == "video" && !we_should_send_video[call]) {
-                mute_own_video(call, true);
-            } else if (media == "audio" && !we_should_send_audio[call]) {
-                mute_own_audio(call, true);
-            }
-        }
+            Conversation? conversation = stream_interactor.get_module(ConversationManager.IDENTITY).get_conversation(inviter_jid.bare_jid, account);
+            stream_interactor.get_module(CallStore.IDENTITY).add_call(call, conversation);
+            conversation.last_active = call.time;
 
-        private void on_counterpart_mute_update(Call call, bool mute, string? media) {
-            if (!call.equals(call)) return;
+            CallState call_state = new CallState(call, stream_interactor);
+            connect_call_state_signals(call_state);
+            call_state.we_should_send_audio = true;
+            call_state.we_should_send_video = video_requested;
+            call_state.invited_to_group_call = muc_jid;
+            call_state.group_call_inviter = inviter_jid;
 
-            if (media == "video") {
-                counterpart_sends_video[call] = !mute;
-                counterpart_sends_video_updated(call, mute);
-            }
+            debug("[%s] on_muji_call_received accepting", account.bare_jid.to_string());
+            call_incoming(call_state.call, call_state, conversation, video_requested);
         }
 
-        private void connect_session_signals(Call call, Xep.Jingle.Session session) {
-            session.terminated.connect((stream, we_terminated, reason_name, reason_text) =>
-                on_call_terminated(call, we_terminated, reason_name, reason_text)
-            );
-            session.additional_content_add_incoming.connect((session,stream, content) =>
-                on_incoming_content_add(stream, call, session, content)
-            );
-
-            foreach (Xep.Jingle.Content content in session.contents) {
-                Xep.JingleRtp.Parameters? rtp_content_parameter = content.content_params as Xep.JingleRtp.Parameters;
-                if (rtp_content_parameter == null) continue;
-
-                connect_content_signals(call, content, rtp_content_parameter);
+        private void remove_call_from_datastructures(Call call) {
+            if (current_jmi_request_call.has_key(call.account) && current_jmi_request_call[call.account].call.equals(call)) {
+                current_jmi_request_call.unset(call.account);
+                current_jmi_request_peer.unset(call.account);
             }
+            call_states.unset(call);
         }
 
-        private void connect_content_signals(Call call, Xep.Jingle.Content content, Xep.JingleRtp.Parameters rtp_content_parameter) {
-            if (rtp_content_parameter.media == "audio") {
-                audio_content[call] = content;
-                audio_content_parameter[call] = rtp_content_parameter;
-            } else if (rtp_content_parameter.media == "video") {
-                video_content[call] = content;
-                video_content_parameter[call] = rtp_content_parameter;
-            }
-
-            rtp_content_parameter.stream_created.connect((stream) => on_stream_created(call, rtp_content_parameter.media, stream));
-            rtp_content_parameter.connection_ready.connect((status) => on_connection_ready(call, content, rtp_content_parameter.media));
-
-            content.senders_modify_incoming.connect((content, proposed_senders) => {
-                if (content.session.senders_include_us(content.senders) != content.session.senders_include_us(proposed_senders)) {
-                    warning("counterpart set us to (not)sending %s. ignoring", content.content_name);
-                    return;
-                }
+        private void connect_call_state_signals(CallState call_state) {
+            call_states[call_state.call] = call_state;
 
-                if (!content.session.senders_include_counterpart(content.senders) && content.session.senders_include_counterpart(proposed_senders)) {
-                    // Counterpart wants to start sending. Ok.
-                    content.accept_content_modify(proposed_senders);
-                    on_counterpart_mute_update(call, false, "video");
-                }
+            ulong terminated_handler_id = -1;
+            terminated_handler_id = call_state.terminated.connect((who_terminated, reason_name, reason_text) => {
+                remove_call_from_datastructures(call_state.call);
+                call_terminated(call_state.call, reason_name, reason_text);
+                call_state.disconnect(terminated_handler_id);
             });
         }
 
-        private void on_connection_ready(Call call, Xep.Jingle.Content content, string media) {
-            if (call.state == Call.State.RINGING || call.state == Call.State.ESTABLISHING) {
-                call.state = Call.State.IN_PROGRESS;
-            }
-
-            if (media == "audio") {
-                audio_encryptions[call] = content.encryptions;
-            } else if (media == "video") {
-                video_encryptions[call] = content.encryptions;
-            }
-
-            if ((audio_encryptions.has_key(call) && audio_encryptions[call].is_empty) || (video_encryptions.has_key(call) && video_encryptions[call].is_empty)) {
-                call.encryption = Encryption.NONE;
-                encryption_updated(call, null, null, true);
-                return;
-            }
-
-            HashMap<string, Xep.Jingle.ContentEncryption> encryptions = audio_encryptions[call] ?? video_encryptions[call];
-
-            Xep.Jingle.ContentEncryption? omemo_encryption = null, dtls_encryption = null, srtp_encryption = null;
-            foreach (string encr_name in encryptions.keys) {
-                if (video_encryptions.has_key(call) && !video_encryptions[call].has_key(encr_name)) continue;
-
-                var encryption = encryptions[encr_name];
-                if (encryption.encryption_ns == "http://gultsch.de/xmpp/drafts/omemo/dlts-srtp-verification") {
-                    omemo_encryption = encryption;
-                } else if (encryption.encryption_ns == Xep.JingleIceUdp.DTLS_NS_URI) {
-                    dtls_encryption = encryption;
-                } else if (encryption.encryption_name == "SRTP") {
-                    srtp_encryption = encryption;
-                }
-            }
-
-            if (omemo_encryption != null && dtls_encryption != null) {
-                call.encryption = Encryption.OMEMO;
-                Xep.Jingle.ContentEncryption? video_encryption = video_encryptions.has_key(call) ? video_encryptions[call]["http://gultsch.de/xmpp/drafts/omemo/dlts-srtp-verification"] : null;
-                omemo_encryption.peer_key = dtls_encryption.peer_key;
-                omemo_encryption.our_key = dtls_encryption.our_key;
-                encryption_updated(call, omemo_encryption, video_encryption, true);
-            } else if (dtls_encryption != null) {
-                call.encryption = Encryption.DTLS_SRTP;
-                Xep.Jingle.ContentEncryption? video_encryption = video_encryptions.has_key(call) ? video_encryptions[call][Xep.JingleIceUdp.DTLS_NS_URI] : null;
-                bool same = true;
-                if (video_encryption != null && dtls_encryption.peer_key.length == video_encryption.peer_key.length) {
-                    for (int i = 0; i < dtls_encryption.peer_key.length; i++) {
-                        if (dtls_encryption.peer_key[i] != video_encryption.peer_key[i]) { same = false; break; }
-                    }
-                }
-                encryption_updated(call, dtls_encryption, video_encryption, same);
-            } else if (srtp_encryption != null) {
-                call.encryption = Encryption.SRTP;
-                encryption_updated(call, srtp_encryption, video_encryptions[call]["SRTP"], false);
-            } else {
-                call.encryption = Encryption.NONE;
-                encryption_updated(call, null, null, true);
-            }
-        }
-
-        private void remove_call_from_datastructures(Call call) {
-            string? sid = sid_by_call[call.account][call];
-            sid_by_call[call.account].unset(call);
-            if (sid != null) call_by_sid[call.account].unset(sid);
-
-            sessions.unset(call);
-
-            counterpart_sends_video.unset(call);
-            we_should_send_video.unset(call);
-            we_should_send_audio.unset(call);
-
-            audio_content_parameter.unset(call);
-            video_content_parameter.unset(call);
-            audio_content.unset(call);
-            video_content.unset(call);
-            audio_encryptions.unset(call);
-            video_encryptions.unset(call);
-        }
-
         private void on_account_added(Account account) {
-            call_by_sid[account] = new HashMap<string, Call>();
-            sid_by_call[account] = new HashMap<Call, string>();
-
             Xep.Jingle.Module jingle_module = stream_interactor.module_manager.get_module(account, Xep.Jingle.Module.IDENTITY);
             jingle_module.session_initiate_received.connect((stream, session) => {
                 foreach (Xep.Jingle.Content content in session.contents) {
@@ -606,27 +310,6 @@ namespace Dino {
                 }
             });
 
-            var session_info_type = stream_interactor.module_manager.get_module(account, Xep.JingleRtp.Module.IDENTITY).session_info_type;
-            session_info_type.mute_update_received.connect((session,mute, name) => {
-                if (!call_by_sid[account].has_key(session.sid)) return;
-                Call call = call_by_sid[account][session.sid];
-
-                foreach (Xep.Jingle.Content content in session.contents) {
-                    if (name == null || content.content_name == name) {
-                        Xep.JingleRtp.Parameters? rtp_content_parameter = content.content_params as Xep.JingleRtp.Parameters;
-                        if (rtp_content_parameter != null) {
-                            on_counterpart_mute_update(call, mute, rtp_content_parameter.media);
-                        }
-                    }
-                }
-            });
-            session_info_type.info_received.connect((session, session_info) => {
-                if (!call_by_sid[account].has_key(session.sid)) return;
-                Call call = call_by_sid[account][session.sid];
-
-                info_received(call, session_info);
-            });
-
             Xep.JingleMessageInitiation.Module mi_module = stream_interactor.module_manager.get_module(account, Xep.JingleMessageInitiation.Module.IDENTITY);
             mi_module.session_proposed.connect((from, to, sid, descriptions) => {
                 if (!can_do_audio_calls()) {
@@ -637,53 +320,94 @@ namespace Dino {
                 bool audio_requested = descriptions.any_match((description) => description.ns_uri == Xep.JingleRtp.NS_URI && description.get_attribute("media") == "audio");
                 bool video_requested = descriptions.any_match((description) => description.ns_uri == Xep.JingleRtp.NS_URI && description.get_attribute("media") == "video");
                 if (!audio_requested && !video_requested) return;
-                Call call = create_received_call(account, from, to, video_requested);
-                call_by_sid[account][sid] = call;
-                sid_by_call[account][call] = sid;
+
+                PeerState peer_state = create_received_call(account, from, to, video_requested);
+                peer_state.sid = sid;
+                peer_state.we_should_send_audio = true;
+                peer_state.we_should_send_video = video_requested;
+
+                current_jmi_request_peer[account] = peer_state;
+                current_jmi_request_call[account] = call_states[peer_state.call];
             });
             mi_module.session_accepted.connect((from, sid) => {
-                if (!call_by_sid[account].has_key(sid)) return;
+                if (!current_jmi_request_peer.has_key(account) || current_jmi_request_peer[account].sid != sid) return;
 
                 if (from.equals_bare(account.bare_jid)) { // Carboned message from our account
                     // Ignore carbon from ourselves
                     if (from.equals(account.full_jid)) return;
 
-                    Call call = call_by_sid[account][sid];
+                    Call call = current_jmi_request_peer[account].call;
                     call.state = Call.State.OTHER_DEVICE_ACCEPTED;
                     remove_call_from_datastructures(call);
-                } else if (from.equals_bare(call_by_sid[account][sid].counterpart)) { // Message from our peer
+                } else if (from.equals_bare(current_jmi_request_peer[account].jid)) { // Message from our peer
                     // We proposed the call
-                    if (jmi_sid.has_key(account) && jmi_sid[account] == sid) {
-                        call_resource.begin(account, from, jmi_call[account], jmi_video[account], jmi_sid[account]);
-                        jmi_call.unset(account);
-                        jmi_sid.unset(account);
-                        jmi_video.unset(account);
-                    }
+                    // We know the full jid of our peer now
+                    current_jmi_request_call[account].rename_peer(current_jmi_request_peer[account].jid, from);
+                    current_jmi_request_peer[account].call_resource(from);
                 }
             });
             mi_module.session_rejected.connect((from, to, sid) => {
-                if (!call_by_sid[account].has_key(sid)) return;
-                Call call = call_by_sid[account][sid];
+                if (!current_jmi_request_peer.has_key(account) || current_jmi_request_peer[account].sid != sid) return;
+                Call call = current_jmi_request_peer[account].call;
 
-                bool outgoing_reject = call.direction == Call.DIRECTION_OUTGOING && from.equals_bare(call.counterpart);
+                bool outgoing_reject = call.direction == Call.DIRECTION_OUTGOING && from.equals_bare(call.counterparts[0]);
                 bool incoming_reject = call.direction == Call.DIRECTION_INCOMING && from.equals_bare(account.bare_jid);
-                if (!(outgoing_reject || incoming_reject)) return;
+                if (!outgoing_reject && !incoming_reject) return;
 
                 call.state = Call.State.DECLINED;
+                call_states[call].terminated(from, Xep.Jingle.ReasonElement.DECLINE, "JMI reject");
                 remove_call_from_datastructures(call);
-                call_terminated(call, null, null);
             });
             mi_module.session_retracted.connect((from, to, sid) => {
-                if (!call_by_sid[account].has_key(sid)) return;
-                Call call = call_by_sid[account][sid];
+                if (!current_jmi_request_peer.has_key(account) || current_jmi_request_peer[account].sid != sid) return;
+                Call call = current_jmi_request_peer[account].call;
 
-                bool outgoing_retract = call.direction == Call.DIRECTION_OUTGOING && from.equals_bare(call.counterpart);
-                bool incoming_retract = call.direction == Call.DIRECTION_INCOMING && from.equals_bare(account.bare_jid);
+                bool outgoing_retract = call.direction == Call.DIRECTION_OUTGOING && from.equals_bare(account.bare_jid);
+                bool incoming_retract = call.direction == Call.DIRECTION_INCOMING && from.equals_bare(call.counterparts[0]);
                 if (!(outgoing_retract || incoming_retract)) return;
 
                 call.state = Call.State.MISSED;
+                call_states[call].terminated(from, Xep.Jingle.ReasonElement.CANCEL, "JMI retract");
                 remove_call_from_datastructures(call);
-                call_terminated(call, null, null);
+            });
+
+            Xep.MujiMeta.Module muji_meta_module = stream_interactor.module_manager.get_module(account, Xep.MujiMeta.Module.IDENTITY);
+            muji_meta_module.call_proposed.connect((inviter_jid, to, muc_jid, descriptions) => {
+                if (inviter_jid.equals_bare(account.bare_jid)) return;
+                on_muji_call_received.begin(account, inviter_jid, muc_jid, descriptions);
+            });
+            muji_meta_module.call_accepted.connect((from_jid, muc_jid) => {
+                if (!from_jid.equals_bare(account.bare_jid)) return;
+
+                // We accepted the call from another device
+                CallState? call_state = get_call_state_for_groupcall(account, muc_jid);
+                if (call_state == null) return;
+
+                call_state.call.state = Call.State.OTHER_DEVICE_ACCEPTED;
+                remove_call_from_datastructures(call_state.call);
+            });
+            muji_meta_module.call_retracted.connect((from_jid, muc_jid) => {
+                if (from_jid.equals_bare(account.bare_jid)) return;
+
+                // The call was retracted by the counterpart
+                CallState? call_state = get_call_state_for_groupcall(account, muc_jid);
+                if (call_state == null) return;
+
+                call_state.call.state = Call.State.MISSED;
+                remove_call_from_datastructures(call_state.call);
+            });
+            muji_meta_module.call_rejected.connect((from_jid, to_jid, muc_jid) => {
+                if (from_jid.equals_bare(account.bare_jid)) return;
+                debug(@"[%s] rejected our MUJI invite to %s", account.bare_jid.to_string(), from_jid.to_string(), muc_jid.to_string());
+            });
+
+            stream_interactor.module_manager.get_module(account, Xep.Coin.Module.IDENTITY).coin_info_received.connect((jid, info) => {
+                foreach (Call call in call_states.keys) {
+                    if (call.counterparts[0].equals_bare(jid)) {
+                        conference_info_received(call, info);
+                        return;
+                    }
+                }
             });
         }
     }
diff --git a/libdino/src/service/connection_manager.vala b/libdino/src/service/connection_manager.vala
index 0eb6a6f5..d114b9ae 100644
--- a/libdino/src/service/connection_manager.vala
+++ b/libdino/src/service/connection_manager.vala
@@ -228,6 +228,8 @@ public class ConnectionManager : Object {
         stream.attached_modules.connect((stream) => {
             stream_attached_modules(account, stream);
             change_connection_state(account, ConnectionState.CONNECTED);
+
+//            stream.get_module(Xep.Muji.Module.IDENTITY).join_call(stream, new Jid("test@muc.poez.io"), true);
         });
         stream.get_module(Sasl.Module.IDENTITY).received_auth_failure.connect((stream, node) => {
             set_connection_error(account, new ConnectionError(ConnectionError.Source.SASL, null));
diff --git a/libdino/src/service/content_item_store.vala b/libdino/src/service/content_item_store.vala
index ddb6571a..e0102d24 100644
--- a/libdino/src/service/content_item_store.vala
+++ b/libdino/src/service/content_item_store.vala
@@ -186,7 +186,7 @@ public class ContentItemStore : StreamInteractionModule, Object {
         }
     }
 
-    private void insert_call(Call call, Conversation conversation) {
+    private void insert_call(Call call, CallState call_state, Conversation conversation) {
         CallItem item = new CallItem(call, conversation, -1);
         item.id = db.add_content_item(conversation, call.time, call.local_time, 3, call.id, false);
         if (collection_conversations.has_key(conversation)) {
@@ -321,7 +321,7 @@ public class CallItem : ContentItem {
     public Conversation conversation;
 
     public CallItem(Call call, Conversation conversation, int id) {
-        base(id, TYPE, call.from, call.time, call.encryption, Message.Marked.NONE);
+        base(id, TYPE, call.direction == Call.DIRECTION_OUTGOING ? conversation.account.bare_jid : conversation.counterpart, call.time, call.encryption, Message.Marked.NONE);
 
         this.call = call;
         this.conversation = conversation;
diff --git a/libdino/src/service/database.vala b/libdino/src/service/database.vala
index dab32749..0300112a 100644
--- a/libdino/src/service/database.vala
+++ b/libdino/src/service/database.vala
@@ -7,7 +7,7 @@ using Dino.Entities;
 namespace Dino {
 
 public class Database : Qlite.Database {
-    private const int VERSION = 21;
+    private const int VERSION = 22;
 
     public class AccountTable : Table {
         public Column<int> id = new Column.Integer("id") { primary_key = true, auto_increment = true };
@@ -174,6 +174,19 @@ public class Database : Qlite.Database {
         }
     }
 
+    public class CallCounterpartTable : Table {
+        public Column<int> id = new Column.Integer("id") { primary_key = true, auto_increment = true };
+        public Column<int> call_id = new Column.Integer("call_id") { not_null = true };
+        public Column<int> jid_id = new Column.Integer("jid_id") { not_null = true };
+        public Column<string> resource = new Column.Text("resource");
+
+        internal CallCounterpartTable(Database db) {
+            base(db, "call_counterpart");
+            init({call_id, jid_id, resource});
+            index("call_counterpart_call_jid_idx", {call_id});
+        }
+    }
+
     public class ConversationTable : Table {
         public Column<int> id = new Column.Integer("id") { primary_key = true, auto_increment = true };
         public Column<int> account_id = new Column.Integer("account_id") { not_null = true };
@@ -295,6 +308,7 @@ public class Database : Qlite.Database {
     public RealJidTable real_jid { get; private set; }
     public FileTransferTable file_transfer { get; private set; }
     public CallTable call { get; private set; }
+    public CallCounterpartTable call_counterpart { get; private set; }
     public ConversationTable conversation { get; private set; }
     public AvatarTable avatar { get; private set; }
     public EntityIdentityTable entity_identity { get; private set; }
@@ -319,6 +333,7 @@ public class Database : Qlite.Database {
         real_jid = new RealJidTable(this);
         file_transfer = new FileTransferTable(this);
         call = new CallTable(this);
+        call_counterpart = new CallCounterpartTable(this);
         conversation = new ConversationTable(this);
         avatar = new AvatarTable(this);
         entity_identity = new EntityIdentityTable(this);
@@ -327,7 +342,7 @@ public class Database : Qlite.Database {
         mam_catchup = new MamCatchupTable(this);
         settings = new SettingsTable(this);
         conversation_settings = new ConversationSettingsTable(this);
-        init({ account, jid, entity, content_item, message, message_correction, real_jid, file_transfer, call, conversation, avatar, entity_identity, entity_feature, roster, mam_catchup, settings, conversation_settings });
+        init({ account, jid, entity, content_item, message, message_correction, real_jid, file_transfer, call, call_counterpart, conversation, avatar, entity_identity, entity_feature, roster, mam_catchup, settings, conversation_settings });
 
         try {
             exec("PRAGMA journal_mode = WAL");
@@ -446,6 +461,19 @@ public class Database : Qlite.Database {
                 error("Failed to upgrade to database version 18: %s", e.message);
             }
         }
+        if (oldVersion < 22) {
+            try {
+                exec("INSERT INTO call_counterpart (call_id, jid_id, resource) SELECT id, counterpart_id, counterpart_resource FROM call");
+            } catch (Error e) {
+                error("Failed to upgrade to database version 22: %s", e.message);
+            }
+//                exec("ALTER TABLE call RENAME TO call2");
+//                call.create_table_at_version(VERSION);
+//                exec("INSERT INTO call (id, account_id, our_resource, direction, time, local_time, end_time, encryption, state)
+//                            SELECT id, account_id, our_resource, direction, time, local_time, end_time, encryption, state
+//                            FROM call2");
+//                exec("DROP TABLE call2");
+        }
     }
 
     public ArrayList<Account> get_accounts() {
diff --git a/libdino/src/service/module_manager.vala b/libdino/src/service/module_manager.vala
index a6165392..39ed8a7c 100644
--- a/libdino/src/service/module_manager.vala
+++ b/libdino/src/service/module_manager.vala
@@ -80,6 +80,10 @@ public class ModuleManager {
             module_map[account].add(new Xep.LastMessageCorrection.Module());
             module_map[account].add(new Xep.DirectMucInvitations.Module());
             module_map[account].add(new Xep.JingleMessageInitiation.Module());
+            module_map[account].add(new Xep.JingleRawUdp.Module());
+            module_map[account].add(new Xep.Muji.Module());
+            module_map[account].add(new Xep.MujiMeta.Module());
+            module_map[account].add(new Xep.Coin.Module());
             initialize_account_modules(account, module_map[account]);
         }
     }
diff --git a/libdino/src/service/muc_manager.vala b/libdino/src/service/muc_manager.vala
index 5a224a18..8a317a08 100644
--- a/libdino/src/service/muc_manager.vala
+++ b/libdino/src/service/muc_manager.vala
@@ -27,6 +27,7 @@ public class MucManager : StreamInteractionModule, Object {
     private ReceivedMessageListener received_message_listener;
     private HashMap<Account, BookmarksProvider> bookmarks_provider = new HashMap<Account, BookmarksProvider>(Account.hash_func, Account.equals_func);
     private HashMap<Account, Gee.List<Jid>> invites = new HashMap<Account, Gee.List<Jid>>(Account.hash_func, Account.equals_func);
+    public HashMap<Account, Jid> default_muc_server = new HashMap<Account, Jid>(Account.hash_func, Account.equals_func);
 
     public static void start(StreamInteractor stream_interactor) {
         MucManager m = new MucManager(stream_interactor);
@@ -76,7 +77,7 @@ public class MucManager : StreamInteractionModule, Object {
         }
         mucs_todo[account].add(jid.with_resource(nick_));
 
-        Muc.JoinResult? res = yield stream.get_module(Xep.Muc.Module.IDENTITY).enter(stream, jid.bare_jid, nick_, password, history_since);
+        Muc.JoinResult? res = yield stream.get_module(Xep.Muc.Module.IDENTITY).enter(stream, jid.bare_jid, nick_, password, history_since, null);
 
         mucs_joining[account].remove(jid);
 
@@ -117,10 +118,10 @@ public class MucManager : StreamInteractionModule, Object {
         return yield stream.get_module(Xep.Muc.Module.IDENTITY).get_config_form(stream, jid);
     }
 
-    public void set_config_form(Account account, Jid jid, DataForms.DataForm data_form) {
+    public async void set_config_form(Account account, Jid jid, DataForms.DataForm data_form) {
         XmppStream? stream = stream_interactor.get_stream(account);
         if (stream == null) return;
-        stream.get_module(Xep.Muc.Module.IDENTITY).set_config_form(stream, jid, data_form);
+        yield stream.get_module(Xep.Muc.Module.IDENTITY).set_config_form(stream, jid, data_form);
     }
 
     public void change_subject(Account account, Jid jid, string subject) {
@@ -170,7 +171,7 @@ public class MucManager : StreamInteractionModule, Object {
 
     public void change_affiliation(Account account, Jid jid, string nick, string role) {
         XmppStream? stream = stream_interactor.get_stream(account);
-        if (stream != null) stream.get_module(Xep.Muc.Module.IDENTITY).change_affiliation(stream, jid.bare_jid, nick, role);
+        if (stream != null) stream.get_module(Xep.Muc.Module.IDENTITY).change_affiliation.begin(stream, jid.bare_jid, null, nick, role);
     }
 
     public void change_role(Account account, Jid jid, string nick, string role) {
@@ -401,6 +402,36 @@ public class MucManager : StreamInteractionModule, Object {
         });
     }
 
+    private async void search_default_muc_server(Account account) {
+        XmppStream? stream = stream_interactor.get_stream(account);
+        if (stream == null) return;
+
+        ServiceDiscovery.ItemsResult? items_result = yield stream.get_module(ServiceDiscovery.Module.IDENTITY).request_items(stream, stream.remote_name);
+        if (items_result == null) return;
+
+        for (int i = 0; i < 2; i++) {
+            foreach (Xep.ServiceDiscovery.Item item in items_result.items) {
+
+                // First try the promising items and only afterwards all the others
+                bool promising_upload_item = item.jid.to_string().has_prefix("conference") ||
+                        item.jid.to_string().has_prefix("muc") ||
+                        item.jid.to_string().has_prefix("chat");
+                if ((i == 0 && !promising_upload_item) || (i == 1) && promising_upload_item) continue;
+
+                Gee.Set<Xep.ServiceDiscovery.Identity> identities = yield stream_interactor.get_module(EntityInfo.IDENTITY).get_identities(account, item.jid);
+                if (identities == null) return;
+
+                foreach (Xep.ServiceDiscovery.Identity identity in identities) {
+                    if (identity.category == Xep.ServiceDiscovery.Identity.CATEGORY_CONFERENCE) {
+                        default_muc_server[account] = item.jid;
+                        print(@"$(account.bare_jid) Default MUC: $(item.jid)\n");
+                        return;
+                    }
+                }
+            }
+        }
+    }
+
     private async void on_stream_negotiated(Account account, XmppStream stream) {
         if (bookmarks_provider[account] == null) return;
 
@@ -411,6 +442,10 @@ public class MucManager : StreamInteractionModule, Object {
         } else {
             sync_autojoin_active(account, conferences);
         }
+
+        if (!default_muc_server.has_key(account)) {
+            search_default_muc_server.begin(account);
+        }
     }
 
     private void on_invite_received(Account account, Jid room_jid, Jid from_jid, string? password, string? reason) {
diff --git a/libdino/src/service/notification_events.vala b/libdino/src/service/notification_events.vala
index f87ebe0d..6f1d0fd4 100644
--- a/libdino/src/service/notification_events.vala
+++ b/libdino/src/service/notification_events.vala
@@ -106,7 +106,7 @@ public class NotificationEvents : StreamInteractionModule, Object {
         notifier.notify_subscription_request.begin(conversation);
     }
 
-    private void on_call_incoming(Call call, Conversation conversation, bool video) {
+    private void on_call_incoming(Call call, CallState call_state, Conversation conversation, bool video) {
         string conversation_display_name = get_conversation_display_name(stream_interactor, conversation, null);
 
         notifier.notify_call.begin(call, conversation, video, conversation_display_name);
diff --git a/xmpp-vala/CMakeLists.txt b/xmpp-vala/CMakeLists.txt
index bf8f0068..27f0d408 100644
--- a/xmpp-vala/CMakeLists.txt
+++ b/xmpp-vala/CMakeLists.txt
@@ -109,6 +109,8 @@ SOURCES
     "src/module/xep/0176_jingle_ice_udp/jingle_ice_udp_module.vala"
     "src/module/xep/0176_jingle_ice_udp/transport_parameters.vala"
 
+    "src/module/xep/0177_jingle_raw_udp.vala"
+
     "src/module/xep/0384_omemo/omemo_encryptor.vala"
     "src/module/xep/0384_omemo/omemo_decryptor.vala"
 
@@ -122,7 +124,9 @@ SOURCES
     "src/module/xep/0249_direct_muc_invitations.vala"
     "src/module/xep/0260_jingle_socks5_bytestreams.vala"
     "src/module/xep/0261_jingle_in_band_bytestreams.vala"
+    "src/module/xep/0272_muji.vala"
     "src/module/xep/0280_message_carbons.vala"
+    "src/module/xep/0298_coin.vala"
     "src/module/xep/0308_last_message_correction.vala"
     "src/module/xep/0313_message_archive_management.vala"
     "src/module/xep/0333_chat_markers.vala"
@@ -133,6 +137,7 @@ SOURCES
     "src/module/xep/0380_explicit_encryption.vala"
     "src/module/xep/0391_jingle_encrypted_transports.vala"
     "src/module/xep/0410_muc_self_ping.vala"
+    "src/module/xep/muji_meta.vala"
     "src/module/xep/pixbuf_storage.vala"
 
     "src/util.vala"
diff --git a/xmpp-vala/src/module/presence/flag.vala b/xmpp-vala/src/module/presence/flag.vala
index 77bc0b5f..8e13d0ad 100644
--- a/xmpp-vala/src/module/presence/flag.vala
+++ b/xmpp-vala/src/module/presence/flag.vala
@@ -20,6 +20,17 @@ public class Flag : XmppStreamFlag {
         return presences[full_jid];
     }
 
+    public Gee.List<Presence.Stanza> get_presences(Jid jid) {
+        Gee.List<Presence.Stanza> ret = new ArrayList<Presence.Stanza>();
+        Gee.List<Jid>? jid_res = resources[jid];
+        if (jid_res == null) return ret;
+
+        foreach (Jid full_jid in jid_res) {
+            ret.add(presences[full_jid]);
+        }
+        return ret;
+    }
+
     public void add_presence(Presence.Stanza presence) {
         if (!resources.has_key(presence.from)) {
             resources[presence.from] = new ArrayList<Jid>(Jid.equals_func);
diff --git a/xmpp-vala/src/module/xep/0045_muc/module.vala b/xmpp-vala/src/module/xep/0045_muc/module.vala
index 4cab9b6a..c9445f7e 100644
--- a/xmpp-vala/src/module/xep/0045_muc/module.vala
+++ b/xmpp-vala/src/module/xep/0045_muc/module.vala
@@ -58,6 +58,7 @@ public class JoinResult {
     public MucEnterError? muc_error;
     public string? stanza_error;
     public string? nick;
+    public bool newly_created = false;
 }
 
 public class Module : XmppStreamModule {
@@ -80,7 +81,7 @@ public class Module : XmppStreamModule {
         received_pipeline_listener = new ReceivedPipelineListener(this);
     }
 
-    public async JoinResult? enter(XmppStream stream, Jid bare_jid, string nick, string? password, DateTime? history_since) {
+    public async JoinResult? enter(XmppStream stream, Jid bare_jid, string nick, string? password, DateTime? history_since, StanzaNode? additional_node) {
         try {
             Presence.Stanza presence = new Presence.Stanza();
             presence.to = bare_jid.with_resource(nick);
@@ -96,6 +97,10 @@ public class Module : XmppStreamModule {
             }
             presence.stanza.put_node(x_node);
 
+            if (additional_node != null) {
+                presence.stanza.put_node(additional_node);
+            }
+
             stream.get_flag(Flag.IDENTITY).start_muc_enter(bare_jid, presence.id);
 
             query_room_info.begin(stream, bare_jid);
@@ -210,11 +215,15 @@ public class Module : XmppStreamModule {
         stream.get_module(Iq.Module.IDENTITY).send_iq(stream, iq);
     }
 
-    public void change_affiliation(XmppStream stream, Jid jid, string nick, string new_affiliation) {
-        StanzaNode query = new StanzaNode.build("query", NS_URI_ADMIN).add_self_xmlns();
-        query.put_node(new StanzaNode.build("item", NS_URI_ADMIN).put_attribute("nick", nick, NS_URI_ADMIN).put_attribute("affiliation", new_affiliation, NS_URI_ADMIN));
-        Iq.Stanza iq = new Iq.Stanza.set(query) { to=jid };
-        stream.get_module(Iq.Module.IDENTITY).send_iq(stream, iq);
+    public async void change_affiliation(XmppStream stream, Jid muc_jid, Jid? user_jid, string? nick, string new_affiliation) {
+        StanzaNode item_node = new StanzaNode.build("item", NS_URI_ADMIN)
+                .put_attribute("affiliation", new_affiliation, NS_URI_ADMIN);
+        if (user_jid != null) item_node.put_attribute("jid", user_jid.to_string(), NS_URI_ADMIN);
+        if (nick != null) item_node.put_attribute("nick", nick, NS_URI_ADMIN);
+
+        StanzaNode query = new StanzaNode.build("query", NS_URI_ADMIN).add_self_xmlns().put_node(item_node);
+        Iq.Stanza iq = new Iq.Stanza.set(query) { to=muc_jid };
+        yield stream.get_module(Iq.Module.IDENTITY).send_iq_async(stream, iq);
     }
 
     public async DataForms.DataForm? get_config_form(XmppStream stream, Jid jid) {
@@ -229,19 +238,19 @@ public class Module : XmppStreamModule {
         return null;
     }
 
-    public void set_config_form(XmppStream stream, Jid jid, DataForms.DataForm data_form) {
+    public async void set_config_form(XmppStream stream, Jid jid, DataForms.DataForm data_form) {
         StanzaNode stanza_node = new StanzaNode.build("query", NS_URI_OWNER);
         stanza_node.add_self_xmlns().put_node(data_form.get_submit_node());
         Iq.Stanza set_iq = new Iq.Stanza.set(stanza_node) { to=jid };
-        stream.get_module(Iq.Module.IDENTITY).send_iq(stream, set_iq);
+        yield stream.get_module(Iq.Module.IDENTITY).send_iq_async(stream, set_iq);
     }
 
     public override void attach(XmppStream stream) {
         stream.add_flag(new Flag());
         stream.get_module(MessageModule.IDENTITY).received_message.connect(on_received_message);
         stream.get_module(MessageModule.IDENTITY).received_pipeline.connect(received_pipeline_listener);
-        stream.get_module(Presence.Module.IDENTITY).received_presence.connect(check_for_enter_error);
         stream.get_module(Presence.Module.IDENTITY).received_available.connect(on_received_available);
+        stream.get_module(Presence.Module.IDENTITY).received_presence.connect(check_for_enter_error);
         stream.get_module(Presence.Module.IDENTITY).received_unavailable.connect(on_received_unavailable);
         stream.get_module(ServiceDiscovery.Module.IDENTITY).add_feature(stream, NS_URI);
     }
@@ -249,8 +258,8 @@ public class Module : XmppStreamModule {
     public override void detach(XmppStream stream) {
         stream.get_module(MessageModule.IDENTITY).received_message.disconnect(on_received_message);
         stream.get_module(MessageModule.IDENTITY).received_pipeline.disconnect(received_pipeline_listener);
-        stream.get_module(Presence.Module.IDENTITY).received_presence.disconnect(check_for_enter_error);
         stream.get_module(Presence.Module.IDENTITY).received_available.disconnect(on_received_available);
+        stream.get_module(Presence.Module.IDENTITY).received_presence.disconnect(check_for_enter_error);
         stream.get_module(Presence.Module.IDENTITY).received_unavailable.disconnect(on_received_unavailable);
         stream.get_module(ServiceDiscovery.Module.IDENTITY).remove_feature(stream, NS_URI);
     }
@@ -339,7 +348,8 @@ public class Module : XmppStreamModule {
                         query_affiliation.begin(stream, bare_jid, "owner");
 
                         flag.finish_muc_enter(bare_jid);
-                        flag.enter_futures[bare_jid].set_value(new JoinResult() {nick=presence.from.resourcepart});
+                        var join_result = new JoinResult() { nick=presence.from.resourcepart, newly_created=status_codes.contains(StatusCode.NEW_ROOM_CREATED) };
+                        flag.enter_futures[bare_jid].set_value(join_result);
                     }
 
                     flag.set_muc_nick(presence.from);
diff --git a/xmpp-vala/src/module/xep/0166_jingle/component.vala b/xmpp-vala/src/module/xep/0166_jingle/component.vala
index 5d573522..e30175d5 100644
--- a/xmpp-vala/src/module/xep/0166_jingle/component.vala
+++ b/xmpp-vala/src/module/xep/0166_jingle/component.vala
@@ -2,6 +2,8 @@ namespace Xmpp.Xep.Jingle {
 
     public abstract class ComponentConnection : Object {
         public uint8 component_id { get; set; default = 0; }
+        public ulong bytes_sent { get; protected set; default=0; }
+        public ulong bytes_received { get; protected set; default=0; }
         public abstract async void terminate(bool we_terminated, string? reason_name = null, string? reason_text = null);
         public signal void connection_closed();
         public signal void connection_error(IOError e);
diff --git a/xmpp-vala/src/module/xep/0166_jingle/content.vala b/xmpp-vala/src/module/xep/0166_jingle/content.vala
index b51bb26d..31d8f9fc 100644
--- a/xmpp-vala/src/module/xep/0166_jingle/content.vala
+++ b/xmpp-vala/src/module/xep/0166_jingle/content.vala
@@ -95,16 +95,27 @@ public class Xmpp.Xep.Jingle.Content : Object {
     }
 
     public void accept() {
+        if (state != State.PENDING) {
+            warning("accepting a non-pending content");
+            return;
+        }
         state = State.WANTS_TO_BE_ACCEPTED;
-
         session.accept_content(this);
     }
 
     public void reject() {
+        if (state != State.PENDING) {
+            warning("rejecting a non-pending content");
+            return;
+        }
         session.reject_content(this);
     }
 
     public void terminate(bool we_terminated, string? reason_name, string? reason_text) {
+        if (state == State.PENDING) {
+            warning("terminating a pending call");
+            return;
+        }
         content_params.terminate(we_terminated, reason_name, reason_text);
         transport_params.dispose();
 
@@ -137,7 +148,7 @@ public class Xmpp.Xep.Jingle.Content : Object {
         this.content_params.handle_accept(stream, this.session, this, content_node.description);
     }
 
-    private async void select_new_transport() {
+    public async void select_new_transport() {
         XmppStream stream = session.stream;
         Transport? new_transport = yield stream.get_module(Module.IDENTITY).select_transport(stream, transport.type_, transport_params.components, peer_full_jid, tried_transport_methods);
         if (new_transport == null) {
diff --git a/xmpp-vala/src/module/xep/0166_jingle/session.vala b/xmpp-vala/src/module/xep/0166_jingle/session.vala
index a45fc6db..af913aab 100644
--- a/xmpp-vala/src/module/xep/0166_jingle/session.vala
+++ b/xmpp-vala/src/module/xep/0166_jingle/session.vala
@@ -264,10 +264,7 @@ public class Xmpp.Xep.Jingle.Session : Object {
                 warning("Received invalid session accept: %s", e.message);
             }
         }
-        // TODO(hrxi): more sanity checking, perhaps replace who we're talking to
-        if (!responder.is_full()) {
-            throw new IqError.BAD_REQUEST("invalid responder JID");
-        }
+
         foreach (ContentNode content_node in content_nodes) {
             handle_content_accept(content_node);
         }
diff --git a/xmpp-vala/src/module/xep/0167_jingle_rtp/content_parameters.vala b/xmpp-vala/src/module/xep/0167_jingle_rtp/content_parameters.vala
index eadc1c8b..9022547d 100644
--- a/xmpp-vala/src/module/xep/0167_jingle_rtp/content_parameters.vala
+++ b/xmpp-vala/src/module/xep/0167_jingle_rtp/content_parameters.vala
@@ -21,6 +21,10 @@ public class Xmpp.Xep.JingleRtp.Parameters : Jingle.ContentParameters, Object {
     public Gee.List<Crypto> remote_cryptos = new ArrayList<Crypto>();
     public Crypto? local_crypto = null;
     public Crypto? remote_crypto = null;
+    public Jid? muji_muc = null;
+
+    public bool rtp_ready { get; private set; default=false; }
+    public bool rtcp_ready { get; private set; default=false; }
 
     public weak Stream? stream { get; private set; }
 
@@ -28,6 +32,7 @@ public class Xmpp.Xep.JingleRtp.Parameters : Jingle.ContentParameters, Object {
 
     public Parameters(Module parent,
                       string media, Gee.List<PayloadType> payload_types,
+                      Jid? muji_muc,
                       string? ssrc = null, bool rtcp_mux = false,
                       string? bandwidth = null, string? bandwidth_type = null,
                       bool encryption_required = false, Crypto? local_crypto = null
@@ -41,6 +46,7 @@ public class Xmpp.Xep.JingleRtp.Parameters : Jingle.ContentParameters, Object {
         this.encryption_required = encryption_required;
         this.payload_types = payload_types;
         this.local_crypto = local_crypto;
+        this.muji_muc = muji_muc;
     }
 
     public Parameters.from_node(Module parent, StanzaNode node) throws Jingle.IqError {
@@ -61,6 +67,10 @@ public class Xmpp.Xep.JingleRtp.Parameters : Jingle.ContentParameters, Object {
         foreach (StanzaNode subnode in node.get_subnodes(HeaderExtension.NAME, HeaderExtension.NS_URI)) {
             this.header_extensions.add(HeaderExtension.parse(subnode));
         }
+        string? muji_muc_str = node.get_deep_attribute(Xep.Muji.NS_URI + ":muji", "muc");
+        if (muji_muc_str != null) {
+            muji_muc = new Jid(muji_muc_str);
+        }
     }
 
     public async void handle_proposed_content(XmppStream stream, Jingle.Session session, Jingle.Content content) {
@@ -95,6 +105,7 @@ public class Xmpp.Xep.JingleRtp.Parameters : Jingle.ContentParameters, Object {
         ulong rtcp_ready_handler_id = 0;
         rtcp_ready_handler_id = rtcp_datagram.notify["ready"].connect((rtcp_datagram, _) => {
             this.stream.on_rtcp_ready();
+            this.rtcp_ready = true;
 
             ((Jingle.DatagramConnection)rtcp_datagram).disconnect(rtcp_ready_handler_id);
             rtcp_ready_handler_id = 0;
@@ -103,8 +114,10 @@ public class Xmpp.Xep.JingleRtp.Parameters : Jingle.ContentParameters, Object {
         ulong rtp_ready_handler_id = 0;
         rtp_ready_handler_id = rtp_datagram.notify["ready"].connect((rtp_datagram, _) => {
             this.stream.on_rtp_ready();
+            this.rtp_ready = true;
             if (rtcp_mux) {
                 this.stream.on_rtcp_ready();
+                this.rtcp_ready = true;
             }
             connection_ready();
 
@@ -202,6 +215,9 @@ public class Xmpp.Xep.JingleRtp.Parameters : Jingle.ContentParameters, Object {
         if (rtcp_mux) {
             ret.put_node(new StanzaNode.build("rtcp-mux", NS_URI));
         }
+        if (muji_muc != null) {
+            ret.put_node(new StanzaNode.build("muji", Xep.Muji.NS_URI).add_self_xmlns().put_attribute("muc", muji_muc.to_string()));
+        }
         return ret;
     }
 }
diff --git a/xmpp-vala/src/module/xep/0167_jingle_rtp/jingle_rtp_module.vala b/xmpp-vala/src/module/xep/0167_jingle_rtp/jingle_rtp_module.vala
index 6b55cbe6..9dab5dc2 100644
--- a/xmpp-vala/src/module/xep/0167_jingle_rtp/jingle_rtp_module.vala
+++ b/xmpp-vala/src/module/xep/0167_jingle_rtp/jingle_rtp_module.vala
@@ -19,6 +19,7 @@ public abstract class Module : XmppStreamModule {
     }
 
     public abstract async Gee.List<PayloadType> get_supported_payloads(string media);
+    public abstract async bool is_payload_supported(string media, JingleRtp.PayloadType payload_type);
     public abstract async PayloadType? pick_payload_type(string media, Gee.List<PayloadType> payloads);
     public abstract Crypto? generate_local_crypto();
     public abstract Crypto? pick_remote_crypto(Gee.List<Crypto> cryptos);
@@ -28,7 +29,7 @@ public abstract class Module : XmppStreamModule {
     public abstract Gee.List<HeaderExtension> get_suggested_header_extensions(string media);
     public abstract void close_stream(Stream stream);
 
-    public async Jingle.Session start_call(XmppStream stream, Jid receiver_full_jid, bool video, string? sid = null) throws Jingle.Error {
+    public async Jingle.Session start_call(XmppStream stream, Jid receiver_full_jid, bool video, string sid, Jid? muji_muc) throws Jingle.Error {
 
         Jingle.Module jingle_module = stream.get_module(Jingle.Module.IDENTITY);
 
@@ -40,7 +41,7 @@ public abstract class Module : XmppStreamModule {
         ArrayList<Jingle.Content> contents = new ArrayList<Jingle.Content>();
 
         // Create audio content
-        Parameters audio_content_parameters = new Parameters(this, "audio", yield get_supported_payloads("audio"));
+        Parameters audio_content_parameters = new Parameters(this, "audio", yield get_supported_payloads("audio"), muji_muc);
         audio_content_parameters.local_crypto = generate_local_crypto();
         audio_content_parameters.header_extensions.add_all(get_suggested_header_extensions("audio"));
         Jingle.Transport? audio_transport = yield jingle_module.select_transport(stream, content_type.required_transport_type, content_type.required_components, receiver_full_jid, Set.empty());
@@ -48,7 +49,7 @@ public abstract class Module : XmppStreamModule {
             throw new Jingle.Error.NO_SHARED_PROTOCOLS("No suitable audio transports");
         }
         Jingle.TransportParameters audio_transport_params = audio_transport.create_transport_parameters(stream, content_type.required_components, my_jid, receiver_full_jid);
-        Jingle.Content audio_content = new Jingle.Content.initiate_sent("voice", Jingle.Senders.BOTH,
+        Jingle.Content audio_content = new Jingle.Content.initiate_sent("audio", Jingle.Senders.BOTH,
                 content_type, audio_content_parameters,
                 audio_transport, audio_transport_params,
                 null, null,
@@ -58,7 +59,7 @@ public abstract class Module : XmppStreamModule {
         Jingle.Content? video_content = null;
         if (video) {
             // Create video content
-            Parameters video_content_parameters = new Parameters(this, "video", yield get_supported_payloads("video"));
+            Parameters video_content_parameters = new Parameters(this, "video", yield get_supported_payloads("video"), muji_muc);
             video_content_parameters.local_crypto = generate_local_crypto();
             video_content_parameters.header_extensions.add_all(get_suggested_header_extensions("video"));
             Jingle.Transport? video_transport = yield stream.get_module(Jingle.Module.IDENTITY).select_transport(stream, content_type.required_transport_type, content_type.required_components, receiver_full_jid, Set.empty());
@@ -66,7 +67,7 @@ public abstract class Module : XmppStreamModule {
                 throw new Jingle.Error.NO_SHARED_PROTOCOLS("No suitable video transports");
             }
             Jingle.TransportParameters video_transport_params = video_transport.create_transport_parameters(stream, content_type.required_components, my_jid, receiver_full_jid);
-            video_content = new Jingle.Content.initiate_sent("webcam", Jingle.Senders.BOTH,
+            video_content = new Jingle.Content.initiate_sent("video", Jingle.Senders.BOTH,
                     content_type, video_content_parameters,
                     video_transport, video_transport_params,
                     null, null,
@@ -83,7 +84,7 @@ public abstract class Module : XmppStreamModule {
         }
     }
 
-    public async Jingle.Content add_outgoing_video_content(XmppStream stream, Jingle.Session session) throws Jingle.Error {
+    public async Jingle.Content add_outgoing_video_content(XmppStream stream, Jingle.Session session, Jid? muji_muc) throws Jingle.Error {
         Jid my_jid = session.local_full_jid;
         Jid receiver_full_jid = session.peer_full_jid;
 
@@ -100,7 +101,7 @@ public abstract class Module : XmppStreamModule {
 
         if (content == null) {
             // Content for video does not yet exist -> create it
-            Parameters video_content_parameters = new Parameters(this, "video", yield get_supported_payloads("video"));
+            Parameters video_content_parameters = new Parameters(this, "video", yield get_supported_payloads("video"), muji_muc);
             video_content_parameters.local_crypto = generate_local_crypto();
             video_content_parameters.header_extensions.add_all(get_suggested_header_extensions("video"));
             Jingle.Transport? video_transport = yield stream.get_module(Jingle.Module.IDENTITY).select_transport(stream, content_type.required_transport_type, content_type.required_components, receiver_full_jid, Set.empty());
@@ -108,7 +109,7 @@ public abstract class Module : XmppStreamModule {
                 throw new Jingle.Error.NO_SHARED_PROTOCOLS("No suitable video transports");
             }
             Jingle.TransportParameters video_transport_params = video_transport.create_transport_parameters(stream, content_type.required_components, my_jid, receiver_full_jid);
-            content = new Jingle.Content.initiate_sent("webcam",
+            content = new Jingle.Content.initiate_sent("video",
                     session.we_initiated ? Jingle.Senders.INITIATOR : Jingle.Senders.RESPONDER,
                     content_type, video_content_parameters,
                     video_transport, video_transport_params,
diff --git a/xmpp-vala/src/module/xep/0167_jingle_rtp/payload_type.vala b/xmpp-vala/src/module/xep/0167_jingle_rtp/payload_type.vala
index faba38c9..73bc9800 100644
--- a/xmpp-vala/src/module/xep/0167_jingle_rtp/payload_type.vala
+++ b/xmpp-vala/src/module/xep/0167_jingle_rtp/payload_type.vala
@@ -64,12 +64,27 @@ public class Xmpp.Xep.JingleRtp.PayloadType {
     }
 
     public static bool equals_func(PayloadType a, PayloadType b) {
-        return a.id == b.id &&
+        bool simple = a.id == b.id &&
                 a.name == b.name &&
                 a.channels == b.channels &&
                 a.clockrate == b.clockrate &&
                 a.maxptime == b.maxptime &&
-                a.ptime == b.ptime;
+                a.ptime == b.ptime &&
+                a.parameters.size == b.parameters.size &&
+                a.rtcp_fbs.size == b.rtcp_fbs.size;
+        if (!simple) return false;
+        foreach (string key in a.parameters.keys) {
+            if (!b.parameters.has_key(key)) return false;
+            if (a.parameters[key] != b.parameters[key]) return false;
+        }
+        foreach (RtcpFeedback fb in a.rtcp_fbs) {
+            if (!b.rtcp_fbs.any_match((it) => it.type_ == fb.type_ && it.subtype == fb.subtype)) return false;
+        }
+        return true;
+    }
+
+    public static uint hash_func(PayloadType payload_type) {
+        return payload_type.to_xml().to_string().hash();
     }
 }
 
diff --git a/xmpp-vala/src/module/xep/0176_jingle_ice_udp/transport_parameters.vala b/xmpp-vala/src/module/xep/0176_jingle_ice_udp/transport_parameters.vala
index 07b599ee..680d7c80 100644
--- a/xmpp-vala/src/module/xep/0176_jingle_ice_udp/transport_parameters.vala
+++ b/xmpp-vala/src/module/xep/0176_jingle_ice_udp/transport_parameters.vala
@@ -28,6 +28,7 @@ public abstract class Xmpp.Xep.JingleIceUdp.IceUdpTransportParameters : Jingle.T
     private bool connection_created = false;
 
     protected weak Jingle.Content? content = null;
+    protected bool use_raw = false;
 
     protected IceUdpTransportParameters(uint8 components, Jid local_full_jid, Jid peer_full_jid, StanzaNode? node = null) {
         this.components_ = components;
@@ -80,10 +81,16 @@ public abstract class Xmpp.Xep.JingleIceUdp.IceUdpTransportParameters : Jingle.T
             node.put_node(fingerprint_node);
         }
 
-        foreach (Candidate candidate in unsent_local_candidates) {
+        if (action_type != "transport-info") {
+            foreach (Candidate candidate in unsent_local_candidates) {
+                node.put_node(candidate.to_xml());
+            }
+            unsent_local_candidates.clear();
+        } else if (!unsent_local_candidates.is_empty) {
+            Candidate candidate = unsent_local_candidates.first();
             node.put_node(candidate.to_xml());
+            unsent_local_candidates.remove(candidate);
         }
-        unsent_local_candidates.clear();
         return node;
     }
 
@@ -128,15 +135,15 @@ public abstract class Xmpp.Xep.JingleIceUdp.IceUdpTransportParameters : Jingle.T
         local_candidates.add(candidate);
 
         if (this.content != null && (this.connection_created || !this.incoming)) {
-            Timeout.add(50, () => {
+            Idle.add( () => {
                 check_send_transport_info();
-                return false;
+                return Source.REMOVE;
             });
         }
     }
 
     private void check_send_transport_info() {
-        if (this.content != null && unsent_local_candidates.size > 0) {
+        if (this.content != null && !unsent_local_candidates.is_empty) {
             content.send_transport_info(to_transport_stanza_node("transport-info"));
         }
     }
diff --git a/xmpp-vala/src/module/xep/0234_jingle_file_transfer.vala b/xmpp-vala/src/module/xep/0234_jingle_file_transfer.vala
index 7b213ca5..f85049ac 100644
--- a/xmpp-vala/src/module/xep/0234_jingle_file_transfer.vala
+++ b/xmpp-vala/src/module/xep/0234_jingle_file_transfer.vala
@@ -100,7 +100,11 @@ public class Module : Jingle.ContentType, XmppStreamModule {
             yield;
 
             // Send the file data
-            Jingle.StreamingConnection connection = content.component_connections.values.to_array()[0] as Jingle.StreamingConnection;
+            Jingle.StreamingConnection connection = content.component_connections[1] as Jingle.StreamingConnection;
+            if (connection == null || connection.stream == null) {
+                warning("Connection or stream not null");
+                return;
+            }
             IOStream io_stream = yield connection.stream.wait_async();
             yield io_stream.input_stream.close_async();
             yield io_stream.output_stream.splice_async(input_stream, OutputStreamSpliceFlags.CLOSE_SOURCE|OutputStreamSpliceFlags.CLOSE_TARGET);
diff --git a/xmpp-vala/src/module/xep/0260_jingle_socks5_bytestreams.vala b/xmpp-vala/src/module/xep/0260_jingle_socks5_bytestreams.vala
index 32ba8bb9..0fe9ce5f 100644
--- a/xmpp-vala/src/module/xep/0260_jingle_socks5_bytestreams.vala
+++ b/xmpp-vala/src/module/xep/0260_jingle_socks5_bytestreams.vala
@@ -759,6 +759,10 @@ class Parameters : Jingle.TransportParameters, Object {
     }
 
     private void content_set_transport_connection_error(Error e) {
+        Jingle.Content? strong_content = content;
+        if (strong_content == null) return;
+
+        strong_content.select_new_transport.begin();
         connection.set_error(e);
     }
 
diff --git a/xmpp-vala/src/module/xep/0384_omemo/omemo_decryptor.vala b/xmpp-vala/src/module/xep/0384_omemo/omemo_decryptor.vala
index 8e3213ae..a8ca5016 100644
--- a/xmpp-vala/src/module/xep/0384_omemo/omemo_decryptor.vala
+++ b/xmpp-vala/src/module/xep/0384_omemo/omemo_decryptor.vala
@@ -18,16 +18,25 @@ namespace Xmpp.Xep.Omemo {
             ParsedData ret = new ParsedData();
 
             StanzaNode? header_node = encrypted_node.get_subnode("header");
-            if (header_node == null) return null;
+            if (header_node == null) {
+                warning("Can't parse OMEMO node: No header node");
+                return null;
+            }
 
             ret.sid = header_node.get_attribute_int("sid", -1);
-            if (ret.sid == -1) return null;
+            if (ret.sid == -1) {
+                warning("Can't parse OMEMO node: No sid");
+                return null;
+            }
 
             string? payload_str = encrypted_node.get_deep_string_content("payload");
             if (payload_str != null) ret.ciphertext = Base64.decode(payload_str);
 
             string? iv_str = header_node.get_deep_string_content("iv");
-            if (iv_str == null) return null;
+            if (iv_str == null) {
+                warning("Can't parse OMEMO node: No iv");
+                return null;
+            }
             ret.iv = Base64.decode(iv_str);
 
             foreach (StanzaNode key_node in header_node.get_subnodes("key")) {
diff --git a/xmpp-vala/src/module/xep/muji_meta.vala b/xmpp-vala/src/module/xep/muji_meta.vala
new file mode 100644
index 00000000..4452e611
--- /dev/null
+++ b/xmpp-vala/src/module/xep/muji_meta.vala
@@ -0,0 +1,117 @@
+using Gee;
+namespace Xmpp.Xep.MujiMeta {
+
+    public const string NS_URI = "http://telepathy.freedesktop.org/muji";
+
+    public class Module : XmppStreamModule {
+        public static ModuleIdentity<Module> IDENTITY = new ModuleIdentity<Module>(NS_URI, "muji_meta");
+
+        public signal void call_proposed(Jid from, Jid to, Jid muc_jid, Gee.List<StanzaNode> descriptions);
+        public signal void call_retracted(Jid from, Jid to, Jid muc_jid);
+        public signal void call_accepted(Jid from, Jid muc_jid);
+        public signal void call_rejected(Jid from, Jid to, Jid muc_jid);
+
+        public void send_invite(XmppStream stream, Jid invitee, Jid muc_jid, bool video) {
+            var invite_node = new StanzaNode.build("propose", NS_URI).put_attribute("muc", muc_jid.to_string());
+            invite_node.put_node(new StanzaNode.build("description", Xep.JingleRtp.NS_URI).add_self_xmlns().put_attribute("media", "audio"));
+            if (video) {
+                invite_node.put_node(new StanzaNode.build("description", Xep.JingleRtp.NS_URI).add_self_xmlns().put_attribute("media", "video"));
+            }
+            var muji_node = new StanzaNode.build("muji", NS_URI).add_self_xmlns().put_node(invite_node);
+            MessageStanza invite_message = new MessageStanza() { to=invitee, type_=MessageStanza.TYPE_CHAT };
+            invite_message.stanza.put_node(muji_node);
+            stream.get_module(MessageModule.IDENTITY).send_message.begin(stream, invite_message);
+        }
+
+        public void send_invite_retract_to_peer(XmppStream stream, Jid invitee, Jid muc_jid) {
+            send_jmi_message(stream, "retract", invitee, muc_jid);
+        }
+
+        public void send_invite_accept_to_peer(XmppStream stream, Jid invitor, Jid muc_jid) {
+            send_jmi_message(stream, "accept", invitor, muc_jid);
+        }
+
+        public void send_invite_accept_to_self(XmppStream stream, Jid muc_jid) {
+            send_jmi_message(stream, "accept", Bind.Flag.get_my_jid(stream).bare_jid, muc_jid);
+        }
+
+        public void send_invite_reject_to_peer(XmppStream stream, Jid invitor, Jid muc_jid) {
+            send_jmi_message(stream, "reject", invitor, muc_jid);
+        }
+
+        public void send_invite_reject_to_self(XmppStream stream, Jid muc_jid) {
+            send_jmi_message(stream, "reject", Bind.Flag.get_my_jid(stream).bare_jid, muc_jid);
+        }
+
+        private void send_jmi_message(XmppStream stream, string name, Jid to, Jid muc) {
+            var jmi_node = new StanzaNode.build(name, NS_URI).add_self_xmlns().put_attribute("muc", muc.to_string());
+            var muji_node = new StanzaNode.build("muji", NS_URI).add_self_xmlns().put_node(jmi_node);
+
+            MessageStanza accepted_message = new MessageStanza() { to=to, type_=MessageStanza.TYPE_CHAT };
+            accepted_message.stanza.put_node(muji_node);
+            stream.get_module(MessageModule.IDENTITY).send_message.begin(stream, accepted_message);
+        }
+
+        private void on_received_message(XmppStream stream, MessageStanza message) {
+            Xep.MessageArchiveManagement.MessageFlag? mam_flag = Xep.MessageArchiveManagement.MessageFlag.get_flag(message);
+            if (mam_flag != null) return;
+
+            var muji_node = message.stanza.get_subnode("muji", NS_URI);
+            if (muji_node == null) return;
+
+            StanzaNode? mi_node = null;
+            foreach (StanzaNode node in muji_node.sub_nodes) {
+                if (node.ns_uri == NS_URI) {
+                    mi_node = node;
+                }
+            }
+            if (mi_node == null) return;
+
+            string? jid_str = mi_node.get_attribute("muc");
+            if (jid_str == null) return;
+
+            Jid muc_jid = null;
+            try {
+                muc_jid = new Jid(jid_str);
+            } catch (Error e) {
+                return;
+            }
+
+            switch (mi_node.name) {
+                case "accept":
+                case "proceed":
+                    call_accepted(message.from, muc_jid);
+                    break;
+                case "propose":
+                    ArrayList<StanzaNode> descriptions = new ArrayList<StanzaNode>();
+
+                    foreach (StanzaNode node in mi_node.sub_nodes) {
+                        if (node.name != "description") continue;
+                        descriptions.add(node);
+                    }
+
+                    if (descriptions.size > 0) {
+                        call_proposed(message.from, message.to, muc_jid, descriptions);
+                    }
+                    break;
+                case "retract":
+                    call_retracted(message.from, message.to, muc_jid);
+                    break;
+                case "reject":
+                    call_rejected(message.from, message.to, muc_jid);
+                    break;
+            }
+        }
+
+        public override void attach(XmppStream stream) {
+            stream.get_module(MessageModule.IDENTITY).received_message.connect(on_received_message);
+        }
+
+        public override void detach(XmppStream stream) {
+            stream.get_module(MessageModule.IDENTITY).received_message.disconnect(on_received_message);
+        }
+
+        public override string get_ns() { return NS_URI; }
+        public override string get_id() { return IDENTITY.id; }
+    }
+}
\ No newline at end of file